gsapp.cpp

网络泡泡被.net管理

		it++;
	}
    switch( uMsg )
    {
        case WM_PAINT:
            break;
		case WM_MOVE:
			{
				CGsEngine*	pEngine;
				GSES::iterator p	= m_gses.begin();
				while(p!=m_gses.end())
				{
					pEngine	= p->second;
					pEngine->UpdateBounds();
					p++;
				}
			}
			break;
		case WM_ACTIVATEAPP:
			if((BOOL)wParam)
			{
				if(!m_enableBackgroundActive)
					SetActive(TRUE);
				else
					if(!m_isActive)
					{
						m_isActive = TRUE;
						if( m_isFrameMoving )
						{
							m_dwBaseTime += timeGetTime() - m_dwStopTime;
							m_dwAppTime	= timeGetTime() - m_dwBaseTime;
						}
					}
			}
			else
			{
				if(!m_enableBackgroundActive)
					SetActive(FALSE);
				else
				{
					m_isActive = FALSE;
					if( m_isFrameMoving )
					{
						m_dwStopTime = timeGetTime();//TIMER::time();
					}
				}
			}
			break;
        case WM_SIZE:
            // Check to see if we are losing our window...
            if( SIZE_MAXHIDE==wParam || SIZE_MINIMIZED==wParam )
			{
				SetActive(FALSE);
//                m_isActive = FALSE;
//				if( m_isFrameMoving && !m_enableBackgroundActive )
//				{
//					m_dwStopTime = timeGetTime();//TIMER::time();
//				}
				UpdateAllEngines();
			}
            else
			{
				SetActive(TRUE);
//				if(!m_isActive)
//				{
//			        m_isActive = TRUE;
//					if( m_isFrameMoving && !m_enableBackgroundActive )
//					{
//						m_dwBaseTime += timeGetTime() - m_dwStopTime;
//						m_dwAppTime	= timeGetTime() - m_dwBaseTime;
//					}
//				}
			}
            break;
        case WM_SETCURSOR:
            // Prevent a cursor in fullscreen mode
			SetCursor(NULL);
			return 1;

        case WM_ENTERMENULOOP:
 		{
           // Pause the app when menus are displayed
			if(!wParam)
			{
				_UpdateMenu(m_hMainMenu);
			}
            Pause(TRUE);
            break;
		}
        case WM_EXITMENULOOP:
            Pause(FALSE);
            break;

        case WM_ENTERSIZEMOVE:
            // Halt frame movement while the app is sizing or moving
			m_dwStopTime = timeGetTime();//TIMER::time();
            break;
        case WM_EXITSIZEMOVE:
			m_dwBaseTime += timeGetTime();//TIMER::time() - m_dwStopTime;
			m_dwAppTime	= timeGetTime();//TIMER::time() - m_dwBaseTime;
            break;

        case WM_CONTEXTMENU:
		{
            // Handle the app's context menu (via right mouse click) 
			if(m_popupMenu && m_hWnd == (HWND) wParam)
			{
				_UpdateMenu(m_popupMenu);
				TrackPopupMenuEx(
                    GetSubMenu( m_popupMenu, 0 ),
                    TPM_VERTICAL, LOWORD(lParam), HIWORD(lParam), m_hWnd, NULL );
			}
            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_command_pause)
			{
				static BOOL bp = false;
				bp	^= 1;
				Pause(bp);
				return 0;
			}
			if(LOWORD(wParam)==idr_full_speed_mode)
			{
				m_isFullspeedMode	^= 1;
				return 0;
			}
			if(LOWORD(wParam)==idr_app_exit)
			{
				PostQuitMessage(0);
			}
			int i = LOWORD(wParam)-IDM_DISPLAY_MODE-1;
			if( i < m_pDeviceInfo->dwNumModes)
			{
				DxEnum_SetDevice(m_pDeviceInfo, i);
			}
            break;
		}
        case WM_GETMINMAXINFO:
			
            break;

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

//        case WM_DESTROY:
//            CleanupAllEngines();
            //PostQuitMessage(0);
            //return 0;
		
	}
	return 0;


}

VOID	CGsApp::_UpdateMenu(HMENU hMenu)
{
	if(!hMenu)
		return;
	char str[150];
	MENUITEMINFO	mii;
	mii.cbSize	= sizeof mii;
	mii.fMask	= MIIM_STATE | MIIM_TYPE;
	mii.cch		= 150;
	mii.dwTypeData = str;
	if(idr_command_pause>0 && GetMenuItemInfo(hMenu, idr_command_pause, false, &mii ) )
	{
		mii.fState	= m_isReady ? MF_UNCHECKED : MF_CHECKED;
		SetMenuItemInfo(hMenu, idr_command_pause, false, &mii );
	}
	mii.cch = 150;
	if(idr_full_speed_mode>0 && GetMenuItemInfo(hMenu, idr_full_speed_mode , false, &mii ) )
	{
		mii.fState	= m_isFullspeedMode ? MF_CHECKED : MF_UNCHECKED;
		SetMenuItemInfo(hMenu, idr_full_speed_mode , false, &mii );
	}
/*
	for(int i=0; i<m_pDeviceInfo->dwNumModes; i++)
	{
		mii.cch = 150;
		if( GetMenuItemInfo( hMenu, IDM_DISPLAY_MODE+i+1, false, &mii ) )
		{
			mii.fType	|= MFT_RADIOCHECK;
			mii.fState	= (m_pDeviceInfo->dwCurrentMode==i) ? MF_CHECKED : MF_UNCHECKED;
			SetMenuItemInfo(hMenu, IDM_DISPLAY_MODE+i+1, false, &mii );
		}
	}
*/
	OnUpdateMenu(hMenu);
}

