imageobj.c

深圳市微逻辑电子有限公司 巨果&#8226 Kingmos&reg 系统核心

			//lpFont->lpDriver = (_LPFONTDRV)_lpSYSFontDrv;//(_LPFONTDRV)&_SYSFontDrv;
			//break;
		//case SYSTEM_FONT_SYMBOL:
			//lpFont->lpDriver = (_LPFONTDRV)_SymbolDrv;//(_LPFONTDRV)&_SYSFontDrv;
			//break;
#ifdef HAVE_16X16_CHS_FIXED
		case SYSTEM_FONT_CHINESE16X16:
			lpFont->lpDriver = (_LPFONTDRV)&_SYSFont16Drv;
			break;
#endif	//HAVE_16X16_CHS_FIXED
#ifdef HAVE_24X24_CHS_FIXED
		case SYSTEM_FONT_CHINESE24X24:
			lpFont->lpDriver = (_LPFONTDRV)&_SYSFont24Drv;
			break;
#endif	//HAVE_24X24_CHS_FIXED
#ifdef HAVE_16X16_SYMBOL_FIXED
		case SYSTEM_FONT_SYMBOL16X16:
			lpFont->lpDriver = (_LPFONTDRV)&_SymbolDrv;
			logFont.lfHeight = logFont.lfWeight = 16;
			lpLogfont = &logFont;
			break;
#endif	//HAVE_16X16_SYMBOL_FIXED
#ifdef HAVE_24X24_SYMBOL_FIXED
		case SYSTEM_FONT_SYMBOL24X24:
			lpFont->lpDriver = (_LPFONTDRV)&_SymbolDrv;
			logFont.lfHeight = logFont.lfWeight = 24;
			lpLogfont = &logFont;
			break;
#endif	//HAVE_24X24_SYMBOL_FIXED
#ifdef HAVE_8X16_PHONETIC_FIXED
		case SYSTEM_FONT_PHONETIC:
			lpFont->lpDriver = (_LPFONTDRV)&_PhoneticDrv;
			break;
#endif	//HAVE_8X16_PHONETIC_FIXED
#ifdef HAVE_8X8_ENG_FIXED
		case SYSTEM_FONT_ENGLISH8X8:
			lpFont->lpDriver = (_LPFONTDRV)&_ROM8x8Drv;
			break;
#endif	//HAVE_8X8_ENG_FIXED
#ifdef HAVE_8X6_ENG_FIXED
		case SYSTEM_FONT_ENGLISH8X6:
			lpFont->lpDriver = (_LPFONTDRV)&_ROM8x6Drv;
			break;
#endif	//HAVE_8X6_ENG_FIXED
		}
		lpFont->dwData = lpFont->lpDriver->lpInit();
		lpFont->handle = lpFont->lpDriver->lpCreateFont( lpFont->dwData, lpLogfont );
		return (HFONT)PTR_TO_HANDLE( lpFont );
	}
	return NULL;	
}

// **************************************************
// 声明：HBITMAP _CreateSysBitmap( 
//							int nWidth, 
//							int nHeight, 
//							UINT cBitsPerPel )
// 参数：
// 	IN nWidth - 位图宽度
//	IN nHeight - 位图高度
//	IN cBitsPerPel - 位图的点格式（每个点的bit数）
// 返回值：
//	假如成功，返回位图句柄；否则，返回NULL
// 功能描述：
//	创建系统位图对象
// 引用: 
//	
// ************************************************

HBITMAP _CreateSysBitmap( int nWidth, 
						  int nHeight, 
						  UINT cBitsPerPel )
{
	return _WinGdi_CreateBitmap( nWidth, nHeight, 1, cBitsPerPel, 0, NULL, NULL, OBJ_FREE_DISABLE, NULL, FALSE );
}

// **************************************************
// 声明：static BOOL _DeletePenObject(HGDIOBJ hgdi)
// 参数：
// 	IN hgdi - 图形对象
// 返回值：
//	假如成功，返回TRUE；否则，返回FALSE
// 功能描述：
//	删除笔对象
// 引用: 
//	
// ************************************************

static BOOL _DeletePenObject(HGDIOBJ hgdi)
{
	_LPPENDATA lpObj = _GetHPENPtr( hgdi );
	//有效并可以释放吗？
    if( lpObj && !(lpObj->obj.objType & OBJ_FREE_DISABLE) )
	{
		lpObj->obj.objType = OBJ_NULL;
		BlockHeap_Free( hgwmeBlockHeap, 0, lpObj, sizeof(_PENDATA) );
		//BLK_Free( 0, lpObj, sizeof(_PENDATA) );
		return TRUE;
	}
	return FALSE;
}

// **************************************************
// 声明：static BOOL _DeleteBrushObject(HGDIOBJ hgdi)
// 参数：
// 	IN hgdi - 图形对象
// 返回值：
//	假如成功，返回TRUE；否则，返回FALSE
// 功能描述：
//	删除刷子对象
// 引用: 
//	
// ************************************************

