winlib.c

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

	{
		bRetv = pReleaseCapture();
		API_Leave(  );
	}
	return bRetv;
#endif
}

typedef HWND ( WINAPI * PWND_GETCAPTURE )( void );
HWND WINAPI Wnd_GetCapture(void)
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_WND, WND_GETCAPTURE, 0 );
    cs.arg0 = 0;
    return (HWND)CALL_SERVER( &cs );
#else

	PWND_GETCAPTURE pGetCapture;// = (PWND_GETCAPTURE)lpWindowAPI[WND_GETCAPTURE];

	HWND  hWndRetv = NULL;
	CALLSTACK cs;

	if( API_Enter( API_WND, WND_GETCAPTURE, &pGetCapture, &cs ) )
	{
		hWndRetv = pGetCapture();
		API_Leave(  );
	}
	return hWndRetv;
#endif
}

typedef HDC ( WINAPI * PWND_BEGINPAINT )( HWND, LPPAINTSTRUCT );
HDC WINAPI Wnd_BeginPaint( HWND hWnd, LPPAINTSTRUCT lpps )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_WND, WND_BEGINPAINT, 2 );
    cs.arg0 = (DWORD)hWnd;
    return (HDC)CALL_SERVER( &cs, lpps );
#else

	PWND_BEGINPAINT pBeginPaint;// = (PWND_BEGINPAINT)lpWindowAPI[WND_BEGINPAINT];

	HDC  hdcRetv = NULL;
	CALLSTACK cs;

	if( API_Enter( API_WND, WND_BEGINPAINT, &pBeginPaint, &cs ) )
	{
		lpps = MapProcessPtr( lpps, (LPPROCESS)cs.lpvData );

		hdcRetv = pBeginPaint( hWnd, lpps );
		API_Leave(  );
	}
	return hdcRetv;
#endif
}

typedef BOOL ( WINAPI * PWND_ENDPAINT )( HWND, const PAINTSTRUCT * );
BOOL WINAPI Wnd_EndPaint( HWND hWnd, const PAINTSTRUCT * lpps )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_WND, WND_ENDPAINT, 2 );
    cs.arg0 = (DWORD)hWnd;
    return (DWORD)CALL_SERVER( &cs, lpps );
#else

	PWND_ENDPAINT pEndPaint;// = (PWND_ENDPAINT)lpWindowAPI[WND_ENDPAINT];

	BOOL  bRetv = FALSE;
	CALLSTACK cs;

	if( API_Enter( API_WND, WND_ENDPAINT, &pEndPaint, &cs ) )
	{
		lpps = MapProcessPtr( lpps, (LPPROCESS)cs.lpvData );

		bRetv = pEndPaint( hWnd, lpps );
		API_Leave(  );
	}
	return bRetv;
#endif
}

typedef HDC ( WINAPI * PWND_GETCLIENTDC )( HWND );
HDC WINAPI Wnd_GetClientDC( HWND hWnd )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_WND, WND_GETCLIENTDC, 1 );
    cs.arg0 = (DWORD)hWnd ;
    return (HDC)CALL_SERVER( &cs );
#else

	PWND_GETCLIENTDC pGetClientDC;// = (PWND_GETCLIENTDC)lpWindowAPI[WND_GETCLIENTDC];

	HDC  hdcRetv = NULL;
	CALLSTACK cs;

	if( API_Enter( API_WND, WND_GETCLIENTDC, &pGetClientDC, &cs ) )
	{
		hdcRetv = pGetClientDC( hWnd );
		API_Leave(  );
	}
	return hdcRetv;
#endif
}

typedef int ( WINAPI * PWND_RELEASEDC )( HWND, HDC );
int WINAPI Wnd_ReleaseDC( HWND hWnd, HDC hdc )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_WND, WND_RELEASEDC, 2 );
    cs.arg0 = (DWORD)hWnd;
    return (DWORD)CALL_SERVER( &cs, hdc );
#else

	PWND_RELEASEDC pReleaseDC;// = (PWND_RELEASEDC)lpWindowAPI[WND_RELEASEDC];

	int  iRetv = 0;
	CALLSTACK cs;

	if( API_Enter( API_WND, WND_RELEASEDC, &pReleaseDC, &cs ) )
	{
		iRetv = pReleaseDC( hWnd, hdc );
		API_Leave(  );
	}
	return iRetv;
#endif
}

typedef HDC ( WINAPI * PWND_GETWINDOWDC )( HWND );
HDC WINAPI Wnd_GetWindowDC( HWND hWnd )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_WND, WND_GETWINDOWDC, 1 );
    cs.arg0 = (DWORD)hWnd ;
    return (HDC)CALL_SERVER( &cs );