//-----------------------------------------------------------------------------
// Name: UpgrateApplicationMenu()
// Desc: 
//-----------------------------------------------------------------------------
VOID	CGsApp::UpgrateAppMenu()
{
	if(0==idr_choose_mode)
		return;
	HMENU	mode_menu	= BuildSupportModeMenu(m_pDeviceInfo);
	char str[50];
	if(m_hMainMenu)
	{
		GetMenuString(m_hMainMenu, idr_choose_mode, str, 50, MF_BYCOMMAND);
		ModifyMenu(m_hMainMenu, idr_choose_mode, MF_BYCOMMAND | MF_POPUP, (UINT)mode_menu, str);
	}	

	if(m_popupMenu)
	{
		GetMenuString(m_popupMenu, idr_choose_mode, str, 50, MF_BYCOMMAND);
		ModifyMenu(m_popupMenu, idr_choose_mode, MF_BYCOMMAND | MF_POPUP, (UINT)mode_menu, str);
	}
}




//-----------------------------------------------------------------------------
// Name: OnQuerySuspend()
// Desc: Called when the app receives a PBT_APMQUERYSUSPEND message, meaning
//       the computer is about to be suspended. At this point, the app should
//       save any data for open network connections, files, etc.., and prepare
//       to go into a suspended mode.
//-----------------------------------------------------------------------------
LRESULT CGsApp::OnQuerySuspend( DWORD dwFlags )
{
    Pause(TRUE);

    return TRUE;
}




//-----------------------------------------------------------------------------
// Name: OnResumeSuspend()
// Desc: Called when the app receives a PBT_APMRESUMESUSPEND message, meaning
//       the computer has just resumed from a suspended state. At this point, 
//       the app should recover any data, network connections, files, etc..,
//       and resume running from when the app was suspended.
//-----------------------------------------------------------------------------
LRESULT CGsApp::OnResumeSuspend( DWORD dwData )
{
    Pause(FALSE);

    return TRUE;
}


//-----------------------------------------------------------------------------
// Name: CleanupAllEngines()
// Desc: 
//-----------------------------------------------------------------------------
HRESULT CGsApp::CleanupAllEngines()
{
	return 0;
}


BOOL CGsApp::DoIdle()
{
	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( 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;
}

DWORD CGsApp::GetAppTimeEx()
{
	return timeGetTime() - m_dwBaseTime;
}



void CGsApp::SetTask(CGsTask *pTask, BOOL bAddOrDel)
{
	TASK_LIST::iterator	it = std::find(m_task_list.begin(), m_task_list.end(), pTask);
	if(it!=m_task_list.end())
	{
		if(!bAddOrDel)
		{
			m_task_list.erase(it);
		}
	}
	else
	{
		m_task_list.push_back(pTask);
	}
	return;
}

void CGsApp::ProcessTask()
{
	TASK_LIST::iterator	it = m_task_list.begin();
	while(it!=m_task_list.end())
	{
		(*it)->OnLoop(m_dwAppTime);
		it++;
	}

}

VOID CGsApp::SetActive(BOOL bActive)
{
	if(m_isActive==bActive)
		return;
	m_isActive = bActive;
	if(bActive)
	{
		if( m_isFrameMoving && !m_enableBackgroundActive )
		{
			m_dwBaseTime += timeGetTime() - m_dwStopTime;
			m_dwAppTime	= timeGetTime() - m_dwBaseTime;
		}
			GSES::iterator	it	= m_gses.begin();
			while(it!=m_gses.end())
			{
				if(it->second)
					it->second->SetActive(TRUE);
				it++;
			}
	}
	else
	{
		if( m_isFrameMoving && !m_enableBackgroundActive )
		{
			m_dwStopTime = timeGetTime();//TIMER::time();
		}
			GSES::iterator	it	= m_gses.begin();
			while(it!=m_gses.end())
			{
				if(it->second)
					it->second->SetActive(FALSE);
				it++;
			}
	}
}

void CGsApp::SetAppTitle(LPCSTR strTitle)
{
	strcpy(m_strWindowTitle, strTitle);
	if(m_hWnd)
	{
		::SetWindowText(m_hWnd, m_strWindowTitle);
	}
}