C++ BaseModHybridButton类代码示例

//=============================================================================
void InGameMainMenu::ApplySchemeSettings( vgui::IScheme *pScheme )
{
	BaseClass::ApplySchemeSettings( pScheme );

	// We cant remove button and resize flyout menu from code, but we can use another .res file for base menu.
#ifdef UI_USING_GAMEPLAYCONFIGDIALOG
	if ( demo_ui_enable.GetString()[0] )
	{
		LoadControlSettings( CFmtStr( "Resource/UI/BaseModUI/InGameMainMenu_%s.res", demo_ui_enable.GetString() ) );
	}
	else
	{
		LoadControlSettings( "Resource/UI/BaseModUI/InGameMainMenu.res" );
	}
#else
	// all that "demoui" stuff confuse me [str]
	const char *pSettings = "Resource/UI/BaseModUI/InGameMainMenu_NoGameplay.res";
#endif

	BaseModHybridButton *button = dynamic_cast< BaseModHybridButton* >( FindChildByName( "BtnDeveloperCommentaries" ) );
	if ( button )
	{
#ifdef UI_USING_DEVCOMMENTARIES
		button->SetEnabled( true ); // we're not just removing button, because of ASWUI flyout system [str]
									// thought: maybe just use different control setting
#endif
	}

	SetPaintBackgroundEnabled( true );

	SetFooterState();
}

//=============================================================================
void InGameDifficultySelect::LoadLayout()
{
	BaseClass::LoadLayout();

	CGameUIConVarRef z_difficulty("z_difficulty");

	if ( z_difficulty.IsValid() )
	{
		// set a label that tells us what the current difficulty is
		char chBuffer[64];
		Q_snprintf( chBuffer, ARRAYSIZE( chBuffer ), "#L4D360UI_Difficulty_%s", z_difficulty.GetString() );

		const char *pszDifficultyLoc = chBuffer;
		wchar_t *pwcDifficulty = g_pVGuiLocalize->Find( pszDifficultyLoc );
		if ( pwcDifficulty )
		{
			wchar_t szWideBuff[200];		
			g_pVGuiLocalize->ConstructString( szWideBuff, sizeof( szWideBuff ), g_pVGuiLocalize->Find( "#L4D360UI_GameSettings_Current_Difficulty" ), 1, pwcDifficulty );

			SetControlString( "LblCurrentDifficulty", szWideBuff );
		}
	
		// Disable the current difficulty's button, and navigate to it.
		BaseModHybridButton *pButton = dynamic_cast< BaseModHybridButton* >( FindChildByName( VarArgs( "Btn%s", z_difficulty.GetString() ) ) );
		if ( pButton )
		{
			pButton->SetEnabled( false );
			pButton->NavigateTo();
		}
	}
}

void Demo_DisableButton( Button *pButton )
{
	BaseModHybridButton *pHybridButton = dynamic_cast<BaseModHybridButton *>(pButton);

	if (pHybridButton)
	{
		pHybridButton->SetEnabled( false );

		char szTooltip[512];
		wchar_t *wUnicode = g_pVGuiLocalize->Find( "#L4D360UI_MainMenu_DemoVersion" );
		if ( !wUnicode )
			wUnicode = L"";

		g_pVGuiLocalize->ConvertUnicodeToANSI( wUnicode, szTooltip, sizeof( szTooltip ) );

		pHybridButton->SetHelpText( szTooltip , false );
	}
}

