ConfigurationDialog.cpp

Go to the documentation of this file.

#include "ConfigurationDialog.h"

#include "../gui.h"
#include "../Networking.h"
#include "../GameClass.h"
#include "../Viewscreen/Viewscreen.h"
#include "RakNetStatistics.h"
#include "GetTime.h"
#include "InformationDialog.h"
#include "../StringUtilities.h"

ConfigurationDialog::ConfigurationDialog(short id) : DialogBase(id)
{
        logger->AddToCallStack("ConfigurationDialog::ctor");
        usesHUD = true;
        HUD.Init(&gui->g_DialogResourceManager, true, L"Textures\\GUI\\dxutcontrols.png");
        HUD.SetCallback(&ConfigurationDialog::DialogCallback, this);
        HUD.EnableKeyboardInput(true);

        RECT rect; rect.left = rect.right = 0; rect.top = rect.bottom = -1;
        WCHAR langTest[2];
        UTF8_to_WChar(langTest, "汉");
        gui->g_pFont->DrawTextW(gui->g_pTextSprite, langTest, 1, &rect, DT_CALCRECT, 0L);
        if (rect.right == 12)
                gui->eastasian = true;
        else
                gui->eastasian = false;

        normalinterlace = false;
        windowdefaultlocation = D3DXVECTOR3(3, 3, 0);
        defaultwidth = 640;
        defaultheight = MAX_LINES * 16;

        tabs = 6; // this gets saved
        tabusedefaultlang[0] = L_TAB_INTERFACE;
        tabusedefaultlang[1] = L_TAB_INPUT;
        tabusedefaultlang[2] = L_TAB_VIDEO;
        tabusedefaultlang[3] = L_TAB_SOUND;
        tabusedefaultlang[4] = L_TAB_ACCOUNT;
        tabusedefaultlang[5] = L_TAB_NETWORK;

        icon = 14;
        text = L_DIALOG_CONFIGURATION;
        allowresize = false;
        allowscroll = false;
}

void ConfigurationDialog::UpdateMenu(short tab)
{
        logger->AddToCallStack("ConfigurationDialog::UpdateMenu");
        if (activetab < 0 || activetab >= MAX_TAB)
        {
                logger->Log("ConfigurationDialog::UpdateMenu activetab was out-of-bounds", Logger::Level::Debug);
                activetab = 0;
        }
        if (tabusedefaultlang[activetab] == L_TAB_VIDEO)
        {
                CDXUTRadioButton* windowed = HUD.GetRadioButton(DXUTSETTINGSDLG_WINDOWED);
                if (windowed == nullptr)
                        logger->Log("ConfigurationDialog::UpdateMenu DXUTSETTINGSDLG_WINDOWED is nullptr", Logger::Level::Debug);
                else
                        windowed->SetChecked(!gui->game->config.g_bStartFullscreen);
                CDXUTRadioButton* full_screen = HUD.GetRadioButton(DXUTSETTINGSDLG_FULLSCREEN);
                if (full_screen == nullptr)
                        logger->Log("ConfigurationDialog::UpdateMenu DXUTSETTINGSDLG_FULLSCREEN is nullptr", Logger::Level::Debug);
                else
                        full_screen->SetChecked(gui->game->config.g_bStartFullscreen);
        }
        logger->AddToCallStack("ConfigurationDialog::UpdateMenu DONE");
}

void ConfigurationDialog::ShowStatus(InputConfig* input_config, int y, D3DXVECTOR3* tracked, bool engine) const
{
        RECT rect;
        rect.top = static_cast<LONG>(y + tracked->y);
        rect.left = static_cast<LONG>(500.0f + tracked->x);
        rect.bottom = rect.right = 0;

        if (input_config->guid == MYGUID_NULL)
        {
                gui->g_pFont->DrawTextW(gui->g_pTextSprite, gui->strings[L_CONFIG_OK].c_str(), -1, &rect, DT_NOCLIP, 0xFF00FF00);
                return;
        }

        long value = 99999;
        DIJOYSTATE js;
        WCHAR str[6];
        // ReSharper disable once CppExpressionWithoutSideEffects
        gui->game->viewscreen->ptrJoystick->Poll(input_config, &value, &js);
        if (value != 99999)
        {
                const int nullzone = gui->game->viewscreen->ptrJoystick->nullzone;
                if (!engine)
                {
                        swprintf_s(str, 6, L"%+i", value);
                        gui->g_pFont->DrawTextW(gui->g_pTextSprite, str, -1, &rect, DT_NOCLIP, abs(value) > nullzone ? 0xFFFFFF00 : 0xFF00FF00);
                }
                else
                {
                        value = (-value + 1000) / 2;
                        if (value != 500)
                        {
                                swprintf_s(str, 6, L"%+i", value);
                                gui->g_pFont->DrawTextW(gui->g_pTextSprite, str, -1, &rect, DT_NOCLIP, value > nullzone ? 0xFFFFFF00 : 0xFF00FF00);
                        }
                        else
                        {
                                gui->g_pFont->DrawTextW(gui->g_pTextSprite, gui->strings[L_CONFIG_MOVE].c_str(), -1, &rect, DT_NOCLIP, 0xFFFFFF00);
                        }
                }
        }
        else
        {
                gui->g_pFont->DrawTextW(gui->g_pTextSprite, gui->strings[L_CONFIG_FAIL].c_str(), -1, &rect, DT_NOCLIP, 0xFFFF0000);
        }
}

void ConfigurationDialog::Update()
{
        logger->AddToCallStack("ConfigurationDialog::Update");

        if (redraw)
        {
                ActiveTab();
                redraw = false;
        }

        if (tabusedefaultlang[activetab] == L_TAB_INTERFACE)
        {
                gui->GetVersionText(msgbartext, HELP_SIZE);
        }
        else if (tabusedefaultlang[activetab] == L_TAB_SOUND)
        {
                const float cpu = BASS_GetCPU();
                swprintf_s(msgbartext, HELP_SIZE, gui->strings[L_MESSAGE_SOUNDUTILIZATION].c_str(), cpu, gui->strings[L_LIST_PERCENT].c_str(), BASS_GetVersion());
                if (cpu > 2.0f)
                        msgbarcolor = 3; // red
                else if (cpu > 1.0f)
                        msgbarcolor = 2; // yellow
                else
                        msgbarcolor = 1; // green
        }
        else if (tabusedefaultlang[activetab] == L_TAB_NETWORK)
        {
                const int pingtime = gui->networking->GetPingTime();
                if (pingtime > 250)
                        msgbarcolor = 3; // red
                else if (pingtime > 100)
                        msgbarcolor = 2; // yellow
                else
                        msgbarcolor = 1; // green
                swprintf_s(msgbartext, HELP_SIZE, gui->strings[L_MESSAGE_NETWORKLAG].c_str(), pingtime);
        }
        else if (tabusedefaultlang[activetab] == L_TAB_VIDEO)
        {
                const float fps = DXUTGetFPS();
                if (fps < 24.0f)
                        msgbarcolor = 3; // red
                else if (fps < 42.0f)
                        msgbarcolor = 2; // yellow
                else
                        msgbarcolor = 1; // green
                swprintf_s(msgbartext, HELP_SIZE, L"%s", DXUTGetFrameStats(true));
        }
}

void ConfigurationDialog::Draw(D3DXVECTOR3* tracked)
{
        logger->AddToCallStack("ConfigurationDialog::Draw");

        if (tabusedefaultlang[activetab] == L_TAB_NETWORK)
        {
                RECT rect;
                rect.top = static_cast<long>(tracked->y) + 2;
                rect.left = static_cast<long>(tracked->x) + 5;
                rect.bottom = 0;
                rect.right = 0;

                char msg[99];
                RakNet::RakNetStatistics* s = gui->networking->GetStatistics();

                sprintf_s(msg, 99, "Actual bytes per second sent         %llu", s->valueOverLastSecond[RakNet::ACTUAL_BYTES_SENT]);
                gui->g_pFont->DrawTextA(gui->g_pTextSprite, msg, -1, &rect, DT_NOCLIP, 0xFFFFFFFF);
                rect.top += 10;

                sprintf_s(msg, 99, "Actual bytes per second received     %llu", s->valueOverLastSecond[RakNet::ACTUAL_BYTES_RECEIVED]);
                gui->g_pFont->DrawTextA(gui->g_pTextSprite, msg, -1, &rect, DT_NOCLIP, 0xFFFFFFFF);
                rect.top += 10;

                sprintf_s(msg, 99, "Message bytes per second sent        %llu", s->valueOverLastSecond[RakNet::USER_MESSAGE_BYTES_SENT]);
                gui->g_pFont->DrawTextA(gui->g_pTextSprite, msg, -1, &rect, DT_NOCLIP, 0xFFFFFFFF);
                rect.top += 10;

                sprintf_s(msg, 99, "Message bytes per second resent      %llu", s->valueOverLastSecond[RakNet::USER_MESSAGE_BYTES_RESENT]);
                gui->g_pFont->DrawTextA(gui->g_pTextSprite, msg, -1, &rect, DT_NOCLIP, 0xFFFFFFFF);
                rect.top += 10;

                sprintf_s(msg, 99, "Message bytes per second pushed      %llu", s->valueOverLastSecond[RakNet::USER_MESSAGE_BYTES_PUSHED]);
                gui->g_pFont->DrawTextA(gui->g_pTextSprite, msg, -1, &rect, DT_NOCLIP, 0xFFFFFFFF);
                rect.top += 10;

                sprintf_s(msg, 99, "Message bytes per second returned    %llu", s->valueOverLastSecond[RakNet::USER_MESSAGE_BYTES_RECEIVED_PROCESSED]);
                gui->g_pFont->DrawTextA(gui->g_pTextSprite, msg, -1, &rect, DT_NOCLIP, 0xFFFFFFFF);
                rect.top += 10;

                sprintf_s(msg, 99, "Message bytes per second ignored     %llu", s->valueOverLastSecond[RakNet::USER_MESSAGE_BYTES_RECEIVED_IGNORED]);
                gui->g_pFont->DrawTextA(gui->g_pTextSprite, msg, -1, &rect, DT_NOCLIP, 0xFFFFFFFF);
                rect.top += 10;

                sprintf_s(msg, 99, "Total bytes sent                     %llu", s->runningTotal[RakNet::ACTUAL_BYTES_SENT]);
                gui->g_pFont->DrawTextA(gui->g_pTextSprite, msg, -1, &rect, DT_NOCLIP, 0xFFFFFFFF);
                rect.top += 10;

                sprintf_s(msg, 99, "Total bytes received                 %llu", s->runningTotal[RakNet::ACTUAL_BYTES_RECEIVED]);
                gui->g_pFont->DrawTextA(gui->g_pTextSprite, msg, -1, &rect, DT_NOCLIP, 0xFFFFFFFF);
                rect.top += 10;

                sprintf_s(msg, 99, "Total message bytes sent             %llu", s->runningTotal[RakNet::USER_MESSAGE_BYTES_SENT]);
                gui->g_pFont->DrawTextA(gui->g_pTextSprite, msg, -1, &rect, DT_NOCLIP, 0xFFFFFFFF);
                rect.top += 10;

                sprintf_s(msg, 99, "Total message bytes resent           %llu", s->runningTotal[RakNet::USER_MESSAGE_BYTES_RESENT]);
                gui->g_pFont->DrawTextA(gui->g_pTextSprite, msg, -1, &rect, DT_NOCLIP, 0xFFFFFFFF);
                rect.top += 10;

                sprintf_s(msg, 99, "Total message bytes pushed           %llu", s->runningTotal[RakNet::USER_MESSAGE_BYTES_PUSHED]);
                gui->g_pFont->DrawTextA(gui->g_pTextSprite, msg, -1, &rect, DT_NOCLIP, 0xFFFFFFFF);
                rect.top += 10;

                sprintf_s(msg, 99, "Total message bytes returned         %llu", s->runningTotal[RakNet::USER_MESSAGE_BYTES_RECEIVED_PROCESSED]);
                gui->g_pFont->DrawTextA(gui->g_pTextSprite, msg, -1, &rect, DT_NOCLIP, 0xFFFFFFFF);
                rect.top += 10;

                sprintf_s(msg, 99, "Total message bytes ignored          %llu", s->runningTotal[RakNet::USER_MESSAGE_BYTES_RECEIVED_IGNORED]);
                gui->g_pFont->DrawTextA(gui->g_pTextSprite, msg, -1, &rect, DT_NOCLIP, 0xFFFFFFFF);
                rect.top += 10;

                sprintf_s(msg, 99, "Messages in send buffer, by priority %i,%i,%i,%i", s->messageInSendBuffer[IMMEDIATE_PRIORITY], s->messageInSendBuffer[HIGH_PRIORITY], s->messageInSendBuffer[MEDIUM_PRIORITY], s->messageInSendBuffer[LOW_PRIORITY]);
                gui->g_pFont->DrawTextA(gui->g_pTextSprite, msg, -1, &rect, DT_NOCLIP, 0xFFFFFFFF);
                rect.top += 10;

                sprintf_s(msg, 99, "Bytes in send buffer, by priority    %.0f,%.0f,%.0f,%.0f", s->bytesInSendBuffer[IMMEDIATE_PRIORITY], s->bytesInSendBuffer[HIGH_PRIORITY], s->bytesInSendBuffer[MEDIUM_PRIORITY], s->bytesInSendBuffer[LOW_PRIORITY]);
                gui->g_pFont->DrawTextA(gui->g_pTextSprite, msg, -1, &rect, DT_NOCLIP, 0xFFFFFFFF);
                rect.top += 10;

                sprintf_s(msg, 99, "Messages in resend buffer            %i", s->messagesInResendBuffer);
                gui->g_pFont->DrawTextA(gui->g_pTextSprite, msg, -1, &rect, DT_NOCLIP, 0xFFFFFFFF);
                rect.top += 10;

                sprintf_s(msg, 99, "Bytes in resend buffer               %llu", s->bytesInResendBuffer);
                gui->g_pFont->DrawTextA(gui->g_pTextSprite, msg, -1, &rect, DT_NOCLIP, 0xFFFFFFFF);
                rect.top += 10;

                sprintf_s(msg, 99, "Current packet loss                  %.1f%%", s->packetlossLastSecond*100.0f);
                gui->g_pFont->DrawTextA(gui->g_pTextSprite, msg, -1, &rect, DT_NOCLIP, 0xFFFFFFFF);
                rect.top += 10;

                sprintf_s(msg, 99, "Average packet loss                  %.1f%%", s->packetlossTotal*100.0f);
                gui->g_pFont->DrawTextA(gui->g_pTextSprite, msg, -1, &rect, DT_NOCLIP, 0xFFFFFFFF);
                rect.top += 10;

                sprintf_s(msg, 99, "Elapsed connection time in seconds   %llu", (RakNet::GetTimeUS() - s->connectionStartTime) / 1000000);
                gui->g_pFont->DrawTextA(gui->g_pTextSprite, msg, -1, &rect, DT_NOCLIP, 0xFFFFFFFF);
                rect.top += 10;

                if (s->BPSLimitByCongestionControl != 0)
                {
                        sprintf_s(msg, 99, "Send capacity                    %llu bytes per second (%.0f%%)", s->BPSLimitByCongestionControl, 100.0f * s->valueOverLastSecond[RakNet::ACTUAL_BYTES_SENT] / s->BPSLimitByCongestionControl);
                        gui->g_pFont->DrawTextA(gui->g_pTextSprite, msg, -1, &rect, DT_NOCLIP, 0xFFFFFFFF);
                        rect.top += 10;
                }

                if (s->BPSLimitByOutgoingBandwidthLimit != 0)
                {
                        sprintf_s(msg, 99, "Send limit                       %llu  (%.0f%%)", s->BPSLimitByOutgoingBandwidthLimit, 100.0f * s->valueOverLastSecond[RakNet::ACTUAL_BYTES_SENT] / s->BPSLimitByOutgoingBandwidthLimit);
                        gui->g_pFont->DrawTextA(gui->g_pTextSprite, msg, -1, &rect, DT_NOCLIP, 0xFFFFFFFF);
                        rect.top += 10;
                }
        }
        else if (tabusedefaultlang[activetab] == L_TAB_INPUT)
        {
                int y = 6;
                ShowStatus(&gui->game->config.inputConfigLookLateral, y += 32, tracked, false);
                ShowStatus(&gui->game->config.inputConfigLookVertical, y += 32, tracked, false);
                ShowStatus(&gui->game->config.inputConfigWalkLateral, y += 32, tracked, false);
                ShowStatus(&gui->game->config.inputConfigWalkVertical, y += 32, tracked, false);
                ShowStatus(&gui->game->config.inputConfigSteer, y += 32, tracked, false);
                ShowStatus(&gui->game->config.inputConfigGas, y += 32, tracked, true);
                ShowStatus(&gui->game->config.inputConfigBrake, y += 32, tracked, true);
                ShowStatus(&gui->game->config.inputConfigPitch, y += 32, tracked, false);
                ShowStatus(&gui->game->config.inputConfigPitchTrim, y += 32, tracked, false);
                ShowStatus(&gui->game->config.inputConfigRoll, y += 32, tracked, false);
                ShowStatus(&gui->game->config.inputConfigYaw, y += 32, tracked, false);
                ShowStatus(&gui->game->config.inputConfigThrustLeft, y += 32, tracked, true);
                ShowStatus(&gui->game->config.inputConfigThrustRight, y += 32, tracked, true);
                ShowStatus(&gui->game->config.inputConfigLeftToeBrake, y += 32, tracked, true);
                ShowStatus(&gui->game->config.inputConfigRightToeBrake, y += 32, tracked, true);
        }
}