#else

	PWND_GETWINDOWDC pGetWindowDC;// = (PWND_GETWINDOWDC)lpWindowAPI[WND_GETWINDOWDC];

	HDC  hdcRetv = NULL;
	CALLSTACK cs;

	if( API_Enter( API_WND, WND_GETWINDOWDC, &pGetWindowDC, &cs ) )
	{
		hdcRetv = pGetWindowDC( hWnd );
		API_Leave(  );
	}
	return hdcRetv;
#endif
}

/*typedef BOOL ( WINAPI * PWND_DRAWCAPTION )( HWND, HDC, LPCRECT, UINT );
BOOL WINAPI Wnd_DrawCaption( HWND hWnd, HDC hdc, LPCRECT lprc, UINT uFlags )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_WND, WND_DRAWCAPTION, 4 );
    cs.arg0 = (DWORD)hWnd;
    return (DWORD)CALL_SERVER( &cs, hdc, lprc, uFlags );
#else

	PWND_DRAWCAPTION pDrawCaption;// = (PWND_DRAWCAPTION)lpWindowAPI[WND_DRAWCAPTION];

	BOOL  bRetv = FALSE;
	CALLSTACK cs;

	if( API_Enter( API_WND, WND_DRAWCAPTION, &pDrawCaption, &cs ) )
	{
		lprc = MapProcessPtr( lprc, (LPPROCESS)cs.lpvData );

		bRetv = pDrawCaption( hWnd, hdc, lprc, uFlags );
		API_Leave(  );
	}
	return bRetv;

#endif
}
*/

typedef int ( WINAPI * PWND_SCROLL )( HWND, int, int, LPCRECT, LPCRECT, HRGN, LPRECT, UINT );
int WINAPI Wnd_Scroll(   
					HWND hWnd,
                    int dx, 
					int dy,
                    LPCRECT lpcScrollRect, 
					LPCRECT lpcClipRect,
                    HRGN hrgnUpdate,
                    LPRECT lpUpdateRect,
                    UINT uFlags )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_WND, WND_SCROLL, 8 );
    cs.arg0 = (DWORD)hWnd;
    return (DWORD)CALL_SERVER( &cs, dx, dy, lpcScrollRect, lpcClipRect, hrgnUpdate, lpUpdateRect, uFlags );
#else

	PWND_SCROLL pScroll;// = (PWND_SCROLL)lpWindowAPI[WND_SCROLL];

	int  iRetv = 0;
	CALLSTACK cs;

	if( API_Enter( API_WND, WND_SCROLL, &pScroll, &cs ) )
	{
		lpcScrollRect = MapProcessPtr( lpcScrollRect, (LPPROCESS)cs.lpvData );
		lpcClipRect = MapProcessPtr( lpcClipRect, (LPPROCESS)cs.lpvData );
		lpUpdateRect = MapProcessPtr( lpUpdateRect, (LPPROCESS)cs.lpvData );

		iRetv = pScroll( hWnd, dx, dy, lpcScrollRect, lpcClipRect, hrgnUpdate, lpUpdateRect, uFlags );
		API_Leave(  );
	}
	return iRetv;
#endif
}

typedef HDC ( WINAPI * PWND_GETDCEX )( HWND, HRGN hrgnClip, DWORD );
HDC WINAPI Wnd_GetDCEx( HWND hWnd, HRGN hrgnClip, DWORD dwFlags )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_WND, WND_GETDCEX, 3 );
    cs.arg0 = (DWORD)hWnd;
    return (HDC)CALL_SERVER( &cs, hrgnClip, dwFlags );
#else

	PWND_GETDCEX pGetDCEx;// = (PWND_GETDCEX)lpWindowAPI[WND_GETDCEX];

	HDC  hdcRetv = NULL;
	CALLSTACK cs;

	if( API_Enter( API_WND, WND_GETDCEX, &pGetDCEx, &cs ) )
	{
		hdcRetv = pGetDCEx( hWnd, hrgnClip, dwFlags );
		API_Leave(  );
	}
	return hdcRetv;
#endif
}

typedef BOOL ( WINAPI * PWND_INVALIDATERECT )( HWND, LPCRECT, BOOL );
BOOL WINAPI Wnd_InvalidateRect( HWND hWnd, LPCRECT lprc, BOOL bErase )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_WND, WND_INVALIDATERECT, 3 );
    cs.arg0 = (DWORD)hWnd;
    return (DWORD)CALL_SERVER( &cs, lprc, bErase );
