gsappex.cpp

来自「网络泡泡被.net管理」· C++ 代码 · 共 371 行

// GsAppEx.cpp: implementation of the CGsAppEx class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "GSLib_Internal.h"

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
static LRESULT CALLBACK WndProc( HWND, UINT, WPARAM, LPARAM );

//-----------------------------------------------------------------------------
// Name: WndProc()
// Desc: Static msg handler which passes messages to the application class.
//-----------------------------------------------------------------------------
LRESULT CALLBACK WndProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
{
    if(g_pGsApp)
		g_pGsApp->MsgProc( uMsg, wParam, lParam );

    return DefWindowProc( hWnd, uMsg, wParam, lParam );
}


CGsAppEx::CGsAppEx()
{
	m_pEngine	= NULL;
}

CGsAppEx::~CGsAppEx()
{

}


BOOL CGsAppEx::CreateApp( HINSTANCE hInst, TCHAR* strCmdLine, WORD idrIcon, 
						  BOOL	bFullScreen,
						  DWORD dwWindowWidth, DWORD dwWindowHeight,
						  WORD idr_menu,
						  WORD idr_accel,
						  WORD idr_command_speed)
{

/*
	HANDLE mutex_handle = CreateMutex( NULL, TRUE, m_strWindowTitle );

	if ( mutex_handle == NULL ) 
		return E_FAIL;

	if (GetLastError() == ERROR_ALREADY_EXISTS)
	{
		ReleaseMutex (mutex_handle);
		mutex_handle = NULL;
		return E_FAIL;
	}
*/

	if(idr_accel!=0)
		idr_main_accel			= idr_accel;
	if(idr_menu!=0)
		idr_main_menu			= idr_menu;
	if(idr_command_speed!=0)
		idr_full_speed_mode		= idr_command_speed;

	D3DXInitialize();
	::GetModuleFileName(NULL, m_strAppPath, 255);
	TCHAR* sz = strrchr(m_strAppPath,'\\');
	strcpy(sz, "");

	if( FAILED( DxEnum_EnumerateDevices( m_fnConfirmDevice ) ) )
	{
		return false;
	}
	DxEnum_SelectDefaultDevice( &m_pDeviceInfo );

	m_pDeviceInfo->bWindowed	= !bFullScreen;

	if(!m_pDeviceInfo)
		return E_FAIL;

    // Register the window class
    WNDCLASS wndClass ;/*= { 0, WndProc, 0, 0, hInst,
                          LoadIcon( hInst, MAKEINTRESOURCE(idr_main_icon) ),
                          LoadCursor( NULL, IDC_ARROW ), 
                          (HBRUSH) (COLOR_WINDOW + 1),
                          NULL, _T("DxApp Window") };
						*/
    wndClass.lpszClassName	= _T("DxApp Window");
    wndClass.lpfnWndProc	= WndProc;
    wndClass.style			= CS_DBLCLKS | CS_VREDRAW | CS_HREDRAW;
    wndClass.hInstance		= hInst;
    wndClass.hIcon			= LoadIcon( hInst, MAKEINTRESOURCE(idrIcon) );
    wndClass.hCursor		= LoadCursor( NULL, IDC_ARROW );
    wndClass.hbrBackground	= (HBRUSH) (COLOR_WINDOW + 1);
    wndClass.lpszMenuName	= NULL;
    wndClass.cbClsExtra		= 0;
    wndClass.cbWndExtra		= 0;
	
    RegisterClass( &wndClass );

    // Calculate the proper size for the window given a client of 640x480
    DWORD dwFrameWidth    = GetSystemMetrics( SM_CXSIZEFRAME );
    DWORD dwFrameHeight   = GetSystemMetrics( SM_CYSIZEFRAME );
    DWORD dwMenuHeight    = GetSystemMetrics( SM_CYMENU );
    DWORD dwCaptionHeight = GetSystemMetrics( SM_CYCAPTION );
    DWORD dwWidth		  = dwWindowWidth  + dwFrameWidth * 2;
    DWORD dwHeight		  = dwWindowHeight + dwFrameHeight * 2 + 
                            dwMenuHeight + dwCaptionHeight;
	//m_dwWindowModeWidth	= dwWindowWidth;
	//m_dwWindowModeHeight = dwWindowHeight;
    // Create the render window
    m_hWnd = CreateWindow( _T("DxApp Window"), m_strWindowTitle,
                           WS_OVERLAPPEDWINDOW|WS_CLIPCHILDREN|WS_VISIBLE,
                           CW_USEDEFAULT, CW_USEDEFAULT, dwWidth, dwHeight, 0L,
                           LoadMenu( hInst, MAKEINTRESOURCE(idr_main_menu) ), 
                           hInst, 0L );
    UpdateWindow( m_hWnd );
	
		GRECT rc1, rc2;
		GetWindowRect( m_hWnd, &rc1 );
		MoveWindow(m_hWnd, rc1.left, rc1.top, dwWindowWidth, dwWindowHeight, true);
		GetWindowRect( m_hWnd, &rc1 );
		GetClientRect( m_hWnd, &rc2 );

		MoveWindow(m_hWnd, rc1.left, rc1.top, dwWindowWidth+rc1.width()-rc2.width(), dwWindowHeight+rc1.height()-rc2.height(), true);

    // Setup the app so it can support single-stepping
	//TIMER::reset();					// this reset can assure that app run with right time for five days 
    m_dwBaseTime = timeGetTime();//TIMER::time();
	m_dwStopTime = m_dwBaseTime;

	OnInitApp();

	//Createing popup menu
	if(m_popupMenu)
	{
		DestroyMenu(m_popupMenu);
	}
	m_popupMenu	= LoadMenu( 0, MAKEINTRESOURCE(idr_popup_menu) );

	m_hMainMenu	= GetMenu(m_hWnd);


	// The app is ready to go
	m_isReady = TRUE;

    return true;
}



