//
// BuildRuleSetList
//
void RuleSetListBox::BuildRuleSetList()
{
ICListBox::Rebuild *rebuild = PreRebuild();
DeleteAllItems();
if (!pub)
{
// Add the 'no rule' option
AddTextItem("None", NULL);
}
const NBinTree<Mods::Mod> *mods = Mods::GetMods(Mods::Types::RuleSet);
if (mods)
{
for (NBinTree<Mods::Mod>::Iterator mod(mods); *mod; ++mod)
{
if (!(pub && (*mod)->IsPrivate()))
{
AddTextItem((*mod)->GetName().str, TRANSLATE(((*mod)->GetDescription().str)));
}
}
}
PostRebuild(&rebuild);
}
// Build the screen
LTBOOL CScreenRatings::Build()
{
CreateTitle(IDS_TITLE_RATINGS);
// Add a "Subroutines" button
AddTextItem(IDS_SUBROUTINES, CMD_SUBROUTINES, IDS_HELP_SUBROUTINES);
// Add a "Compile" button
AddTextItem(IDS_COMPILE, CMD_COMPILE, IDS_HELP_COMPILE);
// Make sure to call the base class
if (!CBaseScreen::Build()) return LTFALSE;
UseBack(LTTRUE);
LTIntPt center;
center.x = 320;
center.y = 240;
m_SystemMemoryCtrl.Init(center, MEMORY_INNER_RADIUS, MEMORY_OUTER_RADIUS, 24);
m_AdditiveCtrl.Init(center, LIBRARY_INNER_RADIUS, LIBRARY_OUTER_RADIUS, 6);
m_AdditiveCtrl.SetArc(45.0f, 135.0f);
m_AdditiveCtrl.SetNumHighlightSegments(1);
m_nAdditives = 0;
m_nAdditiveLibSize = 0;
// TODO mark all slots as "unavailable"
// TODO set the cursor mode
return LTTRUE;
}
LTBOOL CFolderObjectives::Build()
{
CreateTitle(IDS_TITLE_OBJECTIVES);
m_pMissionCtrl=AddTextItem(IDS_SPACER,LTNULL,0,LTTRUE, GetMediumFont());
m_pMissionCtrl->SetFixedWidth(480);
m_pMissionCtrl->Enable(LTFALSE);
AddBlankLine();
CLTGUITextItemCtrl* pCtrl=AddTextItem(IDS_OBJECTIVES,LTNULL,0,LTTRUE, GetMediumFont());
pCtrl->Enable(LTFALSE);
CLTGUIFont *pFont = GetMediumFont();
m_pSpacerCtrl = CreateTextItem(" ",LTNULL,LTNULL, LTTRUE, pFont);
m_pSpacerCtrl->Enable(LTFALSE);
dwNumStaticControls = m_controlArray.GetSize();
return CBaseFolder::Build();
;
}
// Build the screen
LTBOOL CScreenFailure::Build()
{
CreateTitle(NULL);
if (g_pLayoutMgr->HasCustomValue(SCREEN_ID_FAILURE,"FailStringRect"))
{
stringRect = g_pLayoutMgr->GetScreenCustomRect(SCREEN_ID_FAILURE,"FailStringRect");
}
if (g_pLayoutMgr->HasCustomValue(SCREEN_ID_FAILURE,"FailStringSize"))
{
stringSize = (uint8)g_pLayoutMgr->GetScreenCustomInt(SCREEN_ID_FAILURE,"FailStringSize");
}
if (g_pLayoutMgr->HasCustomValue(SCREEN_ID_FAILURE,"HelpStringPos"))
{
helpPos = g_pLayoutMgr->GetScreenCustomPoint(SCREEN_ID_FAILURE,"HelpStringPos");
}
if (g_pLayoutMgr->HasCustomValue(SCREEN_ID_FAILURE,"HelpStringSize"))
{
helpSize = (uint8)g_pLayoutMgr->GetScreenCustomInt(SCREEN_ID_FAILURE,"HelpStringSize");
}
LTIntPt stringPos;
stringPos.x = (stringRect.left + stringRect.right) / 2;
stringPos.y = stringRect.top;
m_pString = AddTextItem("failed",NULL,NULL,stringPos,LTTRUE);
if (m_pString)
{
m_pString->SetFont(NULL,stringSize);
m_pString->SetFixedWidth(stringRect.right - stringRect.left);
CUIFormattedPolyString *pStr = m_pString->GetString();
if (pStr)
{
pStr->SetAlignmentH(CUI_HALIGN_CENTER);
}
}
if (g_pLayoutMgr->HasCustomValue(SCREEN_ID_FAILURE,"Delay"))
{
g_fDelay = g_pLayoutMgr->GetScreenCustomFloat(SCREEN_ID_FAILURE,"Delay");
}
CLTGUITextCtrl *pString = AddTextItem(IDS_HELP_FAILURE,NULL,NULL,helpPos,LTTRUE);
if (pString)
{
pString->SetFont(NULL,helpSize);
}
// Make sure to call the base class
if (! CBaseScreen::Build()) return LTFALSE;
UseBack(LTFALSE);
return LTTRUE;
}
// Build the screen
LTBOOL CScreenHostLevels::Build()
{
LTIntPt addPos = g_pLayoutMgr->GetScreenCustomPoint((eScreenID)m_nScreenID,"AddPos");
LTIntPt removePos = g_pLayoutMgr->GetScreenCustomPoint((eScreenID)m_nScreenID,"RemovePos");
LTIntPt commandPos = g_pLayoutMgr->GetScreenCustomPoint((eScreenID)m_nScreenID,"CommandPos");
if (g_pLayoutMgr->HasCustomValue((eScreenID)m_nScreenID,"ListFontSize"))
nListFontSize = (uint8)g_pLayoutMgr->GetScreenCustomInt((eScreenID)m_nScreenID,"ListFontSize");
CreateTitle(IDS_TITLE_HOST_MISSIONS);
m_pAdd = AddTextItem(IDS_HOST_ADD_MISSION, CMD_ADD_LEVEL, IDS_HELP_ADD_MISSION, addPos);
m_pAddAll = AddTextItem(IDS_HOST_ADD_ALL, CMD_ADD_ALL, IDS_HELP_ADD_ALL, commandPos);
m_pRemoveAll = AddTextItem(IDS_HOST_REMOVE_ALL, CMD_REMOVE_ALL, IDS_HELP_REM_ALL);
m_pRemove = AddTextItem(IDS_HOST_REMOVE_MISSION, CMD_REMOVE_LEVEL, IDS_HELP_REM_MISSION, removePos);
LTRect rcAvailRect = g_pLayoutMgr->GetScreenCustomRect((eScreenID)m_nScreenID,"AvailRect");
int nListHeight = (rcAvailRect.bottom - rcAvailRect.top);
nAvailWidth = (rcAvailRect.right - rcAvailRect.left);
m_pAvailMissions = AddList(LTIntPt(rcAvailRect.left,rcAvailRect.top),nListHeight,LTTRUE,nAvailWidth);
m_pAvailMissions->SetIndent(LTIntPt(5,5));
m_pAvailMissions->SetFrameWidth(2);
m_pAvailMissions->Enable(LTFALSE);
LTRect rcSelRect = g_pLayoutMgr->GetScreenCustomRect((eScreenID)m_nScreenID,"SelectRect");
nListHeight = (rcSelRect.bottom - rcSelRect.top);
nSelWidth = (rcSelRect.right - rcSelRect.left);
m_pSelMissions = AddList(LTIntPt(rcSelRect.left,rcSelRect.top),nListHeight,LTTRUE,nSelWidth);
m_pSelMissions->SetIndent(LTIntPt(5,5));
m_pSelMissions->SetFrameWidth(2);
m_pSelMissions->Enable(LTFALSE);
m_nextPos.y += nListHeight;
uint16 nListWidth = nSelWidth-16;
m_pLoopToggle = AddToggle(IDS_LOOP_MISSIONS,IDS_HELP_LOOP_MISSIONS,nListWidth,&m_bLoopMissions);
m_pLoopToggle->SetOnString(LoadTempString(IDS_YES));
m_pLoopToggle->SetOffString(LoadTempString(IDS_NO));
// Make sure to call the base class
if (!CBaseScreen::Build()) return LTFALSE;
UseBack(LTTRUE,LTTRUE);
return LTTRUE;
}
//
// BuildSideList
//
void SideListBox::BuildSideList()
{
DeleteAllItems();
if (random)
{
AddTextItem("Random", TRANSLATE(("#game.sides.random")));
}
for (NBinTree<Sides::Side>::Iterator sides(&Sides::GetSides()); *sides; sides++)
{
AddTextItem((*sides)->GetName().str, TRANSLATE(((*sides)->GetDescription().str)));
}
}
// Build the screen
LTBOOL CScreenControls::Build()
{
CreateTitle(IDS_TITLE_CONTROLS);
kGap = g_pLayoutMgr->GetScreenCustomInt(SCREEN_ID_CONTROLS,"ColumnWidth");
kWidth = g_pLayoutMgr->GetScreenCustomInt(SCREEN_ID_CONTROLS,"SliderWidth");
//customize
AddTextItem(IDS_CONFIGURE, CMD_CONFIGURE, IDS_HELP_CUSTOMCONTROLS);
// Mouse
AddTextItem(IDS_MOUSE, CMD_MOUSE, IDS_HELP_MOUSE);
// keyboard
AddTextItem(IDS_KEYBOARD, CMD_KEYBOARD, IDS_HELP_KEYBOARD);
// use joystick
CLTGUIToggle* pToggle = AddToggle(IDS_JOYSTICK_USE, IDS_HELP_USEJOYSTICK, kGap, &m_bUseJoystick);
pToggle->NotifyOnChange(CMD_UPDATE,this);
char szYes[16];
FormatString(IDS_YES,szYes,sizeof(szYes));
char szNo[16];
FormatString(IDS_NO,szNo,sizeof(szNo));
pToggle->SetOnString(szYes);
pToggle->SetOffString(szNo);
pToggle->Enable( bHasJoystick ? LTTRUE : LTFALSE );
// pToggle->Enable(LTFALSE);
// joystick
m_pJoystickCtrl = AddTextItem(IDS_JOYSTICK, CMD_JOYSTICK, IDS_HELP_JOYSTICK);
m_pJoystickCtrl->Enable( bHasJoystick );
// m_pJoystickCtrl->Enable(LTFALSE);
//restore
AddTextItem(IDS_RESTOREDEFAULTS, CMD_RESET_DEFAULTS, IDS_HELP_RESTORE);
// Make sure to call the base class
if (! CBaseScreen::Build()) return LTFALSE;
// CScreenJoystick *pJoy = (CScreenJoystick *)m_pScreenMgr->GetScreenFromID(SCREEN_ID_JOYSTICK);
// pJoy->Build();
UseBack(LTTRUE,LTTRUE);
return LTTRUE;
}
//
// Event handling
//
U32 DifficultyList::HandleEvent(Event &e)
{
// Rebuild
if (e.type == IFace::EventID())
{
switch (e.subType)
{
case IFace::NOTIFY:
{
// Do specific handling
switch (e.iface.p1)
{
case ICListBoxMsg::Rebuild:
// Clear any current items
DeleteAllItems();
// Add each existing difficulty setting
for (NList<Difficulty::Setting>::Iterator i(&Difficulty::GetSettings()); *i; i++)
{
AddTextItem
(
(*i)->GetName().str, TRANSLATE(((*i)->GetDescription().str))
);
}
break;
}
}
}
}
return (ICListBox::HandleEvent(e));
}
// Build the screen
LTBOOL CScreenOptions::Build()
{
CreateTitle(IDS_TITLE_OPTIONS);
CLTGUITextCtrl* pDisplay = AddTextItem(IDS_DISPLAY, CMD_DISPLAY, IDS_HELP_DISPLAY);
CLTGUITextCtrl* pSound = AddTextItem(IDS_SOUND, CMD_AUDIO, IDS_HELP_SOUND);
CLTGUITextCtrl* pControls = AddTextItem(IDS_CONTROLS, CMD_CONTROLS, IDS_HELP_CONTROLS);
CLTGUITextCtrl* pGame = AddTextItem(IDS_GAME_OPTIONS, CMD_GAME, IDS_HELP_GAME_OPTIONS);
CLTGUITextCtrl* pPerf = AddTextItem(IDS_PERFORMANCE, CMD_PERFORMANCE, IDS_HELP_PERFORMANCE);
// Make sure to call the base class
if (! CBaseScreen::Build()) return LTFALSE;
UseBack(LTTRUE,LTTRUE);
return LTTRUE;
}
//
// BuildPersonalityList
//
void PersonalityListBox::BuildPersonalityList()
{
DeleteAllItems();
if (random)
{
AddTextItem("Random", TRANSLATE(("#mods.personality.random")));
}
const NBinTree<Mods::Mod> *mods = Mods::GetMods(Mods::Types::Personality);
if (mods)
{
for (NBinTree<Mods::Mod>::Iterator mod(mods); *mod; ++mod)
{
AddTextItem((*mod)->GetName().str, TRANSLATE(((*mod)->GetDescription().str)));
}
}
}
void CFolderIntel::BuildIntelList()
{
if (m_nMissionNum < 0) return;
MISSION* pMission = g_pMissionMgr->GetMission(m_nMissionNum);
if (!pMission) return;
CreateTitle(pMission->nNameId);
for (int n =0;n < kNumSFXTypes;n++)
{
nSFXCounts[n] = 0;
}
CLTGUIFont *pFont;
if (g_pLayoutMgr->GetListFontSize((eFolderID)m_nFolderID) == 0)
pFont = GetSmallFont();
else if (g_pLayoutMgr->GetListFontSize((eFolderID)m_nFolderID) == 1)
pFont = GetMediumFont();
else
pFont = GetLargeFont();
int numItems = g_pGameClientShell->GetIntelItemMgr()->GetNumItems(m_nMissionNum);
for (int i = 0; i < numItems; i++)
{
IntelItem *pItem = debug_new(IntelItem);
g_pGameClientShell->GetIntelItemMgr()->GetItem(m_nMissionNum,i,pItem);
int nNameID = 0;
int nCount = 0;
if (pItem->nID)
{
for (int n =0;!nNameID && n < kNumSFXTypes;n++)
{
if (pItem->nType == nSFXIDs[n])
{
nSFXCounts[n]++;
nNameID = nSFXNameIDs[n];
nCount = nSFXCounts[n];
}
}
}
if (nNameID)
{
m_intelArray.Add(pItem);
HSTRING hStr = g_pLTClient->FormatString(nNameID,nCount);
CLTGUITextItemCtrl *pCtrl = AddTextItem(hStr,0,0,LTFALSE,pFont);
g_pLTClient->FreeString(hStr);
pCtrl->SetParam1(m_intelArray.GetSize());
}
else
{
debug_delete(pItem);
}
}
}
void ChoiceForm::UpdateChoicePanel(String shaderName)
{
glFinish();
if (shaderName.Length())
SetText(L"Choice Control - " + shaderName);
currentShaderName = shaderName;
scrollPanel->ClearChildren();
existingChoices.Clear();
additionalAttribs.Clear();
auto choices = choiceControl->GetChoices(shaderName, existingChoices);
int line = 0;
comboBoxChoiceNames.Clear();
choiceComboBoxes.Clear();
choiceCheckBoxes.Clear();
existingChoices.Clear();
scrollPanel->SetLayout(GraphicsUI::ContainerLayoutType::Stack);
for (auto & choice : choices)
{
if (choice.Options.Count() == 1)
continue;
auto wrapper = new GraphicsUI::Container(scrollPanel);
wrapper->AutoHeight = true;
wrapper->Padding = EM(0.1f);
auto lbl = new GraphicsUI::CheckBox(wrapper);
lbl->SetText(choice.ChoiceName);
lbl->Top = EM(0.2f);
choiceCheckBoxes.Add(choice.ChoiceName, lbl);
auto cmb = new GraphicsUI::ComboBox(wrapper);
cmb->AddTextItem(L"(auto) " + choice.DefaultValue);
for (auto & opt : choice.Options)
{
cmb->AddTextItem(opt.ToString());
}
comboBoxChoiceNames[cmb] = choice.ChoiceName;
choiceComboBoxes[choice.ChoiceName] = cmb;
cmb->SetSelectedIndex(0);
cmb->OnChanged.Bind(this, &ChoiceForm::ChoiceComboBox_Changed);
cmb->Posit(0, 0, EM(7.0f), EM(1.5f));
cmb->DockStyle = GraphicsUI::Control::dsRight;
line++;
}
SizeChanged();
}
//
// BuildList
//
void WorldListBox::BuildWorldList()
{
DeleteAllItems();
if (TerrainGroup::Initialized())
{
// Get the group tree
for (BinTree<TerrainGroup::Group>::Iterator i(&TerrainGroup::GetGroupTree()); *i; ++i)
{
AddTextItem((*i)->Name(), NULL);
}
}
}
//
// TeamListBox::BuildTeamList
//
void TeamListBox::BuildTeamList()
{
DeleteAllItems();
for (U32 i = 0; i < Game::MAX_TEAMS; i++)
{
Team *team = Team::Id2Team(i);
if (team)
{
AddTextItem(team->GetName(), NULL);
}
}
}
void CFolderMultiBriefing::OnFocus(LTBOOL bFocus)
{
if (bFocus)
{
int missionId = g_pGameClientShell->GetMPMissionName();
int briefId = g_pGameClientShell->GetMPMissionBriefing();
if (missionId)
{
CLTGUIFont *pFont = (briefId ? GetMediumFont() : GetLargeFont());
CLTGUITextItemCtrl* pCtrl =AddTextItem(missionId,LTNULL,0,LTTRUE,pFont);
pCtrl->SetFixedWidth(480);
pCtrl->Enable(LTFALSE);
}
if (briefId)
{
if (missionId) AddBlankLine();
CLTGUITextItemCtrl* pCtrl=AddTextItem(IDS_BRIEFING,LTNULL,0,LTTRUE,GetMediumFont());
pCtrl->Enable(LTFALSE);
CStaticTextCtrl *pBrief = AddStaticTextItem(briefId,LTNULL,LTNULL,480,0,LTTRUE,GetSmallFont());
if (pBrief)
{
pBrief->Enable(LTFALSE);
}
}
UseBack(LTFALSE);
}
else
{
RemoveFree();
}
CBaseFolder::OnFocus(bFocus);
}
void TextArea::ChompIntoItems( const char *text, const char *parent )
{
char *temp = strdup( text );
char *cur = temp, chr = '\0';
int i = 0, max = strlen( temp );
float cur_width = 0, wid = 0, end = glutStrokeWidth( GLUT_STROKE_ROMAN, 'A' );
end /= 2500;
wid = end;
for (i = 0; i <= max; i++) {
if (temp[i] == '\r') continue;
cur_width = WidthOfChar( temp[i] );
if (wid+cur_width > width[5] || temp[i] == '\n') {
chr = temp[i];
temp[i] = '\0';
AddTextItem( "content", cur, parent );
temp[i] = chr;
cur = &temp[i];
if (cur[0] == '\n') cur++;
wid = end;
} else {wid += cur_width; }}
if (temp[i] != '\0') AddTextItem( "content", cur, parent );
free( temp );
}
// Build the screen
LTBOOL CScreenJoin::Build()
{
// Make sure to call the base class
if (!CBaseScreen::Build()) return LTFALSE;
CreateTitle(IDS_TITLE_JOIN);
// Very, very temporary....
// NYI NYI NYI
int kColumn0 = g_pLayoutMgr->GetScreenCustomInt(SCREEN_ID_HOST,"ColumnWidth");
int kColumn1 = (640 - GetPageLeft()) - kColumn0;
m_pFindCtrl = AddTextItem(IDS_FIND_SERVERS,CMD_SEARCH,IDS_HELP_FIND_SERVERS);
m_pFindCtrl->Enable(LTFALSE);
m_pStatusCtrl = AddTextItem("Status: Waiting", 0, IDS_HELP_FIND_SERVERS);
m_pStatusCtrl->Enable(LTFALSE);
m_pCDKeyCtrl = AddColumnCtrl(CMD_EDIT_CDKEY, IDS_HELP_FIND_SERVERS);
m_pCDKeyCtrl->AddColumn("CD Key", kColumn0);
m_pCDKeyCtrl->AddColumn(m_sCurCDKey.c_str(), kColumn1, LTTRUE);
CLTGUIColumnCtrl* pCtrl = AddColumnCtrl(LTNULL, LTNULL, kDefaultPos, LTTRUE);
char aTemp[256];
FormatString(IDS_SERVER_NAME,aTemp,sizeof(aTemp));
pCtrl->AddColumn(aTemp, kColumnWidth_ServerName);
pCtrl->AddColumn("Map", kColumnWidth_MapName);
pCtrl->AddColumn("Players", kColumnWidth_Players);
pCtrl->Enable(LTFALSE);
uint16 height = GetPageBottom() - m_nextPos.y;
m_pServerListCtrl = AddList(m_nextPos,height,LTTRUE,kColumnWidth);
m_pServerListCtrl->SetScrollWrap(LTFALSE);
return LTTRUE;
}
// Build the screen
LTBOOL CScreenTeam::Build()
{
CreateTitle(IDS_TITLE_TEAM);
int kColumn0 = g_pLayoutMgr->GetScreenCustomInt(SCREEN_ID_TEAM,"ColumnWidth");
int kColumn1 = (640 - GetPageLeft()) - kColumn0;
int kArrow = g_pLayoutMgr->GetScreenCustomInt(SCREEN_ID_TEAM,"ArrowWidth");
m_pName = AddColumnCtrl(CMD_EDIT_NAME, IDS_HELP_TEAM_NAME);
m_pName->AddColumn(LoadTempString(IDS_TEAM_NAME), kColumn0);
m_pName->AddColumn("<Team name>", kColumn1, LTTRUE);
m_pModel = AddTextItem(IDS_TEAM_MODEL, LTNULL, IDS_HELP_TEAM_MODEL);
LTIntPt arrowPos = m_pModel->GetBasePos();
arrowPos.x += kColumn0;
HTEXTURE hLeft = g_pInterfaceResMgr->GetTexture("interface\\menu\\sprtex\\arrowlt.dtx");
HTEXTURE hLeftH = g_pInterfaceResMgr->GetTexture("interface\\menu\\sprtex\\arrowlt_h.dtx");
m_pLeft = debug_new(CLTGUIButton);
if (m_pLeft)
{
m_pLeft->Create(CMD_LEFT,LTNULL,hLeft,hLeftH);
m_pLeft->SetBasePos(arrowPos);
AddControl(m_pLeft);
m_pLeft->SetCommandHandler(this);
}
arrowPos.x += kArrow;
HTEXTURE hRight = g_pInterfaceResMgr->GetTexture("interface\\menu\\sprtex\\arrowrt.dtx");
HTEXTURE hRightH = g_pInterfaceResMgr->GetTexture("interface\\menu\\sprtex\\arrowrt_h.dtx");
m_pRight = debug_new(CLTGUIButton);
if (m_pRight)
{
m_pRight->Create(CMD_RIGHT,LTNULL,hRight,hRightH);
m_pRight->SetBasePos(arrowPos);
AddControl(m_pRight);
m_pRight->SetCommandHandler(this);
}
// Make sure to call the base class
return CBaseScreen::Build();
}
// Build the folder
LTBOOL CFolderControls::Build()
{
CreateTitle(IDS_TITLE_CONTROLS);
if (g_pLayoutMgr->HasCustomValue(FOLDER_ID_CONTROLS,"ColumnWidth"))
kGap = g_pLayoutMgr->GetFolderCustomInt(FOLDER_ID_CONTROLS,"ColumnWidth");
if (g_pLayoutMgr->HasCustomValue(FOLDER_ID_CONTROLS,"SliderWidth"))
kWidth = g_pLayoutMgr->GetFolderCustomInt(FOLDER_ID_CONTROLS,"SliderWidth");
//customize
AddTextItem(IDS_CUSTOM_CONTROLS, FOLDER_CMD_CUSTOM_CONTROLS, IDS_HELP_CUSTOMCONTROLS);
//customize
AddTextItem(IDS_WEAPON_CONTROLS, FOLDER_CMD_WEAPON_CONTROLS, IDS_HELP_WEAPON_CONTROLS);
// Mouse
AddTextItem(IDS_MOUSE, FOLDER_CMD_MOUSE, IDS_HELP_MOUSE);
// Mouse
AddTextItem(IDS_KEYBOARD, FOLDER_CMD_KEYBOARD, IDS_HELP_KEYBOARD);
// use joystick
uint32 dwAdvancedOptions = g_pInterfaceMgr->GetAdvancedOptions();
CToggleCtrl* pToggle = AddToggle(IDS_JOYSTICK_USE, IDS_HELP_USEJOYSTICK, kGap, &m_bUseJoystick);
pToggle->NotifyOnChange(FOLDER_CMD_UPDATE,this);
pToggle->SetOnString(IDS_YES);
pToggle->SetOffString(IDS_NO);
pToggle->Enable( (dwAdvancedOptions & AO_JOYSTICK) );
// joystick
m_pJoystickCtrl = AddTextItem(IDS_JOYSTICK, FOLDER_CMD_JOYSTICK, IDS_HELP_JOYSTICK);
m_pJoystickCtrl->Enable( (dwAdvancedOptions & AO_JOYSTICK) );
//restore
AddTextItem(IDS_RESTOREDEFAULTS, FOLDER_CMD_RESET_DEFAULTS, IDS_HELP_RESTORE);
// Make sure to call the base class
if (! CBaseFolder::Build()) return LTFALSE;
CFolderJoystick *pJoy = (CFolderJoystick *)m_pFolderMgr->GetFolderFromID(FOLDER_ID_JOYSTICK);
pJoy->Build();
UseBack(LTTRUE,LTTRUE);
return LTTRUE;
}
//
// PlayerListBox::BuildPlayerList
//
void PlayerListBox::BuildPlayerList()
{
DeleteAllItems();
// Step through all players
for (U32 i = 0; i < Game::MAX_PLAYERS; i++)
{
if (Player *player = Player::Id2Player(i))
{
// Always filter AI players from this list
if (player->GetType() != Player::AI)
{
// Should we show the current player
if ((player != Player::GetCurrentPlayer()) || (playerListStyle & STYLE_SHOWCURRENT))
{
// Get the players team
if (Team *team = player->GetTeam())
{
// Is the relation acceptable
if ((playerListStyle & STYLE_ALLRELATIONS) || Team::TestRelation(team, Team::GetDisplayTeam(), Relation::ALLY))
{
char buf[32];
// Key by name as default
const char *key = player->GetName();
if (playerListStyle & STYLE_KEYID)
{
Utils::Sprintf(buf, sizeof(buf), "%3d", i);
key = buf;
}
Color c = player->GetTeam()->GetColor();
AddTextItem(key, player->GetDisplayName(), &c);
}
}
}
}
}
}
}
void CFolderViewInventory::OnFocus(LTBOOL bFocus)
{
if (bFocus)
{
m_nLastWeapon = WMGR_INVALID_ID;
m_szModel[0] = '\0';
m_szSkin[0] = '\0';
BuildInventoryList();
if (!m_controlArray.GetSize())
{
CLTGUITextItemCtrl *pCtrl = AddTextItem(IDS_NO_INVENTORY,LTNULL,LTNULL,LTTRUE,GetLargeFont());
pCtrl->Enable(LTFALSE);
}
m_nKey = GetCommandKey(COMMAND_ID_INVENTORY);
bOKtoDismiss = !IsKeyDown(m_nKey);
}
else
{
SetSelection(kNoSelection);
ClearInventoryList();
}
CBaseSelectionFolder::OnFocus(bFocus);
}
// Build the screen
bool CScreenOptions::Build()
{
CreateTitle("IDS_TITLE_OPTIONS");
CLTGUICtrl_create cs;
cs.rnBaseRect.m_vMin.Init();
cs.rnBaseRect.m_vMax = LTVector2n(m_ScreenRect.GetWidth(),g_pLayoutDB->GetInt32(m_hLayout,LDB_ScreenFontSize));
cs.nCommandID = CMD_DISPLAY;
cs.szHelpID = "IDS_HELP_DISPLAY";
AddTextItem("IDS_DISPLAY", cs );
cs.nCommandID = CMD_AUDIO;
cs.szHelpID = "IDS_HELP_SOUND";
AddTextItem("IDS_SOUND", cs );
cs.nCommandID = CMD_PERFORMANCE;
cs.szHelpID = "IDS_HELP_PERFORMANCE";
AddTextItem("IDS_PERFORMANCE", cs);
cs.nCommandID = CMD_CONTROLS;
cs.szHelpID = "IDS_HELP_CONTROLS";
AddTextItem("IDS_CONTROLS", cs);
cs.nCommandID = CMD_GAME;
cs.szHelpID = "IDS_HELP_GAME_OPTIONS";
AddTextItem("IDS_GAME_OPTIONS", cs );
cs.nCommandID = CMD_WEAPONS;
cs.szHelpID = "IDS_HELP_WEAPONS";
AddTextItem( "IDS_WEAPONS", cs );
// Make sure to call the base class
if (! CBaseScreen::Build()) return false;
UseBack(true,true);
return true;
}
// Build the screen
LTBOOL CScreenGame::Build()
{
CreateTitle(IDS_TITLE_GAME_OPTIONS);
kGap = g_pLayoutMgr->GetScreenCustomInt(SCREEN_ID_GAME,"ColumnWidth");
kWidth = g_pLayoutMgr->GetScreenCustomInt(SCREEN_ID_GAME,"SliderWidth");
//background frame
LTRect frameRect = g_pLayoutMgr->GetScreenCustomRect(SCREEN_ID_GAME,"FrameRect");
LTIntPt pos(frameRect.left,frameRect.top);
int nHt = frameRect.bottom - frameRect.top;
int nWd = frameRect.right - frameRect.left;
char szFrame[128];
g_pLayoutMgr->GetScreenCustomString(SCREEN_ID_GAME,"FrameTexture",szFrame,sizeof(szFrame));
HTEXTURE hFrame = g_pInterfaceResMgr->GetTexture(szFrame);
CLTGUIFrame *pFrame = debug_new(CLTGUIFrame);
pFrame->Create(hFrame,nWd,nHt+8,LTTRUE);
pFrame->SetBasePos(pos);
pFrame->SetBorder(2,m_SelectedColor);
AddControl(pFrame);
//crosshair menu
AddTextItem(IDS_CONTROLS_CROSSHAIR, CMD_CROSSHAIR, IDS_HELP_CROSSHAIRMENU);
CLTGUICycleCtrl* pCycle = AddCycle(IDS_DISPLAY_SUBTITLES,IDS_HELP_SUBTITLES,kGap,&m_nSubtitles);
char szTmp[64];
FormatString(IDS_OFF,szTmp,sizeof(szTmp));
pCycle->AddString(szTmp);
FormatString(IDS_ON,szTmp,sizeof(szTmp));
pCycle->AddString(szTmp);
CUserProfile *pProfile = g_pProfileMgr->GetCurrentProfile();
if (pProfile && !g_pVersionMgr->IsLowViolence())
{
CLTGUIToggle *pGore = AddToggle(IDS_DISPLAY_GORE,IDS_HELP_GORE,kGap,&m_bGore);
}
char szYes[16];
char szNo[16];
FormatString(IDS_YES,szYes,sizeof(szYes));
FormatString(IDS_NO,szNo,sizeof(szNo));
//always run
CLTGUIToggle* pToggle = AddToggle(IDS_ADVCONTROLS_RUNLOCK, IDS_HELP_RUNLOCK, kGap, &m_bAlwaysRun );
pToggle->SetOnString(szYes);
pToggle->SetOffString(szNo);
// Add the Difficulty option
m_pDifficultyCtrl = AddCycle(IDS_DIFFICULTY,IDS_HELP_DIFFICULTY,kGap,&m_nDifficulty);
FormatString(IDS_NEW_EASY,szTmp,sizeof(szTmp));
m_pDifficultyCtrl->AddString(szTmp);
FormatString(IDS_NEW_MEDIUM,szTmp,sizeof(szTmp));
m_pDifficultyCtrl->AddString(szTmp);
FormatString(IDS_NEW_HARD,szTmp,sizeof(szTmp));
m_pDifficultyCtrl->AddString(szTmp);
FormatString(IDS_NEW_INSANE,szTmp,sizeof(szTmp));
m_pDifficultyCtrl->AddString(szTmp);
/*
pCycle = AddCycle(IDS_HUDLAYOUT,IDS_HELP_HUDLAYOUT,kGap,&m_nLayout);
for (int hl = 0; hl < g_pLayoutMgr->GetNumHUDLayouts(); hl++)
{
char szTmpBuffer[128];
FormatString(g_pLayoutMgr->GetLayoutName(hl),szTmpBuffer,sizeof(szTmpBuffer));
pCycle->AddString(szTmpBuffer);
}
*/
CLTGUISlider *pSlider=AddSlider(IDS_HEADBOB, IDS_HELP_HEADBOB, kGap, kWidth, -1, &m_nHeadBob);
pSlider->SetSliderRange(0, 10);
pSlider->SetSliderIncrement(1);
pSlider=AddSlider(IDS_WEAPONSWAY, IDS_HELP_WEAPONSWAY, kGap, kWidth, -1, &m_nWeaponSway);
pSlider->SetSliderRange(0, 10);
pSlider->SetSliderIncrement(1);
pSlider=AddSlider(IDS_PICKUP_MSG_DUR, IDS_HELP_PICKUP_MSG_DUR, kGap, kWidth, -1, &m_nMsgDur);
pSlider->SetSliderRange(1, 10);
pSlider->SetSliderIncrement(1);
pToggle = AddToggle(IDS_AUTOSWITCH_WEAPONS, IDS_HELP_AUTOSWITCH_WEAPONS, kGap, &m_bAutoWeaponSwitch );
pToggle->SetOnString(szYes);
pToggle->SetOffString(szNo);
pToggle = AddToggle(IDS_LOAD_TIPS, IDS_HELP_LOAD_TIPS, kGap, &m_bLoadScreenTips );
pToggle->SetOnString(LoadTempString(IDS_ON));
pToggle->SetOffString(LoadTempString(IDS_OFF));
pToggle = AddToggle(IDS_CONTOUR, IDS_HELP_CONTOUR, kGap, &m_bVehicleContour );
pToggle->SetOnString(LoadTempString(IDS_ON));
pToggle->SetOffString(LoadTempString(IDS_OFF));
// Make sure to call the base class
if (! CBaseScreen::Build()) return LTFALSE;
UseBack(LTTRUE,LTTRUE);
return LTTRUE;
}
// Build the folder
LTBOOL CFolderAdvDisplay::Build()
{
if (g_pLayoutMgr->HasCustomValue(FOLDER_ID_ADVDISPLAY,"ColumnWidth"))
{
kTotalWidth = g_pLayoutMgr->GetFolderCustomInt(FOLDER_ID_ADVDISPLAY,"ColumnWidth");
kHeaderWidth = kTotalWidth - kSpacerWidth;
}
if (g_pLayoutMgr->HasCustomValue(FOLDER_ID_ADVDISPLAY,"SliderWidth"))
kSliderWidth = g_pLayoutMgr->GetFolderCustomInt(FOLDER_ID_ADVDISPLAY,"SliderWidth");
CreateTitle(IDS_TITLE_ADVDISPLAY);
AddTextItem(IDS_TEXTURE_RES, CMD_TEXTURES, IDS_HELP_TEXTURE_RES);
m_pLightMap = AddToggle(IDS_LIGHTMAP, IDS_HELP_LIGHTMAP, kTotalWidth, &m_bLightMap );
m_pLightMap->SetOnString(IDS_ON);
m_pLightMap->SetOffString(IDS_OFF);
m_pMirrors = AddToggle(IDS_MIRRORS, IDS_HELP_MIRRORS, kTotalWidth, &m_bMirrors );
m_pMirrors->SetOnString(IDS_ON);
m_pMirrors->SetOffString(IDS_OFF);
m_pShadows = AddCycleItem(IDS_SHADOWS,IDS_HELP_SHADOWS,kHeaderWidth,kSpacerWidth,&m_nShadows);
m_pShadows->AddString(IDS_NONE);
m_pShadows->AddString(IDS_CIRCULAR);
// m_pShadows->AddString(IDS_PROJECTED);
CToggleCtrl* pToggle = AddToggle(IDS_DETAILTEXTURES, IDS_HELP_DETAILTEXTURES, kTotalWidth, &m_bDetailTextures );
pToggle->SetOnString(IDS_ON);
pToggle->SetOffString(IDS_OFF);
pToggle = AddToggle(IDS_ENVIRONMENT_MAP, IDS_HELP_ENVIRONMENT_MAP, kTotalWidth, &m_bEnvMapWorld );
pToggle->SetOnString(IDS_ON);
pToggle->SetOffString(IDS_OFF);
pToggle = AddToggle(IDS_CHROME, IDS_HELP_CHROME, kTotalWidth, &m_bEnvMapEnable );
pToggle->SetOnString(IDS_ON);
pToggle->SetOffString(IDS_OFF);
// m_pOverdraw = AddToggle(IDS_OVERDRAW, IDS_HELP_OVERDRAW, kTotalWidth, &m_bFixSparkleys );
// m_pOverdraw->SetOnString(IDS_ON);
// m_pOverdraw->SetOffString(IDS_OFF);
pToggle = AddToggle(IDS_TRILINEAR, IDS_HELP_TRILINEAR, kTotalWidth, &m_bTrilinear );
pToggle->SetOnString(IDS_ON);
pToggle->SetOffString(IDS_OFF);
pToggle = AddToggle(IDS_TRIPLE_BUFF, IDS_HELP_TRIPLE_BUFF, kTotalWidth, &m_bTripleBuffer );
pToggle->SetOnString(IDS_ON);
pToggle->SetOffString(IDS_OFF);
uint32 dwAdvancedOptions = g_pInterfaceMgr->GetAdvancedOptions();
pToggle->Enable( (dwAdvancedOptions & AO_TRIPLEBUFFER) );
// Make sure to call the base class
if (!CBaseFolder::Build()) return LTFALSE;
UseBack(LTTRUE,LTTRUE);
return LTTRUE;
}
void CFolderSave::BuildSavedLevelList()
{
AddTextItem(IDS_QUICKSAVE,FOLDER_CMD_CUSTOM,IDS_HELP_QUICKSAVE,LTFALSE,GetMediumFont());
// Create an empty string
HSTRING hEmpty=g_pLTClient->CreateString(" ");
int nFirstEmpty = -1;
CLTGUITextItemCtrl *pCtrl = AddTextItem(IDS_LOAD_USERGAME,LTNULL,LTNULL,LTTRUE,GetMediumFont());
pCtrl->Enable(LTFALSE);
for (int i = 0; i < kMaxSave; i++)
{
LTBOOL bEmpty = LTTRUE;
char strFilename[128];
sprintf (strFilename, "Save\\Slot%02d.sav", i+1);
if (CWinUtil::FileExist(strFilename))
{
char strSaveGameSetting[256];
memset (strSaveGameSetting, 0, 256);
char strKey[32];
sprintf (strKey, "SaveGame%02d", i+1);
CWinUtil::WinGetPrivateProfileString (GAME_NAME, strKey, "", strSaveGameSetting, 256, SAVEGAMEINI_FILENAME);
int mission = -1;
int level = -1;
struct tm* pTimeDate = LTNULL;
char strWorldName[128] = "";
char strUserName[128] = "";
char strTime[128] = "";
if (strlen (strSaveGameSetting) > 0)
{
char* pWorldName = strtok(strSaveGameSetting,"|");
char* pNameStr = strtok(NULL,"|");
char* pTimeStr = strtok(NULL,"|");
time_t nSeconds = (time_t) atol (pTimeStr);
pTimeDate = localtime (&nSeconds);
if (pTimeDate)
{
if (g_pInterfaceResMgr->IsEnglish())
{
sprintf (strTime, "%02d/%02d/%02d %02d:%02d:%02d", pTimeDate->tm_mon + 1, pTimeDate->tm_mday, (pTimeDate->tm_year + 1900) % 100, pTimeDate->tm_hour, pTimeDate->tm_min, pTimeDate->tm_sec);
}
else
{
sprintf (strTime, "%02d/%02d/%02d %02d:%02d:%02d", pTimeDate->tm_mday, pTimeDate->tm_mon + 1, (pTimeDate->tm_year + 1900) % 100, pTimeDate->tm_hour, pTimeDate->tm_min, pTimeDate->tm_sec);
}
}
sprintf(strWorldName," %s",pWorldName);
sprintf(strUserName," %s",pNameStr);
}
HSTRING hWorld = LTNULL;
HSTRING hTime = LTNULL;
if (strlen(strUserName) > 0)
{
hWorld = g_pLTClient->CreateString(strUserName);
bEmpty = LTFALSE;
}
else if (strlen(strWorldName) > 0)
{
hWorld=g_pLTClient->CreateString(strWorldName);
bEmpty = LTFALSE;
}
if (!bEmpty && strlen(strTime) > 0)
{
// Set the text in the control
hTime=g_pLTClient->CreateString(strTime);
}
if (hWorld)
{
CLTGUIColumnTextCtrl* pCtrl = AddColumnText(FOLDER_CMD_CUSTOM+1+i, IDS_HELP_SAVEGAME, LTFALSE, GetSmallFont());
pCtrl->SetParam1( m_controlArray.GetSize() - 1);
// The world name column
pCtrl->AddColumn(hWorld, kColumnWidth, LTF_JUSTIFY_LEFT);
// This is a spacer
pCtrl->AddColumn(hEmpty, kGap, LTF_JUSTIFY_LEFT);
if (hTime)
{
// The column that contains the date/time
pCtrl->AddColumn(hTime, 230, LTF_JUSTIFY_LEFT);
g_pLTClient->FreeString(hTime);
}
g_pLTClient->FreeString(hWorld);
}
}
if (bEmpty && nFirstEmpty < 0)
nFirstEmpty = i;
}
if (nFirstEmpty >= 0)
{
CLTGUIColumnTextCtrl* pCtrl = AddColumnText(FOLDER_CMD_CUSTOM+1+nFirstEmpty, IDS_HELP_SAVEGAME, LTFALSE, GetSmallFont());
pCtrl->SetParam1( m_controlArray.GetSize() - 1);
// The world name column
pCtrl->AddColumn(IDS_EMPTY, kColumnWidth, LTF_JUSTIFY_LEFT);
// This is a spacer
pCtrl->AddColumn(hEmpty, kGap, LTF_JUSTIFY_LEFT);
// The column that contains the date/time
pCtrl->AddColumn(hEmpty, 230, LTF_JUSTIFY_LEFT);
}
g_pLTClient->FreeString(hEmpty);
}
// Build the screen
LTBOOL CScreenPlayerSkills::Build()
{
g_pSkillsScreen = this;
CreateTitle(IDS_TITLE_SKILLS);
int kColumn = g_pLayoutMgr->GetScreenCustomInt(SCREEN_ID_PLAYER_SKILLS,"ColumnWidth");
int kSlider = g_pLayoutMgr->GetScreenCustomInt(SCREEN_ID_PLAYER_SKILLS,"SliderWidth");
s_nMaxPool = g_pSkillsButeMgr->GetMultiplayerPool();
LTIntPt pos = m_nextPos;
AddTextItem(IDS_SKILL_PTS,LTNULL,LTNULL,pos,LTTRUE);
pos.x += kColumn;
m_pPool = AddTextItem("999",LTNULL,LTNULL,pos,LTTRUE);
pos.y += (m_pPool->GetBaseHeight() + 16);
for (uint8 i = 0; i < kNumSkills; i++)
{
pos.x = GetPageLeft();
eSkill skl = (eSkill)i;
if (g_pSkillsButeMgr->IsAvailable(skl) )
{
m_pSkill[i] = AddSlider(GetSkillNameId(skl),GetSkillDescriptionId(skl),kColumn,kSlider,-1,&m_nLevels[i], pos);
m_pSkill[i]->SetSliderIncrement(1);
m_pSkill[i]->SetSliderRange(0,kNumSkillLevels-1);
m_pSkill[i]->SetRangeCallback(SliderCallBack);
m_pSkill[i]->SetParam1(i);
pos.x += (kColumn + kSlider + 5);
m_pLabel[i] = AddCycle(" ",NULL,20,&s_nLevels[i],pos,LTTRUE);
for (int j = 0; j < kNumSkillLevels; j++)
{
eSkillLevel nxt = (eSkillLevel)(j+1);
char szTemp[32];
if ( nxt < kNumSkillLevels)
{
uint32 nCost = g_pSkillsButeMgr->GetCostToUpgrade(skl,nxt);
sprintf(szTemp,"%s (%d)",GetSkillLevelName((eSkillLevel)j),nCost);
}
else
{
SAFE_STRCPY(szTemp,GetSkillLevelName((eSkillLevel)j));
}
m_pLabel[i]->AddString(szTemp);
}
pos.y += m_pSkill[i]->GetBaseHeight();
kNumAvailSkills++;
}
}
pos.x = GetPageLeft();
pos.y += 8;
AddTextItem(IDS_RESET_SKILLS,CMD_SKILLS,IDS_HELP_RESET_SKILLS,pos);
// Make sure to call the base class
return CBaseScreen::Build();
}
// Build the screen
LTBOOL CScreenHostTDMOptions::Build()
{
int kColumn = g_pLayoutMgr->GetScreenCustomInt(SCREEN_ID_HOST_DM_OPTIONS,"ColumnWidth");
int kSlider = g_pLayoutMgr->GetScreenCustomInt(SCREEN_ID_HOST_DM_OPTIONS,"SliderWidth");
CreateTitle(IDS_TITLE_HOST_OPTIONS);
m_pTeam1 = AddTextItem(IDS_TEAM_1, CMD_TEAM1, IDS_HELP_TEAM_1);
m_pTeam2 = AddTextItem(IDS_TEAM_2, CMD_TEAM2, IDS_HELP_TEAM_2);
LTIntPt tmp = m_nextPos;
LTIntPt pos = m_pTeam1->GetBasePos();
pos.x += kColumn;
m_pTeam1Name = AddTextItem("<team one>",0,0,pos,LTTRUE);
pos = m_pTeam2->GetBasePos();
pos.x += kColumn;
m_pTeam2Name = AddTextItem("<team two>",0,0,pos,LTTRUE);
m_nextPos = tmp;
m_pMaxPlayers = AddSlider(IDS_MAX_PLAYERS, IDS_MAX_PLAYERS_HELP, kColumn, kSlider, -1, &m_nMaxPlayers);
m_pMaxPlayers->SetSliderRange(2, 16);
m_pMaxPlayers->SetSliderIncrement(1);
m_pMaxPlayers->SetNumericDisplay(LTTRUE);
char szYes[16];
char szNo[16];
FormatString(IDS_YES,szYes,sizeof(szYes));
FormatString(IDS_NO,szNo,sizeof(szNo));
CLTGUIToggle* pToggle = AddToggle(IDS_FRIENDLY_FIRE,IDS_FRIENDLY_FIRE_HELP,kColumn,&m_bFriendlyFire);
pToggle->SetOnString(szYes);
pToggle->SetOffString(szNo);
CLTGUISlider* pSlider = AddSlider(IDS_RUN_SPEED, IDS_RUN_SPEED_HELP, kColumn, kSlider, -1, &m_nRunSpeed);
pSlider->SetSliderRange(100, kMaxRunSpeed);
pSlider->SetSliderIncrement(10);
pSlider->SetNumericDisplay(LTTRUE);
pSlider = AddSlider(IDS_FRAG_LIMIT, IDS_FRAG_LIMIT_HELP, kColumn, kSlider, -1, &m_nScoreLimit);
pSlider->SetSliderRange(0,kMaxScoreLimit);
pSlider->SetSliderIncrement(10);
pSlider->SetNumericDisplay(LTTRUE);
pSlider = AddSlider(IDS_TIME_LIMIT, IDS_TIME_LIMIT_HELP, kColumn, kSlider, -1, &m_nTimeLimit);
pSlider->SetSliderRange(0,kMaxTimeLimit);
pSlider->SetSliderIncrement(5);
pSlider->SetNumericDisplay(LTTRUE);
pSlider = AddSlider( IDS_ROUNDS, IDS_ROUNDS_HELP, kColumn, kSlider, -1, &m_nRounds );
pSlider->SetSliderRange( 1, kMaxRounds );
pSlider->SetSliderIncrement( 1 );
pSlider->SetNumericDisplay( LTTRUE );
pSlider = AddSlider(IDS_FRAG_SCORE, IDS_FRAG_SCORE_HELP, kColumn, kSlider, -1, &m_nFragScore);
pSlider->SetSliderRange(0,3);
pSlider->SetSliderIncrement(1);
pSlider->SetNumericDisplay(LTTRUE);
pSlider = AddSlider(IDS_TAG_SCORE, IDS_TAG_SCORE_HELP, kColumn, kSlider, -1, &m_nTagScore);
pSlider->SetSliderRange(0,3);
pSlider->SetSliderIncrement(1);
pSlider->SetNumericDisplay(LTTRUE);
// Make sure to call the base class
return CBaseScreen::Build();
}
void CFolderSummary::UpdateData()
{
CPlayerSummaryMgr *pPSummary = g_pGameClientShell->GetPlayerSummary();
if (!pPSummary) return;
CMissionData* pMissionData = g_pInterfaceMgr->GetMissionData();
if (!pMissionData) return;
int nMissionNum = pMissionData->GetMissionNum();
MISSION* pMission = g_pMissionMgr->GetMission(nMissionNum);
if (!pMission) return;
MISSIONSUMMARY* pMSummary = pPSummary->GetMissionSummary(nMissionNum);
if (!pMSummary) return;
pPSummary->ReadRankData();
RemoveFree();
CLTGUITextItemCtrl* pCtrl = LTNULL;
CLTGUIColumnTextCtrl *pRanks=AddColumnText(LTNULL, LTNULL, LTTRUE, GetLargeFont());
// The rank header
pRanks->AddColumn(IDS_STAT_RANK, 200, LTF_JUSTIFY_LEFT);
if (m_nFolderID != FOLDER_ID_FAILURE)
{
pRanks->AddColumn(IDS_SUMMARY_BEST, 200, LTF_JUSTIFY_LEFT);
}
pRanks->Enable(LTFALSE);
pRanks=AddColumnText(LTNULL, LTNULL, LTTRUE, GetSmallFont());
//rank
LTFLOAT fRank = 0.0f;
int nRankId = 0;
if (m_nFolderID == FOLDER_ID_FAILURE)
{
pRanks->AddColumn(IDS_STAT_FAILED, 200, LTF_JUSTIFY_LEFT);
}
else
{
fRank = pMSummary->fCurRank;
nRankId = g_pMissionMgr->GetMissionRating()->GetRankId(fRank);
pRanks->AddColumn(nRankId, 200, LTF_JUSTIFY_LEFT);
}
if (m_nFolderID != FOLDER_ID_FAILURE)
{
//best rank
fRank = pMSummary->fBestRank;
nRankId = g_pMissionMgr->GetMissionRating()->GetRankId(fRank);
pRanks->AddColumn(nRankId, 200, LTF_JUSTIFY_LEFT);
}
pRanks->Enable(LTFALSE);
//time in mission
char str[128];
LTFLOAT fSec = pMSummary->fTotalMissionTime;
uint32 nMin = (uint32)fSec / 60;
fSec -= (60.0f * (LTFLOAT)nMin);
uint32 nHour = nMin / 60;
nMin -= 60 * nHour;
sprintf(str,"%02d:%02d:%.1f",nHour,nMin,fSec);
HSTRING hTxt=g_pLTClient->FormatString(IDS_STAT_TIME,str);
pCtrl= AddTextItem(hTxt,LTNULL,0,LTTRUE, GetLargeFont());
pCtrl->Enable(LTFALSE);
g_pLTClient->FreeString(hTxt);
//accuracy
if (pMission->bAllowAwards)
{
pCtrl = AddTextItem(IDS_STAT_ACCURACY,LTNULL,0, LTTRUE, GetLargeFont());
pCtrl->Enable(LTFALSE);
LTFLOAT fAccuracy = 0.0f;
if (pMSummary->dwNumShotsFired)
{
fAccuracy = (LTFLOAT) pMSummary->dwNumHits / (LTFLOAT) pMSummary->dwNumShotsFired;
int nAccuracy =(int)( 100.0f * fAccuracy);
//shots fired
hTxt=g_pLTClient->FormatString(IDS_STAT_SHOTS,
pMSummary->dwNumShotsFired,pMSummary->dwNumHits, nAccuracy);
pCtrl= AddTextItem(hTxt,LTNULL,0,LTTRUE, GetSmallFont());
pCtrl->Enable(LTFALSE);
g_pLTClient->FreeString(hTxt);
//hit locations
uint32 h = pMSummary->dwHitLocations[HL_HEAD];
uint32 t = pMSummary->dwHitLocations[HL_TORSO];
uint32 a = pMSummary->dwHitLocations[HL_ARM];
uint32 l = pMSummary->dwHitLocations[HL_LEG];
hTxt=g_pLTClient->FormatString(IDS_STAT_HITS,h,t,(a+l));
pCtrl= AddTextItem(hTxt,LTNULL,0, LTTRUE, GetSmallFont());
pCtrl->Enable(LTFALSE);
g_pLTClient->FreeString(hTxt);
// casualties
pCtrl = AddTextItem(IDS_STAT_CASUALTIES,LTNULL,0, LTTRUE, GetLargeFont());
pCtrl->Enable(LTFALSE);
hTxt=g_pLTClient->FormatString(IDS_STAT_KILLS, pMSummary->dwNumEnemyKills,
pMSummary->dwNumFriendKills, pMSummary->dwNumNeutralKills);
pCtrl= AddTextItem(hTxt,LTNULL,0, LTTRUE, GetSmallFont());
pCtrl->Enable(LTFALSE);
g_pLTClient->FreeString(hTxt);
}
else
{
hTxt=g_pLTClient->FormatString(IDS_STAT_NOSHOTS);
pCtrl= AddTextItem(hTxt,LTNULL,0, LTTRUE, GetSmallFont());
pCtrl->Enable(LTFALSE);
g_pLTClient->FreeString(hTxt);
}
//stealth
pCtrl = AddTextItem(IDS_STAT_STEALTH,LTNULL,0, LTTRUE, GetLargeFont());
pCtrl->Enable(LTFALSE);
hTxt=g_pLTClient->FormatString(IDS_STAT_DETECTED,pMSummary->dwNumTimesDetected,pMSummary->dwNumDisturbances);
pCtrl= AddTextItem(hTxt,LTNULL,0, LTTRUE, GetSmallFont());
pCtrl->Enable(LTFALSE);
g_pLTClient->FreeString(hTxt);
hTxt=g_pLTClient->FormatString(IDS_STAT_DETECTED2,pMSummary->dwNumBodies,pMSummary->dwNumTimesHit);
pCtrl= AddTextItem(hTxt,LTNULL,0, LTTRUE, GetSmallFont());
pCtrl->Enable(LTFALSE);
g_pLTClient->FreeString(hTxt);
}
//inteligence
pCtrl = AddTextItem(IDS_STAT_INTEL,LTNULL,0, LTTRUE, GetLargeFont());
pCtrl->Enable(LTFALSE);
int cur = pMSummary->m_nMissionCurNumIntel;
int total = pMSummary->m_nMissionTotalIntel;
hTxt=g_pLTClient->FormatString(IDS_SUMMARY_FOUND,cur,total);
pCtrl= AddTextItem(hTxt,LTNULL,0, LTTRUE, GetSmallFont());
pCtrl->Enable(LTFALSE);
if (m_nFolderID == FOLDER_ID_FAILURE)
{
nContinueId = FOLDER_ID_LOAD;
nContinueHelpId = IDS_HELP_LOAD;
}
else
{
// Generate Awards
CFolderAwards* pAwards = (CFolderAwards*)m_pFolderMgr->GetFolderFromID(FOLDER_ID_AWARDS);
pAwards->UpdateData();
if (pAwards->HasAwards())
{
nContinueId = FOLDER_ID_AWARDS;
nContinueHelpId = IDS_HELP_AWARDS;
}
else
{
nContinueId = FOLDER_ID_BRIEFING;
nContinueHelpId = IDS_HELP_NEXTMISSION;
}
}
UseContinue(nContinueId,nContinueHelpId);
CalculateLastDrawn();
CheckArrows();
SetSelection(GetIndex(m_pContinue));
}
// Build the folder
LTBOOL CFolderGame::Build()
{
CreateTitle(IDS_TITLE_GAME_OPTIONS);
CGameSettings* pSettings = g_pInterfaceMgr->GetSettings();
if (g_pLayoutMgr->HasCustomValue(FOLDER_ID_GAME,"ColumnWidth"))
kGap = g_pLayoutMgr->GetFolderCustomInt(FOLDER_ID_GAME,"ColumnWidth");
if (g_pLayoutMgr->HasCustomValue(FOLDER_ID_GAME,"SliderWidth"))
kWidth = g_pLayoutMgr->GetFolderCustomInt(FOLDER_ID_GAME,"SliderWidth");
//crosshair menu
AddTextItem(IDS_CONTROLS_CROSSHAIR, FOLDER_CMD_CROSSHAIR, IDS_HELP_CROSSHAIRMENU);
CCycleCtrl *pCycle = AddCycleItem(IDS_DISPLAY_SUBTITLES,IDS_HELP_SUBTITLES,kGap-25,25,&m_nSubtitles);
pCycle->AddString(IDS_OFF);
pCycle->AddString(IDS_ON);
if (pSettings && pSettings->IsGoreAllowed())
{
CToggleCtrl *pGore = AddToggle(IDS_DISPLAY_GORE,IDS_HELP_GORE,kGap,&m_bGore);
pGore->SetOnString(IDS_ON);
pGore->SetOffString(IDS_OFF);
}
CToggleCtrl *pFadeBodies = AddToggle(IDS_FADEBODIES,IDS_HELP_FADEBODIES,kGap,&m_bFadeBodies);
pFadeBodies->SetOnString(IDS_YES);
pFadeBodies->SetOffString(IDS_NO);
//always run
CToggleCtrl* pToggle = AddToggle(IDS_ADVCONTROLS_RUNLOCK, IDS_HELP_RUNLOCK, kGap, &m_bAlwaysRun );
pToggle->SetOnString(IDS_YES);
pToggle->SetOffString(IDS_NO);
// Add the Difficulty option
m_pDifficultyCtrl = AddCycleItem(IDS_DIFFICULTY,IDS_HELP_DIFFICULTY,kGap-25,25,&m_nDifficulty);
m_pDifficultyCtrl->AddString(IDS_NEW_EASY);
m_pDifficultyCtrl->AddString(IDS_NEW_MEDIUM);
m_pDifficultyCtrl->AddString(IDS_NEW_HARD);
m_pDifficultyCtrl->AddString(IDS_NEW_INSANE);
pCycle = AddCycleItem(IDS_HUDLAYOUT,IDS_HELP_HUDLAYOUT,kGap-25,25,&m_nLayout);
for (int hl = 0; hl < g_pLayoutMgr->GetNumHUDLayouts(); hl++)
{
pCycle->AddString(g_pLayoutMgr->GetLayoutName(hl));
}
CSliderCtrl *pSlider=AddSlider(IDS_HEADBOB, IDS_HELP_HEADBOB, kGap, kWidth, &m_nHeadBob);
pSlider->SetSliderRange(0, 10);
pSlider->SetSliderIncrement(1);
pSlider=AddSlider(IDS_WEAPONSWAY, IDS_HELP_WEAPONSWAY, kGap, kWidth, &m_nWeaponSway);
pSlider->SetSliderRange(0, 10);
pSlider->SetSliderIncrement(1);
pSlider=AddSlider(IDS_PICKUP_MSG_DUR, IDS_HELP_PICKUP_MSG_DUR, kGap, kWidth, &m_nPickupMsgDur);
pSlider->SetSliderRange(0, 10);
pSlider->SetSliderIncrement(1);
pToggle = AddToggle(IDS_OBJECTIVE_MSGS, IDS_HELP_OBJECTIVE_MSGS, kGap, &m_bObjMessages );
pToggle->SetOnString(IDS_YES);
pToggle->SetOffString(IDS_NO);
// Make sure to call the base class
if (! CBaseFolder::Build()) return LTFALSE;
UseBack(LTTRUE,LTTRUE);
return LTTRUE;
}
// Build the screen
LTBOOL CScreenProfile::Build()
{
// Set the title's text
CreateTitle(IDS_TITLE_PROFILE);
// Get edit controls position and create it.
LTIntPt pos = g_pLayoutMgr->GetScreenCustomPoint((eScreenID)m_nScreenID,"ProfileNamePos");
m_pCurrent = AddTextItem(" ", LTNULL, LTNULL, pos, LTTRUE);
AddTextItem(IDS_CREATE, CMD_CREATE, IDS_HELP_PROFILE_CREATE);
AddTextItem(IDS_LOAD, CMD_LOAD, IDS_HELP_PROFILE_LOAD);
//jrg - 8/18/02 removed as a quick and dirty to multiple issues caused by renaming profiles.
// m_pRename = AddTextItem(IDS_RENAME, CMD_RENAME, IDS_HELP_PROFILE_RENAME);
m_pDelete = AddTextItem(IDS_DELETE, CMD_DELETE, IDS_HELP_PROFILE_DELETE);
LTIntPt dlgPos = g_pLayoutMgr->GetScreenCustomPoint((eScreenID)m_nScreenID,"DialogPos");
LTIntPt dlgSz = g_pLayoutMgr->GetScreenCustomPoint((eScreenID)m_nScreenID,"DialogSize");
kDlgHt = dlgSz.y;
kDlgWd = dlgSz.x;
uint8 nDlgFont = (uint8)g_pLayoutMgr->GetScreenCustomInt((eScreenID)m_nScreenID,"DialogFontFace");
uint8 nDlgFontSz = (uint8)g_pLayoutMgr->GetScreenCustomInt((eScreenID)m_nScreenID,"DialogFontSize");
nListFont = (uint8)g_pLayoutMgr->GetScreenCustomInt((eScreenID)m_nScreenID,"ListFontFace");
nListFontSz = (uint8)g_pLayoutMgr->GetScreenCustomInt((eScreenID)m_nScreenID,"ListFontSize");
char szBack[128] = "";
g_pLayoutMgr->GetScreenCustomString((eScreenID)m_nScreenID,"DialogFrame",szBack,sizeof(szBack));
m_pDlg = debug_new(CLTGUIWindow);
m_pDlg->Create(g_pInterfaceResMgr->GetTexture(szBack),kDlgHt,kDlgWd);
LTIntPt tmp(8,8);
CUIFont *pFont = g_pInterfaceResMgr->GetFont(nDlgFont);
CLTGUITextCtrl *pCtrl = CreateTextItem(IDS_PROFILE_LIST, LTNULL, LTNULL, kDefaultPos, LTTRUE);
pCtrl->SetFont(pFont,nDlgFontSz);
m_pDlg->AddControl(pCtrl, tmp);
tmp.y += 24;
// Make a list controller
m_pListCtrl = debug_new(CLTGUIListCtrl);
if (m_pListCtrl->Create(kDlgHt-64))
{
HTEXTURE hUp = g_pInterfaceResMgr->GetTexture("interface\\menu\\sprtex\\arrowup.dtx");
HTEXTURE hUpH = g_pInterfaceResMgr->GetTexture("interface\\menu\\sprtex\\arrowup_h.dtx");
HTEXTURE hDown = g_pInterfaceResMgr->GetTexture("interface\\menu\\sprtex\\arrowdn.dtx");
HTEXTURE hDownH = g_pInterfaceResMgr->GetTexture("interface\\menu\\sprtex\\arrowdn_h.dtx");
m_pListCtrl->UseArrows(kDlgWd-48,1.0f,hUp,hUpH,hDown,hDownH);
m_pListCtrl->SetIndent(LTIntPt(4,4));
m_pListCtrl->SetFrameWidth(2);
m_pListCtrl->SetColors(m_SelectedColor,m_NonSelectedColor,m_DisabledColor);
m_pDlg->AddControl(m_pListCtrl, tmp);
}
pCtrl = CreateTextItem(IDS_CANCEL, CMD_CANCEL, LTNULL);
pCtrl->SetFont(pFont,nDlgFontSz);
tmp.x = (kDlgWd - pCtrl->GetBaseWidth()) / 2;
tmp.y = (kDlgHt - pCtrl->GetBaseHeight()) - 8;
m_pDlg->AddControl(pCtrl, tmp);
AddControl(m_pDlg);
m_pDlg->SetBasePos(dlgPos);
m_pDlg->SetScale(g_pInterfaceResMgr->GetXRatio());
m_pDlg->Show(LTFALSE);
m_pDlg->SetSelection(1);
UseBack(LTTRUE);
// Make sure to call the base class
return CBaseScreen::Build();
}