void GameSettings::UpdateSelectMissionButton()
{
	DropDownMenu *menu = dynamic_cast< DropDownMenu* >( FindChildByName( "DrpSelectMission", true ) );
	if ( !menu )
		return;

	BaseModHybridButton *button = menu->GetButton(); //dynamic_cast< BaseModHybridButton* >( FindChildByName( "BtnSelectMission", true ) );
	if ( m_pSettings && button )
	{
		const char *szGameType = m_pSettings->GetString( "game/mode", "sdk" );
		if ( !Q_stricmp( szGameType, "campaign" ) )
		{
			button->SetText( "#ASUI_Select_Campaign" );
			button->SetHelpText( "#ASUI_Select_Campaign_tt" );
		}
		else if ( !Q_stricmp( szGameType, "single_mission" ) )
		{
			button->SetText( "#ASUI_Select_Mission" );
			button->SetHelpText( "#ASUI_Select_Mission_tt" );
		}
		else if( !Q_stricmp( szGameType, "sdk" ) )
		{
			button->SetText( "Select Map" );
			button->SetHelpText( "SDK select map example" );
		}
		else if( !Q_stricmp( szGameType, "swarmkeeper" ) )
		{
			button->SetText( "Select level" );
			button->SetHelpText( "Select a Swarm Keeper level" );
		}
	}
	/*
	BaseModHybridButton *button = dynamic_cast< BaseModHybridButton* >( FindChildByName( "BtnSelectMission" ) );
	if ( m_pSettings && button )
	{
		const char *szGameType = m_pSettings->GetString( "game/mode", "campaign" );
		if ( !Q_stricmp( szGameType, "campaign" ) )
		{
			button->SetText( "#ASUI_Select_Campaign" );
			button->SetHelpText( "#ASUI_Select_Campaign_tt" );
		}
		else if ( !Q_stricmp( szGameType, "single_mission" ) )
		{
			button->SetText( "#ASUI_Select_Mission" );
			button->SetHelpText( "#ASUI_Select_Mission_tt" );
		}
	}
	*/
}

//=============================================================================
void MainMenu::OnThink()
{
	// need to change state of flyout if user suddenly disconnects
	// while flyout is open
	BaseModUI::FlyoutMenu *flyout = dynamic_cast< FlyoutMenu* >( FindChildByName( "FlmCampaignFlyout" ) );
	if ( flyout )
	{
		BaseModHybridButton *pButton = dynamic_cast< BaseModHybridButton* >( flyout->FindChildButtonByCommand( "QuickMatchCoOp" ) );
		if ( pButton )
		{
			if ( !CUIGameData::Get()->SignedInToLive() )
			{
				pButton->SetText( "#L4D360UI_QuickStart" );
				if ( m_iQuickJoinHelpText != MMQJHT_QUICKSTART )
				{
					pButton->SetHelpText( "#L4D360UI_QuickMatch_Offline_Tip" );
					m_iQuickJoinHelpText = MMQJHT_QUICKSTART;
				}
			}
			else
			{
				pButton->SetText( "#L4D360UI_QuickMatch" );
				if ( m_iQuickJoinHelpText != MMQJHT_QUICKMATCH )
				{
					pButton->SetHelpText( "#L4D360UI_QuickMatch_Tip" );
					m_iQuickJoinHelpText = MMQJHT_QUICKMATCH;
				}
			}
		}
	}

	if ( IsPC() )
	{
		FlyoutMenu *pFlyout = dynamic_cast< FlyoutMenu* >( FindChildByName( "FlmOptionsFlyout" ) );
		if ( pFlyout )
		{
			const MaterialSystem_Config_t &config = materials->GetCurrentConfigForVideoCard();
			pFlyout->SetControlEnabled( "BtnBrightness", !config.Windowed() );
		}
	}

	BaseClass::OnThink();
}

void QuickJoinPanel::UpdateNumGamesFoundLabel( void )
{
	BaseModHybridButton *title = dynamic_cast< BaseModHybridButton* >( FindChildByName( "LblTitle" ) );
	if ( title )
	{
		wchar_t* wFormatString = g_pVGuiLocalize->Find( GetTitle() );
		if( wFormatString )
		{
			char gameCountTxt[ 4 ];
			itoa( m_FriendInfo.Count(), gameCountTxt, 10 );

			wchar_t wGameCountTxt[ 4 ];
			g_pVGuiLocalize->ConvertANSIToUnicode( gameCountTxt, wGameCountTxt, sizeof( wGameCountTxt ) );

			wchar_t wMessage[ 256 ];
			g_pVGuiLocalize->ConstructString( wMessage, sizeof( wMessage ), wFormatString, 1, wGameCountTxt );
			title->SetText( wMessage );
		}
	}
}

