gdilib.c

来自「深圳市微逻辑电子有限公司 巨果&#8226 Kingmos&reg 系统核心」· C语言 代码 · 共 2,460 行 · 第 1/5 页

C
2,460 行
字号
12345

	PGDI_SETBKCOLOR pSetBkColor;// = (PGDI_SETBKCOLOR)lpGDIAPI[GDI_SETBKCOLOR];

	COLORREF clRetv = CLR_INVALID;
	CALLSTACK cs;

	if( API_Enter( API_GDI, GDI_SETBKCOLOR, &pSetBkColor, &cs ) )
	{
		clRetv = pSetBkColor( hdc, color );
		API_Leave(  );
	}
	return clRetv;
#endif
}

typedef int ( WINAPI * PGDI_SETBKMODE )( HDC hdc, int mode );
int WINAPI Gdi_SetBkMode( HDC hdc, int mode )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_GDI, GDI_SETBKMODE, 2 );
    cs.arg0 = (DWORD)hdc;
    return (DWORD)CALL_SERVER( &cs, mode );
#else

	PGDI_SETBKMODE pSetBkMode;// = (PGDI_SETBKMODE)lpGDIAPI[GDI_SETBKMODE];

	int  iRetv = 0;
	CALLSTACK cs;

	if( API_Enter( API_GDI, GDI_SETBKMODE, &pSetBkMode, &cs ) )
	{
		iRetv = pSetBkMode( hdc, mode );
		API_Leave(  );
	}
	return iRetv;
#endif
}

typedef BOOL ( WINAPI * PGDI_SETBRUSHORG )( HDC hdc, int xOrg, int yOrg, LPPOINT lppt );
BOOL WINAPI Gdi_SetBrushOrg( HDC hdc, int xOrg, int yOrg, LPPOINT lppt )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_GDI, GDI_SETBRUSHORG, 4 );
    cs.arg0 = (DWORD)hdc;
    return (DWORD)CALL_SERVER( &cs, xOrg, yOrg, lppt );
#else

	PGDI_SETBRUSHORG pSetBrushOrg;// = (PGDI_SETBRUSHORG)lpGDIAPI[GDI_SETBRUSHORG];

	BOOL  bRetv = FALSE;
	CALLSTACK cs;

	if( API_Enter( API_GDI, GDI_SETBRUSHORG, &pSetBrushOrg, &cs ) )
	{
		lppt = MapProcessPtr( lppt, (LPPROCESS)cs.lpvData );

		bRetv = pSetBrushOrg( hdc, xOrg, yOrg, lppt );
		API_Leave(  );
	}
	return bRetv;
#endif
}

typedef int ( WINAPI * PGDI_SETMAPMODE )( HDC hdc, int mode );
int WINAPI Gdi_SetMapMode( HDC hdc, int mode )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_GDI, GDI_SETMAPMODE, 2 );
    cs.arg0 = (DWORD)hdc;
    return (DWORD)CALL_SERVER( &cs, mode );
#else

	PGDI_SETMAPMODE pSetMapMode;// = (PGDI_SETMAPMODE)lpGDIAPI[GDI_SETMAPMODE];

	int   retv = 0;
	CALLSTACK cs;

	if( API_Enter( API_GDI, GDI_SETMAPMODE, &pSetMapMode, &cs ) )
	{
		retv = pSetMapMode( hdc, mode );
		API_Leave(  );
	}
	return retv;
#endif
}

typedef COLORREF ( WINAPI * PGDI_SETPIXEL )( HDC hdc, int x, int y, COLORREF color );
COLORREF WINAPI Gdi_SetPixel( HDC hdc, int x, int y, COLORREF color )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_GDI, GDI_SETPIXEL, 4 );
    cs.arg0 = (DWORD)hdc;
    return (DWORD)CALL_SERVER( &cs, x, y, color );