#else

	PWND_INVALIDATERECT pInvalidateRect;// = (PWND_INVALIDATERECT)lpWindowAPI[WND_INVALIDATERECT];

	BOOL  bRetv = FALSE;
	CALLSTACK cs;

	if( API_Enter( API_WND, WND_INVALIDATERECT, &pInvalidateRect, &cs ) )
	{
		lprc = MapProcessPtr( lprc, (LPPROCESS)cs.lpvData );

		bRetv = pInvalidateRect( hWnd, lprc, bErase );
		API_Leave(  );
	}
	return bRetv;
#endif
}

typedef BOOL ( WINAPI * PWND_INVALIDATERGN )( HWND, HRGN, BOOL );
BOOL WINAPI Wnd_InvalidateRgn(HWND hWnd, HRGN hrgn, BOOL bErase)
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_WND, WND_INVALIDATERGN, 3 );
    cs.arg0 = (DWORD)hWnd;
    return (DWORD)CALL_SERVER( &cs, hrgn, bErase );
#else

	PWND_INVALIDATERGN pInvalidateRgn;// = (PWND_INVALIDATERGN)lpWindowAPI[WND_INVALIDATERGN];

	BOOL  bRetv = FALSE;
	CALLSTACK cs;

	if( API_Enter( API_WND, WND_INVALIDATERGN, &pInvalidateRgn, &cs ) )
	{
		bRetv = pInvalidateRgn( hWnd, hrgn, bErase );
		API_Leave(  );
	}
	return bRetv;
#endif
}

typedef BOOL ( WINAPI * PWND_VALIDATERECT )( HWND, LPCRECT );
BOOL WINAPI Wnd_ValidateRect( HWND hWnd, LPCRECT lpcrc )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_WND, WND_VALIDATERECT, 2 );
    cs.arg0 = (DWORD)hWnd;
    return (DWORD)CALL_SERVER( &cs, lpcrc );
#else

	PWND_VALIDATERECT pValidateRect;// = (PWND_VALIDATERECT)lpWindowAPI[WND_VALIDATERECT];

	BOOL  bRetv = FALSE;
	CALLSTACK cs;

	if( API_Enter( API_WND, WND_VALIDATERECT, &pValidateRect, &cs ) )
	{
		lpcrc = MapProcessPtr( lpcrc, (LPPROCESS)cs.lpvData );

		bRetv = pValidateRect( hWnd, lpcrc );
		API_Leave(  );
	}
	return bRetv;
#endif
}

typedef BOOL ( WINAPI * PWND_VALIDATERGN )( HWND, HRGN );
BOOL WINAPI Wnd_ValidateRgn( HWND hWnd, HRGN hrgn )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_WND, WND_VALIDATERGN, 2 );
    cs.arg0 = (DWORD)hWnd;
    return (DWORD)CALL_SERVER( &cs, hrgn );
#else

	PWND_VALIDATERGN pValidateRgn;// = (PWND_VALIDATERGN)lpWindowAPI[WND_VALIDATERGN];

	BOOL  bRetv = FALSE;
	CALLSTACK cs;

	if( API_Enter( API_WND, WND_VALIDATERGN, &pValidateRgn, &cs ) )
	{
		bRetv = pValidateRgn( hWnd, hrgn );
		API_Leave(  );
	}
	return bRetv;
#endif
}

typedef DWORD ( WINAPI * PWND_GETTHREADPROCESSID )( HWND, DWORD * );
DWORD WINAPI Wnd_GetThreadProcessId( HWND hWnd, DWORD * lpProcessID )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_WND, WND_GETTHREADPROCESSID, 2 );
    cs.arg0 = (DWORD)hWnd;
    return (DWORD)CALL_SERVER( &cs, lpProcessID );
#else

	PWND_GETTHREADPROCESSID pGetThreadProcessId;// = (PWND_GETTHREADPROCESSID)lpWindowAPI[WND_GETTHREADPROCESSID];

	DWORD dwRetv = 0;
	CALLSTACK cs;

	if( API_Enter( API_WND, WND_GETTHREADPROCESSID, &pGetThreadProcessId, &cs ) )
	{
		lpProcessID = MapProcessPtr( lpProcessID, (LPPROCESS)cs.lpvData );

		dwRetv = pGetThreadProcessId( hWnd, lpProcessID );
		API_Leave(  );
	}
	return dwRetv;
#endif
}