//=============================================================================
void InGameMainMenu::PerformLayout( void )
{
	BaseClass::PerformLayout();

	BaseModUI::FlyoutMenu *flyout = dynamic_cast< FlyoutMenu* >( FindChildByName( "FlmIngameSingleplayerFlyout" ) );
	if ( flyout )
	{
		flyout->SetListener( this );
	}
	BaseModUI::FlyoutMenu *flyout2 = dynamic_cast< FlyoutMenu* >( FindChildByName( "FlmOptionsFlyout" ) );
	if ( flyout2 )
	{
		flyout2->SetListener( this );
	}
	BaseModHybridButton *button = dynamic_cast< BaseModHybridButton* >( FindChildByName( "BtnReturnToGame" ) );
	if ( button )
	{
		if( m_ActiveControl )
			m_ActiveControl->NavigateFrom();

		button->NavigateTo();
	}
}

//=============================================================================
void DownloadCampaign::UpdateText()
{
	wchar_t s1[MAX_PATH];
	wchar_t s2[MAX_PATH];
	wchar_t text[MAX_PATH];

	g_pVGuiLocalize->ConvertANSIToUnicode( m_campaignName.Get(), s1, sizeof( s1 ) );
	g_pVGuiLocalize->ConvertANSIToUnicode( m_author.Get(), s2, sizeof( s2 ) );
	const wchar_t * downloadCampaignText = g_pVGuiLocalize->Find( "#L4D360UI_DownloadCampaign_Campaign" );
	if ( downloadCampaignText )
	{
		g_pVGuiLocalize->ConstructString( text, sizeof( text ), downloadCampaignText, 2, s1, s2 );

		vgui::Label	*LblDownloadCampaign = dynamic_cast< vgui::Label * > ( FindChildByName( "LblDownloadCampaign" ) );
		if ( LblDownloadCampaign )
		{
			LblDownloadCampaign->SetText( text );
		}
	}

	g_pVGuiLocalize->ConvertANSIToUnicode( m_webSite.Get(), s1, sizeof( s1 ) );
	BaseModHybridButton *BtnURL = dynamic_cast< BaseModHybridButton * > ( FindChildByName( "BtnURL" ) );
	if ( BtnURL )
	{
		BtnURL->SetText( s1 );
	}

	if ( m_fromLobby )
	{
		vgui::Label	*LblDownloadText = dynamic_cast< vgui::Label * > ( FindChildByName( "LblDownloadText" ) );
		if ( LblDownloadText )
		{
			LblDownloadText->SetText( "#L4D360UI_DownloadCampaign_Text_FromLobby" );
		}
	}
}

void QuickJoinPanel::NavigateTo()
{
	BaseClass::NavigateTo();
	SetHasMouseover( true );

	BaseModHybridButton *title = dynamic_cast< BaseModHybridButton* >( FindChildByName( "LblTitle" ) );
	if ( title )
	{
		title->SetNavUp( GetNavUp() );
		title->SetNavDown( GetNavDown() );
		if ( m_bHasMouseover && title->IsVisible() && ( title->GetCurrentState() == BaseModHybridButton::Enabled || title->GetCurrentState() == BaseModHybridButton::Disabled ) )
		{
			title->NavigateTo();
		}
	}

#ifdef _X360
	m_GplQuickJoinList->NavigateTo();
#endif
}

//.........这里部分代码省略.........

		if ( StringHasPrefix( szGameMode, "team" ) )
		{
			pSettings->SetString( "system/netflag", "teamlobby" );
		}