#else

	PGDI_SETPIXEL pSetPixel;// = (PGDI_SETPIXEL)lpGDIAPI[GDI_SETPIXEL];

	COLORREF   retv = CLR_INVALID;
	CALLSTACK cs;

	if( API_Enter( API_GDI, GDI_SETPIXEL, &pSetPixel, &cs ) )
	{
		retv = pSetPixel( hdc, x, y, color );
		API_Leave(  );
	}
	return retv;
#endif
}

typedef int ( WINAPI * PGDI_SETROP2 )( HDC hdc , int fMode );
int WINAPI Gdi_SetROP2( HDC hdc , int fMode )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_GDI, GDI_SETROP2, 2 );
    cs.arg0 = (DWORD)hdc;
    return (DWORD)CALL_SERVER( &cs, fMode );
#else

	PGDI_SETROP2 pSetROP2;// = (PGDI_SETROP2)lpGDIAPI[GDI_SETROP2];

	int   retv = 0;
	CALLSTACK cs;

	if( API_Enter( API_GDI, GDI_SETROP2, &pSetROP2, &cs ) )
	{
		retv = pSetROP2( hdc, fMode );
		API_Leave(  );
	}
	return retv;
#endif
}

typedef COLORREF ( WINAPI * PGDI_SETTEXTCOLOR )( HDC hdc, COLORREF color );
COLORREF WINAPI Gdi_SetTextColor( HDC hdc, COLORREF color )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_GDI, GDI_SETTEXTCOLOR, 2 );
    cs.arg0 = (DWORD)hdc;
    return (DWORD)CALL_SERVER( &cs, color );
#else

	PGDI_SETTEXTCOLOR pSetTextColor;// = (PGDI_SETTEXTCOLOR)lpGDIAPI[GDI_SETTEXTCOLOR];

	COLORREF   retv = CLR_INVALID;
	CALLSTACK cs;

	if( API_Enter( API_GDI, GDI_SETTEXTCOLOR, &pSetTextColor, &cs ) )
	{
		retv = pSetTextColor( hdc, color );
		API_Leave(  );
	}
	return retv;
#endif
}

typedef UINT ( WINAPI * PGDI_SETTEXTALIGN )( HDC hdc, UINT uiAlignMode);
UINT WINAPI Gdi_SetTextAlign( HDC hdc, UINT uiAlignMode )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_GDI, GDI_SETTEXTALIGN, 2 );
    cs.arg0 = (DWORD)hdc;
    return (DWORD)CALL_SERVER( &cs, uiAlignMode );
#else

	PGDI_SETTEXTALIGN pfn;// = (PGDI_SETTEXTCOLOR)lpGDIAPI[GDI_SETTEXTCOLOR];

	UINT   retv = GDI_ERROR;
	CALLSTACK cs;

	if( API_Enter( API_GDI, GDI_SETTEXTALIGN, &pfn, &cs ) )
	{
		retv = pfn( hdc, uiAlignMode );
		API_Leave(  );
	}
	return retv;
#endif
}


typedef BOOL ( WINAPI * PGDI_SETVIEWPORTORG )( HDC hdc, int xOrg, int yOrg, LPPOINT lppt );
BOOL WINAPI Gdi_SetViewportOrg( HDC hdc, int xOrg, int yOrg, LPPOINT lppt )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_GDI, GDI_SETVIEWPORTORG, 4 );
    cs.arg0 = (DWORD)hdc;
    return (DWORD)CALL_SERVER( &cs, xOrg, yOrg, lppt );
#else

	PGDI_SETVIEWPORTORG pSetViewportOrg;// = (PGDI_SETVIEWPORTORG)lpGDIAPI[GDI_SETVIEWPORTORG];

	BOOL   retv = FALSE;
	CALLSTACK cs;

	if( API_Enter( API_GDI, GDI_SETVIEWPORTORG, &pSetViewportOrg, &cs ) )
	{
		lppt = MapProcessPtr( lppt, (LPPROCESS)cs.lpvData );

		retv = pSetViewportOrg( hdc, xOrg, yOrg, lppt );
		API_Leave(  );
	}
	return retv;
#endif
}