/*
typedef BOOL ( WINAPI * PWND_ENABLESCROLLBAR )( HWND, UINT, UINT );
BOOL WINAPI Wnd_EnableScrollBar( HWND hWnd, UINT uFlags, UINT uArrows )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_WND, WND_ENABLESCROLLBAR, 3 );
    cs.arg0 = (DWORD)hWnd;
    return (DWORD)CALL_SERVER( &cs, uFlags, uArrows );
#else

	PWND_ENABLESCROLLBAR pEnableScrollBar;// = (PWND_ENABLESCROLLBAR)lpWindowAPI[WND_ENABLESCROLLBAR];

	BOOL  bRetv = FALSE;
	CALLSTACK cs;

	if( API_Enter( API_WND, WND_ENABLESCROLLBAR, &pEnableScrollBar, &cs ) )
	{
		bRetv = pEnableScrollBar( hWnd, uFlags, uArrows );
		API_Leave(  );
	}
	return bRetv;
#endif
}
*/

/*

typedef int ( WINAPI * PWND_GETSCROLLINFO )( HWND, int, LPSCROLLINFO );
int WINAPI Wnd_GetScrollInfo( HWND hWnd, int fnBar, LPSCROLLINFO lpsi )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_WND, WND_GETSCROLLINFO, 3 );
    cs.arg0 = (DWORD)hWnd;
    return (DWORD)CALL_SERVER( &cs, fnBar, lpsi );
#else

	PWND_GETSCROLLINFO pGetScrollInfo;// = (PWND_GETSCROLLINFO)lpWindowAPI[WND_GETSCROLLINFO];

	int  iRetv = FALSE;
	CALLSTACK cs;

	if( API_Enter( API_WND, WND_GETSCROLLINFO, &pGetScrollInfo, &cs ) )
	{
		lpsi = MapProcessPtr( lpsi, (LPPROCESS)cs.lpvData );

		iRetv = pGetScrollInfo( hWnd, fnBar, lpsi );
		API_Leave(  );
	}
	return iRetv;
#endif
}

typedef int ( WINAPI * PWND_SETSCROLLINFO )( HWND, int, LPCSCROLLINFO, BOOL );
int WINAPI Wnd_SetScrollInfo( HWND hWnd, int fnBar, LPCSCROLLINFO lpcsi, BOOL fRedraw )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_WND, WND_SETSCROLLINFO, 4 );
    cs.arg0 = (DWORD)hWnd;
    return (DWORD)CALL_SERVER( &cs, fnBar, lpcsi, fRedraw );
#else

	PWND_SETSCROLLINFO pSetScrollInfo;// = (PWND_SETSCROLLINFO)lpWindowAPI[WND_SETSCROLLINFO];

	int  iRetv = FALSE;
	CALLSTACK cs;

	if( API_Enter( API_WND, WND_SETSCROLLINFO, &pSetScrollInfo, &cs ) )
	{
		lpcsi = MapProcessPtr( lpcsi, (LPPROCESS)cs.lpvData );

		iRetv = pSetScrollInfo( hWnd, fnBar, lpcsi, fRedraw );
		API_Leave(  );
	}
	return iRetv;
#endif
}
*/

////////////////////////////////////
typedef BOOL ( WINAPI * PWND_CLEAR )( DWORD );
BOOL WINAPI Wnd_Clear( DWORD dwThreadID )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_WND, WND_CLEAR, 1 );
    cs.arg0 = (DWORD)dwThreadID ;
    return (DWORD)CALL_SERVER( &cs );
#else

	PWND_CLEAR pClear;
	BOOL  bRetv = FALSE;
	CALLSTACK cs;

	if( API_Enter( API_WND, WND_CLEAR, &pClear, &cs ) )
	{
		bRetv = pClear( dwThreadID );
		API_Leave(  );
	}
	return bRetv;
#endif
}
/////////////////////////////


typedef BOOL ( WINAPI * PWND_SHOWDESKTOP )( UINT uiFlag );
BOOL WINAPI Wnd_ShowDesktop( UINT uiFlag )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_WND, WND_SHOWDESKTOP, 1 );
    cs.arg0 = (DWORD)uiFlag ;
    return (DWORD)CALL_SERVER( &cs );
#else

	PWND_SHOWDESKTOP pfn;
	BOOL  bRetv = FALSE;
	CALLSTACK cs;

	if( API_Enter( API_WND, WND_SHOWDESKTOP, &pfn, &cs ) )
	{
		bRetv = pfn( uiFlag );
		API_Leave();
	}
	return bRetv;
#endif
}