static BOOL _DeleteBrushObject(HGDIOBJ hgdi)
{
    _LPBRUSHDATA lpObj = _GetHBRUSHPtr( hgdi );
	//有效并可以释放吗？
    if( lpObj && !(lpObj->obj.objType & OBJ_FREE_DISABLE) )
	{
		lpObj->obj.objType = OBJ_NULL;
		BlockHeap_Free( hgwmeBlockHeap, 0, lpObj, sizeof(_BRUSHDATA) );//free( lpObj );
		//BLK_Free( 0, lpObj, sizeof(_BRUSHDATA) );//free( lpObj );
		return TRUE;
	}
	return FALSE;
}

// **************************************************
// 声明：static BOOL _DeleteBitmapObject(HGDIOBJ hgdi)
// 参数：
// 	IN hgdi - 图形对象
// 返回值：
//	假如成功，返回TRUE；否则，返回FALSE
// 功能描述：
//	删除位图对象
// 引用: 
//	
// ************************************************

static BOOL _DeleteBitmapObject(HGDIOBJ hgdi)
{
    _LPBITMAPDATA lpObj = _GetHBITMAPPtr( hgdi );
	//有效并可以释放吗？
    if( lpObj && !(lpObj->obj.objType & OBJ_FREE_DISABLE) )
	{	//是
		lpObj->obj.objType = OBJ_NULL;
		if( lpObj->bmFlags & 0x1 )
		{	//位图指针使用 Page_AllocMem 得到的
			Page_FreeMem( lpObj->bmBits, lpObj->bmWidthBytes * lpObj->bmHeight * lpObj->bmPlanes );
		}
		else
		{	//位图指针使用 BlockHeap_Alloc 得到的
			DWORD size = lpObj->bmWidthBytes * lpObj->bmHeight * lpObj->bmPlanes;

			BlockHeap_Free( hgwmeBlockHeap, 0, lpObj->bmBits, size );
			//BLK_Free( 0, lpObj->bmBits, size );
		}
		BlockHeap_FreeString( hgwmeBlockHeap, 0, lpObj );
		//BLK_FreeString( 0, lpObj );
		return TRUE;
	}
	return FALSE;
}

// **************************************************
// 声明：static BOOL _DeleteFontObject(HGDIOBJ hgdi)
// 参数：
// 	IN hgdi - 图形对象
// 返回值：
//	假如成功，返回TRUE；否则，返回FALSE
// 功能描述：
//	删除字体对象
// 引用: 
//	
// ************************************************

static BOOL _DeleteFontObject(HGDIOBJ hgdi)
{
    _LPFONT lpObj = _GetHFONTPtr( hgdi );
	//有效并可以释放吗？
	if( lpObj && !(lpObj->obj.objType & OBJ_FREE_DISABLE) )
	{	//是
		lpObj->obj.objType = OBJ_NULL;
		BlockHeap_Free( hgwmeBlockHeap, 0, lpObj, sizeof(_FONT) );//free( lpObj );
//		BLK_Free( 0, lpObj, sizeof(_FONT) );//free( lpObj );
		return TRUE;
	}
	return FALSE;
}

// **************************************************
// 声明：BOOL WINAPI WinGdi_DeleteObject( HGDIOBJ hgdiobj )
// 参数：
// 	IN hgdi - 图形对象
// 返回值：
//	假如成功，返回TRUE；否则，返回FALSE
// 功能描述：
//	删除图形对象
// 引用: 
//	系统API
// ************************************************

BOOL WINAPI WinGdi_DeleteObject( HGDIOBJ hgdiobj )
{
	extern BOOL _DeleteRgnObject( HRGN hrgn );
	BOOL bRetv = FALSE;
	LPVOID lpvObj;

	EnterCriticalSection( &csGdiObjList );

	lpvObj = (LPVOID)HANDLE_TO_PTR( hgdiobj );

    if( lpvObj )
	{
		DWORD dwType  = *( (DWORD*)lpvObj );
		//可以释放吗 ？
		if( !(dwType & OBJ_FREE_DISABLE) )
		{	//可以
			switch( (WORD)dwType )
			{
			case OBJ_REGION:			//区域对象
				ObjList_Remove( &_lpGdiObjList, lpvObj );//hgdi );
				bRetv = _DeleteRgnObject( hgdiobj );
				break;
			case OBJ_PEN:				//笔对象
				ObjList_Remove( &_lpGdiObjList, lpvObj );
				bRetv = _DeletePenObject( hgdiobj );
				break;
			case OBJ_BRUSH:				//刷子对象
				ObjList_Remove( &_lpGdiObjList, lpvObj );
				bRetv = _DeleteBrushObject( hgdiobj );
				break;
			case OBJ_BITMAP:			//位图对象
				if( --( ( (LPOBJLIST)lpvObj )->iRefCount ) == 0 )
				{
				    ObjList_Remove( &_lpGdiObjList, lpvObj );
				    bRetv = _DeleteBitmapObject( hgdiobj );
				}
				break;
			case OBJ_FONT:				//字体对象
				ObjList_Remove( &_lpGdiObjList, lpvObj );
				bRetv = _DeleteFontObject( hgdiobj );
				break;
			default:
				SetLastError( ERROR_INVALID_HANDLE );
				WARNMSG( 1, ( "invalid HGDIOBJ handle(0x%x) type when call DeleteObject.\r\n", hgdiobj ) );
				break;
			}
		}
		else
		    bRetv = TRUE; 
	}
	else
	{
		//ASSERT_NOTIFY( 0, "invalid HGDIOBJ handle when call DeleteObject\r\n" );
		WARNMSG( 1, ( "invalid HGDIOBJ handle(0x%x) when call DeleteObject.\r\n", hgdiobj ) );
	}

	LeaveCriticalSection( &csGdiObjList );

    return bRetv;
}