typedef BOOL ( WINAPI * PGDI_SETWINDOWORG )( HDC hdc, int xOrg, int yOrg, LPPOINT lppt );
BOOL WINAPI Gdi_SetWindowOrg( HDC hdc, int xOrg, int yOrg, LPPOINT lppt )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_GDI, GDI_SETWINDOWORG, 4 );
    cs.arg0 = (DWORD)hdc;
    return (DWORD)CALL_SERVER( &cs, xOrg, yOrg, lppt );
#else

	PGDI_SETWINDOWORG pSetWindowOrg;// = (PGDI_SETWINDOWORG)lpGDIAPI[GDI_SETWINDOWORG];

	BOOL   retv = FALSE;
	CALLSTACK cs;

	if( API_Enter( API_GDI, GDI_SETWINDOWORG, &pSetWindowOrg, &cs ) )
	{
		lppt = MapProcessPtr( lppt, (LPPROCESS)cs.lpvData );

		retv = pSetWindowOrg( hdc, xOrg, yOrg, lppt );
		API_Leave(  );
	}
	return retv;
#endif
}

typedef BOOL ( WINAPI * PGDI_TEXTOUT )( HDC hdc, int x, int y, LPCSTR lpcstr, int count );
BOOL WINAPI Gdi_TextOut( HDC hdc, int x, int y, LPCSTR lpcstr, int count )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_GDI, GDI_TEXTOUT, 4 );
    cs.arg0 = (DWORD)hdc;
    return (DWORD)CALL_SERVER( &cs, x, y, lpcstr, count );
#else

	PGDI_TEXTOUT pTextOut;// = (PGDI_TEXTOUT)lpGDIAPI[GDI_TEXTOUT];

	BOOL   retv = FALSE;
	CALLSTACK cs;

	if( API_Enter( API_GDI, GDI_TEXTOUT, &pTextOut, &cs ) )
	{
		lpcstr = MapProcessPtr( lpcstr, (LPPROCESS)cs.lpvData );

		retv = pTextOut( hdc, x, y, lpcstr, count );
		API_Leave(  );
	}
	return retv;
#endif
}

typedef HPEN ( WINAPI * PGDI_CREATEPENINDIRECT )( const LOGPEN * pLogPen );
HPEN WINAPI Gdi_CreatePenIndirect( const LOGPEN * pLogPen )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_GDI, GDI_CREATEPENINDIRECT, 1 );
    cs.arg0 = (DWORD)pLogPen ;
    return (HPEN)CALL_SERVER( &cs );
#else

	PGDI_CREATEPENINDIRECT pCreatePenIndirect;// = (PGDI_CREATEPENINDIRECT)lpGDIAPI[GDI_CREATEPENINDIRECT];

	HPEN   retv = NULL;
	CALLSTACK cs;

	if( API_Enter( API_GDI, GDI_CREATEPENINDIRECT, &pCreatePenIndirect, &cs ) )
	{
		pLogPen = MapProcessPtr( pLogPen, (LPPROCESS)cs.lpvData );

		retv = pCreatePenIndirect( pLogPen );
		API_Leave(  );
	}
	return retv;
#endif	
}

typedef HPEN ( WINAPI * PGDI_CREATEPEN )( int fnPenStyle, int nWidth, COLORREF crColor );
HPEN WINAPI Gdi_CreatePen( int fnPenStyle, int nWidth, COLORREF crColor )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_GDI, GDI_CREATEPEN, 3 );
    cs.arg0 = (DWORD)fnPenStyle;
    return (HPEN)CALL_SERVER( &cs, nWidth, crColor );
#else

	PGDI_CREATEPEN pCreatePen;// = (PGDI_CREATEPEN)lpGDIAPI[GDI_CREATEPEN];

	HPEN   retv = NULL;
	CALLSTACK cs;

	if( API_Enter( API_GDI, GDI_CREATEPEN, &pCreatePen, &cs ) )
	{
		retv = pCreatePen( fnPenStyle, nWidth, crColor );
		API_Leave(  );
	}
	return retv;
#endif
}