// 		else if ( !Q_stricmp( "custommatch", m_pDataSettings->GetString( "options/action", "" ) ) )
// 		{
// 			pSettings->SetString( "system/access", "public" );
// 		}

		// TCR: We need to respect the default difficulty
		pSettings->SetString( "game/difficulty", GameModeGetDefaultDifficulty( szGameMode ) );

		CBaseModPanel::GetSingleton().PlayUISound( UISOUND_ACCEPT );
		CBaseModPanel::GetSingleton().CloseAllWindows();
		CBaseModPanel::GetSingleton().OpenWindow( WT_GAMESETTINGS, NULL, true, pSettings );
	}
	else
	{
		const char *pchCommand = command;
		if ( !Q_strcmp(command, "FlmOptionsFlyout") )
		{
#ifdef _X360
			if ( XBX_GetPrimaryUserIsGuest() )
			{
				pchCommand = "FlmOptionsGuestFlyout";
			}
#endif
		}
		else if ( !Q_strcmp(command, "FlmVersusFlyout") )
		{
			command = "VersusSoftLock";
		}
		else if ( !Q_strcmp( command, "FlmSurvivalFlyout" ) )
		{
			command = "SurvivalCheck";
		}
		else if ( !Q_strcmp( command, "FlmScavengeFlyout" ) )
		{
			command = "ScavengeCheck";
		}
		else if ( StringHasPrefix( command, "FlmExtrasFlyout_" ) )
		{
			command = "FlmExtrasFlyoutCheck";
		}

		// does this command match a flyout menu?
		BaseModUI::FlyoutMenu *flyout = dynamic_cast< FlyoutMenu* >( FindChildByName( pchCommand ) );
		if ( flyout )
		{
			bOpeningFlyout = true;

			// If so, enumerate the buttons on the menu and find the button that issues this command.
			// (No other way to determine which button got pressed; no notion of "current" button on PC.)
			for ( int iChild = 0; iChild < GetChildCount(); iChild++ )
			{
				bool bFound = false;
				GameModes *pGameModes = dynamic_cast< GameModes *>( GetChild( iChild ) );
				if ( pGameModes )
				{
					for ( int iGameMode = 0; iGameMode < pGameModes->GetNumGameInfos(); iGameMode++ )
					{
						BaseModHybridButton *pHybrid = pGameModes->GetHybridButton( iGameMode );
						if ( pHybrid && pHybrid->GetCommand() && !Q_strcmp( pHybrid->GetCommand()->GetString( "command"), command ) )
						{
							pHybrid->NavigateFrom();
							// open the menu next to the button that got clicked
							flyout->OpenMenu( pHybrid );
							flyout->SetListener( this );
							bFound = true;
							break;
						}
					}
				}

				if ( !bFound )
				{
					BaseModHybridButton *hybrid = dynamic_cast<BaseModHybridButton *>( GetChild( iChild ) );
					if ( hybrid && hybrid->GetCommand() && !Q_strcmp( hybrid->GetCommand()->GetString( "command"), command ) )
					{
						hybrid->NavigateFrom();
						// open the menu next to the button that got clicked
						flyout->OpenMenu( hybrid );
						flyout->SetListener( this );
						break;
					}
				}
			}
		}
		else
		{
			BaseClass::OnCommand( command );
		}
	}

	if( !bOpeningFlyout )
	{
		FlyoutMenu::CloseActiveMenu(); //due to unpredictability of mouse navigation over keyboard, we should just close any flyouts that may still be open anywhere.
	}
}

