void CPropertyEditWindow::ShowProperties(ITedPropertyInfo* pPropertyInfo)
{
// Don't redraw window every time we add a component
LockWindowUpdate();
m_arrPropertyInfo.Add(pPropertyInfo);
pPropertyInfo->AddRef();
PropertyInfoDisplay* pDisplay = new PropertyInfoDisplay();
m_arrPropertyInfoDisplay.Add(pDisplay);
RECT labelRect = m_lastRect;
// Add a margin in between sets of properties
if(m_arrPropertyInfo.GetCount() > 1)
{
labelRect.top += ms_LabelHeight;
labelRect.bottom += ms_LabelHeight;
}
CreateTitle(DWORD(m_arrPropertyInfo.GetCount() - 1), labelRect);
DWORD dwCount = 0;
pPropertyInfo->GetPropertyCount(&dwCount);
for(DWORD i = 0; i < dwCount; i++)
{
CreatePropertyInterfaceForIndex(DWORD(m_arrPropertyInfo.GetCount() - 1), i, labelRect);
}
m_AddButton.ShowWindow(SW_SHOW);
m_OKButton.ShowWindow(SW_SHOW);
LockWindowUpdate(FALSE);
}
Menu::Menu(char *category, MotifUI *parent, boolean /*has_title*/,
char *title, char *name, char *mnemonic, MenuType menu_type)
: MotifUI(parent, name, category)
{
CreateMenu(parent->InnerWidget(), name, category, mnemonic, menu_type);
CreateTitle(parent->InnerWidget(), category, title);
}
// 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;
}
// Build the menu
void CMenuJoystick::Build()
{
// Make sure to call the base class
CMenuBase::Build();
// m_pClientDE->CPrint("CMenuJoystick::Build called!"); // BLB TEMP
CreateTitle("interface\\mainmenus\\options.pcx", IDS_MENU_TITLE_OPTIONS, m_pMainMenus->GetTitlePos());
SetOptionPos(m_pMainMenus->GetOptionsPos());
SetItemSpacing(5);
SetScrollWrap(DFALSE);
UseArrows(DTRUE, 300);
m_bUseJoystick=g_pBloodClientShell->IsUseJoystick();
// check if the joystick has been disabled by the advanced menu console variables
HCONSOLEVAR hVar = m_pClientDE->GetConsoleVar( "joystickdisable");
if (hVar != NULL)
{
if (m_pClientDE->GetVarValueFloat(hVar) == 1)
{
m_bUseJoystick = DFALSE;
g_pBloodClientShell->SetUseJoystick(FALSE);
}
}
// read in the JOYSTICK.CFG file
m_pClientDE->ReadConfigFile ("joystick.cfg");
UpdateData(DFALSE);
BuildAxisMenus();
// Update the enable/disable status of the controls
UpdateEnable();
}
// Build the menu
void CMenuMouse::Build()
{
// Make sure to call the base class
CMenuBase::Build();
CreateTitle("interface\\mainmenus\\options.pcx", IDS_MENU_TITLE_OPTIONS, m_pMainMenus->GetTitlePos());
SetOptionPos(m_pMainMenus->GetOptionsPos());
SetItemSpacing(5);
SetScrollWrap(DFALSE);
// Load the mouse settings
LoadMouseSettings();
// Add the controls
CLTGUISliderCtrl *pCtrl=AddSliderOption(IDS_MENU_MOUSE_SENSITIVITY, m_pMainMenus->GetSmallFont(), 100, m_pMainMenus->GetSurfaceSliderBar(), m_pMainMenus->GetSurfaceSliderTab(), &m_nMouseSensitivity);
pCtrl->SetSliderRange(100, 1500);
pCtrl->SetSliderIncrement(20);
m_pInputRateCtrl=AddSliderOption(IDS_MENU_MOUSE_INPUTRATE, m_pMainMenus->GetSmallFont(), 100, m_pMainMenus->GetSurfaceSliderBar(), m_pMainMenus->GetSurfaceSliderTab(), &m_nInputRate);
m_pInputRateCtrl->SetSliderIncrement(2);
m_pInputRateCtrl->SetSliderRange(0, 40);
AddOnOffOption(IDS_MENU_MOUSE_INVERT_YAXIS, m_pMainMenus->GetSmallFont(), 100, &m_bInvertYAxis);
AddOnOffOption(IDS_MENU_MOUSE_MOUSELOOK, m_pMainMenus->GetSmallFont(), 100, &m_bMouseLook);
AddOnOffOption(IDS_MENU_MOUSE_LOOKSPRING, m_pMainMenus->GetSmallFont(), 100, &m_bLookSpring);
AddOnOffOption(IDS_MENU_MOUSE_USEWHEEL, m_pMainMenus->GetSmallFont(), 100, &m_bUseWheel);
UpdateData(DFALSE);
SetInputRateText();
}
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();
;
}
// Generate
//------------------------------------------------------------------------------
void Report::Generate( const FBuildStats & stats )
{
Timer t;
// pre-allocate a large string for output
m_Output.SetReserved( MEGABYTE );
m_Output.SetLength( 0 );
// generate some common data used in reporting
GetLibraryStats( stats );
// build the report
CreateHeader();
CreateTitle();
CreateOverview( stats );
DoCPUTimeByType( stats );
DoCacheStats( stats );
DoCPUTimeByLibrary();
DoCPUTimeByItem( stats );
DoIncludes();
CreateFooter();
// patch in time take
const float time = t.GetElapsed();
AStackString<> timeTakenBuffer;
stats.FormatTime( time, timeTakenBuffer );
char * placeholder = m_Output.Find( "^^^^ " );
memcpy( placeholder, timeTakenBuffer.Get(), timeTakenBuffer.GetLength() );
}
// Build the folder
LTBOOL CFolderDisplay::Build()
{
CreateTitle(IDS_TITLE_DISPLAYOPTIONS);
// m_pRendererLabel = AddTextItem(IDS_DISPLAY_RENDERER, FOLDER_CMD_DISPLAY, IDS_HELP_RENDERER, LTTRUE);
// if (m_pRendererLabel)
// {
// m_pRendererLabel->Enable(LTFALSE);
// }
// Build the array of renderers
BuildRendererArray();
// Add the "renderer" option
m_pRendererCtrl = AddCycleItem(IDS_DISPLAY_RENDERER,IDS_HELP_RENDERER,100,25,LTNULL);
unsigned int i;
for (i=0; i < m_rendererArray.GetSize(); i++)
{
// Load the renderer formating text. This is "Renderer: [%s - %s]" in English
HSTRING hRendererFormat=g_pLTClient->FormatString(IDS_DMODE_RENDERER, m_rendererArray[i].m_renderDll, m_rendererArray[i].m_description);
m_pRendererCtrl->AddString(hRendererFormat);
g_pLTClient->FreeString(hRendererFormat);
}
// m_pResolutionLabel = AddTextItem(IDS_DISPLAY_RESOLUTION, FOLDER_CMD_RESOLUTION, IDS_HELP_RESOLUTION, LTTRUE);
// if (m_pResolutionLabel)
// {
// m_pResolutionLabel->Enable(LTFALSE);
// }
// Add the "resolution" control
m_pResolutionCtrl = AddCycleItem(IDS_DISPLAY_RESOLUTION,IDS_HELP_RESOLUTION,150,25,LTNULL, LTFALSE);
// Setup the resolution control based on the currently selected renderer
SetupResolutionCtrl();
CToggleCtrl *pToggle = AddToggle(IDS_DISPLAY_TEXTURE,IDS_HELP_TEXTUREDEPTH,175,&m_bTexture32);
pToggle->SetOnString(IDS_DISPLAY_32BIT);
pToggle->SetOffString(IDS_DISPLAY_16BIT);
m_pHardwareCursor = AddToggle(IDS_HARDWARE_CURSOR,IDS_HELP_HARDWARE_CURSOR,175,&m_bHardwareCursor);
m_pHardwareCursor->SetOnString(IDS_ON);
m_pHardwareCursor->SetOffString(IDS_OFF);
CalculateLastDrawn();
// Make sure to call the base class
if (!CBaseFolder::Build()) return LTFALSE;
UseBack(LTTRUE,LTTRUE);
return LTTRUE;
}
// Build the screen
LTBOOL CScreenAudio::Build()
{
CreateTitle(IDS_TITLE_SOUND);
kGap = g_pLayoutMgr->GetScreenCustomInt(SCREEN_ID_AUDIO,"ColumnWidth");
kWidth = g_pLayoutMgr->GetScreenCustomInt(SCREEN_ID_AUDIO,"SliderWidth");
uint32 dwAdvancedOptions = g_pInterfaceMgr->GetAdvancedOptions();
m_bMusicEnabled = (dwAdvancedOptions & AO_MUSIC);
//background frame
LTRect frameRect = g_pLayoutMgr->GetScreenCustomRect(SCREEN_ID_AUDIO,"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_AUDIO,"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);
m_pSoundVolumeCtrl=AddSlider(IDS_SOUND_FXVOL, IDS_HELP_SOUNDVOL, kGap, kWidth, -1, &m_nSoundVolume);
m_pSoundVolumeCtrl->Enable( (dwAdvancedOptions & AO_SOUND) );
m_pSoundVolumeCtrl->SetSliderRange(SOUND_MIN_VOL, SOUND_MAX_VOL);
m_pSoundVolumeCtrl->SetSliderIncrement(SOUND_SLIDER_INC);
m_pSpeechVolumeCtrl=AddSlider(IDS_SPEECH_FXVOL, IDS_HELP_SPEECHVOL, kGap, kWidth, -1, &m_nSpeechVolume);
m_pSpeechVolumeCtrl->Enable( (dwAdvancedOptions & AO_SOUND) );
m_pSpeechVolumeCtrl->SetSliderRange(SPEECH_MIN_VOL, SPEECH_MAX_VOL);
m_pSpeechVolumeCtrl->SetSliderIncrement(SPEECH_SLIDER_INC);
m_pSoundQualityCtrl=AddToggle(IDS_SOUND_QUALITY, IDS_HELP_SOUNDQUAL, kGap, &m_bSoundQuality);
m_pSoundQualityCtrl->SetOnString(LoadTempString(IDS_SOUND_HIGH));
m_pSoundQualityCtrl->SetOffString(LoadTempString(IDS_SOUND_LOW));
m_pSoundQualityCtrl->Enable( (dwAdvancedOptions & AO_SOUND) );
m_pMusicVolumeCtrl = AddSlider(IDS_SOUND_MUSICVOL, IDS_HELP_MUSICVOL, kGap, kWidth, -1, &m_nMusicVolume);
m_pMusicVolumeCtrl->Enable( (dwAdvancedOptions & AO_MUSIC) );
m_pMusicVolumeCtrl->SetSliderRange(MUSIC_MIN_VOL, MUSIC_MAX_VOL);
m_pMusicVolumeCtrl->SetSliderIncrement(MUSIC_SLIDER_INC);
m_pMusicQualityCtrl=AddToggle(IDS_MUSIC_QUALITY, IDS_HELP_MUSIC_QUALITY, kGap, &m_bMusicQuality);
m_pMusicQualityCtrl->SetOnString(LoadTempString(IDS_SOUND_HIGH));
m_pMusicQualityCtrl->SetOffString(LoadTempString(IDS_SOUND_LOW));
m_pMusicQualityCtrl->Enable( (dwAdvancedOptions & AO_MUSIC) );
// Make sure to call the base class
if (! CBaseScreen::Build()) return LTFALSE;
UseBack(LTTRUE,LTTRUE);
return LTTRUE;
}
LTBOOL CFolderStats::Build()
{
CreateTitle(IDS_TITLE_PLAYER);
UseArrows(LTTRUE);
UseBack(LTTRUE,LTFALSE,LTTRUE);
return CBaseFolder::Build();
}
Header::Header(
const PageType page_type,
const std::string& filename)
: m_filename(CreateFilename(page_type,filename)),
m_page_type(page_type),
m_title(CreateTitle(page_type,filename))
{
}
LTBOOL CFolderSummary::Build()
{
CreateTitle(IDS_TITLE_SUMMARY);
LTBOOL bSuccess = CBaseFolder::Build();
UseMain(LTTRUE);
UseBack(LTFALSE);
return bSuccess;
}
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);
}
}
}
LTBOOL CFolderAwards::Build()
{
CreateTitle(IDS_TITLE_AWARDS);
LTBOOL bSuccess = CBaseFolder::Build();
UseMain(LTTRUE);
UseBack(LTFALSE);
UseContinue(FOLDER_ID_BRIEFING,IDS_HELP_NEXTMISSION);
return bSuccess;
}
// 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;
}
LTBOOL CFolderSave::Build()
{
CreateTitle(IDS_TITLE_SAVEGAME);
m_pEdit = CreateEditCtrl("", CMD_EDIT_NAME, LTNULL, m_szSaveName, sizeof(m_szSaveName), 0, LTTRUE, GetSmallFont());
m_pEdit->EnableCursor();
m_pEdit->Enable(LTFALSE);
m_pEdit->SetAlignment(LTF_JUSTIFY_LEFT);
return CBaseFolder::Build();
}
// 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;
}
// Build the screen
LTBOOL CScreenHostDMOptions::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_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));
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(5);
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();
}
// Builds the menu
void CMenuBloodBath::Build()
{
// Make sure to call the base class
CMenuBase::Build();
CreateTitle("interface\\mainmenus\\bloodbath.pcx", IDS_MENU_TITLE_BLOODBATH, m_pMainMenus->GetTitlePos());
SetOptionPos(m_pMainMenus->GetOptionsPos());
SetItemSpacing(0);
AddLargeTextItemOption(IDS_MENU_BLOODBATH_JOIN, MENU_CMD_JOIN_GAME);
AddLargeTextItemOption(IDS_MENU_BLOODBATH_HOST, MENU_CMD_HOST_GAME);
AddLargeTextItemOption(IDS_MENU_BLOODBATH_CHARSETUP, MENU_CMD_CHARACTER_SETUP_RESVERIFY);
}
LTBOOL CFolderMultiBriefing::Build()
{
CreateTitle(IDS_TITLE_BRIEFING);
UseBack(LTFALSE);
UseMain(LTFALSE);
UseContinue(LTFALSE);
return CBaseFolder::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;
}
// Build the folder
LTBOOL CFolderEffects::Build()
{
if (g_pLayoutMgr->HasCustomValue(FOLDER_ID_EFFECTS,"ColumnWidth"))
{
kTotalWidth = g_pLayoutMgr->GetFolderCustomInt(FOLDER_ID_EFFECTS,"ColumnWidth");
kHeaderWidth = kTotalWidth - kSpacerWidth;
}
if (g_pLayoutMgr->HasCustomValue(FOLDER_ID_EFFECTS,"SliderWidth"))
kSliderWidth = g_pLayoutMgr->GetFolderCustomInt(FOLDER_ID_EFFECTS,"SliderWidth");
CreateTitle(IDS_TITLE_EFFECTS);
CToggleCtrl* pToggle = AddToggle(IDS_TRACERS, IDS_HELP_TRACERS, kTotalWidth, &m_bTracers );
pToggle->SetOnString(IDS_ON);
pToggle->SetOffString(IDS_OFF);
pToggle = AddToggle(IDS_SHELLCASINGS, IDS_HELP_SHELLCASINGS, kTotalWidth, &m_bShellCasings );
pToggle->SetOnString(IDS_ON);
pToggle->SetOffString(IDS_OFF);
pToggle = AddToggle(IDS_MUZZLELIGHT, IDS_HELP_MUZZLELIGHT, kTotalWidth, &m_bMuzzleLight );
pToggle->SetOnString(IDS_ON);
pToggle->SetOffString(IDS_OFF);
pToggle = AddToggle(IDS_WEATHER, IDS_HELP_WEATHER, kTotalWidth, &m_bWeather );
pToggle->SetOnString(IDS_ON);
pToggle->SetOffString(IDS_OFF);
CCycleCtrl *pCycle = AddCycleItem(IDS_IMPACT,IDS_HELP_IMPACTS,kHeaderWidth,kSpacerWidth,&m_nImpact);
pCycle->AddString(IDS_LOW);
pCycle->AddString(IDS_MEDIUM);
pCycle->AddString(IDS_HIGH);
pCycle = AddCycleItem(IDS_DEBRIS,IDS_HELP_DEBRIS,kHeaderWidth,kSpacerWidth,&m_nDebris);
pCycle->AddString(IDS_LOW);
pCycle->AddString(IDS_MEDIUM);
pCycle->AddString(IDS_HIGH);
// Make sure to call the base class
if (!CBaseFolder::Build()) return LTFALSE;
UseBack(LTTRUE,LTTRUE);
return LTTRUE;
}
// 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;
}
// 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;
}
// 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();
}
bool CNetworkPlayerNumberLayer::init()
{
if ( !CCLayer::init() )
{
return false;
}
// Get Window Size
CCSize visibleSize = CCDirector::sharedDirector()->getVisibleSize();
// CCMenu
CreateNumberOfPlayerMenu(visibleSize);
CreateNextButtonMenu(visibleSize);
CreateBackButtonMenu(visibleSize);
CreateTitle();
return true;
}
LTBOOL CFolderViewInventory::Build()
{
CreateTitle(IDS_TITLE_INVENTORY);
m_pFont = GetLargeFont();
if (g_pLayoutMgr->GetListFontSize((eFolderID)m_nFolderID) == 0)
m_pFont = GetSmallFont();
else if (g_pLayoutMgr->GetListFontSize((eFolderID)m_nFolderID) == 1)
m_pFont = GetMediumFont();
UseArrows(LTTRUE);
UseBack(LTTRUE,LTFALSE,LTTRUE);
LTBOOL success = CBaseSelectionFolder::Build();
return success;
}
// Build the folder
LTBOOL CFolderWeaponControls::Build()
{
CreateTitle(IDS_TITLE_WEAPON_CONTROLS);
if (g_pLayoutMgr->HasCustomValue(FOLDER_ID_WPN_CONTROLS,"ColumnWidth"))
kWidth = g_pLayoutMgr->GetFolderCustomInt(FOLDER_ID_WPN_CONTROLS,"ColumnWidth");
if (g_pLayoutMgr->HasCustomValue(FOLDER_ID_WPN_CONTROLS,"SliderWidth"))
kSlider = g_pLayoutMgr->GetFolderCustomInt(FOLDER_ID_WPN_CONTROLS,"SliderWidth");
kFirstCommand = g_pWeaponMgr->GetFirstWeaponCommandId();
kLastCommand = g_pWeaponMgr->GetLastWeaponCommandId();
UseBack(LTTRUE,LTTRUE);
return CBaseFolder::Build();
}
// Build the folder
LTBOOL CFolderNew::Build()
{
CreateTitle(IDS_TITLE_NEWGAME);
if (strlen(sSelectStr) == 0)
{
HSTRING hTemp = g_pLTClient->FormatString(IDS_HELP_MISSION);
char *pTemp = g_pLTClient->GetStringData(hTemp);
strncpy(sSelectStr,pTemp,ARRAY_LEN(sSelectStr));
g_pLTClient->FreeString(hTemp);
}
LTBOOL success = CBaseSelectionFolder::Build();
UseContinue(FOLDER_ID_NONE);
return success;
}
// Build the menu
void CMenuKeyboard::Build()
{
// Make sure to call the base class
CMenuBase::Build();
CreateTitle("interface\\mainmenus\\options.pcx", IDS_MENU_TITLE_OPTIONS, m_pMainMenus->GetTitlePos());
SetOptionPos(m_pMainMenus->GetOptionsPos());
SetItemSpacing(5);
SetScrollWrap(DFALSE);
m_nKeyboardTurnRate=(int)(g_pBloodClientShell->GetKeyboardTurnRate()*100.0f);
// Add the controls
CLTGUISliderCtrl *pCtrl=AddSliderOption(IDS_MENU_KEYBOARD_TURNSPEED, m_pMainMenus->GetSmallFont(), 100, m_pMainMenus->GetSurfaceSliderBar(), m_pMainMenus->GetSurfaceSliderTab(), &m_nKeyboardTurnRate);
pCtrl->SetSliderRange(15, 400);
pCtrl->SetSliderIncrement(15);
UpdateData(DFALSE);
}