typedef HBRUSH ( WINAPI * PGDI_CREATEBRUSHINDIRECT )(const LOGBRUSH*);
HBRUSH WINAPI Gdi_CreateBrushIndirect( const LOGBRUSH* pBrush )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_GDI, GDI_CREATEBRUSHINDIRECT, 1 );
    cs.arg0 = (DWORD)pBrush ;
    return (HBRUSH)CALL_SERVER( &cs );
#else

	PGDI_CREATEBRUSHINDIRECT pCreateBrushIndirect;// = (PGDI_CREATEBRUSHINDIRECT)lpGDIAPI[GDI_CREATEBRUSHINDIRECT];

	HBRUSH retv = NULL;
	CALLSTACK cs;

	if( API_Enter( API_GDI, GDI_CREATEBRUSHINDIRECT, &pCreateBrushIndirect, &cs ) )
	{
		pBrush = MapProcessPtr( pBrush, (LPPROCESS)cs.lpvData );

		retv = pCreateBrushIndirect( pBrush );
		API_Leave(  );
	}
	return retv;
#endif
}

typedef HBRUSH ( WINAPI * PGDI_CREATEHATCHBRUSH )( int style, COLORREF color );
HBRUSH WINAPI Gdi_CreateHatchBrush( int style, COLORREF color )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_GDI, GDI_CREATEHATCHBRUSH, 2 );
    cs.arg0 = (DWORD)style;
    return (HBRUSH)CALL_SERVER( &cs, color );
#else

	PGDI_CREATEHATCHBRUSH pCreateHatchBrush;// = (PGDI_CREATEHATCHBRUSH)lpGDIAPI[GDI_CREATEHATCHBRUSH];

	HBRUSH retv = NULL;
	CALLSTACK cs;

	if( API_Enter( API_GDI, GDI_CREATEHATCHBRUSH, &pCreateHatchBrush, &cs ) )
	{
		retv = pCreateHatchBrush( style, color );
		API_Leave(  );
	}
	return retv;
#endif
}

typedef HBRUSH ( WINAPI * PGDI_CREATESOLIDBRUSH )( COLORREF );
HBRUSH WINAPI Gdi_CreateSolidBrush( COLORREF color)
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_GDI, GDI_CREATESOLIDBRUSH, 1 );
    cs.arg0 = (DWORD)color ;
    return (HBRUSH)CALL_SERVER( &cs );
#else

	PGDI_CREATESOLIDBRUSH pCreateSolidBrush;// = (PGDI_CREATESOLIDBRUSH)lpGDIAPI[GDI_CREATESOLIDBRUSH];

	HBRUSH retv = NULL;
	CALLSTACK cs;

	if( API_Enter( API_GDI, GDI_CREATESOLIDBRUSH, &pCreateSolidBrush, &cs ) )
	{
		retv = pCreateSolidBrush( color );
		API_Leave(  );
	}
	return retv;
#endif
}

typedef HBITMAP ( WINAPI * PGDI_CREATEBITMAP )(int nWidth, int nHeight,  UINT nPlanes, UINT nBitsPerPel, const VOID * lpcBits);
HBITMAP WINAPI Gdi_CreateBitmap(int nWidth, 
								int nHeight,
								UINT nPlanes,
								UINT nBitsPerPel,
								const VOID * lpcBits)
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_GDI, GDI_CREATEBITMAP, 5 );
    cs.arg0 = (DWORD)nWidth;
    return (HBITMAP)CALL_SERVER( &cs, nHeight, nPlanes, nBitsPerPel, lpcBits );
#else

	PGDI_CREATEBITMAP pCreateBitmap;// = (PGDI_CREATEBITMAP)lpGDIAPI[GDI_CREATEBITMAP];

	HBITMAP retv = NULL;
	CALLSTACK cs;

	if( API_Enter( API_GDI, GDI_CREATEBITMAP, &pCreateBitmap, &cs ) )
	{
		lpcBits = MapProcessPtr( lpcBits, (LPPROCESS)cs.lpvData );

		retv = pCreateBitmap( nWidth, nHeight, nPlanes, nBitsPerPel, lpcBits );
		API_Leave(  );
	}
	return retv;
