miscellaneousness.cpp

windows ce 下的3D桌面

//------------------------------------------------------------------------------
//
//	Copyright (C) 2003 MagicEyes Digital Co., Ltd All Rights Reserved
//	MagicEyes Digital Co. Proprietary & Confidential
//
//	MAGICEYES INFORMS THAT THIS CODE AND INFORMATION IS PROVIDED "AS IS" BASE AND 
//	WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
//	THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE.
//
//	Module     : 
//	File       : miscellaneousness.cpp
//	Description:
//	Author     : Gamza([e-mail])
//	Export     :
//	History    :
//		2008/02/27 Gamza	release build optimization problem is fixed
//		2008/01/10 Gamza	first implementation
//------------------------------------------------------------------------------
#include "miscellaneousness.h"

//------------------------------------------------------------------------------
//
//
//
//------------------------------------------------------------------------------
BOOL IsThisApplicationDuplicated  ( void )
{
	HANDLE hMutexOneInstance = ::CreateMutex(NULL, TRUE, L"MESLauncher_IsDuplicated" ); 
	BOOL bFound = FALSE;
	if(::GetLastError() == ERROR_ALREADY_EXISTS) bFound = TRUE; 
	if(hMutexOneInstance) ::ReleaseMutex(hMutexOneInstance); 
	return bFound;
}

BOOL GetAbsolutePath    ( const char*  pReleativePath, char* pBuffer , int BufferSize )
{
	static char APP_PATH[MAX_PATH];
	static int  APP_PATH_LEN  =0;
	int i;
	memset(pBuffer, BufferSize,BufferSize);
	if( 0 == APP_PATH_LEN )
	{
		TCHAR tcPath[MAX_PATH];
		GetModuleFileName( NULL, tcPath, MAX_PATH );
		for( i=_tcslen( tcPath )-1; i>=0; i-- )
		{
			if( (TCHAR)tcPath[i] == (TCHAR)('\\') ) 
			{
				break;
			}
			else
			{
				tcPath[i] = 0x00;
			}
		}
		wcstombs( APP_PATH, tcPath, sizeof(APP_PATH) );
		APP_PATH_LEN = strlen( APP_PATH );
	}
	int result = strlen(pReleativePath);
	if('\\' == pReleativePath[0])
	{
		if(result > BufferSize - 1)
		{
			result = BufferSize - 1;
		}
		memcpy(pBuffer, pReleativePath, result);
	}
	else if((result > 2) && ('.' == pReleativePath[0]) && 
		('.' == pReleativePath[1]) &&('\\' == pReleativePath[2]))
	{
		int nCount = 0;
		int nCountApp = APP_PATH_LEN - 1;
		char APP_PATH_TEMP[MAX_PATH];
		memcpy(APP_PATH_TEMP, APP_PATH, MAX_PATH);
		while(nCount < result)
		{
			if((nCountApp > 1) && ('.' == pReleativePath[nCount]) && 
				('.' == pReleativePath[nCount + 1]) &&('\\' == pReleativePath[nCount + 2]))
			{
				APP_PATH_TEMP[nCountApp] = 0;
				nCountApp--;
				while(nCountApp > 0)
				{
					if('\\' == APP_PATH_TEMP[nCountApp])
					{
						break;
					}
					else
					{
						APP_PATH_TEMP[nCountApp] = 0;
					}
					nCountApp--;
				}
				nCount += 3;
			}
			else
			{
				break;
			}
		}
		result = _snprintf( pBuffer, BufferSize-1, "%s%s", APP_PATH_TEMP, pReleativePath+nCount);
	}
	else
	{
		result = _snprintf( pBuffer, BufferSize-1, "%s%s", APP_PATH, pReleativePath );
	}
	return (result>=0);
}

BOOL GetAbsolutePathW   ( const TCHAR* pReleativePath, TCHAR* pBuffer, int /*BufferSize*/ )
{
	static TCHAR APP_PATH[MAX_PATH];
	static int  APP_PATH_LEN  =0;
	if( 0 == APP_PATH_LEN )
	{
		int i;
		GetModuleFileName( NULL, APP_PATH, MAX_PATH );
		for( i=_tcslen( APP_PATH )-1; i>=0; i-- )
		{
			if( (TCHAR)APP_PATH[i] == (TCHAR)('\\') ) 
			{
				APP_PATH[i] = 0x00;
				break;
			}
		}
		APP_PATH_LEN = wcslen( APP_PATH );
	}
	swprintf( pBuffer, L"%s\\%s", APP_PATH, pReleativePath );
	return TRUE;
}