//=============================================================================
void MainMenu::ApplySchemeSettings( IScheme *pScheme )
{
	BaseClass::ApplySchemeSettings( pScheme );

	const char *pSettings = "Resource/UI/BaseModUI/MainMenu.res";

#if !defined( _X360 )
	if ( !g_pMatchFramework->GetMatchSystem() )
	{
		Msg( "BAD!\n" );
	}
	if ( !g_pMatchFramework->GetMatchSystem()->GetPlayerManager() )
	{
		Msg( "BAD PLAYER MANAGER!\n" );
	}
	if ( !g_pMatchFramework->GetMatchSystem()->GetPlayerManager()->GetLocalPlayer( 0 ) )
	{
		pSettings = "Resource/UI/BaseModUI/MainMenuStub.res";
	}
#endif

	LoadControlSettings( pSettings );

	BaseModHybridButton *button = dynamic_cast< BaseModHybridButton* >( FindChildByName( "BtnPlaySolo" ) );
	if ( button )
	{
#ifdef _X360
		button->SetText( ( XBX_GetNumGameUsers() > 1 ) ? ( "#L4D360UI_MainMenu_PlaySplitscreen" ) : ( "#L4D360UI_MainMenu_PlaySolo" ) );
		button->SetHelpText( ( XBX_GetNumGameUsers() > 1 ) ? ( "#L4D360UI_MainMenu_OfflineCoOp_Tip" ) : ( "#L4D360UI_MainMenu_PlaySolo_Tip" ) );
#endif
	}

#ifdef _X360
	if ( !XBX_GetPrimaryUserIsGuest() )
	{
		wchar_t wszListText[ 128 ];
		wchar_t wszPlayerName[ 128 ];

		IPlayer *player1 = NULL;
		if ( XBX_GetNumGameUsers() > 0 )
		{
			player1 = g_pMatchFramework->GetMatchSystem()->GetPlayerManager()->GetLocalPlayer( XBX_GetUserId( 0 ) );
		}

		IPlayer *player2 = NULL;
		if ( XBX_GetNumGameUsers() > 1 )
		{
			player2 = g_pMatchFramework->GetMatchSystem()->GetPlayerManager()->GetLocalPlayer( XBX_GetUserId( 1 ) );
		}

		if ( player1 )
		{
			Label *pLblPlayer1GamerTag = dynamic_cast< Label* >( FindChildByName( "LblPlayer1GamerTag" ) );
			if ( pLblPlayer1GamerTag )
			{
				g_pVGuiLocalize->ConvertANSIToUnicode( player1->GetName(), wszPlayerName, sizeof( wszPlayerName ) );
				g_pVGuiLocalize->ConstructString( wszListText, sizeof( wszListText ), g_pVGuiLocalize->Find( "#L4D360UI_MainMenu_LocalProfilePlayer1" ), 1, wszPlayerName );

				pLblPlayer1GamerTag->SetVisible( true );
				pLblPlayer1GamerTag->SetText( wszListText );
			}
		}

		if ( player2 )
		{
			Label *pLblPlayer2GamerTag = dynamic_cast< Label* >( FindChildByName( "LblPlayer2GamerTag" ) );
			if ( pLblPlayer2GamerTag )
			{
				g_pVGuiLocalize->ConvertANSIToUnicode( player2->GetName(), wszPlayerName, sizeof( wszPlayerName ) );
				g_pVGuiLocalize->ConstructString( wszListText, sizeof( wszListText ), g_pVGuiLocalize->Find( "#L4D360UI_MainMenu_LocalProfilePlayer2" ), 1, wszPlayerName );

				pLblPlayer2GamerTag->SetVisible( true );
				pLblPlayer2GamerTag->SetText( wszListText );

				// in split screen, have player2 gamer tag instead of enable, and disable
				SetControlVisible( "LblPlayer2DisableIcon", true );
				SetControlVisible( "LblPlayer2Disable", true );
				SetControlVisible( "LblPlayer2Enable", false );
			}
		}
		else
		{
			SetControlVisible( "LblPlayer2DisableIcon", false );
			SetControlVisible( "LblPlayer2Disable", false );

			// not in split screen, no player2 gamertag, instead have enable
			SetControlVisible( "LblPlayer2GamerTag", false );
			SetControlVisible( "LblPlayer2Enable", true );
		}
	}
#endif

	if ( IsPC() )
	{
		FlyoutMenu *pFlyout = dynamic_cast< FlyoutMenu* >( FindChildByName( "FlmOptionsFlyout" ) );
		if ( pFlyout )
		{
			bool bUsesCloud = false;

//.........这里部分代码省略.........

//.........这里部分代码省略.........
		m_ActiveControl->NavigateFrom( );
		CBaseModPanel::GetSingleton().OpenWindow(WT_GAMEPLAYSETTINGS, this, true );
	}
	else if ( !Q_strcmp( command, "StatsAndAchievements" ) )
	{
		if ( CheckAndDisplayErrorIfNotLoggedIn() )
			return;
		m_ActiveControl->NavigateFrom( );
		CBaseModPanel::GetSingleton().OpenWindow( WT_ACHIEVEMENTS, this, true );
	}
	else if (!Q_strcmp(command, "Controller"))
	{
		CBaseModPanel::GetSingleton().OpenWindow(WT_CONTROLLER, this, true );
	}
	else if (!Q_strcmp(command, "Audio"))
	{
		// audio options dialog, PC only
		m_ActiveControl->NavigateFrom( );
		CBaseModPanel::GetSingleton().OpenWindow(WT_AUDIO, this, true );
	}
	else if (!Q_strcmp(command, "Video"))
	{
		// video options dialog, PC only
		m_ActiveControl->NavigateFrom( );
		CBaseModPanel::GetSingleton().OpenWindow(WT_VIDEO, this, true );
	}
	else if (!Q_strcmp(command, "Brightness"))
	{
		// brightness options dialog, PC only
		OpenGammaDialog( GetVParent() );
	}
	else if (!Q_strcmp(command, "KeyboardMouse"))
	{
		// standalone keyboard/mouse dialog, PC only
		m_ActiveControl->NavigateFrom( );
		CBaseModPanel::GetSingleton().OpenWindow(WT_KEYBOARDMOUSE, this, true );
	}
	else if( Q_stricmp( "#L4D360UI_Controller_Edit_Keys_Buttons", command ) == 0 )
	{
		FlyoutMenu::CloseActiveMenu();
		CBaseModPanel::GetSingleton().OpenKeyBindingsDialog( this );
	}
	else if ( !Q_strcmp( command, "EnableSplitscreen" ) || !Q_strcmp( command, "DisableSplitscreen" ) )
	{
		GenericConfirmation* confirmation = 
			static_cast< GenericConfirmation* >( CBaseModPanel::GetSingleton().OpenWindow( WT_GENERICCONFIRMATION, this, true ) );

		GenericConfirmation::Data_t data;

		data.pWindowTitle = "#L4D360UI_LeaveMultiplayerConf";
		data.pMessageText = "#L4D360UI_MainMenu_SplitscreenChangeConfMsg";

		data.bOkButtonEnabled = true;
		data.pfnOkCallback = &LeaveGameOkCallback;
		data.bCancelButtonEnabled = true;

		confirmation->SetUsageData(data);
	}
	else if( !Q_strcmp( command, "ExitToMainMenu" ) )
	{
		GenericConfirmation* confirmation = 
			static_cast< GenericConfirmation* >( CBaseModPanel::GetSingleton().OpenWindow( WT_GENERICCONFIRMATION, this, true ) );

		GenericConfirmation::Data_t data;

		data.pWindowTitle = "#L4D360UI_LeaveMultiplayerConf";
		data.pMessageText = "#L4D360UI_LeaveMultiplayerConfMsg";
		data.bOkButtonEnabled = true;
		data.pfnOkCallback = &LeaveGameOkCallback;
		data.bCancelButtonEnabled = true;

		confirmation->SetUsageData(data);
	}
	else
	{
		const char *pchCommand = command;
		// does this command match a flyout menu?
		BaseModUI::FlyoutMenu *flyout = dynamic_cast< FlyoutMenu* >( FindChildByName( pchCommand ) );
		if ( flyout )
		{
			// If so, enumerate the buttons on the menu and find the button that issues this command.
			// (No other way to determine which button got pressed; no notion of "current" button on PC.)
			for ( int iChild = 0; iChild < GetChildCount(); iChild++ )
			{
				BaseModHybridButton *hybrid = dynamic_cast<BaseModHybridButton *>( GetChild( iChild ) );
				if ( hybrid && hybrid->GetCommand() && !Q_strcmp( hybrid->GetCommand()->GetString( "command"), command ) )
				{
#ifdef _X360
					hybrid->NavigateFrom( );
#endif //_X360
					// open the menu next to the button that got clicked
					flyout->OpenMenu( hybrid );
					break;
				}
			}
		}
	}

	SetGameUIActiveSplitScreenPlayerSlot( iOldSlot );
}

//=============================================================================
void InGameKickPlayerList::LoadLayout()
{
	BaseClass::LoadLayout();

	//int iLocalPlayerTeam;

	if ( false ) // TODO: !GameClientExports()->GetPlayerTeamIdByUserId( -1, iLocalPlayerTeam ) )
	{
		// no local player?
		Assert( 0 );

		// hide all the buttons, weird state
		for ( int i=0;i<KICK_PLAYER_LIST_MAX_PLAYERS; i++ )
		{
			BaseModHybridButton *pButton = dynamic_cast< BaseModHybridButton* >( FindChildByName( VarArgs( "BtnPlayer%d", i ) ) );
			if ( pButton )
			{
				pButton->SetVisible( false );
			}
		}

		return;
	}

	// get a list of players that we can kick

	m_KickablePlayersUserIDs.Purge();

	for( int i = 1; i <= engine->GetMaxClients(); ++i)
	{
		player_info_t playerInfo;
		if( engine->GetPlayerInfo(i, &playerInfo) && !playerInfo.fakeplayer )
		{
			if ( true ) // TODO: GameClientExports()->IsPlayerKickableByLocalPlayer( i ) )
			{
				m_KickablePlayersUserIDs.AddToTail( playerInfo.userID );
			}
		}
	}

	int iKickablePlayers = m_KickablePlayersUserIDs.Count();

	// If there are no players to be kicked, hide the description and show the label explaining why 
	// there are no players to choose

	SetControlVisible( "LblDescription", iKickablePlayers > 0 );
	SetControlVisible( "LblNoPlayers", iKickablePlayers == 0 );

	for ( int i=0;i<KICK_PLAYER_LIST_MAX_PLAYERS; i++ )
	{
		BaseModHybridButton *pButton = dynamic_cast< BaseModHybridButton* >( FindChildByName( VarArgs( "BtnPlayer%d", i+1 ) ) );
		if ( pButton )
		{
			if ( i < iKickablePlayers )
			{
				int userID = m_KickablePlayersUserIDs.Element(i);

				player_info_t playerInfo;
				if( engine->GetPlayerInfo( engine->GetPlayerForUserID(userID), &playerInfo ) )
				{
					pButton->SetVisible( true );
					pButton->SetText( playerInfo.name );
					pButton->SetCommand( VarArgs( "KickPlayer%d", userID ) );
				}
				else
				{
					pButton->SetVisible( false );
				}
			}
			else
			{
				pButton->SetVisible( false );
			}
		}
	}
}

void GameModes::OnMousePressed( vgui::MouseCode code )
{
	BaseClass::OnMousePressed( code );

	if ( code != MOUSE_LEFT )
		return;		

	if ( IsScrollBusy() )
		return;

	int iPosX;
	int iPosY;
	input()->GetCursorPos( iPosX, iPosY );
	ScreenToLocal( iPosX, iPosY );

	if ( m_nSubPics )
	{
		bool bRightScroll = false;
		bool bLeftScroll = false;
		int nSubPic = 0;

		if ( ( iPosX >= m_nPicOffsetX && iPosX <= m_nPicOffsetX + m_nPicWidth ) &&
			( iPosY >= 0 && iPosY <= m_nPicHeight ) )
		{
			BaseModHybridButton *pHybridButton = GetHybridButton( m_nActive );
			if ( pHybridButton && pHybridButton->GetCurrentState() != BaseModHybridButton::Open )
			{
				// open it
				if ( pHybridButton->IsEnabled() )
				{
					pHybridButton->DoClick();
				}
			}
		}
		else if ( ( iPosX >= m_nLeftArrowX && iPosX <= m_nLeftArrowX + m_nArrowWidth ) &&
			( iPosY >= m_nLeftArrowY && iPosY <= m_nLeftArrowY + m_nArrowHeight ) )
		{
			bLeftScroll = true;
		}
		else if ( ( iPosX >= m_nRightArrowX && iPosX <= m_nRightArrowX + m_nArrowWidth ) &&
			( iPosY >= m_nRightArrowY && iPosY <= m_nRightArrowY + m_nArrowHeight ) )
		{
			bRightScroll = true;
		}
		else
		{
			// determine if sub pic selected
			if ( iPosY >= m_nSubPicY && iPosY <= m_nSubPicY + m_nSubPicHeight )
			{
				int x = m_nSubPicX;
				for ( int i = 1; i <= m_nSubPics; i++ )
				{
					if ( iPosX >= x && iPosX <= x + m_nSubPicWidth )
					{
						nSubPic = i;
						break;
					}
					x += m_nSubPicWidth + m_nSubPicGap;
				}
			}
		}

		if ( bLeftScroll || bRightScroll || nSubPic )
		{
			// close any active flyout
			if ( FlyoutMenu::GetActiveMenu() )
			{
				FlyoutMenu::CloseActiveMenu( this );
			}

			if ( bLeftScroll )
			{
				ScrollLeft();
			}
			else if ( bRightScroll )
			{
				ScrollRight();
			}
			else if ( nSubPic )
			{
				ScrollRight( nSubPic );
			}
		}
	}
}

void GameModes::PaintBackground()
{
	if ( !m_GameModeInfos.Count() )
		return;

	BaseModHybridButton *pHybridButton = m_GameModeInfos[m_nActive].m_pHybridButton;
	bool bHasFocus = pHybridButton->HasFocus() || 
					( pHybridButton->GetCurrentState() == BaseModHybridButton::Focus ) ||
					( pHybridButton->GetCurrentState() == BaseModHybridButton::FocusDisabled );
	bool bIsOpen = ( pHybridButton->GetCurrentState() == BaseModHybridButton::Open );

	// update scroll
	// varies between [0..1] or [1..0]
	float t = 0;
	if ( m_startScrollTime )
	{
		float rate = ( m_nScrollMultipleCount >= 1 ) ? 8.0f : 5.0f;
		t = ( Plat_FloatTime() - m_startScrollTime ) * rate;
		if ( t >= 1.0f )
		{
			// finished, scroll is circular warp around
			t = 1.0f;
			m_startScrollTime = 0;

			int nNewActive = 0;
			if ( m_bLeftScroll )
			{
				nNewActive = ( m_nActive + 1 ) % m_GameModeInfos.Count();
			}
			else
			{
				nNewActive = ( m_nActive - 1 + m_GameModeInfos.Count() ) % m_GameModeInfos.Count();
			}
			SetActiveGameMode( nNewActive, bHasFocus );

			if ( --m_nScrollMultipleCount > 0 )
			{
				m_startScrollTime = Plat_FloatTime();
				t = 0;
			}
		}
	}

	int panelWidth, panelHeight;
	GetSize( panelWidth, panelHeight );

// need this to see panel bounds during debugging
//vgui::surface()->DrawSetColor( Color( 255, 0, 0, 255 ) );
//vgui::surface()->DrawFilledRect( 0, 0, panelWidth, panelHeight );

	// the main pic and all the subpics
	int nPicCount = 1 + m_nSubPics;
	if ( m_startScrollTime && m_bLeftScroll )
	{
		// scrolling means one extra sub pic must be drawn at the far right edge
		// either coming/going
		nPicCount++;
	}

	int nOffscreenSubPicX = m_nPicOffsetX - m_nSubPicOffsetX - m_nSubPicWidth;
	int nOffscreenSubPicY = m_nSubPicY;
	int nOffscreenSubPicW = m_nSubPicWidth;
	int nOffscreenSubPicH = m_nSubPicHeight;

	int nActivePicX = m_nPicOffsetX;
	int nActivePicY = 0;
	int nActivePicW = m_nPicWidth;
	int nActivePicH = m_nPicHeight;
	float nActiveAngle = 0; //-3;

	int x, y;
	int w, h;

	int iPrevActiveMode = ( m_nActive - 1 + m_GameModeInfos.Count() ) % m_GameModeInfos.Count(); 
	int iNextActiveMode = ( m_nActive + 1 ) % m_GameModeInfos.Count();

	// center the vertical smear
	y = nActivePicY + nActivePicH + m_nMenuTitleY + ( m_nMenuTitleActualTall - m_nMenuTitleTall )/2;
	vgui::surface()->DrawSetColor( m_smearColor );
	DrawSmearBackgroundFade( 
		m_nMenuTitleX - ( 0.30f * m_nMenuTitleX ), 
		y, 
		m_nSubPicX + m_nSubPics * ( m_nSubPicWidth + m_nSubPicGap ), 
		y + m_nMenuTitleTall ); 

	// cyclical carousel
	// the first pic to be drawn is the active main pic, followed by all the sub pics
	for ( int i = 0; i < nPicCount; i++ )
	{
		int iGameMode = ( m_nActive + i ) % m_GameModeInfos.Count();

		// in between scrolling, this image transition gets handled by specialized lerp drawing
		bool bSkipSubPicDraw = m_startScrollTime && ( m_bLeftScroll && ( iGameMode == iNextActiveMode ) );

		if ( !i )
		{
			// active pic
			x = nActivePicX;
			y = nActivePicY;
			w = nActivePicW;
//.........这里部分代码省略.........