#endif
}

typedef HBITMAP ( WINAPI * PGDI_CREATECOMPATIBLEBITMAP )( HDC hdc, int nWidth, int nHeight );
HBITMAP WINAPI Gdi_CreateCompatibleBitmap( HDC hdc, int nWidth, int nHeight )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_GDI, GDI_CREATECOMPATIBLEBITMAP, 3 );
    cs.arg0 = (DWORD)hdc;
    return (HBITMAP)CALL_SERVER( &cs, nWidth, nHeight );
#else

	PGDI_CREATECOMPATIBLEBITMAP pCreateCompatibleBitmap;// = (PGDI_CREATECOMPATIBLEBITMAP)lpGDIAPI[GDI_CREATECOMPATIBLEBITMAP];

	HBITMAP retv = NULL;
	CALLSTACK cs;

	if( API_Enter( API_GDI, GDI_CREATECOMPATIBLEBITMAP, &pCreateCompatibleBitmap, &cs ) )
	{
		retv = pCreateCompatibleBitmap( hdc, nWidth, nHeight );
		API_Leave(  );
	}
	return retv;
#endif
}

typedef HBITMAP ( WINAPI * PGDI_CREATEBITMAPINDIRECT )( const BITMAP * pBitmap );
HBITMAP WINAPI Gdi_CreateBitmapIndirect( const BITMAP * pBitmap )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_GDI, GDI_CREATEBITMAPINDIRECT, 1 );
    cs.arg0 = (DWORD)pBitmap ;
    return (HBITMAP)CALL_SERVER( &cs );
#else

	PGDI_CREATEBITMAPINDIRECT pCreateBitmapIndirect;// = (PGDI_CREATEBITMAPINDIRECT)lpGDIAPI[GDI_CREATEBITMAPINDIRECT];

	HBITMAP retv = NULL;
	CALLSTACK cs;

	if( API_Enter( API_GDI, GDI_CREATEBITMAPINDIRECT, &pCreateBitmapIndirect, &cs ) )
	{
		pBitmap = MapProcessPtr( pBitmap, (LPPROCESS)cs.lpvData );

		retv = pCreateBitmapIndirect( pBitmap );
		API_Leave(  );
	}
	return retv;
#endif
}

typedef HDC ( WINAPI * PGDI_CREATECOMPATIBLEDC )( HDC hdc );
HDC WINAPI Gdi_CreateCompatibleDC( HDC hdc )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_GDI, GDI_CREATECOMPATIBLEDC, 1 );
    cs.arg0 = (DWORD)hdc ;
    return (HDC)CALL_SERVER( &cs );
#else

	PGDI_CREATECOMPATIBLEDC pCreateCompatibleDC;// = (PGDI_CREATECOMPATIBLEDC)lpGDIAPI[GDI_CREATECOMPATIBLEDC];

	HDC retv = NULL;
	CALLSTACK cs;

	if( API_Enter( API_GDI, GDI_CREATECOMPATIBLEDC, &pCreateCompatibleDC, &cs ) )
	{
		retv = pCreateCompatibleDC( hdc );
		API_Leave(  );
	}
	return retv;
#endif
}
12345

gdilib.c - 源码说明

本页面展示了「深圳市微逻辑电子有限公司 巨果&#8226 Kingmos&reg 系统核心」中的 gdilib.c 源码文件，采用 C语言 编程语言编写，共 2,460 行代码。您可以在线阅读完整代码内容，也可以返回资源详情页下载完整源码包进行本地学习和开发。

虫虫下载站收录了大量与Kingmos相关的技术资源，包括源代码、技术文档、电路图等，是电子工程师和嵌入式开发者的专业学习平台。

⌨️ 快捷键说明

复制代码Ctrl + C
搜索代码Ctrl + F
全屏模式F11
增大字号Ctrl + =
减小字号Ctrl + -
显示快捷键?