void ConfigurationDialog::CreateAxisDropdown(int control, int y, InputConfig* config)
{
        HUD.AddComboBox(control, static_cast<int>(384.0f * gui->game->displayscale), y, static_cast<int>(104.0f * gui->game->displayscale), static_cast<int>(24.0f * gui->game->displayscale));
        HUD.GetComboBox(control)->SetDropHeight(static_cast<int>(124.0f * gui->game->displayscale));
        HUD.GetComboBox(control)->AddItem(gui->strings[L_CONFIG_AXIS_X].c_str(), nullptr); // 0
        HUD.GetComboBox(control)->AddItem(gui->strings[L_CONFIG_AXIS_Y].c_str(), nullptr); // 1
        HUD.GetComboBox(control)->AddItem(gui->strings[L_CONFIG_AXIS_Z].c_str(), nullptr); // 2
        HUD.GetComboBox(control)->AddItem(gui->strings[L_CONFIG_AXIS_RX].c_str(), nullptr); // 3
        HUD.GetComboBox(control)->AddItem(gui->strings[L_CONFIG_AXIS_RY].c_str(), nullptr); // 4
        HUD.GetComboBox(control)->AddItem(gui->strings[L_CONFIG_AXIS_RZ].c_str(), nullptr); // 5
        HUD.GetComboBox(control)->AddItem(gui->strings[L_CONFIG_AXIS_S1].c_str(), nullptr); // 6
        HUD.GetComboBox(control)->AddItem(gui->strings[L_CONFIG_AXIS_S2].c_str(), nullptr); // 7
        HUD.GetComboBox(control)->SetSelectedByIndex(config->axis);
        HUD.GetComboBox(control)->SetEnabled(config->g_pJoystick);
}

void ConfigurationDialog::UpdateInput(InputConfig* config)
{
        logger->AddToCallStack("ConfigurationDialog::UpdateInput");

        gui->game->config.Save();

        gui->game->viewscreen->ptrJoystick->InitializeDevice(config, config->friendlyName);

        logger->AddToCallStack("ConfigurationDialog::UpdateInput DONE");
}