//------------------------------------------------------------------------------
//
//	Delayed message
//
//------------------------------------------------------------------------------
namespace
{
	struct PostDelayedMessageParam
	{
		volatile UINT   m_Milisecond;
		volatile HWND   m_hWnd;
		volatile UINT   m_Msg;
		volatile WPARAM m_wParam;
		volatile LPARAM m_lParam;
	};
	DWORD WINAPI PostDelayedMessageProc( PostDelayedMessageParam* pparam )
	{
		PostDelayedMessageParam param = *pparam;
		pparam->m_Milisecond = 0; // parameter copy done
		Sleep( param.m_Milisecond );
		PostMessage( param.m_hWnd, param.m_Msg, param.m_wParam, param.m_lParam );		
		//ExitThread(0);
		return 0;
	}
};

HANDLE PostDelayedMessage   ( unsigned int DelayInMilisecond, HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam, BOOL CloseHandleFlag )
{
	if( DelayInMilisecond )
	{
		PostDelayedMessageParam param;
		param.m_Milisecond = DelayInMilisecond;
		param.m_hWnd       = hWnd;
		param.m_Msg        = Msg;
		param.m_wParam     = wParam;
		param.m_lParam     = lParam;
		HANDLE result = CreateThread( NULL, NULL, (LPTHREAD_START_ROUTINE)PostDelayedMessageProc, (void*)&param, CREATE_SUSPENDED, NULL );
		ResumeThread( result );
		if( result )
		{
			while( param.m_Milisecond ){} // wait for parameter copy done
			if( CloseHandleFlag )
			{
				CloseHandle(result);
				return 0;
			}
		}		
		return result;
	}
	else
	{
		PostMessage( hWnd, Msg, wParam, lParam );
		return 0;
	}
}

BOOL IsDelayedMessageAlive( HANDLE* phDelayedMessage )
{
	if( ! *phDelayedMessage ){ return FALSE; }
	DWORD exitcode;
	GetExitCodeThread( *phDelayedMessage, &exitcode );
	if( exitcode == STILL_ACTIVE ){ return TRUE; }
	CloseHandle( *phDelayedMessage );
	*phDelayedMessage = 0;
	return FALSE;
}

void   RemoveDelayedMessage ( HANDLE* phDelayedMessage )
{
	if( ! *phDelayedMessage ){ return; }
	if( ! IsDelayedMessageAlive(phDelayedMessage) ){ return; }
	TerminateThread(*phDelayedMessage,0);
	CloseHandle(*phDelayedMessage);
	*phDelayedMessage = 0;
}

namespace
{
	struct WatchProcessExitParam
	{
		volatile HANDLE m_hProcess;
		volatile HWND   m_hWnd;
		volatile UINT   m_Msg;
		volatile WPARAM m_wParam;
		volatile LPARAM m_lParam;
	};
	DWORD WINAPI WatchProcessExitProc( WatchProcessExitParam* pparam )
	{
		WatchProcessExitParam param = *pparam;
		pparam->m_hProcess = 0; // parameter copy done
		WaitForSingleObject( param.m_hProcess, INFINITE );
		PostMessage( param.m_hWnd, param.m_Msg, param.m_wParam, param.m_lParam );
		ExitThread(0);
		return 0;
	}
};

void WatchProcessExit( HANDLE hProcess, HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam )
{
	if( hProcess )
	{
		WatchProcessExitParam param;
		param.m_hProcess = hProcess;
		param.m_hWnd     = hWnd;
		param.m_Msg      = Msg;
		param.m_wParam   = wParam;
		param.m_lParam   = lParam;
		HANDLE result = CreateThread( NULL, NULL, (LPTHREAD_START_ROUTINE)WatchProcessExitProc, (void*)&param, CREATE_SUSPENDED, NULL );
		ResumeThread( result );
		if( result )
		{
			while( param.m_hProcess ){} // wait for parameter copy done
			CloseHandle(result);
		}
	}
	else
	{
		PostMessage( hWnd, Msg, wParam, lParam );
	}
}