LRESULT	CGsAppEx::MsgProc( UINT uMsg, WPARAM wParam, LPARAM lParam )
{
	TASK_LIST::iterator	it = m_task_list.begin();
	while(it!=m_task_list.end())
	{
		if((*it)->IsActive())
		{
			(*it)->MsgProc(uMsg, wParam, lParam);
		}
		it++;
	}
    switch( uMsg )
    {
        case WM_PAINT:
            break;
		case WM_MOVE:
			break;
		case WM_ACTIVATEAPP:
			if((BOOL)wParam)
			{
				if(!m_isActive)
				{
			        m_isActive = TRUE;
					if( m_isFrameMoving && !m_enableBackgroundActive )
					{
						m_dwBaseTime += timeGetTime() - m_dwStopTime;
						m_dwAppTime	= timeGetTime() - m_dwBaseTime;
						if(m_pEngine)
							m_pEngine->SetActive(TRUE);
					}
				}
			}
			else
			{
                m_isActive = FALSE;
				if( m_isFrameMoving && !m_enableBackgroundActive )
				{
					m_dwStopTime = timeGetTime();//TIMER::time();
					if(m_pEngine)
						m_pEngine->SetActive(FALSE);
				}
			}
			break;
        case WM_SIZE:
            break;
        case WM_SETCURSOR:
            break;

        case WM_ENTERMENULOOP:
			if(!wParam)
			{
				_UpdateMenu(m_hMainMenu);
			}
            break;
        case WM_EXITMENULOOP:
            break;

        case WM_ENTERSIZEMOVE:
            break;
        case WM_EXITSIZEMOVE:
            break;

        case WM_CONTEXTMENU:
            break;
        case WM_NCHITTEST:
			return HTCLIENT;
            break;

        case WM_POWERBROADCAST:
            switch( wParam )
            {
                case PBT_APMQUERYSUSPEND:
                    // At this point, the app should save any data for open
                    // network connections, files, etc.., and prepare to go into
                    // a suspended mode.
                    return OnQuerySuspend( (DWORD)lParam );

                case PBT_APMRESUMESUSPEND:
                    // At this point, the app should recover any data, network
                    // connections, files, etc.., and resume running from when
                    // the app was suspended.
                    return OnResumeSuspend( (DWORD)lParam );
            }
            break;

        case WM_SYSCOMMAND:
            // Prevent moving/sizing and power loss in fullscreen mode
            switch( wParam )
            {
                case SC_MOVE:
                case SC_SIZE:
                case SC_MAXIMIZE:
                case SC_MONITORPOWER:
                    break;
            }
            break;

        case WM_COMMAND:
		{
			if(LOWORD(wParam)==idr_full_speed_mode)
			{
				m_isFullspeedMode	^= 1;
				return 0;
			}
			if(LOWORD(wParam)==idr_app_exit)
			{
				PostQuitMessage(0);
			}
            break;
		}
        case WM_GETMINMAXINFO:
            break;

		case WM_CLOSE:
			DestroyWindow( m_hWnd );
			return -1;

        case WM_DESTROY:
            CleanupAllEngines();
            PostQuitMessage(0);
            return 0;
	}
	if(m_pEngine==NULL)
	{
		if(m_gses.size()!=1)
			return 0;
		m_pEngine	= m_gses.begin()->second;
	}
	return m_pEngine->MsgProc( uMsg, wParam, lParam );
}