void CALLBACK ConfigurationDialog::DialogCallback(UINT nEvent, int nControlID, CDXUTControl* pControl, void* pUserContext)
{
        logger->AddToCallStack("ConfigurationDialog::DialogCallback");

        ConfigurationDialog* cfd = static_cast<ConfigurationDialog*>(pUserContext);

        switch (nControlID)
        {
#pragma region Interface

        case IDC_KEYCARD:
                ShellExecuteW(nullptr, nullptr, L"https://www.risetvp.com/Keycard", nullptr, nullptr, SW_SHOW);
                break;

        case IDC_PLAYERPORTAL:
                ShellExecuteW(nullptr, nullptr, L"https://portal.risetvp.com", nullptr, nullptr, SW_SHOW);
                break;

        case IDC_LANGUAGE:
                if (nEvent == EVENT_COMBOBOX_SELECTION_CHANGED)
                {
                        const unsigned char oldlang = gui->game->config.language;
                        gui->game->config.language = static_cast<unsigned char>(cfd->HUD.GetComboBox(IDC_LANGUAGE)->GetSelectedIndex());

                        if (!gui->eastasian)
                        {
                                if (gui->game->config.language >= 1)
                                        gui->game->config.language++;
                                if (gui->game->config.language >= 7)
                                        gui->game->config.language += 2;
                        }

                        if (oldlang != gui->game->config.language)
                        {
                                gui->LoadLanguage(); // do this first so if it fails it doesn't save it
                                gui->game->config.Save();
                                cfd->ActiveTab();

                                if (!gui->informationDialog->active)
                                        gui->networking->RequestVerbiage(0); // just changing language... same as ActiveHelp::MessageOfTheDay
                        }
                }
                break;

        case IDC_SCALEMAGNIFY:
        {
                float maxScale = 1.5f * gui->game->dpiscale;
                const float xScale = gui->game->displayWidth / designedWidthC; // canary 2.3
                const float yScale = gui->game->displayHeight / designedHeightC; // canary 2.1
                if (maxScale > xScale * 1.5f)
                        maxScale = xScale * 1.5f; // dpi now 2.3x
                if (maxScale > yScale * 1.5f)
                        maxScale = yScale * 1.5f; // dpi now 2.1x
                if ((gui->game->config.scale + 0.1f) > maxScale) break;
                const float oldScale = gui->game->config.scale;
                gui->game->config.scale += 0.1f;
                gui->game->displayscale *= gui->game->config.scale / oldScale;
                OnDeviceReset();
                gui->game->config.Save();
        }
        break;
        case IDC_SCALEMINIFY:
        {
                const float minScale = max(1, 0.5f * gui->game->dpiscale);
                if ((gui->game->config.scale - 0.1f) < minScale)
                        break;
                const float oldScale = gui->game->config.scale;
                gui->game->config.scale -= 0.1f;
                gui->game->displayscale *= gui->game->config.scale / oldScale;
                OnDeviceReset();
                gui->game->config.Save();
        }
        break;

#pragma endregion

#pragma region Input
        case IDC_INPUTDEVICELOOKLATERAL:
        case IDC_INPUTDEVICELOOKVERTICAL:
        case IDC_INPUTDEVICEWALKLATERAL:
        case IDC_INPUTDEVICEWALKVERTICAL:
        case IDC_INPUTDEVICESTEERING:
        case IDC_INPUTDEVICEGAS:
        case IDC_INPUTDEVICEBRAKE:
        case IDC_INPUTDEVICEPITCH:
        case IDC_INPUTDEVICEPITCHTRIM:
        case IDC_INPUTDEVICEROLL:
        case IDC_INPUTDEVICEYAW:
        case IDC_INPUTDEVICETHRUSTLEFT:
        case IDC_INPUTDEVICETHRUSTRIGHT:
        case IDC_INPUTDEVICELEFTTOEBRAKE:
        case IDC_INPUTDEVICERIGHTTOEBRAKE:
        {
                void* pData = cfd->HUD.GetComboBox(nControlID)->GetSelectedItem()->pData;
                InputConfig* inputConfig = static_cast<InputConfig*>(pData);
                const int selectedIndex = cfd->HUD.GetComboBox(nControlID)->GetSelectedIndex();
                if (selectedIndex > 0)
                        inputConfig->guid = gui->game->viewscreen->ptrJoystick->deviceList.at(selectedIndex - 1).guidInstance;
                else
                        inputConfig->guid = MYGUID_NULL;
                if ((nControlID == IDC_INPUTDEVICELOOKLATERAL || nControlID == IDC_INPUTDEVICELOOKVERTICAL))
                {
                        if (selectedIndex == 0) // mouse                        
                        {
                                inputConfig->axis = 0;
                                gui->informationDialog->DismissHelp(ActiveHelp::LookAroundGamepad, GUI_REMINDME);
                                gui->informationDialog->PopUpHelp(ActiveHelp::LookAroundMouse, false);
                                gui->informationDialog->PopUpHelp(ActiveHelp::CenterUp, false);
                        }
                        else
                        {
                                gui->informationDialog->PopUpHelp(ActiveHelp::LookAroundGamepad, false);
                                gui->informationDialog->DismissHelp(ActiveHelp::LookAroundMouse, GUI_REMINDME);
                                gui->informationDialog->DismissHelp(ActiveHelp::CenterUp, GUI_REMINDME);
                        }
                }
                cfd->UpdateInput(inputConfig);

                logger->AddToCallStack("ConfigurationDialog::DialogCallback AxisDisable1");
                cfd->HUD.GetComboBox(nControlID + 1)->SetEnabled(selectedIndex > 0); // Axis is always next door
                logger->AddToCallStack("ConfigurationDialog::DialogCallback SplitDisable");
                CDXUTCheckBox* splitCheckbox = cfd->HUD.GetCheckBox(nControlID + 3);
                if (splitCheckbox)
                {
                        cfd->HUD.GetCheckBox(nControlID + 2)->SetEnabled(selectedIndex > 0); // Invert is always right down the street
                        splitCheckbox->SetEnabled(selectedIndex > 0); // Split is always right down the street
                }
                logger->AddToCallStack("ConfigurationDialog::DialogCallback DisableDone");
        }
        break;
        case IDC_INPUTAXISLOOKLATERAL:
        {
                const int selectedIndex = cfd->HUD.GetComboBox(nControlID)->GetSelectedIndex();
                gui->game->config.inputConfigLookLateral.axis = selectedIndex;
                cfd->UpdateInput(&gui->game->config.inputConfigLookLateral);
        }
        break;
        case IDC_INPUTAXISLOOKVERTICAL:
        {
                const int selectedIndex = cfd->HUD.GetComboBox(nControlID)->GetSelectedIndex();
                gui->game->config.inputConfigLookVertical.axis = selectedIndex;
                cfd->UpdateInput(&gui->game->config.inputConfigLookVertical);
        }
        break;
        case IDC_INPUTAXISWALKLATERAL:
        {
                const int selectedIndex = cfd->HUD.GetComboBox(nControlID)->GetSelectedIndex();
                gui->game->config.inputConfigWalkLateral.axis = selectedIndex;
                cfd->UpdateInput(&gui->game->config.inputConfigWalkLateral);
        }
        break;
        case IDC_INPUTAXISWALKVERTICAL:
        {
                const int selectedIndex = cfd->HUD.GetComboBox(nControlID)->GetSelectedIndex();
                gui->game->config.inputConfigWalkVertical.axis = selectedIndex;
                cfd->UpdateInput(&gui->game->config.inputConfigWalkVertical);
        }
        break;
        case IDC_INPUTAXISSTEERING:
        {
                const int selectedIndex = cfd->HUD.GetComboBox(nControlID)->GetSelectedIndex();
                gui->game->config.inputConfigSteer.axis = selectedIndex;
                cfd->UpdateInput(&gui->game->config.inputConfigSteer);
        }
        break;
        case IDC_INPUTAXISGAS:
        {
                const int selectedIndex = cfd->HUD.GetComboBox(nControlID)->GetSelectedIndex();
                gui->game->config.inputConfigGas.axis = selectedIndex;
                cfd->UpdateInput(&gui->game->config.inputConfigGas);
        }
        break;
        case IDC_INPUTAXISBRAKE:
        {
                const int selectedIndex = cfd->HUD.GetComboBox(nControlID)->GetSelectedIndex();
                gui->game->config.inputConfigBrake.axis = selectedIndex;
                cfd->UpdateInput(&gui->game->config.inputConfigBrake);
        }
        break;
        case IDC_INPUTAXISPITCH:
        {
                const int selectedIndex = cfd->HUD.GetComboBox(nControlID)->GetSelectedIndex();
                gui->game->config.inputConfigPitch.axis = selectedIndex;
                cfd->UpdateInput(&gui->game->config.inputConfigPitch);
        }
        break;
        case IDC_INPUTAXISPITCHTRIM:
        {
                const int selectedIndex = cfd->HUD.GetComboBox(nControlID)->GetSelectedIndex();
                gui->game->config.inputConfigPitchTrim.axis = selectedIndex;
                cfd->UpdateInput(&gui->game->config.inputConfigPitchTrim);
        }
        break;
        case IDC_INPUTAXISROLL:
        {
                const int selectedIndex = cfd->HUD.GetComboBox(nControlID)->GetSelectedIndex();
                gui->game->config.inputConfigRoll.axis = selectedIndex;
                cfd->UpdateInput(&gui->game->config.inputConfigRoll);
        }
        break;
        case IDC_INPUTAXISYAW:
        {
                const int selectedIndex = cfd->HUD.GetComboBox(nControlID)->GetSelectedIndex();
                gui->game->config.inputConfigYaw.axis = selectedIndex;
                cfd->UpdateInput(&gui->game->config.inputConfigYaw);
        }
        break;
        case IDC_INPUTAXISTHRUSTLEFT:
        {
                const int selectedIndex = cfd->HUD.GetComboBox(nControlID)->GetSelectedIndex();
                gui->game->config.inputConfigThrustLeft.axis = selectedIndex;
                cfd->UpdateInput(&gui->game->config.inputConfigThrustLeft);
        }
        break;
        case IDC_INPUTAXISTHRUSTRIGHT:
        {
                const int selectedIndex = cfd->HUD.GetComboBox(nControlID)->GetSelectedIndex();
                gui->game->config.inputConfigThrustRight.axis = selectedIndex;
                cfd->UpdateInput(&gui->game->config.inputConfigThrustRight);
        }
        break;
        case IDC_INPUTAXISLEFTTOEBRAKE:
        {
                const int selectedIndex = cfd->HUD.GetComboBox(nControlID)->GetSelectedIndex();
                gui->game->config.inputConfigLeftToeBrake.axis = selectedIndex;
                cfd->UpdateInput(&gui->game->config.inputConfigLeftToeBrake);
        }
        break;
        case IDC_INPUTAXISRIGHTTOEBRAKE:
        {
                const int selectedIndex = cfd->HUD.GetComboBox(nControlID)->GetSelectedIndex();
                gui->game->config.inputConfigRightToeBrake.axis = selectedIndex;
                cfd->UpdateInput(&gui->game->config.inputConfigRightToeBrake);
        }
        break;
        case IDC_INPUTINVLOOKLATERAL:
        {
                gui->game->config.inputConfigLookLateral.invert = cfd->HUD.GetCheckBox(nControlID)->GetChecked();
                cfd->UpdateInput(&gui->game->config.inputConfigLookLateral);
        }
        break;
        case IDC_INPUTINVLOOKVERTICAL:
        {
                gui->game->config.inputConfigLookVertical.invert = cfd->HUD.GetCheckBox(nControlID)->GetChecked();
                cfd->UpdateInput(&gui->game->config.inputConfigLookVertical);
        }
        break;
        case IDC_INPUTINVWALKLATERAL:
        {
                gui->game->config.inputConfigWalkLateral.invert = cfd->HUD.GetCheckBox(nControlID)->GetChecked();
                cfd->UpdateInput(&gui->game->config.inputConfigWalkLateral);
        }
        break;
        case IDC_INPUTINVWALKVERTICAL:
        {
                gui->game->config.inputConfigWalkVertical.invert = cfd->HUD.GetCheckBox(nControlID)->GetChecked();
                cfd->UpdateInput(&gui->game->config.inputConfigWalkVertical);
        }
        break;
        case IDC_INPUTINVSTEERING:
        {
                gui->game->config.inputConfigSteer.invert = cfd->HUD.GetCheckBox(nControlID)->GetChecked();
                cfd->UpdateInput(&gui->game->config.inputConfigSteer);
        }
        break;
        case IDC_INPUTINVGAS:
        {
                gui->game->config.inputConfigGas.invert = cfd->HUD.GetCheckBox(nControlID)->GetChecked();
                cfd->UpdateInput(&gui->game->config.inputConfigGas);
        }
        break;
        case IDC_INPUTINVBRAKE:
        {
                gui->game->config.inputConfigBrake.invert = cfd->HUD.GetCheckBox(nControlID)->GetChecked();
                cfd->UpdateInput(&gui->game->config.inputConfigBrake);
        }
        break;
        case IDC_INPUTINVPITCH:
        {
                gui->game->config.inputConfigPitch.invert = cfd->HUD.GetCheckBox(nControlID)->GetChecked();
                cfd->UpdateInput(&gui->game->config.inputConfigPitch);
        }
        break;
        case IDC_INPUTINVPITCHTRIM:
        {
                gui->game->config.inputConfigPitchTrim.invert = cfd->HUD.GetCheckBox(nControlID)->GetChecked();
                cfd->UpdateInput(&gui->game->config.inputConfigPitchTrim);
        }
        break;
        case IDC_INPUTINVROLL:
        {
                gui->game->config.inputConfigRoll.invert = cfd->HUD.GetCheckBox(nControlID)->GetChecked();
                cfd->UpdateInput(&gui->game->config.inputConfigRoll);
        }
        break;
        case IDC_INPUTINVYAW:
        {
                gui->game->config.inputConfigYaw.invert = cfd->HUD.GetCheckBox(nControlID)->GetChecked();
                cfd->UpdateInput(&gui->game->config.inputConfigYaw);
        }
        break;
        case IDC_INPUTINVTHRUSTLEFT:
        {
                gui->game->config.inputConfigThrustLeft.invert = cfd->HUD.GetCheckBox(nControlID)->GetChecked();
                cfd->UpdateInput(&gui->game->config.inputConfigThrustLeft);
        }
        break;
        case IDC_INPUTINVTHRUSTRIGHT:
        {
                gui->game->config.inputConfigThrustRight.invert = cfd->HUD.GetCheckBox(nControlID)->GetChecked();
                cfd->UpdateInput(&gui->game->config.inputConfigThrustRight);
        }
        break;
        case IDC_INPUTINVLEFTTOEBRAKE:
        {
                gui->game->config.inputConfigLeftToeBrake.invert = cfd->HUD.GetCheckBox(nControlID)->GetChecked();
                cfd->UpdateInput(&gui->game->config.inputConfigLeftToeBrake);
        }
        break;
        case IDC_INPUTINVRIGHTTOEBRAKE:
        {
                gui->game->config.inputConfigRightToeBrake.invert = cfd->HUD.GetCheckBox(nControlID)->GetChecked();
                cfd->UpdateInput(&gui->game->config.inputConfigRightToeBrake);
        }
        break;
        case IDC_INPUTSPLITTHRUSTLEFT:
        {
                gui->game->config.inputConfigThrustLeft.split = cfd->HUD.GetCheckBox(nControlID)->GetChecked();
                cfd->UpdateInput(&gui->game->config.inputConfigThrustLeft);
        }
        break;
        case IDC_INPUTSPLITTHRUSTRIGHT:
        {
                gui->game->config.inputConfigThrustRight.split = cfd->HUD.GetCheckBox(nControlID)->GetChecked();
                cfd->UpdateInput(&gui->game->config.inputConfigThrustRight);
        }
        break;
        case IDC_INPUTSPLITLEFTTOEBRAKE:
        {
                gui->game->config.inputConfigLeftToeBrake.split = cfd->HUD.GetCheckBox(nControlID)->GetChecked();
                cfd->UpdateInput(&gui->game->config.inputConfigLeftToeBrake);
        }
        break;
        case IDC_INPUTSPLITRIGHTTOEBRAKE:
        {
                gui->game->config.inputConfigRightToeBrake.split = cfd->HUD.GetCheckBox(nControlID)->GetChecked();
                cfd->UpdateInput(&gui->game->config.inputConfigRightToeBrake);
        }
        break;
        case IDC_INPUTSPLITGAS:
        {
                gui->game->config.inputConfigGas.split = cfd->HUD.GetCheckBox(nControlID)->GetChecked();
                cfd->UpdateInput(&gui->game->config.inputConfigGas);
        }
        break;
        case IDC_INPUTSPLITBRAKE:
        {
                gui->game->config.inputConfigBrake.split = cfd->HUD.GetCheckBox(nControlID)->GetChecked();
                cfd->UpdateInput(&gui->game->config.inputConfigBrake);
        }
        break;

#pragma endregion

#pragma region Sound
        case IDC_SOUNDDEVICELEGACY:
        case IDC_SOUNDDEVICECOMPUTER:
        case IDC_SOUNDDEVICECOMMS:
        case IDC_SOUNDDEVICERADIO:
        {
                if (nEvent == EVENT_COMBOBOX_SELECTION_CHANGED)
                {
                        CDXUTComboBox* cdxut_combo_box = cfd->HUD.GetComboBox(nControlID);
                        SoundConfig* modifyConfig = static_cast<SoundConfig*>(cdxut_combo_box->GetSelectedItem()->pData);

                        const int selected_index = cdxut_combo_box->GetSelectedIndex();
                        modifyConfig->guid = gui->game->sound->deviceGuids.at(selected_index);
                        modifyConfig->bassDevice = selected_index;

                        gui->game->sound->InitDevice(modifyConfig);

                        if (nControlID != IDC_SOUNDDEVICERADIO)
                        {
                                for (int i = 0; i < SOUND_ENUMERATION; i++)
                                        gui->game->sound->LoadSounds(i);
                                gui->game->sound->ChangeCockpit(false);
                                gui->LoadPeopleSounds();
                        }
                        else
                        {
                                gui->game->sound->LoadSounds(SOUND_STATIONID2);
                                gui->game->sound->FrameMoveAAC();
                        }

                        gui->game->config.Save();

                        cfd->redraw = true;
                }
        }
        break;

        case IDC_SOUNDPLAYINTRO:
                gui->game->config.g_bSoundIntroMusic = cfd->HUD.GetCheckBox(IDC_SOUNDPLAYINTRO)->GetChecked();
                gui->game->config.Save();

                if (!gui->game->config.g_bSoundIntroMusic && gui->game->sound->g_pSoundIntro)
                        BASS_ChannelStop(gui->game->sound->g_pSoundIntro);
                break;

        case IDC_MASTERVOLUMELEGACY:
                gui->game->config.soundConfigLegacy.volume = 0.01f*static_cast<float>(cfd->HUD.GetSlider(nControlID)->GetValue());
                gui->game->sound->ChangeVolume(&gui->game->config.soundConfigLegacy, 1.0f);
                gui->game->config.Save();
                break;
        case IDC_MASTERVOLUMECOMPUTER:
                gui->game->config.soundConfigComputer.volume = 0.01f*static_cast<float>(cfd->HUD.GetSlider(nControlID)->GetValue());
                gui->game->sound->ChangeVolume(&gui->game->config.soundConfigComputer, gui->game->viewscreen->outside ? 0.0f : 1.0f);
                gui->game->config.Save();
                break;
        case IDC_MASTERVOLUMECOMMS:
                gui->game->config.soundConfigComms.volume = 0.01f*static_cast<float>(cfd->HUD.GetSlider(nControlID)->GetValue());
                gui->game->sound->ChangeVolume(&gui->game->config.soundConfigComms, gui->game->viewscreen->outside ? 0.0f : 1.0f);
                gui->game->config.Save();
                break;
        case IDC_MASTERVOLUMERADIO:
                gui->game->config.soundConfigRadio.volume = 0.01f*static_cast<float>(cfd->HUD.GetSlider(nControlID)->GetValue());
                gui->game->sound->ChangeVolume(&gui->game->config.soundConfigRadio, gui->game->viewscreen->outside ? 0.0f : 1.0f);
                gui->game->config.Save();
                break;
#pragma endregion

        case IDC_REMEMBERLOGIN:
                gui->game->config.g_bAutoLogin = cfd->HUD.GetCheckBox(IDC_REMEMBERLOGIN)->GetChecked();
                gui->game->config.Save();
                break;

        case DXUTSETTINGSDLG_WINDOWED:
        case DXUTSETTINGSDLG_FULLSCREEN:
                gui->game->config.g_bStartFullscreen = cfd->HUD.GetRadioButton(DXUTSETTINGSDLG_FULLSCREEN)->GetChecked();
                gui->game->config.Save(); // save first in case it bombs!
                gui->game->ToggleFullScreen(gui->game->config.g_bStartFullscreen);
                break;

        case IDC_RESTOREDEFAULTS:
                HMI::RestoreDefaults();
                break;

        case IDC_GAMEHELPRESET:
                for (int i = 0; i < vphelpC; i++)
                {
                        if (gui->game->vphelp[i]) // seen
                        {
                                gui->game->vphelp[i] = false;
                                SClientPacket outpacket = SClientPacket();
                                // 41=HelpVerbiageControl, x=helpId, y=(0=remindme,1=understood,2=reset,3=disable,4=import), z=, w=
                                outpacket.type = 41;
                                outpacket.f_x = static_cast<float>(i);
                                outpacket.f_y = 2.0f;
                                outpacket.f_z = 0.0f;
                                outpacket.f_w = 0.0f;
                                gui->game->networking->SendToServer(&outpacket, sizeof(SClientPacket), true);
                        }
                }
                gui->game->viewscreen->ptrCockpit->ResetHelp();
                break;

        case IDC_GAMEHELPDISABLE:
                for (int i = 0; i < vphelpC; i++)
                {
                        if (!gui->game->vphelp[i]) // not seen
                        {
                                gui->game->vphelp[i] = true;
                                SClientPacket outpacket = SClientPacket();
                                // 41=HelpVerbiageControl, x=helpId, y=(0=remindme,1=understood,2=reset,3=disable,4=import), z=, w=
                                outpacket.type = 41;
                                outpacket.f_x = static_cast<float>(i);
                                outpacket.f_y = 3.0f;
                                outpacket.f_z = 0.0f;
                                outpacket.f_w = 0.0f;
                                gui->game->networking->SendToServer(&outpacket, sizeof(SClientPacket), true);
                        }
                }
                gui->informationDialog->ClearHelp();
                break;

        default:
                break;
        }
}