//------------------------------------------------------------------------------
//
//	Registry
//
//------------------------------------------------------------------------------
UINT  RegistryReadInt (HKEY hKey, LPCTSTR lpPath, LPCTSTR lpValue, UINT nDefault)
{
	HKEY key;
	if( RegOpenKeyEx( hKey, lpPath, 0, KEY_ALL_ACCESS, &key ) != ERROR_SUCCESS )
	{
		DWORD dwState;
		if( RegCreateKeyEx( hKey, lpPath, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &key, &dwState ) != ERROR_SUCCESS )
		{
			RETAILMSG( 1, (L"RegistryReadInt: Cannt Read Registry Info [%s][%s]\n", lpPath, lpValue) );			
			return nDefault;
		}
	}
	UINT  Result;
	DWORD Size = sizeof(Result);
	if( RegQueryValueEx( key, lpValue, 0, NULL, (BYTE*)&Result, &Size ) != ERROR_SUCCESS )
	{
		RETAILMSG( 1, (L"RegistryReadInt: Create key [%s][%s][%d]\n", lpPath, lpValue, nDefault) );
		Result = nDefault;
		RegSetValueEx( key, lpValue, 0, REG_DWORD, (const BYTE*)&Result, Size );		
	}
	RegCloseKey( key );
	return Result;
}

void RegistryReadString(HKEY hKey, LPCTSTR lpPath, LPCTSTR lpValue, LPCTSTR lpDefault, LPTSTR lpRet, DWORD nSize)
{
	HKEY key;
	if( RegOpenKeyEx( hKey, lpPath, 0, KEY_ALL_ACCESS, &key ) != ERROR_SUCCESS )
	{
		DWORD dwState;		
		if( RegCreateKeyEx( hKey, lpPath, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &key, &dwState ) != ERROR_SUCCESS )
		{
			RETAILMSG( 1, (L"RegistryReadString: Cannt Read Registry Info [%s][%s]\n", lpPath, lpValue) );
			if( nSize > wcslen( lpDefault )+1 ){ nSize = wcslen( lpDefault )+1; }
			wcsncpy( lpRet, lpDefault, nSize );
			return;
		}
	}
	if( RegQueryValueEx( key, lpValue, 0, NULL, (BYTE*)lpRet, &nSize ) != ERROR_SUCCESS )
	{
		RETAILMSG( 1, (L"RegistryReadString: Create key [%s][%s][%s]\n", lpPath, lpValue, lpDefault) );
		if( nSize > wcslen( lpDefault )+1 ){ nSize = wcslen( lpDefault )+1; }
		RegSetValueEx( key, lpValue, 0, REG_SZ, (const BYTE*)lpDefault, nSize*sizeof(TCHAR) );
		wcsncpy( lpRet, lpDefault, nSize );
	}
	RegCloseKey( key );
}

void RegistryWriteInt   (HKEY hKey, LPCTSTR lpPath, LPCTSTR lpValue, UINT WriteValue)
{
	HKEY key;
	if( RegOpenKeyEx( hKey, lpPath, 0, KEY_ALL_ACCESS, &key ) != ERROR_SUCCESS )
	{
		DWORD dwState;
		if( RegCreateKeyEx( hKey, lpPath, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &key, &dwState ) != ERROR_SUCCESS )
		{
			RETAILMSG( 1, (L"RegistryWriteInt: Cannt Read Registry Info [%s][%s]\n", lpPath, lpValue) );			
			return;
		}
	}
	DWORD Size = sizeof(WriteValue);
	if( RegSetValueEx( key, lpValue, 0, REG_DWORD, (const BYTE*)&WriteValue, Size ) != ERROR_SUCCESS )
	{
		RETAILMSG( 1, (L"RegistryWriteInt: write error [%s][%s][%d]\n", lpPath, lpValue, WriteValue) );
	}
	RegCloseKey( key );
}

void RegistryWriteString(HKEY hKey, LPCTSTR lpPath, LPCTSTR lpValue, LPCTSTR WriteValue)
{
	HKEY key;
	if( RegOpenKeyEx( hKey, lpPath, 0, KEY_ALL_ACCESS, &key ) != ERROR_SUCCESS )
	{
		DWORD dwState;		
		if( RegCreateKeyEx( hKey, lpPath, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &key, &dwState ) != ERROR_SUCCESS )
		{
			RETAILMSG( 1, (L"RegistryReadString: Cannt Read Registry Info [%s][%s]\n", lpPath, lpValue) );
			return;
		}
	}
	DWORD Size = wcslen( WriteValue )+1;
	if( RegSetValueEx( key, lpValue, 0, REG_SZ, (const BYTE*)WriteValue, Size*sizeof(TCHAR) ) != ERROR_SUCCESS )
	{
		RETAILMSG( 1, (L"RegistryWriteString: write error [%s][%s][%s]\n", lpPath, lpValue, WriteValue) );
	}
	RegCloseKey( key );
}