BOOL CGsAppEx::DoIdle()
{
	HRESULT hr;
	static	DWORD dwLastTime	= 0;
	static	DWORD dwLoop		= 0;
	if(m_isReady)
	{
		m_dwAppTime	= timeGetTime() - m_dwBaseTime;
		if( (m_isActive || m_enableBackgroundActive) && m_isReady )
		{
			ProcessTask();
			if( FAILED( MainLoop( m_dwAppTime ) ) )
			{
				return false;
			}
		}
		if(m_pEngine)
		{
			if( m_isActive || m_enableBackgroundActive )
			{
				if( TRUE==m_pEngine->_UpdateEngine() && NULL==m_pEngine->GetPlayVideo())
				{
					if(FAILED(hr=m_pEngine->_RenderEngine()))
					{
						if(hr==DDERR_SURFACELOST)
						{
							if(FAILED(m_pEngine->RestoreEngine()))
								return FALSE;
							else
								return TRUE;
							
						}
						else
							return FALSE;
					}
					if(m_pEngine->IsChanged())
					{
						//frame_count	+= 10000;
						if(FAILED(hr = m_pEngine->Present()))
						{
							if(hr	== DDERR_SURFACELOST)
							{
								if(FAILED(m_pEngine->RestoreSurfaces()))
									return false;
							}
							else
								return false;
						}
					}
				}
			}


		}
		//if( FAILED( UpdateAllEngines() ) )
		//{
		//		return false;
		//}
	}
	dwLoop++;
	if(m_dwAppTime-dwLastTime>500)
	{
		m_fLps	= (float)dwLoop*1000.0f/(float)(m_dwAppTime-dwLastTime);
		OnLpsChange(m_fLps);
		dwLoop	= 0;
		dwLastTime	= m_dwAppTime;
	}
	if(false==m_isFullspeedMode)
	{
		Sleep(m_dwSpeedRate);
	}
	return true;
}


VOID CGsAppEx::OnEngineConnected(CGsEngine* pEngine)
{
	if(m_popupMenu)
	{
		DestroyMenu(m_popupMenu);
	}
	idr_popup_menu			= pEngine->idr_popup_menu;
	m_popupMenu				= pEngine->m_popupMenu;
	idr_choose_mode			= pEngine->idr_choose_mode;	
	UpgrateAppMenu();
}