// 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;
}
float GUI::GUISlider(Rect slider_rect, float _minValue, float _maxValue, float _value, char* slider_id, SliderStyle* slider_style)
{
Slider* slider = New Slider(slider_rect, _minValue, _maxValue, _value, slider_id, slider_style);
AddSlider(slider);
if(sliderState.count(slider_id))
slider->state = sliderState[slider_id];
else
slider->state = Normal;
slider->GetButtonState();
sliderState[slider_id] = slider->state;
if(slider->state == Active){
float width = slider->style->sliderBarSize*(slider->rect.bottom - slider->rect.top);
POINT cursorPos = gEngine->GetInput()->GetCursorPos();
slider->value = slider->minValue + (slider->maxValue - slider->minValue)*(cursorPos.x - width/2 - slider->rect.left)/
(slider->rect.right - slider->rect.left - width);
if(slider->value < slider->minValue)
slider->value = slider->minValue;
if(slider->value > slider->maxValue)
slider->value = slider->maxValue;
}
return slider->value;
}
// 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();
}
void CGUIDialogVideoSettings::CreateSettings()
{
// clear out any old settings
m_settings.clear();
// create our settings
{
#ifdef __APPLE__
const int entries[] = { 16018, 16019, 16020, 16021, 16022, 20129, 20130 };
AddSpin(VIDEO_SETTINGS_INTERLACEMETHOD, 16023, (int*)&g_stSettings.m_currentVideoSettings.m_InterlaceMethod, 7, entries);
#else
const int entries[] = { 16018, 16019, 16020, 16021, 16022, 20129, 20130, 20131 };
AddSpin(VIDEO_SETTINGS_INTERLACEMETHOD, 16023, (int*)&g_stSettings.m_currentVideoSettings.m_InterlaceMethod, 8, entries);
#endif
}
{
#ifdef __APPLE__
const int entries[] = { 16302, 16307, 16308 };
AddSpin(VIDEO_SETTINGS_SCALINGMETHOD, 16300, (int*)&g_stSettings.m_currentVideoSettings.m_ScalingMethod, 3, entries);
#else
const int entries[] = { 16301, 16302, 16303, 16304, 16305, 16306, 16307, 16308, 16309 };
AddSpin(VIDEO_SETTINGS_SCALINGMETHOD, 16300, (int*)&g_stSettings.m_currentVideoSettings.m_ScalingMethod, 3, entries);
#endif
}
AddBool(VIDEO_SETTINGS_CROP, 644, &g_stSettings.m_currentVideoSettings.m_Crop);
{
const int entries[] = {630, 631, 632, 633, 634, 635, 636 };
AddSpin(VIDEO_SETTINGS_VIEW_MODE, 629, &g_stSettings.m_currentVideoSettings.m_ViewMode, 7, entries);
}
AddSlider(VIDEO_SETTINGS_ZOOM, 216, &g_stSettings.m_currentVideoSettings.m_CustomZoomAmount, 0.5f, 0.01f, 2.0f);
AddSlider(VIDEO_SETTINGS_PIXEL_RATIO, 217, &g_stSettings.m_currentVideoSettings.m_CustomPixelRatio, 0.5f, 0.01f, 2.0f);
if (g_renderManager.SupportsBrightness())
AddSlider(VIDEO_SETTINGS_BRIGHTNESS, 464, &g_stSettings.m_currentVideoSettings.m_Brightness, 0, 100);
if (g_renderManager.SupportsContrast())
AddSlider(VIDEO_SETTINGS_CONTRAST, 465, &g_stSettings.m_currentVideoSettings.m_Contrast, 0, 100);
if (g_renderManager.SupportsGamma())
AddSlider(VIDEO_SETTINGS_GAMMA, 466, &g_stSettings.m_currentVideoSettings.m_Gamma, 0, 100);
AddSeparator(8);
AddButton(VIDEO_SETTINGS_MAKE_DEFAULT, 12376);
#ifdef HAS_XBOX_HARDWARE
m_flickerFilter = g_guiSettings.GetInt("videoplayer.flicker");
AddSpin(VIDEO_SETTINGS_FLICKER, 13100, &m_flickerFilter, 0, 5, g_localizeStrings.Get(351).c_str());
m_soften = g_guiSettings.GetBool("videoplayer.soften");
AddBool(VIDEO_SETTINGS_SOFTEN, 215, &m_soften);
#endif
AddButton(VIDEO_SETTINGS_CALIBRATION, 214);
if (g_application.GetCurrentPlayer() == EPC_MPLAYER)
{
AddSlider(VIDEO_SETTINGS_FILM_GRAIN, 14058, (int*)&g_stSettings.m_currentVideoSettings.m_FilmGrain, 0, 10);
AddBool(VIDEO_SETTINGS_NON_INTERLEAVED, 306, &g_stSettings.m_currentVideoSettings.m_NonInterleaved);
AddBool(VIDEO_SETTINGS_NO_CACHE, 431, &g_stSettings.m_currentVideoSettings.m_NoCache);
AddButton(VIDEO_SETTINGS_FORCE_INDEX, 12009);
}
}
wxSlider * ShuttleGuiBase::TieSlider( const wxString &Prompt, WrappedType & WrappedRef, const int max )
{
// The Add function does a UseUpId(), so don't do it here in that case.
if( mShuttleMode != eIsCreating )
UseUpId();
wxSlider * pSlider=NULL;
switch( mShuttleMode )
{
case eIsCreating:
{
pSlider = AddSlider( Prompt, WrappedRef.ReadAsInt(), max );
}
break;
// IF setting internal storage from the controls.
case eIsGettingFromDialog:
{
wxWindow * pWnd = wxWindow::FindWindowById( miId, mpDlg);
pSlider = wxDynamicCast(pWnd, wxSlider);
wxASSERT( pSlider );
WrappedRef.WriteToAsInt( pSlider->GetValue() );
}
break;
case eIsSettingToDialog:
{
wxWindow * pWnd = wxWindow::FindWindowById( miId, mpDlg);
pSlider = wxDynamicCast(pWnd, wxSlider);
wxASSERT( pSlider );
pSlider->SetValue( WrappedRef.ReadAsInt() );
}
break;
// IF Saving settings to external storage...
// or IF Getting settings from external storage.
case eIsSavingViaShuttle:
case eIsGettingViaShuttle:
DoDataShuttle( Prompt, WrappedRef );
break;
default:
wxASSERT( false );
break;
}
return pSlider;
}
void StandardJoints (DemoEntityManager* const scene)
{
scene->CreateSkyBox();
// customize the scene after loading
// set a user friction variable in the body for variable friction demos
// later this will be done using LUA script
dMatrix offsetMatrix (dGetIdentityMatrix());
CreateLevelMesh (scene, "flatPlane.ngd", 1);
dVector location (0.0f, 0.0f, 0.0f, 0.0f);
dVector size (1.5f, 2.0f, 2.0f, 0.0f);
// AddPoweredRagDoll (scene, dVector (-20.0f, 0.0f, -15.0f));
AddDistance (scene, dVector (-20.0f, 0.0f, -25.0f));
AddLimitedBallAndSocket (scene, dVector (-20.0f, 0.0f, -20.0f));
// AddPoweredRagDoll (scene, dVector (-20.0f, 0.0f, -15.0f));
AddBallAndSockectWithFriction (scene, dVector (-20.0f, 0.0f, -10.0f));
Add6DOF (scene, dVector (-20.0f, 0.0f, -5.0f));
AddHinge (scene, dVector (-20.0f, 0.0f, 0.0f));
AddSlider (scene, dVector (-20.0f, 0.0f, 5.0f));
AddCylindrical (scene, dVector (-20.0f, 0.0f, 10.0f));
AddUniversal (scene, dVector (-20.0f, 0.0f, 15.0f));
//just to show up add some relational joints example
AddGear (scene, dVector (-20.0f, 0.0f, 20.0f));
AddPulley (scene, dVector (-20.0f, 0.0f, 25.0f));
AddGearAndRack (scene, dVector (-20.0f, 0.0f, 30.0f));
AddSlidingContact (scene, dVector (-20.0f, 0.0f, 35.0f));
// AddPathFollow (scene, dVector (20.0f, 0.0f, 0.0f));
// place camera into position
dMatrix camMatrix (dGetIdentityMatrix());
dQuaternion rot (camMatrix);
dVector origin (-40.0f, 5.0f, 0.0f, 0.0f);
scene->SetCameraMatrix(rot, origin);
}
//==== Add Parameter Driver Group ====//
void GroupLayout::AddDriverGroupBank( DriverGroupBank & dgBank, const vector < string > &labels, double range, const char* format )
{
assert( m_Group && m_Screen );
bool oldSameLine = m_SameLineFlag;
bool oldFitWidth = m_FitWidthFlag;
SetSameLineFlag( true );
SetFitWidthFlag( true );
vector< vector< Fl_Button* > > buttons;
buttons.resize( dgBank.GetDriverGroup()->GetNvar() );
vector< SliderAdjRangeInput* > sliders;
sliders.resize( dgBank.GetDriverGroup()->GetNvar() );
for( int i = 0; i < dgBank.GetDriverGroup()->GetNvar(); i++ )
{
buttons[i].resize( dgBank.GetDriverGroup()->GetNchoice() );
for( int j = 0; j < dgBank.GetDriverGroup()->GetNchoice(); j++ )
{
int roundW = 17;
buttons[i][j] = new GroupBankRoundButton( m_X, m_Y, roundW, m_StdHeight );
m_Group->add( buttons[i][j] );
AddX( roundW );
}
AddX( 1 );
sliders[i] = new SliderAdjRangeInput();
AddSlider( *sliders[i], labels[i].c_str(), range, format );
ForceNewLine();
}
SetSameLineFlag( oldSameLine );
SetFitWidthFlag( oldFitWidth );
dgBank.Init( m_Screen, buttons, sliders );
}
void GradientSliderWidget::SetGradientStops(QGradientStops newStops)
{
QList<uint> keys = sliders.keys();
for (int i=0; i<keys.size(); ++i)
{
RemoveSlider(keys[i]);
}
if (newStops.size() >= 2)
{
for (int i=0; i<newStops.size(); ++i)
{
unsigned int newSlider = AddSlider();
SetSliderValue(newSlider, minValue + (1.0-newStops[i].first) * (maxValue-minValue));
SetSliderColor(newSlider, newStops[i].second);
}
} else {
CreateDefaultSliders();
}
UpdateGradientStops();
}
// Build the folder
LTBOOL CFolderPlayer::Build()
{
CreateTitle(IDS_TITLE_PLAYER_SETUP);
g_vtPlayerModel.Init(g_pLTClient, "NetPlayerModel", "Hero,action", 0.0f);
g_vtPlayerTeam.Init(g_pLTClient, "NetPlayerTeam", LTNULL, 0.0f);
g_vtTargetNameTransparency.Init(g_pLTClient, "TargetNameTransparency", LTNULL, 1.0f);
g_vtTargetNameSize.Init(g_pLTClient, "TargetNameSize", LTNULL, 0.0f);
m_pLabel = CreateTextItem(IDS_PLAYER_NAME, CMD_EDIT_NAME, IDS_HELP_PLAYER_NAME);
m_pEdit = CreateEditCtrl(" ", CMD_EDIT_NAME, LTNULL, m_szPlayerName, sizeof(m_szPlayerName), 25, LTTRUE, GetMediumFont());
m_pEdit->EnableCursor();
m_pEdit->Enable(LTFALSE);
m_pEdit->SetAlignment(LTF_JUSTIFY_CENTER);
m_pNameGroup = AddGroup(640,m_pLabel->GetHeight(),IDS_HELP_PLAYER_NAME);
LTIntPt offset(0,0);
m_pNameGroup->AddControl(m_pLabel,offset,LTTRUE);
offset.x = 200;
m_pNameGroup->AddControl(m_pEdit,offset,LTFALSE);
AddBlankLine();
CToggleCtrl* pToggle = AddToggle(IDS_AUTOSWITCH_WEAPONS, IDS_HELP_AUTOSWITCH_WEAPONS, 225, &m_bAutoSwitchWeapons );
pToggle->SetOnString(IDS_ON);
pToggle->SetOffString(IDS_OFF);
pToggle = AddToggle(IDS_AUTOSWITCH_AMMO, IDS_HELP_AUTOSWITCH_AMMO, 225, &m_bAutoSwitchAmmo );
pToggle->SetOnString(IDS_ON);
pToggle->SetOffString(IDS_OFF);
pToggle = AddToggle(IDS_IGNORE_TAUNTS, IDS_HELP_IGNORE_TAUNTS, 225, &m_bIgnoreTaunts );
pToggle->SetOnString(IDS_YES);
pToggle->SetOffString(IDS_NO);
CCycleCtrl *pCycle = AddCycleItem(IDS_CONNECT_SPEED,IDS_CONNECT_SPEED,200,25,&m_nConnect);
pCycle->AddString(IDS_CONNECT_VSLOW);
pCycle->AddString(IDS_CONNECT_SLOW);
pCycle->AddString(IDS_CONNECT_MEDIUM);
pCycle->AddString(IDS_CONNECT_FAST);
pCycle = AddCycleItem(IDS_PLAYER_TEAM,IDS_HELP_PLAYER_TEAM,200,25,&m_nTeam);
pCycle->AddString(IDS_PLAYER_EITHER);
pCycle->AddString(IDS_PLAYER_UNITY);
pCycle->AddString(IDS_PLAYER_HARM);
CSliderCtrl* pSlider = AddSlider(IDS_TARGETNAMETRANSPARENCY, IDS_TARGETNAMETRANSPARENCY_HELP, 225, 200, &m_nTargetNameTransparency);
pSlider->SetSliderRange(0, 100);
pSlider->SetSliderIncrement(5);
pCycle = AddCycleItem(IDS_TARGETNAMESIZE,IDS_TARGETNAMESIZE_HELP,200,25,&m_nTargetNameSize);
pCycle->AddString(IDS_SMALL);
pCycle->AddString(IDS_MEDIUM);
pCycle->AddString(IDS_LARGE);
m_pModelCtrl = AddCycleItem(IDS_PLAYER_MODEL,IDS_HELP_PLAYER_MODEL,200,25,&m_nModNum);
m_pModelCtrl->NotifyOnChange(CMD_MODEL_CHANGE,this);
m_pSkinCtrl = AddCycleItem(IDS_PLAYER_SKIN,IDS_HELP_PLAYER_SKIN,200,25,&m_nSkinNum);
m_pSkinCtrl->NotifyOnChange(CMD_SKIN_CHANGE,this);
m_pHeadCtrl = AddCycleItem(IDS_PLAYER_HEAD,IDS_HELP_PLAYER_HEAD,200,25,&m_nHeadNum);
m_pHeadCtrl->NotifyOnChange(CMD_HEAD_CHANGE,this);
// Make sure to call the base class
if (! CBaseFolder::Build()) return LTFALSE;
UseBack(LTTRUE,LTTRUE);
return LTTRUE;
}
// 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();
}
// Build the screen
LTBOOL CScreenCrosshair::Build()
{
CreateTitle(IDS_TITLE_CROSSHAIR);
kGap = g_pLayoutMgr->GetScreenCustomInt(SCREEN_ID_CROSSHAIR,"ColumnWidth");
kWidth = g_pLayoutMgr->GetScreenCustomInt(SCREEN_ID_CROSSHAIR,"SliderWidth");
char szYes[16];
char szNo[16];
FormatString(IDS_YES,szYes,sizeof(szYes));
FormatString(IDS_NO,szNo,sizeof(szNo));
//background frame
LTRect frameRect = g_pLayoutMgr->GetScreenCustomRect(SCREEN_ID_CROSSHAIR,"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_CROSSHAIR,"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);
CLTGUISlider *pSlider = AddSlider(IDS_CH_R, IDS_HELP_CH_R, kGap, kWidth, -1, &m_nColorR);
pSlider->SetSliderRange(15,255);
pSlider->SetSliderIncrement(16);
pSlider = AddSlider(IDS_CH_G, IDS_HELP_CH_G, kGap, kWidth, -1, &m_nColorG);
pSlider->SetSliderRange(15,255);
pSlider->SetSliderIncrement(16);
pSlider = AddSlider(IDS_CH_B, IDS_HELP_CH_B, kGap, kWidth, -1, &m_nColorB);
pSlider->SetSliderRange(15,255);
pSlider->SetSliderIncrement(16);
CLTGUIToggle* pToggle = AddToggle(IDS_CH_DYNAMIC, IDS_HELP_CH_DYNAMIC, kGap, &m_bDynamic );
m_pStyle = AddCycle(IDS_CH_STYLE,IDS_HELP_CH_STYLE,kGap,&m_nStyle);
char szTmp[kMaxStringBuffer];
uint8 style = 0;
char *szTag = "HUDCrosshair";
char szAtt[32];
sprintf(szAtt,"Crosshair%d",style);
while (g_pLayoutMgr->HasValue(szTag,szAtt))
{
g_pLayoutMgr->GetString(szTag,szAtt,szTmp,sizeof(szTmp));
strcat(szTmp,"_A.dtx");
m_styles.push_back(szTmp);
sprintf(szTmp,"%d",style);
// m_pStyle->AddString(szTmp);
m_pStyle->AddString(" ");
style++;
sprintf(szAtt,"Crosshair%d",style);
}
g_pDrawPrim->SetRGBA(&m_Poly,argbWhite);
// Make sure to call the base class
if (! CBaseScreen::Build()) return LTFALSE;
UseBack(LTTRUE,LTTRUE);
return LTTRUE;
}
// 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
bool CScreenAudio::Build()
{
CreateTitle("IDS_TITLE_SOUND");
kGap = g_pLayoutDB->GetInt32(m_hLayout,LDB_ScreenColumnWidths,0);
kWidth = g_pLayoutDB->GetInt32(m_hLayout,LDB_ScreenColumnWidths,1);
uint32 dwAdvancedOptions = g_pInterfaceMgr->GetAdvancedOptions();
SoundCapabilities SoundCaps;
g_pLTClient->SoundMgr()->GetSoundCapabilities(&SoundCaps);
//background frame
CLTGUICtrl_create cs;
cs.rnBaseRect = g_pLayoutDB->GetRect(m_hLayout,LDB_ScreenFrameRect,0);
TextureReference hFrame(g_pLayoutDB->GetString(m_hLayout,LDB_ScreenFrameTexture));
CLTGUIFrame *pFrame = debug_new(CLTGUIFrame);
pFrame->Create(hFrame,cs);
AddControl(pFrame);
cs.rnBaseRect = g_pLayoutDB->GetRect(m_hLayout,LDB_ScreenFrameRect,1);
hFrame.Load(g_pLayoutDB->GetString(m_hLayout,LDB_ScreenAddTex,0));
pFrame = debug_new(CLTGUIFrame);
pFrame->Create(hFrame,cs,true);
AddControl(pFrame);
m_DefaultPos = m_ScreenRect.m_vMin;
CLTGUISlider_create scs;
scs.rnBaseRect.m_vMin.Init();
scs.rnBaseRect.m_vMax = LTVector2n(kGap+kWidth,g_pLayoutDB->GetInt32(m_hLayout,LDB_ScreenFontSize));
scs.nBarOffset = kGap;
scs.szHelpID = "IDS_HELP_SOUNDVOL";
scs.pnValue = &m_nSoundVolume;
scs.nMin = 0;
scs.nMax = 100;
scs.nIncrement = 5;
m_pSoundVolumeCtrl= AddSlider("IDS_SOUND_FXVOL", scs );
m_pSoundVolumeCtrl->Enable( !!(dwAdvancedOptions & AO_SOUND) );
scs.szHelpID = "IDS_HELP_SPEECHVOL";
scs.pnValue = &m_nSpeechVolume;
m_pSpeechVolumeCtrl= AddSlider("IDS_SPEECH_FXVOL", scs );
m_pSpeechVolumeCtrl->Enable( !!(dwAdvancedOptions & AO_SOUND) );
scs.szHelpID = "IDS_HELP_MUSICVOL";
scs.pnValue = &m_nMusicVolume;
m_pMusicVolumeCtrl= AddSlider("IDS_SOUND_MUSICVOL", scs );
m_pMusicVolumeCtrl->Enable( !!(dwAdvancedOptions & AO_SOUND) );
CLTGUIToggle_create tcs;
tcs.rnBaseRect.m_vMin.Init();
tcs.rnBaseRect.m_vMax = LTVector2n(m_ScreenRect.GetWidth(),g_pLayoutDB->GetInt32(m_hLayout,LDB_ScreenFontSize));
tcs.szHelpID = "IDS_HELP_SOUND_USE_HW";
tcs.pbValue = &m_bHWSoundsEnable;
tcs.nHeaderWidth = kGap;
// Enable HW Sounds
m_pHWSoundsEnableCtrl= AddToggle("IDS_SOUND_USE_HW", tcs );
m_pHWSoundsEnableCtrl->Enable( !!(dwAdvancedOptions & AO_SOUND) && SoundCaps.bSupportsHWSounds);
// Use EAX
tcs.szHelpID = "IDS_HELP_SOUND_USE_EAX";
tcs.pbValue = &m_bEAXEnable;
m_pEAXEnableCtrl= AddToggle("IDS_SOUND_USE_EAX", tcs );
m_pEAXEnableCtrl->Enable( !!(dwAdvancedOptions & AO_SOUND) && SoundCaps.bSupportsEAX);
// Use EAX 4.0, if available
tcs.szHelpID = "IDS_HELP_SOUND_USE_EAX4";
tcs.pbValue = &m_bEAX4Enable;
m_pEAX4EnableCtrl= AddToggle("IDS_SOUND_USE_EAX4", tcs );
m_pEAX4EnableCtrl->Enable( !!(dwAdvancedOptions & AO_SOUND) && SoundCaps.bSupportsEAX4);
// Make sure to call the base class
if (! CBaseScreen::Build()) return false;
UseBack(true,true);
return true;
}
// Build the screen
LTBOOL CScreenDisplay::Build()
{
CreateTitle(IDS_TITLE_DISPLAYOPTIONS);
kGap = g_pLayoutMgr->GetScreenCustomInt(SCREEN_ID_DISPLAY,"ColumnWidth");
kWidth = g_pLayoutMgr->GetScreenCustomInt(SCREEN_ID_DISPLAY,"SliderWidth");
//background frame
LTRect frameRect = g_pLayoutMgr->GetScreenCustomRect(SCREEN_ID_DISPLAY,"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_DISPLAY,"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);
// Build the array of renderers
GetRendererData();
// Add the "resolution" control
m_pResolutionCtrl = AddCycle(IDS_DISPLAY_RESOLUTION,IDS_HELP_RESOLUTION,kGap);
// Setup the resolution control based on the current renderer
SetupResolutionCtrl();
m_pHardwareCursor = AddToggle(IDS_HARDWARE_CURSOR,IDS_HELP_HARDWARE_CURSOR,kGap,&m_bHardwareCursor);
AddToggle(IDS_VSYNC,IDS_HELP_VSYNC,kGap,&m_bVSync);
m_pGamma = AddSlider(IDS_GAMMA,IDS_HELP_GAMMA,kGap,kWidth,-1,&m_nGamma);
m_pGamma->SetSliderRange(0,kNumSteps);
m_pGamma->SetSliderIncrement(1);
int nBaseGamma = ConvertToSlider(1.0f);
float xoffset = (m_pGamma->CalculateSliderOffset(nBaseGamma) / m_pGamma->GetScale());
uint16 nHeight = m_pGamma->GetBarHeight();
float yoffset = ((( (float)m_pGamma->GetBaseHeight()) - (float)nHeight)) / 2.0f;
pos = m_pGamma->GetBasePos();
pos.x += (int)(xoffset - 1.0f);
pos.y += (int)(yoffset + 0.5f);
CLTGUIFrame *pBar = debug_new(CLTGUIFrame);
pBar->Create(0xBF000000,3,nHeight+1);
pBar->SetBasePos(pos);
pBar->SetScale(g_pInterfaceResMgr->GetXRatio());
AddControl(pBar);
// Make sure to call the base class
if (!CBaseScreen::Build()) return LTFALSE;
UseBack(LTTRUE,LTTRUE);
return LTTRUE;
}
int SEARCHER::see(MOVE move) {
int list[32],n;
int from = m_from(move),to = m_to(move),sq,score;
int w_atkers[16],b_atkers[16];
int w_atks = 0,b_atks = 0;
int w_count , b_count;
int col,atkd_val;
int i,bi,bv,v,step,temp;
PLIST current;
/*initial value*/
col = PCOLOR(m_piece(move));
score = piece_see_v[m_capture(move)];
atkd_val = piece_see_v[m_piece(move)];
/*king captures*/
if(atkd_val > 1000)
return score;
/*collect pawn attackers*/
temp = score - atkd_val + piece_see_v[pawn];
if (board[to + RD] == wpawn && from != (to + RD)) {
QUICK_CUT(black);
w_atkers[w_atks++] = to + RD;
}
if (board[to + LD] == wpawn && from != (to + LD)) {
QUICK_CUT(black);
w_atkers[w_atks++] = to + LD;
}
if (board[to + RU] == bpawn && from != (to + RU)) {
QUICK_CUT(white);
b_atkers[b_atks++] = to + RU;
}
if (board[to + LU] == bpawn && from != (to + LU)) {
QUICK_CUT(white);
b_atkers[b_atks++] = to + LU;
}
/*knight attackers*/
temp = score - atkd_val + piece_see_v[knight];
current = plist[wknight];
while (current) {
sq = current->sq;
if (sqatt_pieces(to - sq) & NM) {
if(sq != from) {
QUICK_CUT(black);
w_atkers[w_atks++] = sq;
}
}
current = current->next;
}
current = plist[bknight];
while (current) {
sq = current->sq;
if (sqatt_pieces(to - sq) & NM) {
if(sq != from) {
QUICK_CUT(white);
b_atkers[b_atks++] = sq;
}
}
current = current->next;
}
/*sliders*/
temp = score - atkd_val + piece_see_v[bishop];
AddSlider(to,RU,wbishop,bbishop,1);
AddSlider(to,LU,wbishop,bbishop,1);
AddSlider(to,RD,wbishop,bbishop,1);
AddSlider(to,LD,wbishop,bbishop,1);
temp = score - atkd_val + piece_see_v[rook];
AddSlider(to,UU,wrook,brook,1);
AddSlider(to,DD,wrook,brook,1);
AddSlider(to,RR,wrook,brook,1);
AddSlider(to,LL,wrook,brook,1);
/*king attackers*/
sq = plist[wking]->sq;
if (sq != from && (sqatt_pieces(to - sq) & KM)) {
w_atkers[w_atks++] = sq;
}
sq = plist[bking]->sq;
if (sq != from && (sqatt_pieces(to - sq) & KM)) {
b_atkers[b_atks++] = sq;
}
/*we start by capturing*/
col = invert(col);
if(col == opponent)
AddHiddenAttacker(from);
/*no attackers*/
if((col == white && !w_atks)
|| (col == black && !b_atks))
return score;
/*swap*/
list[0] = score;
n = 1;
w_count = 0;
b_count = 0;
while(true) {
if((col == white && w_count == w_atks) ||
(col == black && b_count == b_atks) )
break;
list[n] = -list[n-1] + atkd_val;
n++;
if(col == white) {
/*get smallest attacker to the front*/
bi = w_count;
bv = piece_see_v[board[w_atkers[bi]]];
for(i = w_count + 1;i < w_atks;i++) {
v = piece_see_v[board[w_atkers[i]]];
if(v < bv) {
bi = i;
bv = v;
}
}
if(bi != w_count) {
temp = w_atkers[bi];
w_atkers[bi] = w_atkers[w_count];
w_atkers[w_count] = temp;
}
/*add hidden attacker*/
sq = w_atkers[w_count];
AddHiddenAttacker(sq);
atkd_val = bv;
col = black;
w_count++;
} else {
/*get smallest attacker to the front*/
bi = b_count;
bv = piece_see_v[board[b_atkers[bi]]];
for(i = b_count + 1;i < b_atks;i++) {
v = piece_see_v[board[b_atkers[i]]];
if(v < bv) {
bi = i;
bv = v;
}
}
if(bi != b_count) {
temp = b_atkers[bi];
b_atkers[bi] = b_atkers[b_count];
b_atkers[b_count] = temp;
}
/*add hidden attacker*/
sq = b_atkers[b_count];
AddHiddenAttacker(sq);
atkd_val = bv;
col = white;
b_count++;
}
}
while(--n)
list[n-1] = MIN(-list[n], list[n-1]);
score = list[0];
return score;
}
/*******************************************************************************
* Slot function. Translates command object recevied from the parser thread
* to appropriate function call.
* ****************************************************************************/
void DialogBox::ExecuteCommand(DialogCommand command)
{
QWidget* widget=NULL;
if(empty)
{
ClearDialog();
empty=false;
}
switch(command.command & DialogCommand::command_mask)
{
case DialogCommand::add:
if(command.command & DialogCommand::option_space & DialogCommand::option_mask)
{
// Seems sscanf %d in some versions of standard C library has a bug
// returning 32k on sero-size strings
if(command.GetText()[0])
{
int size;
sscanf(command.GetText(), "%d", &size);
AddSpace(size);
}
else AddSpace();
break;
}
if(command.command & DialogCommand::option_stretch & DialogCommand::option_mask)
{
AddStretch();
break;
}
switch(command.control & ~DialogCommand::property_mask)
{
case DialogCommand::label:
AddLabel(command.GetTitle(), command.GetName(),
command.control & DialogCommand::property_picture & DialogCommand::property_mask ? DialogBox::pixmap :
command.control & DialogCommand::property_animation & DialogCommand::property_mask ? DialogBox::movie :
DialogBox::text);
break;
case DialogCommand::groupbox:
AddGroupbox(command.GetTitle(), command.GetName(),
command.control & DialogCommand::property_vertical & DialogCommand::property_mask,
command.control & DialogCommand::property_checkable & DialogCommand::property_mask,
command.control & DialogCommand::property_checked & DialogCommand::property_mask);
break;
case DialogCommand::frame:
AddFrame(command.GetTitle(),
command.control & DialogCommand::property_vertical & DialogCommand::property_mask,
command.control);
break;
case DialogCommand::pushbutton:
AddPushbutton(command.GetTitle(), command.GetName(),
command.control & DialogCommand::property_apply & DialogCommand::property_mask,
command.control & DialogCommand::property_exit & DialogCommand::property_mask,
command.control & DialogCommand::property_default & DialogCommand::property_mask);
break;
case DialogCommand::checkbox:
AddCheckbox(command.GetTitle(), command.GetName(),
command.control & DialogCommand::property_checked & DialogCommand::property_mask);
break;
case DialogCommand::radiobutton:
AddRadiobutton(command.GetTitle(), command.GetName(),
command.control & DialogCommand::property_checked & DialogCommand::property_mask);
break;
case DialogCommand::textbox:
AddTextbox(command.GetTitle(), command.GetName(),
command.GetText(),
command.GetAuxText(),
command.control & DialogCommand::property_password & DialogCommand::property_mask);
break;
case DialogCommand::listbox:
AddListbox(command.GetTitle(), command.GetName(),
command.control & DialogCommand::property_activation & DialogCommand::property_mask,
command.control & DialogCommand::property_selection & DialogCommand::property_mask);
break;
case DialogCommand::combobox:
AddCombobox(command.GetTitle(), command.GetName(),
command.control & DialogCommand::property_editable & DialogCommand::property_mask,
command.control & DialogCommand::property_selection & DialogCommand::property_mask);
break;
case DialogCommand::item:
AddItem(command.GetTitle(), command.GetName(),
command.control & DialogCommand::property_current & DialogCommand::property_mask);
break;
case DialogCommand::separator:
AddSeparator(command.GetTitle(),
command.control & DialogCommand::property_vertical & DialogCommand::property_mask,
command.control);
break;
case DialogCommand::progressbar:
AddProgressbar(command.GetTitle(),
command.control & DialogCommand::property_vertical & DialogCommand::property_mask,
command.control & DialogCommand::property_busy & DialogCommand::property_mask);
break;
case DialogCommand::slider:
{
int min(0), max(100);
if(command.GetName()[0]) sscanf(command.GetName(), "%d", &min);
if(command.GetText()[0]) sscanf(command.GetText(), "%d", &max);
AddSlider(command.GetTitle(),
command.control & DialogCommand::property_vertical & DialogCommand::property_mask,
min, max);
}
break;
case DialogCommand::textview:
AddTextview(command.GetTitle(), command.GetName());
break;
case DialogCommand::tabs:
AddTabs(command.GetTitle(), command.control);
break;
case DialogCommand::page:
AddPage(command.GetTitle(), command.GetName(), command.GetText(),
command.control & DialogCommand::property_current & DialogCommand::property_mask);
break;
}
break;
case DialogCommand::clear:
Clear(command.GetName());
break;
case DialogCommand::end:
switch(command.control & ~DialogCommand::property_mask)
{
case DialogCommand::groupbox:
case DialogCommand::frame:
EndGroup();
break;
case DialogCommand::listbox:
case DialogCommand::combobox:
EndList();
break;
case DialogCommand::tabs:
EndTabs();
break;
case DialogCommand::page:
EndPage();
break;
case DialogCommand::widget_mask: // none type mentioned
if(current_view) EndList();
else if(group_layout) EndGroup();
else if(current_tab_widget)
{
if(current_tab_widget->indexOf(current_layout->parentWidget())==-1) EndTabs();
else EndPage();
}
break;
}
break;
case DialogCommand::step:
if(command.command & DialogCommand::option_vertical & DialogCommand::option_mask) StepVertical();
else StepHorizontal();
break;
case DialogCommand::set:
if(command.GetName()[0])
{
if(!(widget=FindWidget(command.GetName()))) break;
}
else widget=this;
if(command.command & DialogCommand::option_enabled & DialogCommand::option_mask)
SetEnabled(widget, true);
if(command.command & DialogCommand::option_focus & DialogCommand::option_mask)
{
QTimer::singleShot(0, widget, SLOT(setFocus()));
// select text for QLineEdit objects
// selectedText property is not writable and this must be done in the class specific way
if(QWidget* proxywidget=widget->focusProxy())
{
switch(WidgetType(proxywidget))
{
case DialogCommand::combobox:
proxywidget=((QComboBox*)proxywidget)->lineEdit();
break;
case DialogCommand::textbox:
break;
default:
proxywidget=NULL;
break;
}
if(proxywidget) ((QLineEdit*)proxywidget)->selectAll();
}
}
// see http://doc.qt.io/qt-4.8/stylesheet.html for reference
if(command.command & DialogCommand::option_stylesheet & DialogCommand::option_mask)
{
widget->setStyleSheet(command.GetText());
if(QWidget* proxywidget=widget->focusProxy())
proxywidget->setStyleSheet(command.GetText());
}
if(command.command & DialogCommand::option_visible & DialogCommand::option_mask)
{
widget->show();
if(QWidget* proxywidget=widget->focusProxy()) proxywidget->show();
}
if(command.control) SetOptions(widget, command.control, command.control, command.GetText());
// setting of some properties (calls like show and hide) generates events which are optimised next
// or sets widget attributes which might impact next calls
// to avoid races and to ensure the command is executed as expected we process all events that
// have been generated:
QCoreApplication::processEvents(QEventLoop::ExcludeUserInputEvents | QEventLoop::ExcludeSocketNotifiers);
break;
case DialogCommand::unset:
if(command.GetName()[0])
{
if(!(widget=FindWidget(command.GetName()))) break;
}
else widget=this;
if(command.command & DialogCommand::option_enabled & DialogCommand::option_mask)
SetEnabled(widget, false);
// see http://doc.qt.io/qt-4.8/stylesheet.html for reference
if(command.command & DialogCommand::option_stylesheet & DialogCommand::option_mask)
{
// rarely it was seen this fails (unset stylesheet or set it to empty string)
// hopefully this was caused by the race which is now fixed
// (queued signaling between threads and optimisation of queued GUI events)
widget->setStyleSheet(QString());
if(QWidget* proxywidget=widget->focusProxy())
proxywidget->setStyleSheet(QString());
}
if(command.command & DialogCommand::option_visible & DialogCommand::option_mask)
{
widget->hide();
if(QWidget* proxywidget=widget->focusProxy()) proxywidget->hide();
}
if(command.control) SetOptions(widget, 0, command.control, NULL);
// setting of some properties (calls like show and hide) generates events which are optimised next
// or sets widget attributes which might impact next calls
// to avoid races and to ensure the command is executed as expected we process all events that
// have been generated:
QCoreApplication::processEvents(QEventLoop::ExcludeUserInputEvents | QEventLoop::ExcludeSocketNotifiers);
break;
case DialogCommand::remove:
RemoveWidget(command.GetName());
break;
case DialogCommand::position:
Position(command.GetText(),
command.command & DialogCommand::option_behind & DialogCommand::option_mask,
command.command & DialogCommand::option_onto & DialogCommand::option_mask);
break;
case DialogCommand::query:
Report();
break;
case DialogCommand::noop:
default:
;
}
// clean up after possible FindWidget call
chosen_view=NULL;
chosen_row_flag=false;
}
// 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 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();
}
// Change in focus
void CFolderWeaponControls::OnFocus(LTBOOL bFocus)
{
if (bFocus)
{
nLastId = WMGR_INVALID_ID;
ReadBindings();
CLTGUIColumnTextCtrl *pCtrl=AddColumnText(LTNULL, LTNULL, LTTRUE, GetMediumFont());
HSTRING hText = g_pLTClient->FormatString(IDS_KEY);
pCtrl->AddColumn(hText, 50, LTF_JUSTIFY_LEFT);
g_pLTClient->FreeString(hText);
hText = g_pLTClient->FormatString(IDS_WEAPON);
pCtrl->AddColumn(hText, kWidth, LTF_JUSTIFY_LEFT);
pCtrl->Enable(LTFALSE);
g_pLTClient->FreeString(hText);
// AddBlankLine();
for (int i = 0; i < 10; i++)
{
pCtrl=AddColumnText(LTNULL, IDS_HELP_SETWEAPON, LTFALSE, GetSmallFont());
pCtrl->SetParam1(i+1);
char str[16];
sprintf(str," %s",szTriggers[i]);
hText = g_pLTClient->CreateString(str);
pCtrl->AddColumn(hText, 50, LTF_JUSTIFY_LEFT);
g_pLTClient->FreeString(hText);
int nWeaponId = g_pWeaponMgr->GetWeaponId(m_nActions[i]);
WEAPON *pWeapon = g_pWeaponMgr->GetWeapon(nWeaponId);
if (pWeapon)
pCtrl->AddColumn(pWeapon->nNameId, kWidth, LTF_JUSTIFY_LEFT);
else
pCtrl->AddColumn(IDS_CONTROL_UNASSIGNED, kWidth, LTF_JUSTIFY_LEFT);
}
AddBlankLine();
m_bLargeIcon = (GetConsoleInt("BindingIconSize",0) > 0);
CToggleCtrl *pToggle = AddToggle(IDS_WPN_ICON_SZ,IDS_HELP_WPN_ICON_SZ, kWidth, &m_bLargeIcon,LTFALSE,GetSmallFont());
pToggle->SetOnString(IDS_LARGE);
pToggle->SetOffString(IDS_SMALL);
m_nIconAlpha = (int)(GetConsoleFloat("BindingIconAlpha",0.7f) * 10.0f);
CSliderCtrl *pSlider = AddSlider(IDS_WPN_ICON_A,IDS_HELP_WPN_ICON_A,kWidth,kSlider,&m_nIconAlpha,LTFALSE,GetSmallFont());
pSlider->SetSliderIncrement(1);
pSlider->SetSliderRange(0,10);
m_bUseNumbers = (GetConsoleInt("BindingNumbers",1) > 0);
pToggle = AddToggle(IDS_WPN_USE_NUMS,IDS_HELP_WPN_USE_NUMS, kWidth, &m_bUseNumbers,LTFALSE,GetSmallFont());
pToggle->SetOnString(IDS_YES);
pToggle->SetOffString(IDS_NO);
UpdateData(LTFALSE);
}
else
{
UpdateData();
WriteConsoleInt("BindingIconSize",m_bLargeIcon);
WriteConsoleInt("BindingNumbers",m_bUseNumbers);
WriteConsoleFloat("BindingIconAlpha",((LTFLOAT)m_nIconAlpha) / 10.0f);
WriteBindings();
g_pInterfaceMgr->GetPlayerStats()->UpdateWeaponBindings();
// Just to be safe save the config incase anything changed...
g_pLTClient->WriteConfigFile("autoexec.cfg");
RemoveFree();
}
CBaseFolder::OnFocus(bFocus);
if (bFocus) UpdateSelection();
}
void CGUIDialogVideoSettings::InitializeSettings()
{
CGUIDialogSettingsManualBase::InitializeSettings();
CSettingCategory *category = AddCategory("videosettings", -1);
if (category == NULL)
{
CLog::Log(LOGERROR, "CGUIDialogVideoSettings: unable to setup settings");
return;
}
// get all necessary setting groups
CSettingGroup *groupVideoStream = AddGroup(category);
if (groupVideoStream == NULL)
{
CLog::Log(LOGERROR, "CGUIDialogVideoSettings: unable to setup settings");
return;
}
CSettingGroup *groupVideo = AddGroup(category);
if (groupVideo == NULL)
{
CLog::Log(LOGERROR, "CGUIDialogVideoSettings: unable to setup settings");
return;
}
CSettingGroup *groupVideoPlayback = AddGroup(category);
if (groupVideoPlayback == NULL)
{
CLog::Log(LOGERROR, "CGUIDialogVideoSettings: unable to setup settings");
return;
}
CSettingGroup *groupStereoscopic = AddGroup(category);
if (groupStereoscopic == NULL)
{
CLog::Log(LOGERROR, "CGUIDialogVideoSettings: unable to setup settings");
return;
}
CSettingGroup *groupSaveAsDefault = AddGroup(category);
if (groupSaveAsDefault == NULL)
{
CLog::Log(LOGERROR, "CGUIDialogVideoSettings: unable to setup settings");
return;
}
bool usePopup = g_SkinInfo->HasSkinFile("DialogSlider.xml");
CVideoSettings &videoSettings = CMediaSettings::GetInstance().GetCurrentVideoSettings();
StaticIntegerSettingOptions entries;
entries.clear();
entries.push_back(std::make_pair(16039, VS_INTERLACEMETHOD_NONE));
entries.push_back(std::make_pair(16019, VS_INTERLACEMETHOD_AUTO));
entries.push_back(std::make_pair(20131, VS_INTERLACEMETHOD_RENDER_BLEND));
entries.push_back(std::make_pair(20130, VS_INTERLACEMETHOD_RENDER_WEAVE_INVERTED));
entries.push_back(std::make_pair(20129, VS_INTERLACEMETHOD_RENDER_WEAVE));
entries.push_back(std::make_pair(16022, VS_INTERLACEMETHOD_RENDER_BOB_INVERTED));
entries.push_back(std::make_pair(16021, VS_INTERLACEMETHOD_RENDER_BOB));
entries.push_back(std::make_pair(16020, VS_INTERLACEMETHOD_DEINTERLACE));
entries.push_back(std::make_pair(16036, VS_INTERLACEMETHOD_DEINTERLACE_HALF));
entries.push_back(std::make_pair(16314, VS_INTERLACEMETHOD_INVERSE_TELECINE));
entries.push_back(std::make_pair(16311, VS_INTERLACEMETHOD_VDPAU_TEMPORAL_SPATIAL));
entries.push_back(std::make_pair(16310, VS_INTERLACEMETHOD_VDPAU_TEMPORAL));
entries.push_back(std::make_pair(16325, VS_INTERLACEMETHOD_VDPAU_BOB));
entries.push_back(std::make_pair(16318, VS_INTERLACEMETHOD_VDPAU_TEMPORAL_SPATIAL_HALF));
entries.push_back(std::make_pair(16317, VS_INTERLACEMETHOD_VDPAU_TEMPORAL_HALF));
entries.push_back(std::make_pair(16314, VS_INTERLACEMETHOD_VDPAU_INVERSE_TELECINE));
entries.push_back(std::make_pair(16325, VS_INTERLACEMETHOD_AUTO_ION));
entries.push_back(std::make_pair(16327, VS_INTERLACEMETHOD_VAAPI_BOB));
entries.push_back(std::make_pair(16328, VS_INTERLACEMETHOD_VAAPI_MADI));
entries.push_back(std::make_pair(16329, VS_INTERLACEMETHOD_VAAPI_MACI));
entries.push_back(std::make_pair(16330, VS_INTERLACEMETHOD_MMAL_ADVANCED));
entries.push_back(std::make_pair(16331, VS_INTERLACEMETHOD_MMAL_ADVANCED_HALF));
entries.push_back(std::make_pair(16332, VS_INTERLACEMETHOD_MMAL_BOB));
entries.push_back(std::make_pair(16333, VS_INTERLACEMETHOD_MMAL_BOB_HALF));
entries.push_back(std::make_pair(16334, VS_INTERLACEMETHOD_IMX_FASTMOTION));
entries.push_back(std::make_pair(16335, VS_INTERLACEMETHOD_IMX_FASTMOTION_DOUBLE));
/* remove unsupported methods */
for (StaticIntegerSettingOptions::iterator it = entries.begin(); it != entries.end(); )
{
if (g_application.m_pPlayer->Supports((EINTERLACEMETHOD)it->second))
++it;
else
it = entries.erase(it);
}
if (!entries.empty())
{
AddSpinner(groupVideo, SETTING_VIDEO_INTERLACEMETHOD, 16038, 0, static_cast<int>(videoSettings.m_InterlaceMethod), entries);
}
entries.clear();
entries.push_back(std::make_pair(16301, VS_SCALINGMETHOD_NEAREST));
entries.push_back(std::make_pair(16302, VS_SCALINGMETHOD_LINEAR));
entries.push_back(std::make_pair(16303, VS_SCALINGMETHOD_CUBIC ));
entries.push_back(std::make_pair(16304, VS_SCALINGMETHOD_LANCZOS2));
entries.push_back(std::make_pair(16323, VS_SCALINGMETHOD_SPLINE36_FAST));
entries.push_back(std::make_pair(16315, VS_SCALINGMETHOD_LANCZOS3_FAST));
entries.push_back(std::make_pair(16322, VS_SCALINGMETHOD_SPLINE36));
entries.push_back(std::make_pair(16305, VS_SCALINGMETHOD_LANCZOS3));
entries.push_back(std::make_pair(16306, VS_SCALINGMETHOD_SINC8));
// entries.push_back(make_pair(?????, VS_SCALINGMETHOD_NEDI));
entries.push_back(std::make_pair(16307, VS_SCALINGMETHOD_BICUBIC_SOFTWARE));
entries.push_back(std::make_pair(16308, VS_SCALINGMETHOD_LANCZOS_SOFTWARE));
entries.push_back(std::make_pair(16309, VS_SCALINGMETHOD_SINC_SOFTWARE));
entries.push_back(std::make_pair(13120, VS_SCALINGMETHOD_VDPAU_HARDWARE));
entries.push_back(std::make_pair(16319, VS_SCALINGMETHOD_DXVA_HARDWARE));
entries.push_back(std::make_pair(16316, VS_SCALINGMETHOD_AUTO));
/* remove unsupported methods */
for(StaticIntegerSettingOptions::iterator it = entries.begin(); it != entries.end(); )
{
if (g_application.m_pPlayer->Supports((ESCALINGMETHOD)it->second))
++it;
else
it = entries.erase(it);
}
AddSpinner(groupVideo, SETTING_VIDEO_SCALINGMETHOD, 16300, 0, static_cast<int>(videoSettings.m_ScalingMethod), entries);
#ifdef HAS_VIDEO_PLAYBACK
AddVideoStreams(groupVideoStream, SETTING_VIDEO_STREAM);
if (g_application.m_pPlayer->Supports(RENDERFEATURE_STRETCH) || g_application.m_pPlayer->Supports(RENDERFEATURE_PIXEL_RATIO))
{
entries.clear();
for (int i = 0; i < 7; ++i)
entries.push_back(std::make_pair(630 + i, i));
AddSpinner(groupVideo, SETTING_VIDEO_VIEW_MODE, 629, 0, videoSettings.m_ViewMode, entries);
}
if (g_application.m_pPlayer->Supports(RENDERFEATURE_ZOOM))
AddSlider(groupVideo, SETTING_VIDEO_ZOOM, 216, 0, videoSettings.m_CustomZoomAmount, "%2.2f", 0.5f, 0.01f, 2.0f, 216, usePopup);
if (g_application.m_pPlayer->Supports(RENDERFEATURE_VERTICAL_SHIFT))
AddSlider(groupVideo, SETTING_VIDEO_VERTICAL_SHIFT, 225, 0, videoSettings.m_CustomVerticalShift, "%2.2f", -2.0f, 0.01f, 2.0f, 225, usePopup);
if (g_application.m_pPlayer->Supports(RENDERFEATURE_PIXEL_RATIO))
AddSlider(groupVideo, SETTING_VIDEO_PIXEL_RATIO, 217, 0, videoSettings.m_CustomPixelRatio, "%2.2f", 0.5f, 0.01f, 2.0f, 217, usePopup);
if (g_application.m_pPlayer->Supports(RENDERFEATURE_POSTPROCESS))
AddToggle(groupVideo, SETTING_VIDEO_POSTPROCESS, 16400, 0, videoSettings.m_PostProcess);
if (g_application.m_pPlayer->Supports(RENDERFEATURE_BRIGHTNESS))
AddPercentageSlider(groupVideoPlayback, SETTING_VIDEO_BRIGHTNESS, 464, 0, static_cast<int>(videoSettings.m_Brightness), 14047, 1, 464, usePopup);
if (g_application.m_pPlayer->Supports(RENDERFEATURE_CONTRAST))
AddPercentageSlider(groupVideoPlayback, SETTING_VIDEO_CONTRAST, 465, 0, static_cast<int>(videoSettings.m_Contrast), 14047, 1, 465, usePopup);
if (g_application.m_pPlayer->Supports(RENDERFEATURE_GAMMA))
AddPercentageSlider(groupVideoPlayback, SETTING_VIDEO_GAMMA, 466, 0, static_cast<int>(videoSettings.m_Gamma), 14047, 1, 466, usePopup);
if (g_application.m_pPlayer->Supports(RENDERFEATURE_NOISE))
AddSlider(groupVideoPlayback, SETTING_VIDEO_VDPAU_NOISE, 16312, 0, videoSettings.m_NoiseReduction, "%2.2f", 0.0f, 0.01f, 1.0f, 16312, usePopup);
if (g_application.m_pPlayer->Supports(RENDERFEATURE_SHARPNESS))
AddSlider(groupVideoPlayback, SETTING_VIDEO_VDPAU_SHARPNESS, 16313, 0, videoSettings.m_Sharpness, "%2.2f", -1.0f, 0.02f, 1.0f, 16313, usePopup);
if (g_application.m_pPlayer->Supports(RENDERFEATURE_NONLINSTRETCH))
AddToggle(groupVideoPlayback, SETTING_VIDEO_NONLIN_STRETCH, 659, 0, videoSettings.m_CustomNonLinStretch);
#endif
// stereoscopic settings
entries.clear();
entries.push_back(std::make_pair(16316, RENDER_STEREO_MODE_OFF));
entries.push_back(std::make_pair(36503, RENDER_STEREO_MODE_SPLIT_HORIZONTAL));
entries.push_back(std::make_pair(36504, RENDER_STEREO_MODE_SPLIT_VERTICAL));
AddSpinner(groupStereoscopic, SETTING_VIDEO_STEREOSCOPICMODE , 36535, 0, videoSettings.m_StereoMode, entries);
AddToggle(groupStereoscopic, SETTING_VIDEO_STEREOSCOPICINVERT, 36536, 0, videoSettings.m_StereoInvert);
// general settings
AddButton(groupSaveAsDefault, SETTING_VIDEO_MAKE_DEFAULT, 12376, 0);
AddButton(groupSaveAsDefault, SETTING_VIDEO_CALIBRATION, 214, 0);
}
void CGUIDialogSubtitleSettings::InitializeSettings()
{
CGUIDialogSettingsManualBase::InitializeSettings();
const std::shared_ptr<CSettingCategory> category = AddCategory("audiosubtitlesettings", -1);
if (category == NULL)
{
CLog::Log(LOGERROR, "CGUIDialogSubtitleSettings: unable to setup settings");
return;
}
// get all necessary setting groups
const std::shared_ptr<CSettingGroup> groupAudio = AddGroup(category);
if (groupAudio == NULL)
{
CLog::Log(LOGERROR, "CGUIDialogSubtitleSettings: unable to setup settings");
return;
}
const std::shared_ptr<CSettingGroup> groupSubtitles = AddGroup(category);
if (groupSubtitles == NULL)
{
CLog::Log(LOGERROR, "CGUIDialogSubtitleSettings: unable to setup settings");
return;
}
const std::shared_ptr<CSettingGroup> groupSaveAsDefault = AddGroup(category);
if (groupSaveAsDefault == NULL)
{
CLog::Log(LOGERROR, "CGUIDialogSubtitleSettings: unable to setup settings");
return;
}
bool usePopup = g_SkinInfo->HasSkinFile("DialogSlider.xml");
const CVideoSettings videoSettings = g_application.GetAppPlayer().GetVideoSettings();
if (g_application.GetAppPlayer().HasPlayer())
{
g_application.GetAppPlayer().GetSubtitleCapabilities(m_subtitleCapabilities);
}
// subtitle settings
m_subtitleVisible = g_application.GetAppPlayer().GetSubtitleVisible();
// subtitle enabled setting
AddToggle(groupSubtitles, SETTING_SUBTITLE_ENABLE, 13397, SettingLevel::Basic, m_subtitleVisible);
// subtitle delay setting
if (SupportsSubtitleFeature(IPC_SUBS_OFFSET))
{
std::shared_ptr<CSettingNumber> settingSubtitleDelay = AddSlider(groupSubtitles, SETTING_SUBTITLE_DELAY, 22006, SettingLevel::Basic, videoSettings.m_SubtitleDelay, 0, -CServiceBroker::GetSettingsComponent()->GetAdvancedSettings()->m_videoSubsDelayRange, 0.1f, CServiceBroker::GetSettingsComponent()->GetAdvancedSettings()->m_videoSubsDelayRange, 22006, usePopup);
std::static_pointer_cast<CSettingControlSlider>(settingSubtitleDelay->GetControl())->SetFormatter(SettingFormatterDelay);
}
// subtitle stream setting
if (SupportsSubtitleFeature(IPC_SUBS_SELECT))
AddSubtitleStreams(groupSubtitles, SETTING_SUBTITLE_STREAM);
// subtitle browser setting
if (SupportsSubtitleFeature(IPC_SUBS_EXTERNAL))
AddButton(groupSubtitles, SETTING_SUBTITLE_BROWSER, 13250, SettingLevel::Basic);
AddButton(groupSubtitles, SETTING_SUBTITLE_SEARCH, 24134, SettingLevel::Basic);
// subtitle stream setting
AddButton(groupSaveAsDefault, SETTING_MAKE_DEFAULT, 12376, SettingLevel::Basic);
}
void CGUIDialogAudioSubtitleSettings::InitializeSettings()
{
CGUIDialogSettingsManualBase::InitializeSettings();
CSettingCategory *category = AddCategory("audiosubtitlesettings", -1);
if (category == NULL)
{
CLog::Log(LOGERROR, "CGUIDialogAudioSubtitleSettings: unable to setup settings");
return;
}
// get all necessary setting groups
CSettingGroup *groupAudio = AddGroup(category);
if (groupAudio == NULL)
{
CLog::Log(LOGERROR, "CGUIDialogAudioSubtitleSettings: unable to setup settings");
return;
}
CSettingGroup *groupSubtitles = AddGroup(category);
if (groupSubtitles == NULL)
{
CLog::Log(LOGERROR, "CGUIDialogAudioSubtitleSettings: unable to setup settings");
return;
}
CSettingGroup *groupSaveAsDefault = AddGroup(category);
if (groupSaveAsDefault == NULL)
{
CLog::Log(LOGERROR, "CGUIDialogAudioSubtitleSettings: unable to setup settings");
return;
}
bool usePopup = g_SkinInfo->HasSkinFile("DialogSlider.xml");
CVideoSettings &videoSettings = CMediaSettings::GetInstance().GetCurrentVideoSettings();
if (g_application.m_pPlayer->HasPlayer())
{
g_application.m_pPlayer->GetAudioCapabilities(m_audioCaps);
g_application.m_pPlayer->GetSubtitleCapabilities(m_subCaps);
}
// register IsPlayingPassthrough condition
m_settingsManager->AddCondition("IsPlayingPassthrough", IsPlayingPassthrough);
CSettingDependency dependencyAudioOutputPassthroughDisabled(SettingDependencyTypeEnable, m_settingsManager);
dependencyAudioOutputPassthroughDisabled.Or()
->Add(CSettingDependencyConditionPtr(new CSettingDependencyCondition(SETTING_AUDIO_PASSTHROUGH, "false", SettingDependencyOperatorEquals, false, m_settingsManager)))
->Add(CSettingDependencyConditionPtr(new CSettingDependencyCondition("IsPlayingPassthrough", "", "", true, m_settingsManager)));
SettingDependencies depsAudioOutputPassthroughDisabled;
depsAudioOutputPassthroughDisabled.push_back(dependencyAudioOutputPassthroughDisabled);
m_dspEnabled = CServiceBroker::GetSettings().GetBool(CSettings::SETTING_AUDIOOUTPUT_DSPADDONSENABLED);
// audio settings
// audio volume setting
m_volume = g_application.GetVolume(false);
CSettingNumber *settingAudioVolume = AddSlider(groupAudio, SETTING_AUDIO_VOLUME, 13376, 0, m_volume, 14054, VOLUME_MINIMUM, VOLUME_MAXIMUM / 100.0f, VOLUME_MAXIMUM);
settingAudioVolume->SetDependencies(depsAudioOutputPassthroughDisabled);
static_cast<CSettingControlSlider*>(settingAudioVolume->GetControl())->SetFormatter(SettingFormatterPercentAsDecibel);
if (m_dspEnabled)
AddButton(groupAudio, SETTING_AUDIO_DSP, 24136, 0);
// audio volume amplification setting
if (SupportsAudioFeature(IPC_AUD_AMP) && !m_dspEnabled)
{
CSettingNumber *settingAudioVolumeAmplification = AddSlider(groupAudio, SETTING_AUDIO_VOLUME_AMPLIFICATION, 660, 0, videoSettings.m_VolumeAmplification, 14054, VOLUME_DRC_MINIMUM * 0.01f, (VOLUME_DRC_MAXIMUM - VOLUME_DRC_MINIMUM) / 6000.0f, VOLUME_DRC_MAXIMUM * 0.01f);
settingAudioVolumeAmplification->SetDependencies(depsAudioOutputPassthroughDisabled);
}
// audio delay setting
if (SupportsAudioFeature(IPC_AUD_OFFSET) && !m_dspEnabled)
{
CSettingNumber *settingAudioDelay = AddSlider(groupAudio, SETTING_AUDIO_DELAY, 297, 0, videoSettings.m_AudioDelay, 0, -g_advancedSettings.m_videoAudioDelayRange, 0.025f, g_advancedSettings.m_videoAudioDelayRange, 297, usePopup);
static_cast<CSettingControlSlider*>(settingAudioDelay->GetControl())->SetFormatter(SettingFormatterDelay);
}
// audio stream setting
if (SupportsAudioFeature(IPC_AUD_SELECT_STREAM))
AddAudioStreams(groupAudio, SETTING_AUDIO_STREAM);
// audio output to all speakers setting
//! @todo remove this setting
if (SupportsAudioFeature(IPC_AUD_OUTPUT_STEREO) && !m_dspEnabled)
AddToggle(groupAudio, SETTING_AUDIO_OUTPUT_TO_ALL_SPEAKERS, 252, 0, videoSettings.m_OutputToAllSpeakers);
// audio digital/analog setting
if (SupportsAudioFeature(IPC_AUD_SELECT_OUTPUT))
{
m_passthrough = CServiceBroker::GetSettings().GetBool(CSettings::SETTING_AUDIOOUTPUT_PASSTHROUGH);
AddToggle(groupAudio, SETTING_AUDIO_PASSTHROUGH, 348, 0, m_passthrough);
}
// subtitle settings
m_subtitleVisible = g_application.m_pPlayer->GetSubtitleVisible();
// subtitle enabled setting
AddToggle(groupSubtitles, SETTING_SUBTITLE_ENABLE, 13397, 0, m_subtitleVisible);
// subtitle delay setting
if (SupportsSubtitleFeature(IPC_SUBS_OFFSET))
{
CSettingNumber *settingSubtitleDelay = AddSlider(groupSubtitles, SETTING_SUBTITLE_DELAY, 22006, 0, videoSettings.m_SubtitleDelay, 0, -g_advancedSettings.m_videoSubsDelayRange, 0.1f, g_advancedSettings.m_videoSubsDelayRange, 22006, usePopup);
static_cast<CSettingControlSlider*>(settingSubtitleDelay->GetControl())->SetFormatter(SettingFormatterDelay);
}
// subtitle stream setting
if (SupportsSubtitleFeature(IPC_SUBS_SELECT))
AddSubtitleStreams(groupSubtitles, SETTING_SUBTITLE_STREAM);
// subtitle browser setting
if (SupportsSubtitleFeature(IPC_SUBS_EXTERNAL))
AddButton(groupSubtitles, SETTING_SUBTITLE_BROWSER, 13250, 0);
// subtitle stream setting
AddButton(groupSaveAsDefault, SETTING_AUDIO_MAKE_DEFAULT, 12376, 0);
}
// Build the screen
bool CScreenGame::Build()
{
CreateTitle("IDS_TITLE_GAME_OPTIONS");
kGap = g_pLayoutDB->GetInt32(m_hLayout,LDB_ScreenColumnWidths,0);
kWidth = g_pLayoutDB->GetInt32(m_hLayout,LDB_ScreenColumnWidths,1);
kTextWidth = g_pLayoutDB->GetInt32(m_hLayout,LDB_ScreenColumnWidths,2);
//background frame
CLTGUICtrl_create cs;
cs.rnBaseRect = g_pLayoutDB->GetRect(m_hLayout,LDB_ScreenFrameRect);
TextureReference hFrame(g_pLayoutDB->GetString(m_hLayout,LDB_ScreenFrameTexture));
CLTGUIFrame *pFrame = debug_new(CLTGUIFrame);
pFrame->Create(hFrame,cs);
AddControl(pFrame);
m_DefaultPos = m_ScreenRect.m_vMin;
//crosshair menu
cs.rnBaseRect.m_vMin.Init();
cs.rnBaseRect.m_vMax = LTVector2n(m_ScreenRect.GetWidth(),g_pLayoutDB->GetInt32(m_hLayout,LDB_ScreenFontSize));
cs.nCommandID = CMD_CROSSHAIR;
cs.szHelpID = "IDS_HELP_CROSSHAIRMENU";
AddTextItem("IDS_CONTROLS_CROSSHAIR", cs);
CLTGUIToggle_create tcs;
tcs.nHeaderWidth = kGap;
CLTGUIToggle *pToggle = NULL;
#if !defined(_DEMO) || defined(_SPDEMO)
tcs.rnBaseRect.m_vMin.Init();
tcs.rnBaseRect.m_vMax = LTVector2n(m_ScreenRect.GetWidth(),g_pLayoutDB->GetInt32(m_hLayout,LDB_ScreenFontSize));
tcs.szHelpID = "IDS_HELP_SUBTITLES";
tcs.pbValue = &m_bSubtitles;
pToggle = AddToggle("IDS_DISPLAY_SUBTITLES", tcs);
pToggle->SetOnString(LoadString("IDS_ON"));
pToggle->SetOffString(LoadString("IDS_OFF"));
#endif
const wchar_t* szYes = LoadString( "IDS_YES" );
const wchar_t* szNo = LoadString( "IDS_NO" );
tcs.rnBaseRect.m_vMin.Init();
tcs.rnBaseRect.m_vMax = LTVector2n(m_ScreenRect.GetWidth(),g_pLayoutDB->GetInt32(m_hLayout,LDB_ScreenFontSize));
CUserProfile *pProfile = g_pProfileMgr->GetCurrentProfile();
if (pProfile && !g_pVersionMgr->IsLowViolence())
{
tcs.szHelpID = "IDS_HELP_GORE";
tcs.pbValue = &m_bGore;
tcs.nHeaderWidth = kGap;
CLTGUIToggle *pGore = AddToggle("IDS_DISPLAY_GORE",tcs);
pGore->SetOnString(szYes);
pGore->SetOffString(szNo);
}
//always run
tcs.szHelpID = "IDS_HELP_RUNLOCK";
tcs.pbValue = &m_bAlwaysRun;
tcs.nHeaderWidth = kGap;
pToggle = AddToggle("IDS_ADVCONTROLS_RUNLOCK",tcs);
pToggle->SetOnString(szYes);
pToggle->SetOffString(szNo);
tcs.szHelpID = "ScreenOptions_CrouchToggle_Help";
tcs.pbValue = &m_bCrouchToggle;
tcs.nHeaderWidth = kGap;
pToggle = AddToggle("ScreenOptions_CrouchToggle",tcs);
pToggle->SetOnString(szYes);
pToggle->SetOffString(szNo);
#if !defined(_DEMO) || defined(_SPDEMO)
// Add the Difficulty option
CLTGUICycleCtrl_create ccs;
ccs.szHelpID = "IDS_HELP_DIFFICULTY";
ccs.pnValue = &m_nDifficulty;
ccs.nHeaderWidth = kGap;
ccs.rnBaseRect.m_vMin.Init();
ccs.rnBaseRect.m_vMax = LTVector2n(m_ScreenRect.GetWidth(),g_pLayoutDB->GetInt32(m_hLayout,LDB_ScreenFontSize));
m_pDifficultyCtrl = AddCycle("IDS_DIFFICULTY",ccs);
m_pDifficultyCtrl->AddString(LoadString("IDS_NEW_EASY"));
m_pDifficultyCtrl->AddString(LoadString("IDS_NEW_MEDIUM"));
m_pDifficultyCtrl->AddString(LoadString("IDS_NEW_HARD"));
m_pDifficultyCtrl->AddString(LoadString("IDS_NEW_INSANE"));
#endif
CLTGUISlider_create scs;
scs.rnBaseRect.m_vMin.Init();
scs.rnBaseRect.m_vMax = LTVector2n(kGap+kWidth,g_pLayoutDB->GetInt32(m_hLayout,LDB_ScreenFontSize));
scs.nBarOffset = kGap;
scs.szHelpID = "IDS_HELP_PICKUP_MSG_DUR";
scs.pnValue = &m_nMsgDur;
scs.nMin = 1;
scs.nMax = 10;
scs.nIncrement = 1;
CLTGUISlider* pSlider = AddSlider("IDS_PICKUP_MSG_DUR", scs );
scs.rnBaseRect.m_vMin.Init();
scs.rnBaseRect.m_vMax = LTVector2n(kGap+kWidth,g_pLayoutDB->GetInt32(m_hLayout,LDB_ScreenFontSize));
scs.nBarOffset = kGap;
scs.szHelpID = "IDS_HELP_HEADBOB";
scs.pnValue = &m_nHeadBob;
scs.nMin = 1;
scs.nMax = 10;
scs.nIncrement = 1;
pSlider = AddSlider("IDS_HEADBOB", scs );
#if defined(_MPDEMO)
tcs.szHelpID = "IDS_HELP_AUTOSWITCH_WEAPONS";
tcs.pbValue = &m_bMPAutoWeaponSwitch;
tcs.nHeaderWidth = kGap;
pToggle = AddToggle("IDS_AUTOSWITCH_WEAPONS",tcs);
pToggle->SetOnString(szYes);
pToggle->SetOffString(szNo);
#elif defined(_SPDEMO)
tcs.szHelpID = "IDS_HELP_AUTOSWITCH_WEAPONS";
tcs.pbValue = &m_bSPAutoWeaponSwitch;
tcs.nHeaderWidth = kGap;
pToggle = AddToggle("IDS_AUTOSWITCH_WEAPONS",tcs);
pToggle->SetOnString(szYes);
pToggle->SetOffString(szNo);
#else
ccs.szHelpID = "IDS_HELP_AUTOSWITCH_WEAPONS";
ccs.pnValue = &m_nAutoWeaponSwitch;
CLTGUICycleCtrl *pCycle = AddCycle("IDS_AUTOSWITCH_WEAPONS", ccs);
pCycle->AddString(LoadString("IDS_NEVER"));
pCycle->AddString(LoadString("IDS_SP_ONLY"));
pCycle->AddString(LoadString("IDS_MP_ONLY"));
pCycle->AddString(LoadString("IDS_ALWAYS"));
#endif
//slowmo overlay
tcs.szHelpID = "Screen_Options_SlowMoFX_Help";
tcs.pbValue = &m_bSlowMoFX;
tcs.nHeaderWidth = kGap;
pToggle = AddToggle("Screen_Options_SlowMoFX",tcs);
pToggle->SetOnString(szYes);
pToggle->SetOffString(szNo);
scs.rnBaseRect.m_vMin.Init();
scs.rnBaseRect.m_vMax = LTVector2n(kGap+kWidth,g_pLayoutDB->GetInt32(m_hLayout,LDB_ScreenFontSize));
scs.nBarOffset = kGap;
scs.szHelpID = "IDS_HELP_HUD_FADE_TIME";
scs.pnValue = &m_nHUDFade;
scs.nMin = kMinFade;
scs.nMax = kMaxFade;
scs.nIncrement = 3;
scs.pnTextCallback = HUDSliderTextCallback;
scs.nDisplayWidth = kTextWidth;
pSlider = AddSlider("IDS_HUD_FADE_TIME", scs );
// Make sure to call the base class
if (! CBaseScreen::Build()) return false;
UseBack(true,true);
return true;
}
void CGUIDialogCMSSettings::InitializeSettings()
{
CGUIDialogSettingsManualBase::InitializeSettings();
const std::shared_ptr<CSettingCategory> category = AddCategory("cms", -1);
if (category == NULL)
{
CLog::Log(LOGERROR, "CGUIDialogCMSSettings: unable to setup settings");
return;
}
// get all necessary setting groups
const std::shared_ptr<CSettingGroup> groupColorManagement = AddGroup(category);
if (groupColorManagement == NULL)
{
CLog::Log(LOGERROR, "CGUIDialogCMSSettings: unable to setup settings");
return;
}
bool usePopup = g_SkinInfo->HasSkinFile("DialogSlider.xml");
TranslatableIntegerSettingOptions entries;
// create "depsCmsEnabled" for settings depending on CMS being enabled
CSettingDependency dependencyCmsEnabled(SettingDependencyType::Enable, GetSettingsManager());
dependencyCmsEnabled.Or()
->Add(CSettingDependencyConditionPtr(new CSettingDependencyCondition(SETTING_VIDEO_CMSENABLE, "true", SettingDependencyOperator::Equals, false, GetSettingsManager())));
SettingDependencies depsCmsEnabled;
depsCmsEnabled.push_back(dependencyCmsEnabled);
// create "depsCms3dlut" for 3dlut settings
CSettingDependency dependencyCms3dlut(SettingDependencyType::Visible, GetSettingsManager());
dependencyCms3dlut.And()
->Add(CSettingDependencyConditionPtr(new CSettingDependencyCondition(SETTING_VIDEO_CMSMODE, std::to_string(CMS_MODE_3DLUT), SettingDependencyOperator::Equals, false, GetSettingsManager())));
SettingDependencies depsCms3dlut;
depsCms3dlut.push_back(dependencyCmsEnabled);
depsCms3dlut.push_back(dependencyCms3dlut);
// create "depsCmsIcc" for display settings with icc profile
CSettingDependency dependencyCmsIcc(SettingDependencyType::Visible, GetSettingsManager());
dependencyCmsIcc.And()
->Add(CSettingDependencyConditionPtr(new CSettingDependencyCondition(SETTING_VIDEO_CMSMODE, std::to_string(CMS_MODE_PROFILE), SettingDependencyOperator::Equals, false, GetSettingsManager())));
SettingDependencies depsCmsIcc;
depsCmsIcc.push_back(dependencyCmsEnabled);
depsCmsIcc.push_back(dependencyCmsIcc);
// create "depsCmsGamma" for effective gamma adjustment (not available with bt.1886)
CSettingDependency dependencyCmsGamma(SettingDependencyType::Visible, GetSettingsManager());
dependencyCmsGamma.And()
->Add(CSettingDependencyConditionPtr(new CSettingDependencyCondition(SETTING_VIDEO_CMSGAMMAMODE, std::to_string(CMS_TRC_BT1886), SettingDependencyOperator::Equals, true, GetSettingsManager())));
SettingDependencies depsCmsGamma;
depsCmsGamma.push_back(dependencyCmsEnabled);
depsCmsGamma.push_back(dependencyCmsIcc);
depsCmsGamma.push_back(dependencyCmsGamma);
// color management settings
AddToggle(groupColorManagement, SETTING_VIDEO_CMSENABLE, 36560, SettingLevel::Basic, CServiceBroker::GetSettings().GetBool(SETTING_VIDEO_CMSENABLE));
int currentMode = CServiceBroker::GetSettings().GetInt(SETTING_VIDEO_CMSMODE);
entries.clear();
// entries.push_back(std::make_pair(16039, CMS_MODE_OFF)); // FIXME: get from CMS class
entries.push_back(std::make_pair(36580, CMS_MODE_3DLUT));
#ifdef HAVE_LCMS2
entries.push_back(std::make_pair(36581, CMS_MODE_PROFILE));
#endif
std::shared_ptr<CSettingInt> settingCmsMode = AddSpinner(groupColorManagement, SETTING_VIDEO_CMSMODE, 36562, SettingLevel::Basic, currentMode, entries);
settingCmsMode->SetDependencies(depsCmsEnabled);
std::string current3dLUT = CServiceBroker::GetSettings().GetString(SETTING_VIDEO_CMS3DLUT);
std::shared_ptr<CSettingString> settingCms3dlut = AddList(groupColorManagement, SETTING_VIDEO_CMS3DLUT, 36564, SettingLevel::Basic, current3dLUT, Cms3dLutsFiller, 36564);
settingCms3dlut->SetDependencies(depsCms3dlut);
// display settings
int currentWhitepoint = CServiceBroker::GetSettings().GetInt(SETTING_VIDEO_CMSWHITEPOINT);
entries.clear();
entries.push_back(std::make_pair(36586, CMS_WHITEPOINT_D65));
entries.push_back(std::make_pair(36587, CMS_WHITEPOINT_D93));
std::shared_ptr<CSettingInt> settingCmsWhitepoint = AddSpinner(groupColorManagement, SETTING_VIDEO_CMSWHITEPOINT, 36568, SettingLevel::Basic, currentWhitepoint, entries);
settingCmsWhitepoint->SetDependencies(depsCmsIcc);
int currentPrimaries = CServiceBroker::GetSettings().GetInt(SETTING_VIDEO_CMSPRIMARIES);
entries.clear();
entries.push_back(std::make_pair(36588, CMS_PRIMARIES_AUTO));
entries.push_back(std::make_pair(36589, CMS_PRIMARIES_BT709));
entries.push_back(std::make_pair(36590, CMS_PRIMARIES_170M));
entries.push_back(std::make_pair(36591, CMS_PRIMARIES_BT470M));
entries.push_back(std::make_pair(36592, CMS_PRIMARIES_BT470BG));
entries.push_back(std::make_pair(36593, CMS_PRIMARIES_240M));
std::shared_ptr<CSettingInt> settingCmsPrimaries = AddSpinner(groupColorManagement, SETTING_VIDEO_CMSPRIMARIES, 36570, SettingLevel::Basic, currentPrimaries, entries);
settingCmsPrimaries->SetDependencies(depsCmsIcc);
int currentGammaMode = CServiceBroker::GetSettings().GetInt(SETTING_VIDEO_CMSGAMMAMODE);
entries.clear();
entries.push_back(std::make_pair(36582, CMS_TRC_BT1886));
entries.push_back(std::make_pair(36583, CMS_TRC_INPUT_OFFSET));
entries.push_back(std::make_pair(36584, CMS_TRC_OUTPUT_OFFSET));
entries.push_back(std::make_pair(36585, CMS_TRC_ABSOLUTE));
std::shared_ptr<CSettingInt> settingCmsGammaMode = AddSpinner(groupColorManagement, SETTING_VIDEO_CMSGAMMAMODE, 36572, SettingLevel::Basic, currentGammaMode, entries);
settingCmsGammaMode->SetDependencies(depsCmsIcc);
float currentGamma = CServiceBroker::GetSettings().GetInt(SETTING_VIDEO_CMSGAMMA)/100.0f;
if (currentGamma == 0.0) currentGamma = 2.20;
std::shared_ptr<CSettingNumber> settingCmsGamma = AddSlider(groupColorManagement, SETTING_VIDEO_CMSGAMMA, 36574, SettingLevel::Basic, currentGamma, 36597, 1.6, 0.05, 2.8, 36574, usePopup);
settingCmsGamma->SetDependencies(depsCmsGamma);
int currentLutSize = CServiceBroker::GetSettings().GetInt(SETTING_VIDEO_CMSLUTSIZE);
entries.clear();
entries.push_back(std::make_pair(36594, 4));
entries.push_back(std::make_pair(36595, 6));
entries.push_back(std::make_pair(36596, 8));
std::shared_ptr<CSettingInt> settingCmsLutSize = AddSpinner(groupColorManagement, SETTING_VIDEO_CMSLUTSIZE, 36576, SettingLevel::Basic, currentLutSize, entries);
settingCmsLutSize->SetDependencies(depsCmsIcc);
}
// Build the screen
bool CScreenDisplay::Build()
{
CreateTitle("IDS_TITLE_DISPLAYOPTIONS");
kGap = g_pLayoutDB->GetInt32(m_hLayout,LDB_ScreenColumnWidths,0);
kWidth = g_pLayoutDB->GetInt32(m_hLayout,LDB_ScreenColumnWidths,1);
kTotalWidth = kGap + kWidth;
m_nWarningColor = g_pLayoutDB->GetInt32(m_hLayout, LDB_ScreenAddColor, 0);
//background frame
CLTGUICtrl_create frameCs;
TextureReference hFrame(g_pLayoutDB->GetString(m_hLayout,LDB_ScreenFrameTexture));
frameCs.rnBaseRect = g_pLayoutDB->GetRect(m_hLayout,LDB_ScreenFrameRect,0);
CLTGUIFrame *pFrame = debug_new(CLTGUIFrame);
pFrame->Create(hFrame, frameCs);
AddControl(pFrame);
// Build the array of renderers
GetRendererData( m_rendererData );
// Add the "resolution" control
CLTGUICycleCtrl_create ccs;
ccs.nHeaderWidth = kGap;
ccs.rnBaseRect.m_vMin = m_ScreenRect.m_vMin;
ccs.rnBaseRect.m_vMax = m_ScreenRect.m_vMin + LTVector2n(kTotalWidth,g_pLayoutDB->GetInt32(m_hLayout,LDB_ScreenFontSize));
ccs.szHelpID = "IDS_HELP_RESOLUTION";
ccs.pCommandHandler = this;
ccs.nCommandID = CMD_DISPLAY_CYCLE;
m_pResolutionCtrl = AddCycle("IDS_DISPLAY_RESOLUTION",ccs);
// Setup the resolution control based on the current renderer
SetupResolutionCtrl();
CLTGUIToggle_create tcs;
tcs.rnBaseRect.m_vMin.Init();
tcs.rnBaseRect.m_vMax = LTVector2n(kGap+kWidth,g_pLayoutDB->GetInt32(m_hLayout,LDB_ScreenFontSize));
tcs.szHelpID = "IDS_HELP_VSYNC";
tcs.pbValue = &m_bVSync;
tcs.nHeaderWidth = kGap;
AddToggle("IDS_VSYNC",tcs);
tcs.szHelpID = "ScreenDisplay_RestartRender_Help";
tcs.pbValue = &m_bRestartRenderBetweenMaps;
tcs.nHeaderWidth = kGap;
AddToggle("ScreenDisplay_RestartRender",tcs);
tcs.szHelpID = "ScreenDisplay_TextScaling_Help";
tcs.pbValue = &m_bUseTextScaling;
tcs.nHeaderWidth = kGap;
CLTGUIToggle* pTog = AddToggle("ScreenDisplay_TextScaling",tcs);
pTog->SetOnString(LoadString("ScreenDisplay_TextScaling_Large"));
pTog->SetOffString(LoadString("ScreenDisplay_TextScaling_Small"));
CLTGUISlider_create scs;
scs.rnBaseRect.m_vMin.Init();
scs.rnBaseRect.m_vMax = LTVector2n(kGap+kWidth,g_pLayoutDB->GetInt32(m_hLayout,LDB_ScreenFontSize));
scs.nBarOffset = kGap;
scs.szHelpID = "IDS_HELP_GAMMA";
scs.pnValue = &m_nGamma;
scs.nMin = 0;
scs.nMax = kNumSteps;
scs.nIncrement = 1;
m_pGamma= AddSlider("IDS_GAMMA", scs );
int nBaseGamma = ConvertToSlider(kDefaultGamma);
float xoffset = (m_pGamma->CalculateSliderOffset(nBaseGamma) / m_pGamma->GetScale().x);
uint16 nHeight = m_pGamma->GetBarHeight();
float yoffset = ((( (float)m_pGamma->GetBaseHeight()) - (float)nHeight)) / 2.0f;
LTVector2n pos = m_pGamma->GetBasePos();
pos.x += int(xoffset - 1.0f);
pos.y += int(yoffset - 0.5f);
CLTGUIFrame *pBar = debug_new(CLTGUIFrame);
CLTGUICtrl_create cs;
cs.rnBaseRect.m_vMin.Init();
cs.rnBaseRect.m_vMax = LTVector2n(3,nHeight+2);
pBar->Create(0xBF000000,cs);
pBar->SetBasePos(pos);
pBar->SetScale(g_pInterfaceResMgr->GetScreenScale());
AddControl(pBar);
CLTGUICtrl_create imageCs;
hFrame.Load(g_pLayoutDB->GetString(m_hLayout,LDB_ScreenAddTex));
imageCs.rnBaseRect = g_pLayoutDB->GetRect(m_hLayout,LDB_ScreenFrameRect,1);
pFrame = debug_new(CLTGUIFrame);
pFrame->Create(hFrame, imageCs, true);
AddControl(pFrame);
uint32 nFontHeight = g_pLayoutDB->GetInt32(m_hLayout,LDB_ScreenAdditionalInt,0);
cs.rnBaseRect = g_pLayoutDB->GetRect(m_hLayout,LDB_ScreenFrameRect,2);
m_pWarning = AddTextItem("ScreenDisplay_ResolutionWarning",cs,true,NULL,nFontHeight);
m_pWarning->SetWordWrap(true);
m_pWarning->Show(false);
// Make sure to call the base class
if (!CBaseScreen::Build()) return false;
UseBack(true,true);
return true;
}