void ConfigurationDialog::ActiveTab()
{
        logger->AddToCallStack("ConfigurationDialog::ActiveTab");
        //DialogBase::ActiveTab();
        HUD.SetFont(0, L"DejaVu Sans Mono", static_cast<long>(12.0f * gui->game->displayscale), FW_THIN);

        msgbarcolor = 0; // normal
        msgbartext[0] = 0;

#pragma region Interface
        HUD.RemoveControl(IDC_RESTOREDEFAULTS);
        HUD.RemoveControl(IDC_LANGUAGE);
        HUD.RemoveControl(IDC_LANGUAGELABEL);
        HUD.RemoveControl(IDC_GAMEHELPLABEL);
        HUD.RemoveControl(IDC_GAMEHELPRESET);
        HUD.RemoveControl(IDC_GAMEHELPDISABLE);
        HUD.RemoveControl(IDC_SCALEMAGNIFY);
        HUD.RemoveControl(IDC_SCALEMINIFY);
        HUD.RemoveControl(IDC_SCALELABEL);
        HUD.RemoveControl(IDC_KEYCARD);
#pragma endregion

#pragma region Input
        HUD.RemoveControl(IDC_INPUTHEADERCHANNEL);
        HUD.RemoveControl(IDC_INPUTHEADERDEVICE);
        HUD.RemoveControl(IDC_INPUTHEADERAXIS);
        HUD.RemoveControl(IDC_INPUTHEADERVALUE);
        HUD.RemoveControl(IDC_INPUTHEADERINV);
        HUD.RemoveControl(IDC_INPUTHEADERSPLIT);
        //HUD.RemoveControl(IDC_INPUTHEADERFEEDBACK);
        HUD.RemoveControl(IDC_INPUTLABELLOOKLATERAL);
        HUD.RemoveControl(IDC_INPUTDEVICELOOKLATERAL);
        HUD.RemoveControl(IDC_INPUTAXISLOOKLATERAL);
        HUD.RemoveControl(IDC_INPUTINVLOOKLATERAL);
        //HUD.RemoveControl(IDC_INPUTFEEDBACKLOOKLATERAL);
        HUD.RemoveControl(IDC_INPUTLABELLOOKVERTICAL);
        HUD.RemoveControl(IDC_INPUTDEVICELOOKVERTICAL);
        HUD.RemoveControl(IDC_INPUTAXISLOOKVERTICAL);
        HUD.RemoveControl(IDC_INPUTINVLOOKVERTICAL);
        //HUD.RemoveControl(IDC_INPUTFEEDBACKLOOKVERTICAL);
        HUD.RemoveControl(IDC_INPUTLABELWALKLATERAL);
        HUD.RemoveControl(IDC_INPUTDEVICEWALKLATERAL);
        HUD.RemoveControl(IDC_INPUTAXISWALKLATERAL);
        HUD.RemoveControl(IDC_INPUTINVWALKLATERAL);
        //HUD.RemoveControl(IDC_INPUTFEEDBACKWALKLATERAL);
        HUD.RemoveControl(IDC_INPUTLABELWALKVERTICAL);
        HUD.RemoveControl(IDC_INPUTDEVICEWALKVERTICAL);
        HUD.RemoveControl(IDC_INPUTAXISWALKVERTICAL);
        HUD.RemoveControl(IDC_INPUTINVWALKVERTICAL);
        //HUD.RemoveControl(IDC_INPUTFEEDBACKWALKVERTICAL);
        HUD.RemoveControl(IDC_INPUTLABELSTEERING);
        HUD.RemoveControl(IDC_INPUTDEVICESTEERING);
        HUD.RemoveControl(IDC_INPUTAXISSTEERING);
        HUD.RemoveControl(IDC_INPUTINVSTEERING);
        //HUD.RemoveControl(IDC_INPUTFEEDBACKSTEERING);
        HUD.RemoveControl(IDC_INPUTLABELGAS);
        HUD.RemoveControl(IDC_INPUTDEVICEGAS);
        HUD.RemoveControl(IDC_INPUTAXISGAS);
        HUD.RemoveControl(IDC_INPUTINVGAS);
        HUD.RemoveControl(IDC_INPUTSPLITGAS);
        //HUD.RemoveControl(IDC_INPUTFEEDBACKGAS);
        HUD.RemoveControl(IDC_INPUTLABELBRAKE);
        HUD.RemoveControl(IDC_INPUTDEVICEBRAKE);
        HUD.RemoveControl(IDC_INPUTAXISBRAKE);
        HUD.RemoveControl(IDC_INPUTINVBRAKE);
        HUD.RemoveControl(IDC_INPUTSPLITBRAKE);
        //HUD.RemoveControl(IDC_INPUTFEEDBACKBRAKE);
        HUD.RemoveControl(IDC_INPUTLABELPITCH);
        HUD.RemoveControl(IDC_INPUTDEVICEPITCH);
        HUD.RemoveControl(IDC_INPUTAXISPITCH);
        HUD.RemoveControl(IDC_INPUTINVPITCH);
        //HUD.RemoveControl(IDC_INPUTFEEDBACKPITCH);
        HUD.RemoveControl(IDC_INPUTLABELPITCHTRIM);
        HUD.RemoveControl(IDC_INPUTDEVICEPITCHTRIM);
        HUD.RemoveControl(IDC_INPUTAXISPITCHTRIM);
        HUD.RemoveControl(IDC_INPUTINVPITCHTRIM);
        //HUD.RemoveControl(IDC_INPUTFEEDBACKPITCHTRIM);
        HUD.RemoveControl(IDC_INPUTLABELROLL);
        HUD.RemoveControl(IDC_INPUTDEVICEROLL);
        HUD.RemoveControl(IDC_INPUTAXISROLL);
        HUD.RemoveControl(IDC_INPUTINVROLL);
        //HUD.RemoveControl(IDC_INPUTFEEDBACKROLL);
        HUD.RemoveControl(IDC_INPUTLABELYAW);
        HUD.RemoveControl(IDC_INPUTDEVICEYAW);
        HUD.RemoveControl(IDC_INPUTAXISYAW);
        HUD.RemoveControl(IDC_INPUTINVYAW);
        //HUD.RemoveControl(IDC_INPUTFEEDBACKYAW);
        HUD.RemoveControl(IDC_INPUTLABELTHRUSTLEFT);
        HUD.RemoveControl(IDC_INPUTDEVICETHRUSTLEFT);
        HUD.RemoveControl(IDC_INPUTAXISTHRUSTLEFT);
        HUD.RemoveControl(IDC_INPUTINVTHRUSTLEFT);
        HUD.RemoveControl(IDC_INPUTSPLITTHRUSTLEFT);
        //HUD.RemoveControl(IDC_INPUTFEEDBACKTHRUSTLEFT);
        HUD.RemoveControl(IDC_INPUTLABELTHRUSTRIGHT);
        HUD.RemoveControl(IDC_INPUTDEVICETHRUSTRIGHT);
        HUD.RemoveControl(IDC_INPUTAXISTHRUSTRIGHT);
        HUD.RemoveControl(IDC_INPUTINVTHRUSTRIGHT);
        HUD.RemoveControl(IDC_INPUTSPLITTHRUSTRIGHT);
        //HUD.RemoveControl(IDC_INPUTFEEDBACKTHRUSTRIGHT);
        HUD.RemoveControl(IDC_INPUTLABELLEFTTOEBRAKE);
        HUD.RemoveControl(IDC_INPUTDEVICELEFTTOEBRAKE);
        HUD.RemoveControl(IDC_INPUTAXISLEFTTOEBRAKE);
        HUD.RemoveControl(IDC_INPUTINVLEFTTOEBRAKE);
        HUD.RemoveControl(IDC_INPUTSPLITLEFTTOEBRAKE);
        //HUD.RemoveControl(IDC_INPUTFEEDBACKLEFTTOEBRAKE);
        HUD.RemoveControl(IDC_INPUTLABELRIGHTTOEBRAKE);
        HUD.RemoveControl(IDC_INPUTDEVICERIGHTTOEBRAKE);
        HUD.RemoveControl(IDC_INPUTAXISRIGHTTOEBRAKE);
        HUD.RemoveControl(IDC_INPUTINVRIGHTTOEBRAKE);
        HUD.RemoveControl(IDC_INPUTSPLITRIGHTTOEBRAKE);
        //HUD.RemoveControl(IDC_INPUTFEEDBACKRIGHTTOEBRAKE);
#pragma endregion

#pragma region Sound
        HUD.RemoveControl(IDC_SOUNDLEGACYLABEL);
        HUD.RemoveControl(IDC_SOUNDDEVICELEGACY);
        HUD.RemoveControl(IDC_SOUNDPLAYINTRO);
        HUD.RemoveControl(IDC_MASTERVOLUMELEGACY);
        HUD.RemoveControl(IDC_SOUNDCOMPUTERLABEL);
        HUD.RemoveControl(IDC_SOUNDDEVICECOMPUTER);
        HUD.RemoveControl(IDC_MASTERVOLUMECOMPUTER);
        HUD.RemoveControl(IDC_SOUNDCOMMSLABEL);
        HUD.RemoveControl(IDC_SOUNDDEVICECOMMS);
        HUD.RemoveControl(IDC_MASTERVOLUMECOMMS);
        HUD.RemoveControl(IDC_SOUNDRADIOLABEL);
        HUD.RemoveControl(IDC_SOUNDDEVICERADIO);
        HUD.RemoveControl(IDC_MASTERVOLUMERADIO);
#pragma endregion

#pragma region Account
        HUD.RemoveControl(IDC_REMEMBERLOGIN);
        HUD.RemoveControl(IDC_PLAYERPORTAL);
#pragma endregion 

#pragma region Video
        HUD.RemoveControl(DXUTSETTINGSDLG_STATIC1);
        HUD.RemoveControl(DXUTSETTINGSDLG_STATIC2);
        HUD.RemoveControl(DXUTSETTINGSDLG_STATIC3);
        HUD.RemoveControl(DXUTSETTINGSDLG_API_VERSION);
        HUD.RemoveControl(DXUTSETTINGSDLG_ADAPTER);
        HUD.RemoveControl(DXUTSETTINGSDLG_DEVICE_TYPE);
        HUD.RemoveControl(DXUTSETTINGSDLG_WINDOWED);
        HUD.RemoveControl(DXUTSETTINGSDLG_DEVICECLIP);
        HUD.RemoveControl(DXUTSETTINGSDLG_FULLSCREEN);
        HUD.RemoveControl(DXUTSETTINGSDLG_ADAPTER_FORMAT_LABEL);
        HUD.RemoveControl(DXUTSETTINGSDLG_ADAPTER_FORMAT);
        HUD.RemoveControl(DXUTSETTINGSDLG_RESOLUTION_LABEL);
        HUD.RemoveControl(DXUTSETTINGSDLG_RESOLUTION);
        //                      dialog[t].HUD.GetComboBox( DXUTSETTINGSDLG_RESOLUTION )->SetDropHeight( 106 );
        HUD.RemoveControl(DXUTSETTINGSDLG_RESOLUTION_SHOW_ALL);
        HUD.RemoveControl(DXUTSETTINGSDLG_REFRESH_RATE_LABEL);
        HUD.RemoveControl(DXUTSETTINGSDLG_REFRESH_RATE);
        HUD.RemoveControl(DXUTSETTINGSDLG_BACK_BUFFER_FORMAT_LABEL);
        HUD.RemoveControl(DXUTSETTINGSDLG_BACK_BUFFER_FORMAT);
        HUD.RemoveControl(DXUTSETTINGSDLG_DEPTH_STENCIL_LABEL);
        HUD.RemoveControl(DXUTSETTINGSDLG_DEPTH_STENCIL);
        HUD.RemoveControl(DXUTSETTINGSDLG_MULTISAMPLE_TYPE_LABEL);
        HUD.RemoveControl(DXUTSETTINGSDLG_MULTISAMPLE_TYPE);
        HUD.RemoveControl(DXUTSETTINGSDLG_MULTISAMPLE_QUALITY_LABEL);
        HUD.RemoveControl(DXUTSETTINGSDLG_MULTISAMPLE_QUALITY);
        HUD.RemoveControl(DXUTSETTINGSDLG_VERTEX_PROCESSING_LABEL);
        HUD.RemoveControl(DXUTSETTINGSDLG_VERTEX_PROCESSING);
        HUD.RemoveControl(DXUTSETTINGSDLG_PRESENT_INTERVAL_LABEL);
        HUD.RemoveControl(DXUTSETTINGSDLG_PRESENT_INTERVAL);
        /*                      dialog[t].HUD.RemoveControl(DXUTSETTINGSDLG_D3D10_ADAPTER_OUTPUT_LABEL);
                                dialog[t].HUD.RemoveControl(DXUTSETTINGSDLG_D3D10_ADAPTER_OUTPUT);
                                dialog[t].HUD.RemoveControl(DXUTSETTINGSDLG_D3D10_RESOLUTION_LABEL);
                                dialog[t].HUD.RemoveControl(DXUTSETTINGSDLG_D3D10_RESOLUTION);
        //                      dialog[t].HUD.RemoveControl(DXUTSETTINGSDLG_D3D10_RESOLUTION )->SetDropHeight( 106 );
                                dialog[t].HUD.RemoveControl(DXUTSETTINGSDLG_D3D10_REFRESH_RATE_LABEL);
                                dialog[t].HUD.RemoveControl(DXUTSETTINGSDLG_D3D10_REFRESH_RATE);
                                dialog[t].HUD.RemoveControl(DXUTSETTINGSDLG_D3D10_BACK_BUFFER_FORMAT_LABEL);
                                dialog[t].HUD.RemoveControl(DXUTSETTINGSDLG_D3D10_BACK_BUFFER_FORMAT);
                                dialog[t].HUD.RemoveControl(DXUTSETTINGSDLG_D3D10_MULTISAMPLE_COUNT_LABEL);
                                dialog[t].HUD.RemoveControl(DXUTSETTINGSDLG_D3D10_MULTISAMPLE_COUNT);
                                dialog[t].HUD.RemoveControl(DXUTSETTINGSDLG_D3D10_MULTISAMPLE_QUALITY_LABEL);
                                dialog[t].HUD.RemoveControl(DXUTSETTINGSDLG_D3D10_MULTISAMPLE_QUALITY);
                                dialog[t].HUD.RemoveControl(DXUTSETTINGSDLG_D3D10_PRESENT_INTERVAL_LABEL);
                                dialog[t].HUD.RemoveControl(DXUTSETTINGSDLG_D3D10_PRESENT_INTERVAL);
                                dialog[t].HUD.RemoveControl(DXUTSETTINGSDLG_D3D10_DEBUG_DEVICE);*/
                                //                      dialog[t].HUD.RemoveControl(DXUTSETTINGSDLG_OK, L"OK", 230, 440, 73, 31 );
                                //                      dialog[t].HUD.AddButton( DXUTSETTINGSDLG_CANCEL, L"Cancel", 315, 440, 73, 31, 0, true );
#pragma endregion 

        int xLabel = static_cast<int>(16.0f * gui->game->displayscale);
        const int lineHeight = static_cast<int>(24.0f * gui->game->displayscale);

        switch (tabusedefaultlang[activetab])
        {
        case L_TAB_INTERFACE:
        {
                HUD.AddStatic(IDC_LANGUAGELABEL, gui->strings[L_CONFIG_LANGUAGE].c_str(), static_cast<int>(16.0f * gui->game->displayscale), static_cast<int>(24.0f * gui->game->displayscale), static_cast<int>(192.0f * gui->game->displayscale), static_cast<int>(24.0f * gui->game->displayscale));

                HUD.AddComboBox(IDC_LANGUAGE, static_cast<int>(16.0f * gui->game->displayscale), static_cast<int>(48.0f * gui->game->displayscale), static_cast<int>(192.0f * gui->game->displayscale), static_cast<int>(24.0f * gui->game->displayscale));
                gui->AddLanguageOptions(IDC_LANGUAGE, &HUD);

                HUD.AddButton(IDC_RESTOREDEFAULTS, gui->strings[L_BUTTON_RESTOREDEFAULTS].c_str(), static_cast<int>(16.0f * gui->game->displayscale), static_cast<int>(96.0f * gui->game->displayscale), static_cast<int>(192.0f * gui->game->displayscale), static_cast<int>(24.0f * gui->game->displayscale), 0, false);
                if (!gui->eastasian)
                {
                        msgbarcolor = 2; // amber
                        wcscpy_s(msgbartext, HELP_SIZE, gui->strings[L_MESSAGE_EASTASIANSUPPORT].c_str());
                }
                else
                {
                        msgbarcolor = 0;
                        msgbartext[0] = 0;
                }

                HUD.AddStatic(IDC_GAMEHELPLABEL, gui->strings[L_CONFIG_GAMEHELP].c_str(), static_cast<int>(16.0f * gui->game->displayscale), static_cast<int>(144.0f * gui->game->displayscale), static_cast<int>(192.0f * gui->game->displayscale), static_cast<int>(24.0f * gui->game->displayscale));
                HUD.AddButton(IDC_GAMEHELPRESET, gui->strings[L_CONFIG_RESET].c_str(), static_cast<int>(16.0f * gui->game->displayscale), static_cast<int>(168.0f * gui->game->displayscale), static_cast<int>(192.0f * gui->game->displayscale), static_cast<int>(24.0f * gui->game->displayscale), 0, false);
                HUD.AddButton(IDC_GAMEHELPDISABLE, gui->strings[L_CONFIG_DISABLE].c_str(), static_cast<int>(16.0f * gui->game->displayscale), static_cast<int>(192.0f * gui->game->displayscale), static_cast<int>(192.0f * gui->game->displayscale), static_cast<int>(24.0f * gui->game->displayscale), 0, false);
                HUD.AddStatic(IDC_SCALELABEL, gui->strings[L_CONFIG_FONTANDSCALE].c_str(), static_cast<int>(16.0f * gui->game->displayscale), static_cast<int>(240.0f * gui->game->displayscale), static_cast<int>(192.0f * gui->game->displayscale), static_cast<int>(24.0f * gui->game->displayscale));
                HUD.AddButton(IDC_SCALEMINIFY, gui->strings[L_CONFIG_MINIFY].c_str(), static_cast<int>(16.0f * gui->game->displayscale), static_cast<int>(264.0f * gui->game->displayscale), static_cast<int>(92.0f * gui->game->displayscale), static_cast<int>(24.0f * gui->game->displayscale), 0, false);
                HUD.AddButton(IDC_SCALEMAGNIFY, gui->strings[L_CONFIG_MAGNIFY].c_str(), static_cast<int>(112.0f * gui->game->displayscale), static_cast<int>(264.0f * gui->game->displayscale), static_cast<int>(92.0f * gui->game->displayscale), static_cast<int>(24.0f * gui->game->displayscale), 0, false);

                HUD.AddButton(IDC_KEYCARD, gui->strings[L_CAPTION_VIEWKEYCARD].c_str(), static_cast<int>(300.0f * gui->game->displayscale), static_cast<int>(42.0f * gui->game->displayscale), static_cast<int>(192.0f * gui->game->displayscale), static_cast<int>(32.0f * gui->game->displayscale), 0, false);
        }
        break;

        case L_TAB_INPUT:
        {
                const int xDevice = static_cast<int>(94.0f * gui->game->displayscale);
                const int widthDevice = static_cast<int>(286.0f * gui->game->displayscale);
                const int xInv = static_cast<int>(550.0f * gui->game->displayscale);
                const int xSplit = static_cast<int>(600.0f * gui->game->displayscale);
                const int widthCheckboxes = static_cast<int>(50.0f * gui->game->displayscale);
                float y = 8.0f * gui->game->displayscale;
                xLabel = static_cast<int>(10.0f * gui->game->displayscale);
                const float labelOffsetY = 4.0f * gui->game->displayscale;

                HUD.AddStatic(IDC_INPUTHEADERCHANNEL, gui->strings[L_CONFIG_CHANNEL].c_str(), xLabel, static_cast<int>(y), widthDevice, lineHeight);
                HUD.GetStatic(IDC_INPUTHEADERCHANNEL)->GetElement(0)->dwTextFormat = DT_LEFT;
                HUD.AddStatic(IDC_INPUTHEADERDEVICE, gui->strings[L_CONFIG_DEVICE].c_str(), xDevice, static_cast<int>(y), widthDevice, lineHeight);
                HUD.GetStatic(IDC_INPUTHEADERDEVICE)->GetElement(0)->dwTextFormat = DT_LEFT;
                HUD.AddStatic(IDC_INPUTHEADERAXIS, gui->strings[L_CONFIG_AXIS].c_str(), static_cast<int>(384.0f * gui->game->displayscale), static_cast<int>(y), widthDevice, lineHeight);
                HUD.GetStatic(IDC_INPUTHEADERAXIS)->GetElement(0)->dwTextFormat = DT_LEFT;
                HUD.AddStatic(IDC_INPUTHEADERVALUE, gui->strings[L_CONFIG_VALUE].c_str(), static_cast<int>(500.0f * gui->game->displayscale), static_cast<int>(y), widthDevice, lineHeight);
                HUD.GetStatic(IDC_INPUTHEADERVALUE)->GetElement(0)->dwTextFormat = DT_LEFT;
                HUD.AddStatic(IDC_INPUTHEADERINV, gui->strings[L_CONFIG_INVERT].c_str(), xInv, static_cast<int>(y), widthCheckboxes, lineHeight);
                HUD.GetStatic(IDC_INPUTHEADERINV)->GetElement(0)->dwTextFormat = DT_LEFT;
                HUD.AddStatic(IDC_INPUTHEADERSPLIT, gui->strings[L_CONFIG_SPLIT].c_str(), xSplit, static_cast<int>(y), widthCheckboxes, lineHeight);
                HUD.GetStatic(IDC_INPUTHEADERSPLIT)->GetElement(0)->dwTextFormat = DT_LEFT;
                y += 24.0f * gui->game->displayscale;

                HUD.AddStatic(IDC_INPUTLABELLOOKLATERAL, gui->strings[L_CONFIG_LOOKLATERAL].c_str(), xLabel, static_cast<int>(y + labelOffsetY), widthDevice, lineHeight);
                HUD.GetStatic(IDC_INPUTLABELLOOKLATERAL)->GetElement(0)->dwTextFormat = DT_LEFT;
                HUD.AddComboBox(IDC_INPUTDEVICELOOKLATERAL, xDevice, static_cast<int>(y), widthDevice, lineHeight);
                CreateAxisDropdown(IDC_INPUTAXISLOOKLATERAL, static_cast<int>(y), &gui->game->config.inputConfigLookLateral);
                HUD.AddCheckBox(IDC_INPUTINVLOOKLATERAL, nullptr, xInv, static_cast<int>(y), widthCheckboxes, static_cast<int>(24.0f * gui->game->displayscale), gui->game->config.inputConfigLookLateral.invert);
                y += 32.0f * gui->game->displayscale;

                HUD.AddStatic(IDC_INPUTLABELLOOKVERTICAL, gui->strings[L_CONFIG_LOOKVERTICAL].c_str(), xLabel, static_cast<int>(y + labelOffsetY), widthDevice, lineHeight);
                HUD.GetStatic(IDC_INPUTLABELLOOKVERTICAL)->GetElement(0)->dwTextFormat = DT_LEFT;
                HUD.AddComboBox(IDC_INPUTDEVICELOOKVERTICAL, xDevice, static_cast<int>(y), widthDevice, lineHeight);
                CreateAxisDropdown(IDC_INPUTAXISLOOKVERTICAL, static_cast<int>(y), &gui->game->config.inputConfigLookVertical);
                HUD.AddCheckBox(IDC_INPUTINVLOOKVERTICAL, nullptr, xInv, static_cast<int>(y), widthCheckboxes, static_cast<int>(24.0f * gui->game->displayscale), gui->game->config.inputConfigLookVertical.invert);
                y += 32.0f * gui->game->displayscale;

                HUD.AddStatic(IDC_INPUTLABELWALKLATERAL, gui->strings[L_CONFIG_WALKLATERAL].c_str(), xLabel, static_cast<int>(y + labelOffsetY), widthDevice, lineHeight);
                HUD.GetStatic(IDC_INPUTLABELWALKLATERAL)->GetElement(0)->dwTextFormat = DT_LEFT;
                HUD.AddComboBox(IDC_INPUTDEVICEWALKLATERAL, xDevice, static_cast<int>(y), widthDevice, lineHeight);
                CreateAxisDropdown(IDC_INPUTAXISWALKLATERAL, static_cast<int>(y), &gui->game->config.inputConfigWalkLateral);
                HUD.AddCheckBox(IDC_INPUTINVWALKLATERAL, nullptr, xInv, static_cast<int>(y), widthCheckboxes, static_cast<int>(24.0f * gui->game->displayscale), gui->game->config.inputConfigWalkLateral.invert);
                y += 32.0f * gui->game->displayscale;

                HUD.AddStatic(IDC_INPUTLABELWALKVERTICAL, gui->strings[L_CONFIG_WALKVERTICAL].c_str(), xLabel, static_cast<int>(y + labelOffsetY), widthDevice, lineHeight);
                HUD.GetStatic(IDC_INPUTLABELWALKVERTICAL)->GetElement(0)->dwTextFormat = DT_LEFT;
                HUD.AddComboBox(IDC_INPUTDEVICEWALKVERTICAL, xDevice, static_cast<int>(y), widthDevice, lineHeight);
                CreateAxisDropdown(IDC_INPUTAXISWALKVERTICAL, static_cast<int>(y), &gui->game->config.inputConfigWalkVertical);
                HUD.AddCheckBox(IDC_INPUTINVWALKVERTICAL, nullptr, xInv, static_cast<int>(y), widthCheckboxes, static_cast<int>(24.0f * gui->game->displayscale), gui->game->config.inputConfigWalkVertical.invert);
                y += 32.0f * gui->game->displayscale;

                HUD.AddStatic(IDC_INPUTLABELSTEERING, gui->strings[L_CONFIG_STEERING].c_str(), xLabel, static_cast<int>(y + labelOffsetY), widthDevice, lineHeight);
                HUD.GetStatic(IDC_INPUTLABELSTEERING)->GetElement(0)->dwTextFormat = DT_LEFT;
                HUD.AddComboBox(IDC_INPUTDEVICESTEERING, xDevice, static_cast<int>(y), widthDevice, lineHeight);
                CreateAxisDropdown(IDC_INPUTAXISSTEERING, static_cast<int>(y), &gui->game->config.inputConfigSteer);
                HUD.AddCheckBox(IDC_INPUTINVSTEERING, nullptr, xInv, static_cast<int>(y), widthCheckboxes, static_cast<int>(24.0f * gui->game->displayscale), gui->game->config.inputConfigSteer.invert);
                y += 32.0f * gui->game->displayscale;

                HUD.AddStatic(IDC_INPUTLABELGAS, gui->strings[L_CONFIG_ACCELERATOR].c_str(), xLabel, static_cast<int>(y + labelOffsetY), widthDevice, lineHeight);
                HUD.GetStatic(IDC_INPUTLABELGAS)->GetElement(0)->dwTextFormat = DT_LEFT;
                HUD.AddComboBox(IDC_INPUTDEVICEGAS, xDevice, static_cast<int>(y), widthDevice, lineHeight);
                CreateAxisDropdown(IDC_INPUTAXISGAS, static_cast<int>(y), &gui->game->config.inputConfigGas);
                HUD.AddCheckBox(IDC_INPUTINVGAS, nullptr, xInv, static_cast<int>(y), widthCheckboxes, static_cast<int>(24.0f * gui->game->displayscale), gui->game->config.inputConfigGas.invert);
                HUD.GetCheckBox(IDC_INPUTINVGAS)->SetEnabled(gui->game->config.inputConfigGas.g_pJoystick);
                HUD.AddCheckBox(IDC_INPUTSPLITGAS, nullptr, xSplit, static_cast<int>(y), widthCheckboxes, static_cast<int>(24.0f * gui->game->displayscale), gui->game->config.inputConfigGas.split);
                HUD.GetCheckBox(IDC_INPUTSPLITGAS)->SetEnabled(gui->game->config.inputConfigGas.g_pJoystick);
                y += 32.0f * gui->game->displayscale;

                HUD.AddStatic(IDC_INPUTLABELBRAKE, gui->strings[L_CONFIG_BRAKE].c_str(), xLabel, static_cast<int>(y + labelOffsetY), widthDevice, lineHeight);
                HUD.GetStatic(IDC_INPUTLABELBRAKE)->GetElement(0)->dwTextFormat = DT_LEFT;
                HUD.AddComboBox(IDC_INPUTDEVICEBRAKE, xDevice, static_cast<int>(y), widthDevice, lineHeight);
                CreateAxisDropdown(IDC_INPUTAXISBRAKE, static_cast<int>(y), &gui->game->config.inputConfigBrake);
                HUD.AddCheckBox(IDC_INPUTINVBRAKE, nullptr, xInv, static_cast<int>(y), widthCheckboxes, static_cast<int>(24.0f * gui->game->displayscale), gui->game->config.inputConfigBrake.invert);
                HUD.GetCheckBox(IDC_INPUTINVBRAKE)->SetEnabled(gui->game->config.inputConfigBrake.g_pJoystick);
                HUD.AddCheckBox(IDC_INPUTSPLITBRAKE, nullptr, xSplit, static_cast<int>(y), widthCheckboxes, static_cast<int>(24.0f * gui->game->displayscale), gui->game->config.inputConfigBrake.split);
                HUD.GetCheckBox(IDC_INPUTSPLITBRAKE)->SetEnabled(gui->game->config.inputConfigBrake.g_pJoystick);
                y += 32.0f * gui->game->displayscale;

                HUD.AddStatic(IDC_INPUTLABELPITCH, gui->strings[L_CONFIG_PITCH].c_str(), xLabel, static_cast<int>(y + labelOffsetY), widthDevice, lineHeight);
                HUD.GetStatic(IDC_INPUTLABELPITCH)->GetElement(0)->dwTextFormat = DT_LEFT;
                HUD.AddComboBox(IDC_INPUTDEVICEPITCH, xDevice, static_cast<int>(y), widthDevice, lineHeight);
                CreateAxisDropdown(IDC_INPUTAXISPITCH, static_cast<int>(y), &gui->game->config.inputConfigPitch);
                HUD.AddCheckBox(IDC_INPUTINVPITCH, nullptr, xInv, static_cast<int>(y), widthCheckboxes, static_cast<int>(24.0f * gui->game->displayscale), gui->game->config.inputConfigPitch.invert);
                y += 32.0f * gui->game->displayscale;

                HUD.AddStatic(IDC_INPUTLABELPITCHTRIM, gui->strings[L_CONFIG_PITCHTRIM].c_str(), xLabel, static_cast<int>(y + labelOffsetY), widthDevice, lineHeight);
                HUD.GetStatic(IDC_INPUTLABELPITCHTRIM)->GetElement(0)->dwTextFormat = DT_LEFT;
                HUD.AddComboBox(IDC_INPUTDEVICEPITCHTRIM, xDevice, static_cast<int>(y), widthDevice, lineHeight);
                CreateAxisDropdown(IDC_INPUTAXISPITCHTRIM, static_cast<int>(y), &gui->game->config.inputConfigPitchTrim);
                HUD.AddCheckBox(IDC_INPUTINVPITCHTRIM, nullptr, xInv, static_cast<int>(y), widthCheckboxes, static_cast<int>(24.0f * gui->game->displayscale), gui->game->config.inputConfigPitchTrim.invert);
                y += 32.0f * gui->game->displayscale;

                HUD.AddStatic(IDC_INPUTLABELROLL, gui->strings[L_CONFIG_ROLL].c_str(), xLabel, static_cast<int>(y + labelOffsetY), widthDevice, lineHeight);
                HUD.GetStatic(IDC_INPUTLABELROLL)->GetElement(0)->dwTextFormat = DT_LEFT;
                HUD.AddComboBox(IDC_INPUTDEVICEROLL, xDevice, static_cast<int>(y), widthDevice, lineHeight);
                CreateAxisDropdown(IDC_INPUTAXISROLL, static_cast<int>(y), &gui->game->config.inputConfigRoll);
                HUD.AddCheckBox(IDC_INPUTINVROLL, nullptr, xInv, static_cast<int>(y), widthCheckboxes, static_cast<int>(24.0f * gui->game->displayscale), gui->game->config.inputConfigRoll.invert);
                y += 32.0f * gui->game->displayscale;

                HUD.AddStatic(IDC_INPUTLABELYAW, gui->strings[L_CONFIG_YAW].c_str(), xLabel, static_cast<int>(y + labelOffsetY), widthDevice, lineHeight);
                HUD.GetStatic(IDC_INPUTLABELYAW)->GetElement(0)->dwTextFormat = DT_LEFT;
                HUD.AddComboBox(IDC_INPUTDEVICEYAW, xDevice, static_cast<int>(y), widthDevice, lineHeight);
                CreateAxisDropdown(IDC_INPUTAXISYAW, static_cast<int>(y), &gui->game->config.inputConfigYaw);
                HUD.AddCheckBox(IDC_INPUTINVYAW, nullptr, xInv, static_cast<int>(y), widthCheckboxes, static_cast<int>(24.0f * gui->game->displayscale), gui->game->config.inputConfigYaw.invert);
                y += 32.0f * gui->game->displayscale;

                HUD.AddStatic(IDC_INPUTLABELTHRUSTLEFT, gui->strings[L_CONFIG_LEFTTHRUST].c_str(), xLabel, static_cast<int>(y + labelOffsetY), widthDevice, lineHeight);
                HUD.GetStatic(IDC_INPUTLABELTHRUSTLEFT)->GetElement(0)->dwTextFormat = DT_LEFT;
                HUD.AddComboBox(IDC_INPUTDEVICETHRUSTLEFT, xDevice, static_cast<int>(y), widthDevice, lineHeight);
                CreateAxisDropdown(IDC_INPUTAXISTHRUSTLEFT, static_cast<int>(y), &gui->game->config.inputConfigThrustLeft);
                HUD.AddCheckBox(IDC_INPUTINVTHRUSTLEFT, nullptr, xInv, static_cast<int>(y), widthCheckboxes, static_cast<int>(24.0f * gui->game->displayscale), gui->game->config.inputConfigThrustLeft.invert);
                HUD.GetCheckBox(IDC_INPUTINVTHRUSTLEFT)->SetEnabled(gui->game->config.inputConfigThrustLeft.g_pJoystick);
                HUD.AddCheckBox(IDC_INPUTSPLITTHRUSTLEFT, nullptr, xSplit, static_cast<int>(y), widthCheckboxes, static_cast<int>(24.0f * gui->game->displayscale), gui->game->config.inputConfigThrustLeft.split);
                HUD.GetCheckBox(IDC_INPUTSPLITTHRUSTLEFT)->SetEnabled(gui->game->config.inputConfigThrustLeft.g_pJoystick);
                y += 32.0f * gui->game->displayscale;

                HUD.AddStatic(IDC_INPUTLABELTHRUSTRIGHT, gui->strings[L_CONFIG_RIGHTTHRUST].c_str(), xLabel, static_cast<int>(y + labelOffsetY), widthDevice, lineHeight);
                HUD.GetStatic(IDC_INPUTLABELTHRUSTRIGHT)->GetElement(0)->dwTextFormat = DT_LEFT;
                HUD.AddComboBox(IDC_INPUTDEVICETHRUSTRIGHT, xDevice, static_cast<int>(y), widthDevice, lineHeight);
                CreateAxisDropdown(IDC_INPUTAXISTHRUSTRIGHT, static_cast<int>(y), &gui->game->config.inputConfigThrustRight);
                HUD.AddCheckBox(IDC_INPUTINVTHRUSTRIGHT, nullptr, xInv, static_cast<int>(y), widthCheckboxes, static_cast<int>(24.0f * gui->game->displayscale), gui->game->config.inputConfigThrustRight.invert);
                HUD.GetCheckBox(IDC_INPUTINVTHRUSTRIGHT)->SetEnabled(gui->game->config.inputConfigThrustRight.g_pJoystick);
                HUD.AddCheckBox(IDC_INPUTSPLITTHRUSTRIGHT, nullptr, xSplit, static_cast<int>(y), widthCheckboxes, static_cast<int>(24.0f * gui->game->displayscale), gui->game->config.inputConfigThrustRight.split);
                HUD.GetCheckBox(IDC_INPUTSPLITTHRUSTRIGHT)->SetEnabled(gui->game->config.inputConfigThrustRight.g_pJoystick);
                y += 32.0f * gui->game->displayscale;

                HUD.AddStatic(IDC_INPUTLABELLEFTTOEBRAKE, gui->strings[L_CONFIG_LEFTBRAKE].c_str(), xLabel, static_cast<int>(y + labelOffsetY), widthDevice, lineHeight);
                HUD.GetStatic(IDC_INPUTLABELLEFTTOEBRAKE)->GetElement(0)->dwTextFormat = DT_LEFT;
                HUD.AddComboBox(IDC_INPUTDEVICELEFTTOEBRAKE, xDevice, static_cast<int>(y), widthDevice, lineHeight);
                CreateAxisDropdown(IDC_INPUTAXISLEFTTOEBRAKE, static_cast<int>(y), &gui->game->config.inputConfigLeftToeBrake);
                HUD.AddCheckBox(IDC_INPUTINVLEFTTOEBRAKE, nullptr, xInv, static_cast<int>(y), widthCheckboxes, static_cast<int>(24.0f * gui->game->displayscale), gui->game->config.inputConfigLeftToeBrake.invert);
                HUD.GetCheckBox(IDC_INPUTINVLEFTTOEBRAKE)->SetEnabled(gui->game->config.inputConfigLeftToeBrake.g_pJoystick);
                HUD.AddCheckBox(IDC_INPUTSPLITLEFTTOEBRAKE, nullptr, xSplit, static_cast<int>(y), widthCheckboxes, static_cast<int>(24.0f * gui->game->displayscale), gui->game->config.inputConfigLeftToeBrake.split);
                HUD.GetCheckBox(IDC_INPUTSPLITLEFTTOEBRAKE)->SetEnabled(gui->game->config.inputConfigLeftToeBrake.g_pJoystick);
                y += 32.0f * gui->game->displayscale;

                HUD.AddStatic(IDC_INPUTLABELRIGHTTOEBRAKE, gui->strings[L_CONFIG_RIGHTBRAKE].c_str(), xLabel, static_cast<int>(y + labelOffsetY), widthDevice, lineHeight);
                HUD.GetStatic(IDC_INPUTLABELRIGHTTOEBRAKE)->GetElement(0)->dwTextFormat = DT_LEFT;
                HUD.AddComboBox(IDC_INPUTDEVICERIGHTTOEBRAKE, xDevice, static_cast<int>(y), widthDevice, lineHeight);
                CreateAxisDropdown(IDC_INPUTAXISRIGHTTOEBRAKE, static_cast<int>(y), &gui->game->config.inputConfigRightToeBrake);
                HUD.AddCheckBox(IDC_INPUTINVRIGHTTOEBRAKE, nullptr, xInv, static_cast<int>(y), widthCheckboxes, static_cast<int>(24.0f * gui->game->displayscale), gui->game->config.inputConfigRightToeBrake.invert);
                HUD.GetCheckBox(IDC_INPUTINVRIGHTTOEBRAKE)->SetEnabled(gui->game->config.inputConfigRightToeBrake.g_pJoystick);
                HUD.AddCheckBox(IDC_INPUTSPLITRIGHTTOEBRAKE, nullptr, xSplit, static_cast<int>(y), widthCheckboxes, static_cast<int>(24.0f * gui->game->displayscale), gui->game->config.inputConfigRightToeBrake.split);
                HUD.GetCheckBox(IDC_INPUTSPLITRIGHTTOEBRAKE)->SetEnabled(gui->game->config.inputConfigRightToeBrake.g_pJoystick);
                y += 32.0f * gui->game->displayscale;


                HUD.GetComboBox(IDC_INPUTDEVICELOOKLATERAL)->AddItem(gui->strings[L_CONFIG_MOUSE].c_str(), &gui->game->config.inputConfigLookLateral);
                HUD.GetComboBox(IDC_INPUTDEVICELOOKLATERAL)->SetSelectedByIndex(0);
                HUD.GetComboBox(IDC_INPUTDEVICELOOKVERTICAL)->AddItem(gui->strings[L_CONFIG_MOUSE].c_str(), &gui->game->config.inputConfigLookVertical);
                HUD.GetComboBox(IDC_INPUTDEVICELOOKVERTICAL)->SetSelectedByIndex(0);
                HUD.GetComboBox(IDC_INPUTDEVICEWALKLATERAL)->AddItem(gui->strings[L_CONFIG_KEYBOARD].c_str(), &gui->game->config.inputConfigWalkLateral);
                HUD.GetComboBox(IDC_INPUTDEVICEWALKLATERAL)->SetSelectedByIndex(0);
                HUD.GetComboBox(IDC_INPUTDEVICEWALKVERTICAL)->AddItem(gui->strings[L_CONFIG_KEYBOARD].c_str(), &gui->game->config.inputConfigWalkVertical);
                HUD.GetComboBox(IDC_INPUTDEVICEWALKVERTICAL)->SetSelectedByIndex(0);
                HUD.GetComboBox(IDC_INPUTDEVICESTEERING)->AddItem(gui->strings[L_CONFIG_KEYBOARD].c_str(), &gui->game->config.inputConfigSteer);
                HUD.GetComboBox(IDC_INPUTDEVICESTEERING)->SetSelectedByIndex(0);
                HUD.GetComboBox(IDC_INPUTDEVICEGAS)->AddItem(gui->strings[L_CONFIG_KEYBOARD].c_str(), &gui->game->config.inputConfigGas);
                HUD.GetComboBox(IDC_INPUTDEVICEGAS)->SetSelectedByIndex(0);
                HUD.GetComboBox(IDC_INPUTDEVICEBRAKE)->AddItem(gui->strings[L_CONFIG_KEYBOARD].c_str(), &gui->game->config.inputConfigBrake);
                HUD.GetComboBox(IDC_INPUTDEVICEBRAKE)->SetSelectedByIndex(0);
                HUD.GetComboBox(IDC_INPUTDEVICEPITCH)->AddItem(gui->strings[L_CONFIG_KEYBOARD].c_str(), &gui->game->config.inputConfigPitch);
                HUD.GetComboBox(IDC_INPUTDEVICEPITCH)->SetSelectedByIndex(0);
                HUD.GetComboBox(IDC_INPUTDEVICEPITCHTRIM)->AddItem(gui->strings[L_CONFIG_KEYBOARD].c_str(), &gui->game->config.inputConfigPitchTrim);
                HUD.GetComboBox(IDC_INPUTDEVICEPITCHTRIM)->SetSelectedByIndex(0);
                HUD.GetComboBox(IDC_INPUTDEVICEROLL)->AddItem(gui->strings[L_CONFIG_KEYBOARD].c_str(), &gui->game->config.inputConfigRoll);
                HUD.GetComboBox(IDC_INPUTDEVICEROLL)->SetSelectedByIndex(0);
                HUD.GetComboBox(IDC_INPUTDEVICEYAW)->AddItem(gui->strings[L_CONFIG_KEYBOARD].c_str(), &gui->game->config.inputConfigYaw);
                HUD.GetComboBox(IDC_INPUTDEVICEYAW)->SetSelectedByIndex(0);
                HUD.GetComboBox(IDC_INPUTDEVICETHRUSTLEFT)->AddItem(gui->strings[L_CONFIG_KEYBOARD].c_str(), &gui->game->config.inputConfigThrustLeft);
                HUD.GetComboBox(IDC_INPUTDEVICETHRUSTLEFT)->SetSelectedByIndex(0);
                HUD.GetComboBox(IDC_INPUTDEVICETHRUSTRIGHT)->AddItem(gui->strings[L_CONFIG_KEYBOARD].c_str(), &gui->game->config.inputConfigThrustRight);
                HUD.GetComboBox(IDC_INPUTDEVICETHRUSTRIGHT)->SetSelectedByIndex(0);
                HUD.GetComboBox(IDC_INPUTDEVICELEFTTOEBRAKE)->AddItem(gui->strings[L_CONFIG_KEYBOARD].c_str(), &gui->game->config.inputConfigLeftToeBrake);
                HUD.GetComboBox(IDC_INPUTDEVICELEFTTOEBRAKE)->SetSelectedByIndex(0);
                HUD.GetComboBox(IDC_INPUTDEVICERIGHTTOEBRAKE)->AddItem(gui->strings[L_CONFIG_KEYBOARD].c_str(), &gui->game->config.inputConfigRightToeBrake);
                HUD.GetComboBox(IDC_INPUTDEVICERIGHTTOEBRAKE)->SetSelectedByIndex(0);
                for (UINT i = 0; i < gui->game->viewscreen->ptrJoystick->deviceList.size(); i++)
                {
                        const DIDEVICEINSTANCE device = gui->game->viewscreen->ptrJoystick->deviceList.at(i);
                        HUD.GetComboBox(IDC_INPUTDEVICELOOKLATERAL)->AddItem(device.tszInstanceName, &gui->game->config.inputConfigLookLateral);
                        if (gui->game->config.inputConfigLookLateral.guid == device.guidInstance)
                                HUD.GetComboBox(IDC_INPUTDEVICELOOKLATERAL)->SetSelectedByIndex(i + 1);
                        HUD.GetComboBox(IDC_INPUTDEVICELOOKVERTICAL)->AddItem(device.tszInstanceName, &gui->game->config.inputConfigLookVertical);
                        if (gui->game->config.inputConfigLookVertical.guid == device.guidInstance)
                                HUD.GetComboBox(IDC_INPUTDEVICELOOKVERTICAL)->SetSelectedByIndex(i + 1);
                        HUD.GetComboBox(IDC_INPUTDEVICEWALKLATERAL)->AddItem(device.tszInstanceName, &gui->game->config.inputConfigWalkLateral);
                        if (gui->game->config.inputConfigWalkLateral.guid == device.guidInstance)
                                HUD.GetComboBox(IDC_INPUTDEVICEWALKLATERAL)->SetSelectedByIndex(i + 1);
                        HUD.GetComboBox(IDC_INPUTDEVICEWALKVERTICAL)->AddItem(device.tszInstanceName, &gui->game->config.inputConfigWalkVertical);
                        if (gui->game->config.inputConfigWalkVertical.guid == device.guidInstance)
                                HUD.GetComboBox(IDC_INPUTDEVICEWALKVERTICAL)->SetSelectedByIndex(i + 1);
                        HUD.GetComboBox(IDC_INPUTDEVICESTEERING)->AddItem(device.tszInstanceName, &gui->game->config.inputConfigSteer);
                        if (gui->game->config.inputConfigSteer.guid == device.guidInstance)
                                HUD.GetComboBox(IDC_INPUTDEVICESTEERING)->SetSelectedByIndex(i + 1);
                        HUD.GetComboBox(IDC_INPUTDEVICEGAS)->AddItem(device.tszInstanceName, &gui->game->config.inputConfigGas);
                        if (gui->game->config.inputConfigGas.guid == device.guidInstance)
                                HUD.GetComboBox(IDC_INPUTDEVICEGAS)->SetSelectedByIndex(i + 1);
                        HUD.GetComboBox(IDC_INPUTDEVICEBRAKE)->AddItem(device.tszInstanceName, &gui->game->config.inputConfigBrake);
                        if (gui->game->config.inputConfigBrake.guid == device.guidInstance)
                                HUD.GetComboBox(IDC_INPUTDEVICEBRAKE)->SetSelectedByIndex(i + 1);
                        HUD.GetComboBox(IDC_INPUTDEVICEPITCH)->AddItem(device.tszInstanceName, &gui->game->config.inputConfigPitch);
                        if (gui->game->config.inputConfigPitch.guid == device.guidInstance)
                                HUD.GetComboBox(IDC_INPUTDEVICEPITCH)->SetSelectedByIndex(i + 1);
                        HUD.GetComboBox(IDC_INPUTDEVICEPITCHTRIM)->AddItem(device.tszInstanceName, &gui->game->config.inputConfigPitchTrim);
                        if (gui->game->config.inputConfigPitchTrim.guid == device.guidInstance)
                                HUD.GetComboBox(IDC_INPUTDEVICEPITCHTRIM)->SetSelectedByIndex(i + 1);
                        HUD.GetComboBox(IDC_INPUTDEVICEROLL)->AddItem(device.tszInstanceName, &gui->game->config.inputConfigRoll);
                        if (gui->game->config.inputConfigRoll.guid == device.guidInstance)
                                HUD.GetComboBox(IDC_INPUTDEVICEROLL)->SetSelectedByIndex(i + 1);
                        HUD.GetComboBox(IDC_INPUTDEVICEYAW)->AddItem(device.tszInstanceName, &gui->game->config.inputConfigYaw);
                        if (gui->game->config.inputConfigYaw.guid == device.guidInstance)
                                HUD.GetComboBox(IDC_INPUTDEVICEYAW)->SetSelectedByIndex(i + 1);
                        HUD.GetComboBox(IDC_INPUTDEVICETHRUSTLEFT)->AddItem(device.tszInstanceName, &gui->game->config.inputConfigThrustLeft);
                        if (gui->game->config.inputConfigThrustLeft.guid == device.guidInstance)
                                HUD.GetComboBox(IDC_INPUTDEVICETHRUSTLEFT)->SetSelectedByIndex(i + 1);
                        HUD.GetComboBox(IDC_INPUTDEVICETHRUSTRIGHT)->AddItem(device.tszInstanceName, &gui->game->config.inputConfigThrustRight);
                        if (gui->game->config.inputConfigThrustRight.guid == device.guidInstance)
                                HUD.GetComboBox(IDC_INPUTDEVICETHRUSTRIGHT)->SetSelectedByIndex(i + 1);
                        HUD.GetComboBox(IDC_INPUTDEVICELEFTTOEBRAKE)->AddItem(device.tszInstanceName, &gui->game->config.inputConfigLeftToeBrake);
                        if (gui->game->config.inputConfigLeftToeBrake.guid == device.guidInstance)
                                HUD.GetComboBox(IDC_INPUTDEVICELEFTTOEBRAKE)->SetSelectedByIndex(i + 1);
                        HUD.GetComboBox(IDC_INPUTDEVICERIGHTTOEBRAKE)->AddItem(device.tszInstanceName, &gui->game->config.inputConfigRightToeBrake);
                        if (gui->game->config.inputConfigRightToeBrake.guid == device.guidInstance)
                                HUD.GetComboBox(IDC_INPUTDEVICERIGHTTOEBRAKE)->SetSelectedByIndex(i + 1);
                }
        }
        break;

        case L_TAB_VIDEO:
        {
                //const int x = static_cast<int>(10.0f * gui->game->displayscalex);

                //const int height = static_cast<int>(23.0f * gui->game->displayscaley);

                //HUD.AddStatic(DXUTSETTINGSDLG_STATIC1, L"API Version", x, static_cast<int>(2.0f * gui->game->displayscaley), static_cast<int>(180.0f * gui->game->displayscalex), height);
                //HUD.AddComboBox(DXUTSETTINGSDLG_API_VERSION, static_cast<int>(200.0f * gui->game->displayscalex), static_cast<int>(2.0f * gui->game->displayscaley), static_cast<int>(300.0f * gui->game->displayscalex), height);

                //HUD.AddStatic(DXUTSETTINGSDLG_STATIC2, L"Display Adapter", x, 27 * gui->game->displayscaley, 180 * gui->game->displayscalex, height);
                //HUD.AddComboBox(DXUTSETTINGSDLG_ADAPTER, 200 * gui->game->displayscalex, 27 * gui->game->displayscaley, 300 * gui->game->displayscalex, height);

                //HUD.AddStatic(DXUTSETTINGSDLG_STATIC3, L"Render Device", x, 52 * gui->game->displayscaley, 180 * gui->game->displayscalex, height);
                //HUD.AddComboBox(DXUTSETTINGSDLG_DEVICE_TYPE, 200 * gui->game->displayscalex, 52 * gui->game->displayscaley, 300 * gui->game->displayscalex, height);

                // DXUTSETTINGSDLG_WINDOWED, DXUTSETTINGSDLG_FULLSCREEN
                HUD.AddRadioButton(DXUTSETTINGSDLG_WINDOWED, DXUTSETTINGSDLG_WINDOWED_GROUP, gui->strings[L_CONFIG_WINDOWED].c_str(), (int)(240.0f * gui->game->displayscale), (int)(79.0f * gui->game->displayscale), (int)(300.0f * gui->game->displayscale), (int)(16.0f * gui->game->displayscale), !gui->game->config.g_bStartFullscreen);
                //HUD.AddCheckBox(DXUTSETTINGSDLG_DEVICECLIP, L"Clip to device when window spans across multiple monitors", 250 * gui->game->displayscalex, 100 * gui->game->displayscaley, 400 * gui->game->displayscalex, 16 * gui->game->displayscaley);
                //HUD.GetCheckBox(DXUTSETTINGSDLG_DEVICECLIP)->SetEnabled(false);
                HUD.AddRadioButton(DXUTSETTINGSDLG_FULLSCREEN, DXUTSETTINGSDLG_WINDOWED_GROUP, gui->strings[L_CONFIG_FULLSCREEN].c_str(), (int)(240.0f * gui->game->displayscale), (int)(121.0f * gui->game->displayscale), (int)(300.0f * gui->game->displayscale), (int)(16.0f * gui->game->displayscale), gui->game->config.g_bStartFullscreen);

                //HUD.AddStatic(DXUTSETTINGSDLG_ADAPTER_FORMAT_LABEL, L"Adapter Format", x, 139 * gui->game->displayscaley, 180 * gui->game->displayscalex, height);
                //HUD.AddComboBox(DXUTSETTINGSDLG_ADAPTER_FORMAT, 200 * gui->game->displayscalex, 139 * gui->game->displayscaley, 300 * gui->game->displayscalex, height);

                //HUD.AddStatic(DXUTSETTINGSDLG_RESOLUTION_LABEL, L"Resolution", x, 164 * gui->game->displayscaley, 180 * gui->game->displayscalex, height);
                //HUD.AddComboBox(DXUTSETTINGSDLG_RESOLUTION, 200 * gui->game->displayscalex, 164 * gui->game->displayscaley, 200 * gui->game->displayscalex, height);
                //HUD.GetComboBox(DXUTSETTINGSDLG_RESOLUTION)->SetDropHeight(static_cast<UINT>(106.0f * gui->game->displayscaley));

                //HUD.AddCheckBox(DXUTSETTINGSDLG_RESOLUTION_SHOW_ALL, L"Show All Aspect Ratios", 420 * gui->game->displayscalex, 164 * gui->game->displayscaley, 200 * gui->game->displayscalex, height, false);

                //HUD.AddStatic(DXUTSETTINGSDLG_REFRESH_RATE_LABEL, L"Refresh Rate", x, 189 * gui->game->displayscaley, 180 * gui->game->displayscalex, height);
                //HUD.AddComboBox(DXUTSETTINGSDLG_REFRESH_RATE, 200 * gui->game->displayscalex, 189 * gui->game->displayscaley, 300 * gui->game->displayscalex, height);

                //HUD.AddStatic(DXUTSETTINGSDLG_BACK_BUFFER_FORMAT_LABEL, L"Back Buffer Format", x, 224 * gui->game->displayscaley, 180 * gui->game->displayscalex, height);
                //HUD.AddComboBox(DXUTSETTINGSDLG_BACK_BUFFER_FORMAT, 200 * gui->game->displayscalex, 224 * gui->game->displayscaley, 300 * gui->game->displayscalex, height);

                //HUD.AddStatic(DXUTSETTINGSDLG_DEPTH_STENCIL_LABEL, L"Depth/Stencil Format", x, 249 * gui->game->displayscaley, 180 * gui->game->displayscalex, height);
                //HUD.AddComboBox(DXUTSETTINGSDLG_DEPTH_STENCIL, 200 * gui->game->displayscalex, 249 * gui->game->displayscaley, 300 * gui->game->displayscalex, height);

                //HUD.AddStatic(DXUTSETTINGSDLG_MULTISAMPLE_TYPE_LABEL, L"Multisample Type", x, 274 * gui->game->displayscaley, 180 * gui->game->displayscalex, height);
                //HUD.AddComboBox(DXUTSETTINGSDLG_MULTISAMPLE_TYPE, 200 * gui->game->displayscalex, 274 * gui->game->displayscaley, 300 * gui->game->displayscalex, height);

                //HUD.AddStatic(DXUTSETTINGSDLG_MULTISAMPLE_QUALITY_LABEL, L"Multisample Quality", x, 309 * gui->game->displayscaley, 180 * gui->game->displayscalex, height);
                //HUD.AddComboBox(DXUTSETTINGSDLG_MULTISAMPLE_QUALITY, 200 * gui->game->displayscalex, 309 * gui->game->displayscaley, 300 * gui->game->displayscalex, height);

                //HUD.AddStatic(DXUTSETTINGSDLG_VERTEX_PROCESSING_LABEL, L"Vertex Processing", x, 334 * gui->game->displayscaley, 180 * gui->game->displayscalex, height);
                //HUD.AddComboBox(DXUTSETTINGSDLG_VERTEX_PROCESSING, 200 * gui->game->displayscalex, 334 * gui->game->displayscaley, 300 * gui->game->displayscalex, height);

                //HUD.AddStatic(DXUTSETTINGSDLG_PRESENT_INTERVAL_LABEL, L"Vertical Sync", x, 359 * gui->game->displayscaley, 180 * gui->game->displayscalex, height);
                //HUD.AddComboBox(DXUTSETTINGSDLG_PRESENT_INTERVAL, 200 * gui->game->displayscalex, 359 * gui->game->displayscaley, 300 * gui->game->displayscalex, height);
        }
        break;

        case L_TAB_SOUND:
        {
                float y = 12.0f * gui->game->displayscale;

                HUD.AddStatic(IDC_SOUNDLEGACYLABEL, gui->strings[L_CONFIG_DEFAULT].c_str(), xLabel, static_cast<int>(y), static_cast<int>(400.0f * gui->game->displayscale), lineHeight);
                HUD.GetStatic(IDC_SOUNDLEGACYLABEL)->GetElement(0)->dwTextFormat = DT_LEFT;
                y += lineHeight;
                HUD.AddComboBox(IDC_SOUNDDEVICELEGACY, xLabel, static_cast<int>(y), static_cast<int>(400.0f * gui->game->displayscale), lineHeight);
                HUD.AddCheckBox(IDC_SOUNDPLAYINTRO, gui->strings[L_CONFIG_MUSIC].c_str(), static_cast<int>(448.0f * gui->game->displayscale), static_cast<int>(y), static_cast<int>(150.0f * gui->game->displayscale), lineHeight, gui->game->config.g_bSoundIntroMusic);
                y += lineHeight;
                HUD.AddSlider(IDC_MASTERVOLUMELEGACY, static_cast<int>(24.0f* gui->game->displayscale), static_cast<int>(y), static_cast<int>(175.0f* gui->game->displayscale), lineHeight, 0, 100, static_cast<int>(gui->game->config.soundConfigLegacy.volume * 100.0f));
                y += 36 * gui->game->displayscale;

                HUD.AddStatic(IDC_SOUNDCOMPUTERLABEL, gui->strings[L_CONFIG_AVIONICS].c_str(), xLabel, static_cast<int>(y), static_cast<int>(400.0f * gui->game->displayscale), lineHeight);
                HUD.GetStatic(IDC_SOUNDCOMPUTERLABEL)->GetElement(0)->dwTextFormat = DT_LEFT;
                y += lineHeight;
                HUD.AddComboBox(IDC_SOUNDDEVICECOMPUTER, xLabel, static_cast<int>(y), static_cast<int>(400.0f * gui->game->displayscale), lineHeight);
                y += lineHeight;
                HUD.AddSlider(IDC_MASTERVOLUMECOMPUTER, static_cast<int>(24.0f* gui->game->displayscale), static_cast<int>(y), static_cast<int>(175.0f* gui->game->displayscale), lineHeight, 0, 100, static_cast<int>(gui->game->config.soundConfigComputer.volume * 100.0f));
                y += 36 * gui->game->displayscale;

                HUD.AddStatic(IDC_SOUNDCOMMSLABEL, gui->strings[L_CONFIG_COMMUNICATIONS].c_str(), xLabel, static_cast<int>(y), static_cast<int>(400.0f * gui->game->displayscale), lineHeight);
                HUD.GetStatic(IDC_SOUNDCOMMSLABEL)->GetElement(0)->dwTextFormat = DT_LEFT;
                y += lineHeight;
                HUD.AddComboBox(IDC_SOUNDDEVICECOMMS, xLabel, static_cast<int>(y), static_cast<int>(400.0f * gui->game->displayscale), lineHeight);
                y += lineHeight;
                HUD.AddSlider(IDC_MASTERVOLUMECOMMS, static_cast<int>(24.0f* gui->game->displayscale), static_cast<int>(y), static_cast<int>(175.0f* gui->game->displayscale), lineHeight, 0, 100, static_cast<int>(gui->game->config.soundConfigComms.volume * 100.0f));
                y += 36 * gui->game->displayscale;

                HUD.AddStatic(IDC_SOUNDRADIOLABEL, gui->strings[L_CONFIG_RADIO].c_str(), xLabel, static_cast<int>(y), static_cast<int>(400.0f * gui->game->displayscale), lineHeight);
                HUD.GetStatic(IDC_SOUNDRADIOLABEL)->GetElement(0)->dwTextFormat = DT_LEFT;
                y += lineHeight;
                HUD.AddComboBox(IDC_SOUNDDEVICERADIO, xLabel, static_cast<int>(y), static_cast<int>(400.0f * gui->game->displayscale), lineHeight);
                y += lineHeight;
                HUD.AddSlider(IDC_MASTERVOLUMERADIO, static_cast<int>(24.0f* gui->game->displayscale), static_cast<int>(y), static_cast<int>(175.0f* gui->game->displayscale), lineHeight, 0, 100, static_cast<int>(gui->game->config.soundConfigRadio.volume * 100.0f));
                y += 36 * gui->game->displayscale;

                for (size_t i = 0; i < gui->game->sound->deviceNames.size(); i++)
                {
                        WCHAR widever[99];
                        swprintf_s(widever, 99, L"%S", gui->game->sound->deviceNames.at(i).c_str());
                        HUD.GetComboBox(IDC_SOUNDDEVICELEGACY)->AddItem(widever, &gui->game->config.soundConfigLegacy);
                        HUD.GetComboBox(IDC_SOUNDDEVICECOMPUTER)->AddItem(widever, &gui->game->config.soundConfigComputer);
                        HUD.GetComboBox(IDC_SOUNDDEVICECOMMS)->AddItem(widever, &gui->game->config.soundConfigComms);
                        HUD.GetComboBox(IDC_SOUNDDEVICERADIO)->AddItem(widever, &gui->game->config.soundConfigRadio);
                }

                HUD.GetComboBox(IDC_SOUNDDEVICELEGACY)->SetSelectedByIndex(gui->game->config.soundConfigLegacy.bassDevice);
                HUD.GetComboBox(IDC_SOUNDDEVICECOMPUTER)->SetSelectedByIndex(gui->game->config.soundConfigComputer.bassDevice);
                HUD.GetComboBox(IDC_SOUNDDEVICECOMMS)->SetSelectedByIndex(gui->game->config.soundConfigComms.bassDevice);
                HUD.GetComboBox(IDC_SOUNDDEVICERADIO)->SetSelectedByIndex(gui->game->config.soundConfigRadio.bassDevice);
        }
        break;

        case L_TAB_ACCOUNT:
        {
                int x = xLabel;
                float y = 12.0f * gui->game->displayscale;

                HUD.AddCheckBox(IDC_REMEMBERLOGIN, gui->strings[L_BUTTON_REMEMBERLOGIN].c_str(), static_cast<int>(x + 200.0f * gui->game->displayscale), static_cast<int>(y), static_cast<int>(192.0f * gui->game->displayscale), static_cast<int>(24.0f * gui->game->displayscale), gui->game->config.g_bAutoLogin);

                y += 32 * gui->game->displayscale;
                y += lineHeight;

                HUD.AddButton(IDC_PLAYERPORTAL, gui->strings[L_CAPTION_PLAYERPORTAL].c_str(), static_cast<int>(200.0f * gui->game->displayscale), static_cast<int>(y), static_cast<int>(192.0f * gui->game->displayscale), static_cast<int>(32.0f * gui->game->displayscale), 0, false);
        }
        break;

        default:
                break;
        }
}

void ConfigurationDialog::Close()
{
        gui->TriggerWelcomeApt2();
        active = false;
}