// **************************************************
// 声明：BOOL DeleteGdiObject( HANDLE hOwner )
// 参数：
// 	IN hOwner - 对象的拥有者
// 返回值：
//	假如成功，返回TRUE；否则，返回FALSE
// 功能描述：
//	释放该拥有者的所有图形对象
// 引用: 
//	
// ************************************************

BOOL DeleteGdiObject( HANDLE hOwner )
{
    EnterCriticalSection( &csGdiObjList );

	{
		LPOBJLIST lpObj = _lpGdiObjList;
		
		if( lpObj )
		{
			do{
				if( lpObj->ulOwner == (ULONG)hOwner )
				{
					LPOBJLIST lpTemp = lpObj->lpNext;
#ifdef __DEBUG
					WARNMSG( 1, ("not release gdi object:handle(0x%x),objtype(%d).\r\n", PTR_TO_HANDLE( (HGDIOBJ)lpObj ), lpObj->objType ) );
					
#endif
					WinGdi_DeleteObject( (HGDIOBJ)PTR_TO_HANDLE( (HGDIOBJ)lpObj ) );
					lpObj = lpTemp;
				}
				else
					lpObj = lpObj->lpNext;
			}while( lpObj );
		}
	}

	LeaveCriticalSection( &csGdiObjList );
	return TRUE;
}

// **************************************************
// 声明：_LPPENDATA _GetHPENPtr( HPEN hPen )
// 参数：
// 	IN hPen - 笔对象
// 返回值：
//	假如成功，返回对象指针；否则，返回NULL
// 功能描述：
//	检查对象句柄并得到对象指针
// 引用: 
//	
// ************************************************

_LPPENDATA _GetHPENPtr( HPEN hPen )
{
    _LPPENDATA lpPen = (_LPPENDATA)HANDLE_TO_PTR( hPen );

	if( lpPen && (WORD)GET_OBJ_TYPE(lpPen) == OBJ_PEN )
        return (_LPPENDATA)lpPen;
	WARNMSG( 1, ("error: Invalid HPEN handle=0x%x\r\n", hPen) );
	SetLastError( ERROR_INVALID_HANDLE );
    return NULL;
}

// **************************************************
// 声明：_LPBITMAPDATA _GetHBITMAPPtr( HBITMAP hBitmap )
// 参数：
// 	IN hBitmap - 位图对象
// 返回值：
//	假如成功，返回对象指针；否则，返回NULL
// 功能描述：
//	检查对象句柄并得到对象指针
// 引用: 
//	
// ************************************************

_LPBITMAPDATA _GetHBITMAPPtr( HBITMAP hBitmap )
{
	if( hBitmap == hbmpDisplayBitmap )
	{
		return (_LPBITMAPDATA)lpDisplayBitmap;
	}
	else
	{
		_LPBITMAPDATA lpbmp = (_LPBITMAPDATA)HANDLE_TO_PTR( hBitmap );
		
		if( lpbmp && (WORD)GET_OBJ_TYPE(lpbmp) == OBJ_BITMAP )
			return lpbmp;
		WARNMSG( 1, ("error: Invalid HBITMAP handle=0x%x\r\n", hBitmap) );
		SetLastError( ERROR_INVALID_HANDLE );
		return NULL;
	}	
}

// **************************************************
// 声明：_LPBRUSHDATA _GetHBRUSHPtr( HBRUSH hBrush )
// 参数：
// 	IN hBrush - 刷子对象
// 返回值：
//	假如成功，返回对象指针；否则，返回NULL
// 功能描述：
//	检查对象句柄并得到对象指针
// 引用: 
//	
// ************************************************

_LPBRUSHDATA _GetHBRUSHPtr( HBRUSH hBrush )
{
	_LPBRUSHDATA lpBrush = (_LPBRUSHDATA)HANDLE_TO_PTR( hBrush );

	if( lpBrush && (WORD)GET_OBJ_TYPE(lpBrush) == OBJ_BRUSH )
        return lpBrush;
	WARNMSG( 1, ("error: Invalid HBRUSH handle=0x%x\r\n", hBrush) );
	SetLastError( ERROR_INVALID_HANDLE );
    return NULL;
}