From 8afb232f2ae1c29ff89917de244f34b50a6e854a Mon Sep 17 00:00:00 2001 From: jerrrrycho Date: Sat, 10 Oct 2026 16:49:01 +0200 Subject: [PATCH] refactor(sonar): reduce enum qualification with using enum (cpp:S6177) Applied only where no unqualified name in the block could be captured by the introduced enumerators. Co-Authored-By: Claude Opus 5.5 --- McZapkie/Mover.cpp | 256 +++++----- audio/sound.cpp | 11 +- input/driverkeyboardinput.cpp | 301 +++++------ input/drivermouseinput.cpp | 910 +++++++++++++++++----------------- input/editorkeyboardinput.cpp | 25 +- input/gamepadinput.cpp | 14 +- input/keyboardinput.cpp | 13 +- launcher/textures_scanner.cpp | 31 +- scripting/ladderlogic.cpp | 7 +- utilities/comparison.h | 50 +- vehicle/Gauge.cpp | 13 +- vehicle/Train.cpp | 62 +-- widgets/time.cpp | 7 +- world/MemCell.cpp | 33 +- 14 files changed, 887 insertions(+), 846 deletions(-) diff --git a/McZapkie/Mover.cpp b/McZapkie/Mover.cpp index 7ff19b4a..5cca8c72 100644 --- a/McZapkie/Mover.cpp +++ b/McZapkie/Mover.cpp @@ -2173,11 +2173,12 @@ void TMoverParameters::WaterHeaterCheck(double const /*Timestep*/) // fuel pump status update void TMoverParameters::FuelPumpCheck(double const /*Timestep*/) { + using enum start_t; FuelPump.is_active = true == (Power24vIsAvailable || Power110vIsAvailable) && false == FuelPump.is_disabled && - (FuelPump.is_active || (FuelPump.start_type == start_t::manual ? FuelPump.is_enabled : - FuelPump.start_type == start_t::automatic ? dizel_startup || Mains : - FuelPump.start_type == start_t::manualwithautofallback ? FuelPump.is_enabled || dizel_startup || Mains : + (FuelPump.is_active || (FuelPump.start_type == manual ? FuelPump.is_enabled : + FuelPump.start_type == automatic ? dizel_startup || Mains : + FuelPump.start_type == manualwithautofallback ? FuelPump.is_enabled || dizel_startup || Mains : false)); // shouldn't ever get this far but, eh } @@ -2272,12 +2273,13 @@ void TMoverParameters::MotorBlowersCheck(double const Timestep) void TMoverParameters::PantographsCheck(double const /*Timestep*/) { + using enum start_t; { auto &valve{PantsValve}; auto const lowvoltagepower{valve.solenoid ? Power24vIsAvailable || Power110vIsAvailable : true}; - auto const autostart{valve.start_type == start_t::automatic || valve.start_type == start_t::manualwithautofallback}; - auto const manualcontrol{valve.start_type == start_t::manual || valve.start_type == start_t::manualwithautofallback}; + auto const autostart{valve.start_type == automatic || valve.start_type == manualwithautofallback}; + auto const manualcontrol{valve.start_type == manual || valve.start_type == manualwithautofallback}; PantsValve.is_active = (valve.spring ? lowvoltagepower : true) // spring actuator needs power to maintain non-default state && (manualcontrol && lowvoltagepower ? false == valve.is_disabled : true) // needs power to change state @@ -2292,8 +2294,8 @@ void TMoverParameters::PantographsCheck(double const /*Timestep*/) auto &valve{pantograph.valve}; auto const lowvoltagepower{valve.solenoid ? Power24vIsAvailable || Power110vIsAvailable : true}; - auto const autostart{valve.start_type == start_t::automatic || valve.start_type == start_t::manualwithautofallback}; - auto const manualcontrol{valve.start_type == start_t::manual || valve.start_type == start_t::manualwithautofallback}; + auto const autostart{valve.start_type == automatic || valve.start_type == manualwithautofallback}; + auto const manualcontrol{valve.start_type == manual || valve.start_type == manualwithautofallback}; valve.is_active = (valve.spring ? lowvoltagepower : true) // spring actuator needs power to maintain non-default state && (manualcontrol && lowvoltagepower ? false == valve.is_disabled : true) // needs power to change state, without it just pass through @@ -3128,6 +3130,7 @@ void TMoverParameters::SecuritySystemCheck(double dt) // ************************************************************************************************* bool TMoverParameters::BatterySwitch(bool State, range_t const Notify) { + using enum range_t; auto const initialstate{Battery}; // Ra: ukrotnienie załączania baterii jest jakąś fikcją... @@ -3137,10 +3140,10 @@ bool TMoverParameters::BatterySwitch(bool State, range_t const Notify) } // switching batteries does not require activation - if (Notify != range_t::local) + if (Notify != local) { - SendCtrlToNext("BatterySwitch", State ? 1 : 0, 1, Notify == range_t::unit ? coupling::control | coupling::permanent : coupling::control); - SendCtrlToNext("BatterySwitch", State ? 1 : 0, -1, Notify == range_t::unit ? coupling::control | coupling::permanent : coupling::control); + SendCtrlToNext("BatterySwitch", State ? 1 : 0, 1, Notify == unit ? coupling::control | coupling::permanent : coupling::control); + SendCtrlToNext("BatterySwitch", State ? 1 : 0, -1, Notify == unit ? coupling::control | coupling::permanent : coupling::control); } return Battery != initialstate; @@ -3634,6 +3637,7 @@ void TMoverParameters::MainSwitch_(bool const State) bool TMoverParameters::MainSwitchCheck() const { + using enum TEngineType; // prevent the switch from working if there's no power // TODO: consider whether it makes sense for diesel engines and such @@ -3641,15 +3645,15 @@ bool TMoverParameters::MainSwitchCheck() const switch (EngineType) { - case TEngineType::DieselElectric: - case TEngineType::DieselEngine: - case TEngineType::Dumb: + case DieselElectric: + case DieselEngine: + case Dumb: { powerisavailable = Power24vIsAvailable; break; } - case TEngineType::ElectricSeriesMotor: - case TEngineType::ElectricInductionMotor: + case ElectricSeriesMotor: + case ElectricInductionMotor: { // TODO: check whether we can simplify this check and skip the outer EngineType switch powerisavailable = EnginePowerSourceVoltage() > 0.5 * EnginePowerSource.MaxVoltage; @@ -3661,7 +3665,7 @@ bool TMoverParameters::MainSwitchCheck() const } } - return powerisavailable && (ScndCtrlPos == 0 || EngineType == TEngineType::ElectricInductionMotor) && MainsInitTimeCountdown <= 0.0 && + return powerisavailable && (ScndCtrlPos == 0 || EngineType == ElectricInductionMotor) && MainsInitTimeCountdown <= 0.0 && (ConvOvldFlag == false || ConverterOverloadRelayOffWhenMainIsOff) && true == GroundRelay && true == NoVoltRelay && true == OvervoltageRelay && LastSwitchingTime > CtrlDelay && (HasCamshaft ? IsMainCtrlActualNoPowerPos() : LineBreakerClosesOnlyAtNoPowerPos ? IsMainCtrlNoPowerPos() : @@ -7147,40 +7151,41 @@ bool TMoverParameters::OperatePantographsValve(operation_t const State, range_t switch (State) { - case operation_t::none: + using enum operation_t; + case none: { valve.is_enabled = false; valve.is_disabled = false; break; } - case operation_t::enable: + case enable: { valve.is_enabled = true; valve.is_disabled = false; break; } - case operation_t::disable: + case disable: { valve.is_enabled = false; valve.is_disabled = true; break; } - case operation_t::enable_on: + case enable_on: { valve.is_enabled = true; break; } - case operation_t::enable_off: + case enable_off: { valve.is_enabled = false; break; } - case operation_t::disable_on: + case disable_on: { valve.is_disabled = true; break; } - case operation_t::disable_off: + case disable_off: { valve.is_disabled = false; break; @@ -7206,40 +7211,41 @@ bool TMoverParameters::OperatePantographValve(end const End, operation_t const S switch (State) { - case operation_t::none: + using enum operation_t; + case none: { valve.is_enabled = false; valve.is_disabled = false; break; } - case operation_t::enable: + case enable: { valve.is_enabled = true; valve.is_disabled = false; break; } - case operation_t::disable: + case disable: { valve.is_enabled = false; valve.is_disabled = true; break; } - case operation_t::enable_on: + case enable_on: { valve.is_enabled = true; break; } - case operation_t::enable_off: + case enable_off: { valve.is_enabled = false; break; } - case operation_t::disable_on: + case disable_on: { valve.is_disabled = true; break; } - case operation_t::disable_off: + case disable_off: { valve.is_disabled = false; break; @@ -9517,42 +9523,43 @@ bool TMoverParameters::readCompressorList(std::string const &Input) // ************************************************************************************************* void TMoverParameters::BrakeValveDecode(std::string const &Valve) { + using enum TBrakeValve; - std::map valvetypes{{"W", TBrakeValve::W}, - {"W_Lu_L", TBrakeValve::W_Lu_L}, - {"W_Lu_XR", TBrakeValve::W_Lu_XR}, - {"W_Lu_VI", TBrakeValve::W_Lu_VI}, - {"K", TBrakeValve::K}, - {"Kg", TBrakeValve::Kg}, - {"Kp", TBrakeValve::Kp}, - {"Kss", TBrakeValve::Kss}, - {"Kkg", TBrakeValve::Kkg}, - {"Kkp", TBrakeValve::Kkp}, - {"Kks", TBrakeValve::Kks}, - {"Hikp1", TBrakeValve::Hikp1}, - {"Hikss", TBrakeValve::Hikss}, - {"Hikg1", TBrakeValve::Hikg1}, - {"KE", TBrakeValve::KE}, - {"SW", TBrakeValve::SW}, - {"EStED", TBrakeValve::EStED}, - {"NESt3", TBrakeValve::NESt3}, - {"ESt3", TBrakeValve::ESt3}, - {"LSt", TBrakeValve::LSt}, - {"ESt4", TBrakeValve::ESt4}, - {"ESt3AL2", TBrakeValve::ESt3AL2}, - {"EP1", TBrakeValve::EP1}, - {"EP2", TBrakeValve::EP2}, - {"M483", TBrakeValve::M483}, - {"CV1_L_TR", TBrakeValve::CV1_L_TR}, - {"CV1", TBrakeValve::CV1}, - {"CV1_R", TBrakeValve::CV1_R}}; + std::map valvetypes{{"W", W}, + {"W_Lu_L", W_Lu_L}, + {"W_Lu_XR", W_Lu_XR}, + {"W_Lu_VI", W_Lu_VI}, + {"K", K}, + {"Kg", Kg}, + {"Kp", Kp}, + {"Kss", Kss}, + {"Kkg", Kkg}, + {"Kkp", Kkp}, + {"Kks", Kks}, + {"Hikp1", Hikp1}, + {"Hikss", Hikss}, + {"Hikg1", Hikg1}, + {"KE", KE}, + {"SW", SW}, + {"EStED", EStED}, + {"NESt3", NESt3}, + {"ESt3", ESt3}, + {"LSt", LSt}, + {"ESt4", ESt4}, + {"ESt3AL2", ESt3AL2}, + {"EP1", EP1}, + {"EP2", EP2}, + {"M483", M483}, + {"CV1_L_TR", CV1_L_TR}, + {"CV1", CV1}, + {"CV1_R", CV1_R}}; auto lookup = valvetypes.find(Valve); - BrakeValve = lookup != valvetypes.end() ? lookup->second : TBrakeValve::Other; + BrakeValve = lookup != valvetypes.end() ? lookup->second : Other; - if (BrakeValve == TBrakeValve::Other && contains(Valve, "ESt")) + if (BrakeValve == Other && contains(Valve, "ESt")) { - BrakeValve = TBrakeValve::ESt3; + BrakeValve = ESt3; } } @@ -9561,32 +9568,34 @@ void TMoverParameters::BrakeValveDecode(std::string const &Valve) // ************************************************************************************************* void TMoverParameters::BrakeSubsystemDecode() { - BrakeSubsystem = TBrakeSubSystem::ss_None; + using enum TBrakeSubSystem; + BrakeSubsystem = ss_None; switch (BrakeValve) { - case TBrakeValve::W: - case TBrakeValve::W_Lu_L: - case TBrakeValve::W_Lu_VI: - case TBrakeValve::W_Lu_XR: - BrakeSubsystem = TBrakeSubSystem::ss_W; + using enum TBrakeValve; + case W: + case W_Lu_L: + case W_Lu_VI: + case W_Lu_XR: + BrakeSubsystem = ss_W; break; - case TBrakeValve::ESt3: - case TBrakeValve::ESt3AL2: - case TBrakeValve::ESt4: - case TBrakeValve::EP2: - case TBrakeValve::EP1: - BrakeSubsystem = TBrakeSubSystem::ss_ESt; + case ESt3: + case ESt3AL2: + case ESt4: + case EP2: + case EP1: + BrakeSubsystem = ss_ESt; break; - case TBrakeValve::KE: - BrakeSubsystem = TBrakeSubSystem::ss_KE; + case KE: + BrakeSubsystem = ss_KE; break; - case TBrakeValve::CV1: - case TBrakeValve::CV1_L_TR: - BrakeSubsystem = TBrakeSubSystem::ss_Dako; + case CV1: + case CV1_L_TR: + BrakeSubsystem = ss_Dako; break; - case TBrakeValve::LSt: - case TBrakeValve::EStED: - BrakeSubsystem = TBrakeSubSystem::ss_LSt; + case LSt: + case EStED: + BrakeSubsystem = ss_LSt; break; default: break; @@ -10702,12 +10711,14 @@ void TMoverParameters::LoadFIZ_Cntrl(std::string const &line) { { - std::map brakesystems{{"Pneumatic", TBrakeSystem::Pneumatic}, {"ElectroPneumatic", TBrakeSystem::ElectroPneumatic}}; + using enum TBrakeSystem; + std::map brakesystems{{"Pneumatic", Pneumatic}, {"ElectroPneumatic", ElectroPneumatic}}; auto lookup = brakesystems.find(extract_value("BrakeSystem", line)); - BrakeSystem = lookup != brakesystems.end() ? lookup->second : TBrakeSystem::Individual; + BrakeSystem = lookup != brakesystems.end() ? lookup->second : Individual; } if (BrakeSystem != TBrakeSystem::Individual) { + using enum TBrakeHandle; extract_value(BrakeCtrlPosNo, "BCPN", line, ""); for (int idx = 0; idx < 4; ++idx) @@ -10742,11 +10753,11 @@ void TMoverParameters::LoadFIZ_Cntrl(std::string const &line) // brakehandle { std::map brakehandles{ - {"FV4a", TBrakeHandle::FV4a}, {"test", TBrakeHandle::testH}, {"D2", TBrakeHandle::D2}, {"MHZ_EN57", TBrakeHandle::MHZ_EN57}, {"MHZ_K5P", TBrakeHandle::MHZ_K5P}, - {"MHZ_K8P", TBrakeHandle::MHZ_K8P}, {"MHZ_6P", TBrakeHandle::MHZ_6P}, {"M394", TBrakeHandle::M394}, {"Knorr", TBrakeHandle::Knorr}, {"Westinghouse", TBrakeHandle::West}, - {"FVel6", TBrakeHandle::FVel6}, {"FVE408", TBrakeHandle::FVE408}, {"St113", TBrakeHandle::St113}}; + {"FV4a", FV4a}, {"test", testH}, {"D2", D2}, {"MHZ_EN57", MHZ_EN57}, {"MHZ_K5P", MHZ_K5P}, + {"MHZ_K8P", MHZ_K8P}, {"MHZ_6P", MHZ_6P}, {"M394", M394}, {"Knorr", Knorr}, {"Westinghouse", West}, + {"FVel6", FVel6}, {"FVE408", FVE408}, {"St113", St113}}; auto lookup = brakehandles.find(extract_value("BrakeHandle", line)); - BrakeHandle = lookup != brakehandles.end() ? lookup->second : TBrakeHandle::NoHandle; + BrakeHandle = lookup != brakehandles.end() ? lookup->second : NoHandle; } extract_value(Handle_AutomaticOverload, "HAO", line, ""); extract_value(Handle_ManualOverload, "HMO", line, ""); @@ -10756,9 +10767,9 @@ void TMoverParameters::LoadFIZ_Cntrl(std::string const &line) extract_value(Handle_OverloadPressureDecrease, "OPD", line, ""); // brakelochandle { - std::map locbrakehandles{{"FD1", TBrakeHandle::FD1}, {"Knorr", TBrakeHandle::Knorr}, {"Westinghouse", TBrakeHandle::West}}; + std::map locbrakehandles{{"FD1", FD1}, {"Knorr", Knorr}, {"Westinghouse", West}}; auto lookup = locbrakehandles.find(extract_value("LocBrakeHandle", line)); - BrakeLocHandle = lookup != locbrakehandles.end() ? lookup->second : TBrakeHandle::NoHandle; + BrakeLocHandle = lookup != locbrakehandles.end() ? lookup->second : NoHandle; } // mbpm @@ -10798,9 +10809,10 @@ void TMoverParameters::LoadFIZ_Cntrl(std::string const &line) // localbrake { - std::map localbrakes{{"ManualBrake", TLocalBrake::ManualBrake}, {"PneumaticBrake", TLocalBrake::PneumaticBrake}, {"HydraulicBrake", TLocalBrake::HydraulicBrake}}; + using enum TLocalBrake; + std::map localbrakes{{"ManualBrake", ManualBrake}, {"PneumaticBrake", PneumaticBrake}, {"HydraulicBrake", HydraulicBrake}}; auto lookup = localbrakes.find(extract_value("LocalBrake", line)); - LocalBrake = lookup != localbrakes.end() ? lookup->second : TLocalBrake::NoBrake; + LocalBrake = lookup != localbrakes.end() ? lookup->second : NoBrake; } // mbrake extract_value(MBrake, "ManualBrake", line, ""); @@ -11658,39 +11670,42 @@ void TMoverParameters::LoadFIZ_PowerParamsDecode(TPowerParameters &Powerparamete TPowerType TMoverParameters::LoadFIZ_PowerDecode(std::string const &Powertype) const { + using enum TPowerType; std::map powertypes{ - {"BioPower", TPowerType::BioPower}, {"MechPower", TPowerType::MechPower}, {"ElectricPower", TPowerType::ElectricPower}, {"SteamPower", TPowerType::SteamPower}}; + {"BioPower", BioPower}, {"MechPower", MechPower}, {"ElectricPower", ElectricPower}, {"SteamPower", SteamPower}}; auto lookup = powertypes.find(Powertype); - return lookup != powertypes.end() ? lookup->second : TPowerType::NoPower; + return lookup != powertypes.end() ? lookup->second : NoPower; } TPowerSource TMoverParameters::LoadFIZ_SourceDecode(std::string const &Source) const { + using enum TPowerSource; - std::map powersources{{"Transducer", TPowerSource::Transducer}, {"Generator", TPowerSource::Generator}, - {"Accu", TPowerSource::Accumulator}, // legacy compatibility leftover. TODO: check if we can get rid of it - {"Accumulator", TPowerSource::Accumulator}, {"CurrentCollector", TPowerSource::CurrentCollector}, - {"PowerCable", TPowerSource::PowerCable}, {"Heater", TPowerSource::Heater}, - {"Internal", TPowerSource::InternalSource}, {"Main", TPowerSource::Main}}; + std::map powersources{{"Transducer", Transducer}, {"Generator", Generator}, + {"Accu", Accumulator}, // legacy compatibility leftover. TODO: check if we can get rid of it + {"Accumulator", Accumulator}, {"CurrentCollector", CurrentCollector}, + {"PowerCable", PowerCable}, {"Heater", Heater}, + {"Internal", InternalSource}, {"Main", Main}}; auto lookup = powersources.find(Source); - return lookup != powersources.end() ? lookup->second : TPowerSource::NotDefined; + return lookup != powersources.end() ? lookup->second : NotDefined; } TEngineType TMoverParameters::LoadFIZ_EngineDecode(std::string const &Engine) const { + using enum TEngineType; - std::map enginetypes{{"ElectricSeriesMotor", TEngineType::ElectricSeriesMotor}, - {"DieselEngine", TEngineType::DieselEngine}, - {"SteamEngine", TEngineType::SteamEngine}, - {"WheelsDriven", TEngineType::WheelsDriven}, - {"Dumb", TEngineType::Dumb}, - {"DieselElectric", TEngineType::DieselElectric}, - {"DumbDE", TEngineType::DieselElectric}, - {"ElectricInductionMotor", TEngineType::ElectricInductionMotor}, - {"Main", TEngineType::Main}}; + std::map enginetypes{{"ElectricSeriesMotor", ElectricSeriesMotor}, + {"DieselEngine", DieselEngine}, + {"SteamEngine", SteamEngine}, + {"WheelsDriven", WheelsDriven}, + {"Dumb", Dumb}, + {"DieselElectric", DieselElectric}, + {"DumbDE", DieselElectric}, + {"ElectricInductionMotor", ElectricInductionMotor}, + {"Main", Main}}; auto lookup = enginetypes.find(Engine); - return lookup != enginetypes.end() ? lookup->second : TEngineType::None; + return lookup != enginetypes.end() ? lookup->second : None; } // ************************************************************************************************* @@ -11844,35 +11859,36 @@ bool TMoverParameters::CheckLocomotiveParameters(bool ReadyFlag, int /*Dir*/) switch (BrakeHandle) { - case TBrakeHandle::FV4a: + using enum TBrakeHandle; + case FV4a: Handle = std::make_shared(); break; - case TBrakeHandle::MHZ_EN57: - case TBrakeHandle::MHZ_K8P: + case MHZ_EN57: + case MHZ_K8P: Handle = std::make_shared(); break; - case TBrakeHandle::FVel6: + case FVel6: Handle = std::make_shared(); break; - case TBrakeHandle::FVE408: + case FVE408: Handle = std::make_shared(); break; - case TBrakeHandle::testH: + case testH: Handle = std::make_shared(); break; - case TBrakeHandle::M394: + case M394: Handle = std::make_shared(); break; - case TBrakeHandle::Knorr: + case Knorr: Handle = std::make_shared(); break; - case TBrakeHandle::St113: + case St113: Handle = std::make_shared(); break; - case TBrakeHandle::MHZ_K5P: + case MHZ_K5P: Handle = std::make_shared(); break; - case TBrakeHandle::MHZ_6P: + case MHZ_6P: Handle = std::make_shared(); break; default: diff --git a/audio/sound.cpp b/audio/sound.cpp index 01d982eb..18d2d107 100644 --- a/audio/sound.cpp +++ b/audio/sound.cpp @@ -233,13 +233,14 @@ sound_source::deserialize_mapping( cParser &Input ) { m_crossfaderange = std::clamp( m_crossfaderange, 0, 100 ); } else if( key == "placement:" ) { + using enum sound_placement; auto const value { Input.getToken( true, "\n\r\t ,;" ) }; std::map const placements { - { "internal", sound_placement::internal }, - { "engine", sound_placement::engine }, - { "external", sound_placement::external }, - { "custom", sound_placement::custom }, - { "general", sound_placement::general } }; + { "internal", internal }, + { "engine", engine }, + { "external", external }, + { "custom", custom }, + { "general", general } }; auto lookup{ placements.find( value ) }; if( lookup != placements.end() ) { m_placement = lookup->second; diff --git a/input/driverkeyboardinput.cpp b/input/driverkeyboardinput.cpp index 48c8c1fc..e7e636b3 100644 --- a/input/driverkeyboardinput.cpp +++ b/input/driverkeyboardinput.cpp @@ -22,276 +22,277 @@ driverkeyboard_input::init() { void driverkeyboard_input::default_bindings() { + using enum user_command; m_bindingsetups = { - { user_command::aidriverenable, {GLFW_KEY_Q | keymodifier::shift, ""} }, - { user_command::aidriverdisable, {GLFW_KEY_Q, ""} }, + { aidriverenable, {GLFW_KEY_Q | keymodifier::shift, ""} }, + { aidriverdisable, {GLFW_KEY_Q, ""} }, // jointcontrollerset, - { user_command::mastercontrollerincrease, {GLFW_KEY_KP_ADD, ""} }, - { user_command::mastercontrollerincreasefast, {GLFW_KEY_KP_ADD | keymodifier::shift, ""} }, - { user_command::mastercontrollerdecrease, {GLFW_KEY_KP_SUBTRACT, ""} }, - { user_command::mastercontrollerdecreasefast, {GLFW_KEY_KP_SUBTRACT | keymodifier::shift, ""} }, + { mastercontrollerincrease, {GLFW_KEY_KP_ADD, ""} }, + { mastercontrollerincreasefast, {GLFW_KEY_KP_ADD | keymodifier::shift, ""} }, + { mastercontrollerdecrease, {GLFW_KEY_KP_SUBTRACT, ""} }, + { mastercontrollerdecreasefast, {GLFW_KEY_KP_SUBTRACT | keymodifier::shift, ""} }, // mastercontrollerset, - { user_command::dynamicbrakecontrollerincrease, {GLFW_KEY_KP_3 | keymodifier::control, ""} }, - { user_command::dynamicbrakecontrollerdecrease, {GLFW_KEY_KP_9 | keymodifier::control, ""} }, + { dynamicbrakecontrollerincrease, {GLFW_KEY_KP_3 | keymodifier::control, ""} }, + { dynamicbrakecontrollerdecrease, {GLFW_KEY_KP_9 | keymodifier::control, ""} }, // mastercontrollerset, - { user_command::dynamicbrakecontrollerincreasefast, {GLFW_KEY_KP_3 | keymodifier::control | keymodifier::shift, ""} }, - { user_command::dynamicbrakecontrollerdecreasefast, {GLFW_KEY_KP_9 | keymodifier::control | keymodifier::shift, ""} }, + { dynamicbrakecontrollerincreasefast, {GLFW_KEY_KP_3 | keymodifier::control | keymodifier::shift, ""} }, + { dynamicbrakecontrollerdecreasefast, {GLFW_KEY_KP_9 | keymodifier::control | keymodifier::shift, ""} }, - { user_command::secondcontrollerincrease, {GLFW_KEY_KP_DIVIDE, ""} }, - { user_command::secondcontrollerincreasefast, {GLFW_KEY_KP_DIVIDE | keymodifier::shift, ""} }, - { user_command::secondcontrollerdecrease, {GLFW_KEY_KP_MULTIPLY, ""} }, - { user_command::secondcontrollerdecreasefast, {GLFW_KEY_KP_MULTIPLY | keymodifier::shift, ""} }, + { secondcontrollerincrease, {GLFW_KEY_KP_DIVIDE, ""} }, + { secondcontrollerincreasefast, {GLFW_KEY_KP_DIVIDE | keymodifier::shift, ""} }, + { secondcontrollerdecrease, {GLFW_KEY_KP_MULTIPLY, ""} }, + { secondcontrollerdecreasefast, {GLFW_KEY_KP_MULTIPLY | keymodifier::shift, ""} }, // secondcontrollerset, - { user_command::mucurrentindicatorothersourceactivate, {GLFW_KEY_Z | keymodifier::shift, ""} }, - { user_command::independentbrakeincrease, {GLFW_KEY_KP_1, ""} }, - { user_command::independentbrakeincreasefast, {GLFW_KEY_KP_1 | keymodifier::shift, ""} }, - { user_command::independentbrakedecrease, {GLFW_KEY_KP_7, ""} }, - { user_command::independentbrakedecreasefast, {GLFW_KEY_KP_7 | keymodifier::shift, ""} }, + { mucurrentindicatorothersourceactivate, {GLFW_KEY_Z | keymodifier::shift, ""} }, + { independentbrakeincrease, {GLFW_KEY_KP_1, ""} }, + { independentbrakeincreasefast, {GLFW_KEY_KP_1 | keymodifier::shift, ""} }, + { independentbrakedecrease, {GLFW_KEY_KP_7, ""} }, + { independentbrakedecreasefast, {GLFW_KEY_KP_7 | keymodifier::shift, ""} }, // independentbrakeset, - { user_command::independentbrakebailoff, {GLFW_KEY_KP_4, ""} }, + { independentbrakebailoff, {GLFW_KEY_KP_4, ""} }, // universalbrakebutton1, // universalbrakebutton2, // universalbrakebutton3, - { user_command::trainbrakeincrease, {GLFW_KEY_KP_3, ""} }, - { user_command::trainbrakedecrease, {GLFW_KEY_KP_9, ""} }, + { trainbrakeincrease, {GLFW_KEY_KP_3, ""} }, + { trainbrakedecrease, {GLFW_KEY_KP_9, ""} }, // trainbrakeset, - { user_command::trainbrakecharging, {GLFW_KEY_KP_DECIMAL, ""} }, - { user_command::trainbrakerelease, {GLFW_KEY_KP_6, ""} }, - { user_command::trainbrakefirstservice, {GLFW_KEY_KP_8, ""} }, - { user_command::trainbrakeservice, {GLFW_KEY_KP_5, ""} }, - { user_command::trainbrakefullservice, {GLFW_KEY_KP_2, ""} }, - { user_command::trainbrakehandleoff, {GLFW_KEY_KP_5 | keymodifier::control, ""} }, - { user_command::trainbrakeemergency, {GLFW_KEY_KP_0, ""} }, - { user_command::trainbrakebasepressureincrease, {GLFW_KEY_KP_3 | keymodifier::control, ""} }, - { user_command::trainbrakebasepressuredecrease, {GLFW_KEY_KP_9 | keymodifier::control, ""} }, - { user_command::trainbrakebasepressurereset, {GLFW_KEY_KP_6 | keymodifier::control, ""} }, - { user_command::trainbrakeoperationtoggle, {GLFW_KEY_KP_4 | keymodifier::control, ""} }, - { user_command::manualbrakeincrease, {GLFW_KEY_KP_1 | keymodifier::control, ""} }, - { user_command::manualbrakedecrease, {GLFW_KEY_KP_7 | keymodifier::control, ""} }, - { user_command::alarmchaintoggle, {GLFW_KEY_B | keymodifier::shift | keymodifier::control, ""} }, + { trainbrakecharging, {GLFW_KEY_KP_DECIMAL, ""} }, + { trainbrakerelease, {GLFW_KEY_KP_6, ""} }, + { trainbrakefirstservice, {GLFW_KEY_KP_8, ""} }, + { trainbrakeservice, {GLFW_KEY_KP_5, ""} }, + { trainbrakefullservice, {GLFW_KEY_KP_2, ""} }, + { trainbrakehandleoff, {GLFW_KEY_KP_5 | keymodifier::control, ""} }, + { trainbrakeemergency, {GLFW_KEY_KP_0, ""} }, + { trainbrakebasepressureincrease, {GLFW_KEY_KP_3 | keymodifier::control, ""} }, + { trainbrakebasepressuredecrease, {GLFW_KEY_KP_9 | keymodifier::control, ""} }, + { trainbrakebasepressurereset, {GLFW_KEY_KP_6 | keymodifier::control, ""} }, + { trainbrakeoperationtoggle, {GLFW_KEY_KP_4 | keymodifier::control, ""} }, + { manualbrakeincrease, {GLFW_KEY_KP_1 | keymodifier::control, ""} }, + { manualbrakedecrease, {GLFW_KEY_KP_7 | keymodifier::control, ""} }, + { alarmchaintoggle, {GLFW_KEY_B | keymodifier::shift | keymodifier::control, ""} }, // alarmchainenable, // alarmchaindisable, - { user_command::wheelspinbrakeactivate, {GLFW_KEY_KP_ENTER, ""} }, - { user_command::sandboxactivate, {GLFW_KEY_S | keymodifier::shift, ""} }, + { wheelspinbrakeactivate, {GLFW_KEY_KP_ENTER, ""} }, + { sandboxactivate, {GLFW_KEY_S | keymodifier::shift, ""} }, // autosandboxtoggle, // autosandboxactivate, // autosandboxdeactivate, - { user_command::reverserincrease, {GLFW_KEY_D, ""} }, - { user_command::reverserdecrease, {GLFW_KEY_R, ""} }, + { reverserincrease, {GLFW_KEY_D, ""} }, + { reverserdecrease, {GLFW_KEY_R, ""} }, // reverserforwardhigh, // reverserforward, // reverserneutral, // reverserbackward, - { user_command::waterpumpbreakertoggle, {GLFW_KEY_W | keymodifier::control, ""} }, + { waterpumpbreakertoggle, {GLFW_KEY_W | keymodifier::control, ""} }, // waterpumpbreakerclose, // waterpumpbreakeropen, - { user_command::waterpumptoggle, {GLFW_KEY_W, ""} }, + { waterpumptoggle, {GLFW_KEY_W, ""} }, // waterpumpenable, // waterpumpdisable, - { user_command::waterheaterbreakertoggle, {GLFW_KEY_W | keymodifier::control | keymodifier::shift, ""} }, + { waterheaterbreakertoggle, {GLFW_KEY_W | keymodifier::control | keymodifier::shift, ""} }, // waterheaterbreakerclose, // waterheaterbreakeropen, - { user_command::waterheatertoggle, {GLFW_KEY_W | keymodifier::shift, ""} }, + { waterheatertoggle, {GLFW_KEY_W | keymodifier::shift, ""} }, // waterheaterenable, // waterheaterdisable, - { user_command::watercircuitslinktoggle, {GLFW_KEY_H | keymodifier::shift, ""} }, + { watercircuitslinktoggle, {GLFW_KEY_H | keymodifier::shift, ""} }, // watercircuitslinkenable, // watercircuitslinkdisable, - { user_command::fuelpumptoggle, {GLFW_KEY_F, ""} }, + { fuelpumptoggle, {GLFW_KEY_F, ""} }, // fuelpumpenable, // fuelpumpdisable, - { user_command::oilpumptoggle, {GLFW_KEY_F | keymodifier::shift, ""} }, + { oilpumptoggle, {GLFW_KEY_F | keymodifier::shift, ""} }, // oilpumpenable, // oilpumpdisable, - { user_command::linebreakertoggle, {GLFW_KEY_M, ""} }, + { linebreakertoggle, {GLFW_KEY_M, ""} }, // linebreakeropen, // linebreakerclose, - { user_command::convertertoggle, {GLFW_KEY_X, ""} }, + { convertertoggle, {GLFW_KEY_X, ""} }, // converterenable, // converterdisable, - { user_command::convertertogglelocal, {GLFW_KEY_X | keymodifier::shift, ""} }, - { user_command::converteroverloadrelayreset, {GLFW_KEY_N | keymodifier::control, ""} }, - { user_command::compressortoggle, {GLFW_KEY_C, ""} }, + { convertertogglelocal, {GLFW_KEY_X | keymodifier::shift, ""} }, + { converteroverloadrelayreset, {GLFW_KEY_N | keymodifier::control, ""} }, + { compressortoggle, {GLFW_KEY_C, ""} }, // compressorenable, // compressordisable, - { user_command::compressortogglelocal, {GLFW_KEY_C | keymodifier::shift, ""} }, + { compressortogglelocal, {GLFW_KEY_C | keymodifier::shift, ""} }, // compressorpresetactivatenext, // compressorpresetactivateprevious, // compressorpresetactivatedefault, - { user_command::motoroverloadrelaythresholdtoggle, {GLFW_KEY_F | keymodifier::control, ""} }, + { motoroverloadrelaythresholdtoggle, {GLFW_KEY_F | keymodifier::control, ""} }, // motoroverloadrelaythresholdsetlow, // motoroverloadrelaythresholdsethigh, - { user_command::motoroverloadrelayreset, {GLFW_KEY_N, ""} }, + { motoroverloadrelayreset, {GLFW_KEY_N, ""} }, // universalrelayreset1, // universalrelayreset2, // universalrelayreset3, - { user_command::notchingrelaytoggle, {GLFW_KEY_G, ""} }, - { user_command::epbrakecontroltoggle, {GLFW_KEY_Z | keymodifier::control, ""} }, + { notchingrelaytoggle, {GLFW_KEY_G, ""} }, + { epbrakecontroltoggle, {GLFW_KEY_Z | keymodifier::control, ""} }, // epbrakecontrolenable // epbrakecontroldisable - { user_command::trainbrakeoperationmodeincrease, {GLFW_KEY_KP_2 | keymodifier::control, ""} }, - { user_command::trainbrakeoperationmodedecrease, {GLFW_KEY_KP_8 | keymodifier::control, ""} }, - { user_command::brakeactingspeedincrease, {GLFW_KEY_B | keymodifier::shift, ""} }, - { user_command::brakeactingspeeddecrease, {GLFW_KEY_B, ""} }, + { trainbrakeoperationmodeincrease, {GLFW_KEY_KP_2 | keymodifier::control, ""} }, + { trainbrakeoperationmodedecrease, {GLFW_KEY_KP_8 | keymodifier::control, ""} }, + { brakeactingspeedincrease, {GLFW_KEY_B | keymodifier::shift, ""} }, + { brakeactingspeeddecrease, {GLFW_KEY_B, ""} }, // brakeactingspeedsetcargo, // brakeactingspeedsetpassenger, // brakeactingspeedsetrapid, - { user_command::brakeloadcompensationincrease, {GLFW_KEY_H | keymodifier::shift | keymodifier::control, ""} }, - { user_command::brakeloadcompensationdecrease, {GLFW_KEY_H | keymodifier::control, ""} }, - { user_command::mubrakingindicatortoggle, {GLFW_KEY_L | keymodifier::shift, ""} }, - { user_command::alerteracknowledge, {GLFW_KEY_SPACE, ""} }, - { user_command::hornlowactivate, {GLFW_KEY_A, ""} }, - { user_command::hornhighactivate, {GLFW_KEY_S, ""} }, - { user_command::whistleactivate, {GLFW_KEY_Z, ""} }, - { user_command::radiotoggle, {GLFW_KEY_R | keymodifier::control, ""} }, + { brakeloadcompensationincrease, {GLFW_KEY_H | keymodifier::shift | keymodifier::control, ""} }, + { brakeloadcompensationdecrease, {GLFW_KEY_H | keymodifier::control, ""} }, + { mubrakingindicatortoggle, {GLFW_KEY_L | keymodifier::shift, ""} }, + { alerteracknowledge, {GLFW_KEY_SPACE, ""} }, + { hornlowactivate, {GLFW_KEY_A, ""} }, + { hornhighactivate, {GLFW_KEY_S, ""} }, + { whistleactivate, {GLFW_KEY_Z, ""} }, + { radiotoggle, {GLFW_KEY_R | keymodifier::control, ""} }, // radioenable // radiodisable - { user_command::radiochannelincrease, {GLFW_KEY_EQUAL, ""} }, - { user_command::radiochanneldecrease, {GLFW_KEY_MINUS, ""} }, + { radiochannelincrease, {GLFW_KEY_EQUAL, ""} }, + { radiochanneldecrease, {GLFW_KEY_MINUS, ""} }, // radiochannelset - { user_command::radiostopsend, {GLFW_KEY_PAUSE | keymodifier::shift | keymodifier::control, ""} }, + { radiostopsend, {GLFW_KEY_PAUSE | keymodifier::shift | keymodifier::control, ""} }, // radiostopenable // radiostopdisable - { user_command::radiostoptest, {GLFW_KEY_R | keymodifier::shift | keymodifier::control, ""} }, - { user_command::radiocall3send, {GLFW_KEY_BACKSPACE, ""} }, + { radiostoptest, {GLFW_KEY_R | keymodifier::shift | keymodifier::control, ""} }, + { radiocall3send, {GLFW_KEY_BACKSPACE, ""} }, // radiovolumeincrease, // radiovolumedecrease, // radiovolumeset, - { user_command::cabchangeforward, {GLFW_KEY_HOME, ""} }, - { user_command::cabchangebackward, {GLFW_KEY_END, ""} }, + { cabchangeforward, {GLFW_KEY_HOME, ""} }, + { cabchangebackward, {GLFW_KEY_END, ""} }, // viewturn, // movehorizontal, // movehorizontalfast, // movevertical, // moveverticalfast, - { user_command::moveleft, {GLFW_KEY_LEFT, "Move left"} }, - { user_command::moveright, {GLFW_KEY_RIGHT, "Move right"} }, - { user_command::moveforward, {GLFW_KEY_UP, "Move forwards"} }, - { user_command::moveback, {GLFW_KEY_DOWN, "Move backwards"} }, - { user_command::moveup, {GLFW_KEY_PAGE_UP, "Move up"} }, - { user_command::movedown, {GLFW_KEY_PAGE_DOWN, "Move down"} }, - { user_command::nearestcarcouplingincrease, {GLFW_KEY_INSERT, ""} }, - { user_command::nearestcarcouplingdisconnect, {GLFW_KEY_DELETE, ""} }, - { user_command::nearestcarcoupleradapterattach, {GLFW_KEY_INSERT | keymodifier::control, ""} }, - { user_command::nearestcarcoupleradapterremove, {GLFW_KEY_DELETE | keymodifier::control, ""} }, - { user_command::occupiedcarcouplingdisconnect, {GLFW_KEY_DELETE | keymodifier::shift, ""} }, - { user_command::doortoggleleft, {GLFW_KEY_COMMA, ""} }, - { user_command::doortoggleright, {GLFW_KEY_PERIOD, ""} }, - { user_command::doorpermitleft, {GLFW_KEY_COMMA | keymodifier::shift, ""} }, - { user_command::doorpermitright, {GLFW_KEY_PERIOD | keymodifier::shift, ""} }, - { user_command::doorpermitpresetactivatenext, {GLFW_KEY_PERIOD | keymodifier::shift | keymodifier::control, ""} }, - { user_command::doorpermitpresetactivateprevious, {GLFW_KEY_COMMA | keymodifier::shift | keymodifier::control, ""} }, + { moveleft, {GLFW_KEY_LEFT, "Move left"} }, + { moveright, {GLFW_KEY_RIGHT, "Move right"} }, + { moveforward, {GLFW_KEY_UP, "Move forwards"} }, + { moveback, {GLFW_KEY_DOWN, "Move backwards"} }, + { moveup, {GLFW_KEY_PAGE_UP, "Move up"} }, + { movedown, {GLFW_KEY_PAGE_DOWN, "Move down"} }, + { nearestcarcouplingincrease, {GLFW_KEY_INSERT, ""} }, + { nearestcarcouplingdisconnect, {GLFW_KEY_DELETE, ""} }, + { nearestcarcoupleradapterattach, {GLFW_KEY_INSERT | keymodifier::control, ""} }, + { nearestcarcoupleradapterremove, {GLFW_KEY_DELETE | keymodifier::control, ""} }, + { occupiedcarcouplingdisconnect, {GLFW_KEY_DELETE | keymodifier::shift, ""} }, + { doortoggleleft, {GLFW_KEY_COMMA, ""} }, + { doortoggleright, {GLFW_KEY_PERIOD, ""} }, + { doorpermitleft, {GLFW_KEY_COMMA | keymodifier::shift, ""} }, + { doorpermitright, {GLFW_KEY_PERIOD | keymodifier::shift, ""} }, + { doorpermitpresetactivatenext, {GLFW_KEY_PERIOD | keymodifier::shift | keymodifier::control, ""} }, + { doorpermitpresetactivateprevious, {GLFW_KEY_COMMA | keymodifier::shift | keymodifier::control, ""} }, // dooropenleft, // dooropenright, - { user_command::dooropenall, {GLFW_KEY_SLASH | keymodifier::shift, ""} }, + { dooropenall, {GLFW_KEY_SLASH | keymodifier::shift, ""} }, // doorcloseleft, // doorcloseright, - { user_command::doorcloseall, {GLFW_KEY_SLASH | keymodifier::control, ""} }, + { doorcloseall, {GLFW_KEY_SLASH | keymodifier::control, ""} }, // doorsteptoggle, - { user_command::doormodetoggle, {GLFW_KEY_SLASH | keymodifier::shift | keymodifier::control, ""} }, + { doormodetoggle, {GLFW_KEY_SLASH | keymodifier::shift | keymodifier::control, ""} }, // mirrorstoggle, - { user_command::departureannounce, {GLFW_KEY_SLASH, ""} }, - { user_command::doorlocktoggle, {GLFW_KEY_S | keymodifier::control, ""} }, - { user_command::pantographcompressorvalvetoggle, {GLFW_KEY_V | keymodifier::control, ""} }, + { departureannounce, {GLFW_KEY_SLASH, ""} }, + { doorlocktoggle, {GLFW_KEY_S | keymodifier::control, ""} }, + { pantographcompressorvalvetoggle, {GLFW_KEY_V | keymodifier::control, ""} }, // pantographcompressorvalveenable, // pantographcompressorvalvedisable, - { user_command::pantographcompressoractivate, {GLFW_KEY_V | keymodifier::shift, ""} }, - { user_command::pantographtogglefront, {GLFW_KEY_P, ""} }, - { user_command::pantographtogglerear, {GLFW_KEY_O, ""} }, + { pantographcompressoractivate, {GLFW_KEY_V | keymodifier::shift, ""} }, + { pantographtogglefront, {GLFW_KEY_P, ""} }, + { pantographtogglerear, {GLFW_KEY_O, ""} }, // pantographraisefront, // pantographraiserear, // pantographlowerfront, // pantographlowerrear, - { user_command::pantographlowerall, {GLFW_KEY_P | keymodifier::control, ""} }, - { user_command::pantographselectnext, {GLFW_KEY_P | keymodifier::shift, ""} }, - { user_command::pantographselectprevious, {GLFW_KEY_O | keymodifier::shift, ""} }, - { user_command::pantographtoggleselected, {GLFW_KEY_O | keymodifier::shift | keymodifier::control, ""} }, + { pantographlowerall, {GLFW_KEY_P | keymodifier::control, ""} }, + { pantographselectnext, {GLFW_KEY_P | keymodifier::shift, ""} }, + { pantographselectprevious, {GLFW_KEY_O | keymodifier::shift, ""} }, + { pantographtoggleselected, {GLFW_KEY_O | keymodifier::shift | keymodifier::control, ""} }, // pantographraiseselected, // pantographlowerselected, // pantographvalvesupdate, // pantographvalvesoff, - { user_command::heatingtoggle, {GLFW_KEY_H, ""} }, + { heatingtoggle, {GLFW_KEY_H, ""} }, // heatingenable, // heatingdisable, - { user_command::lightspresetactivatenext, {GLFW_KEY_T | keymodifier::shift, ""} }, - { user_command::lightspresetactivateprevious, {GLFW_KEY_T, ""} }, - { user_command::headlighttoggleleft, {GLFW_KEY_Y, ""} }, + { lightspresetactivatenext, {GLFW_KEY_T | keymodifier::shift, ""} }, + { lightspresetactivateprevious, {GLFW_KEY_T, ""} }, + { headlighttoggleleft, {GLFW_KEY_Y, ""} }, // headlightenableleft, // headlightdisableleft, - { user_command::headlighttoggleright, {GLFW_KEY_I, ""} }, + { headlighttoggleright, {GLFW_KEY_I, ""} }, // headlightenableright, // headlightdisableright, - { user_command::headlighttoggleupper, {GLFW_KEY_U, ""} }, + { headlighttoggleupper, {GLFW_KEY_U, ""} }, // headlightenableupper, // headlightdisableupper, - { user_command::redmarkertoggleleft, {GLFW_KEY_Y | keymodifier::shift, ""} }, + { redmarkertoggleleft, {GLFW_KEY_Y | keymodifier::shift, ""} }, // redmarkerenableleft, // redmarkerdisableleft, - { user_command::redmarkertoggleright, {GLFW_KEY_I | keymodifier::shift, ""} }, + { redmarkertoggleright, {GLFW_KEY_I | keymodifier::shift, ""} }, // redmarkerenableright, // redmarkerdisableright, - { user_command::headlighttogglerearleft, {GLFW_KEY_Y | keymodifier::control, ""} }, + { headlighttogglerearleft, {GLFW_KEY_Y | keymodifier::control, ""} }, // headlightenablerearleft // headlightdisablerearleft - { user_command::headlighttogglerearright, {GLFW_KEY_I | keymodifier::control, ""} }, + { headlighttogglerearright, {GLFW_KEY_I | keymodifier::control, ""} }, // headlightenablerearright // headlightdisablerearright - { user_command::headlighttogglerearupper, {GLFW_KEY_U | keymodifier::control, ""} }, + { headlighttogglerearupper, {GLFW_KEY_U | keymodifier::control, ""} }, // headlightenablerearupper // headlightdisablerearupper - { user_command::redmarkertogglerearleft, {GLFW_KEY_Y | keymodifier::control | keymodifier::shift, ""} }, + { redmarkertogglerearleft, {GLFW_KEY_Y | keymodifier::control | keymodifier::shift, ""} }, // redmarkerenablerearleft // redmarkerdisablerearleft - { user_command::redmarkertogglerearright, {GLFW_KEY_I | keymodifier::control | keymodifier::shift, ""} }, + { redmarkertogglerearright, {GLFW_KEY_I | keymodifier::control | keymodifier::shift, ""} }, // redmarkerenablerearright // redmarkerdisablerearright - { user_command::redmarkerstoggle, {GLFW_KEY_E | keymodifier::shift, ""} }, - { user_command::endsignalstoggle, {GLFW_KEY_E, ""} }, - { user_command::headlightsdimtoggle, {GLFW_KEY_L | keymodifier::control, ""} }, + { redmarkerstoggle, {GLFW_KEY_E | keymodifier::shift, ""} }, + { endsignalstoggle, {GLFW_KEY_E, ""} }, + { headlightsdimtoggle, {GLFW_KEY_L | keymodifier::control, ""} }, // headlightsdimenable, // headlightsdimdisable, - { user_command::motorconnectorsopen, {GLFW_KEY_L, ""} }, + { motorconnectorsopen, {GLFW_KEY_L, ""} }, // motorconnectorsclose, - { user_command::motordisconnect, {GLFW_KEY_E | keymodifier::control, ""} }, - { user_command::interiorlighttoggle, {GLFW_KEY_APOSTROPHE, ""} }, + { motordisconnect, {GLFW_KEY_E | keymodifier::control, ""} }, + { interiorlighttoggle, {GLFW_KEY_APOSTROPHE, ""} }, // interiorlightenable, // interiorlightdisable, - { user_command::interiorlightdimtoggle, {GLFW_KEY_APOSTROPHE | keymodifier::control, ""} }, + { interiorlightdimtoggle, {GLFW_KEY_APOSTROPHE | keymodifier::control, ""} }, // interiorlightdimenable, // interiorlightdimdisable, // compartmentlightstoggle, // compartmentlightsenable, // compartmentlightsdisable, - { user_command::instrumentlighttoggle, {GLFW_KEY_SEMICOLON, ""} }, + { instrumentlighttoggle, {GLFW_KEY_SEMICOLON, ""} }, // instrumentlightenable, // instrumentlightdisable, - { user_command::dashboardlighttoggle, {GLFW_KEY_SEMICOLON | keymodifier::shift, ""} }, + { dashboardlighttoggle, {GLFW_KEY_SEMICOLON | keymodifier::shift, ""} }, // dashboardlightenable // dashboardlightdisable - { user_command::timetablelighttoggle, {GLFW_KEY_APOSTROPHE | keymodifier::shift, ""} }, + { timetablelighttoggle, {GLFW_KEY_APOSTROPHE | keymodifier::shift, ""} }, // timetablelightenable // timetablelightdisable - { user_command::generictoggle0, {GLFW_KEY_0, ""} }, - { user_command::generictoggle1, {GLFW_KEY_1, ""} }, - { user_command::generictoggle2, {GLFW_KEY_2, ""} }, - { user_command::generictoggle3, {GLFW_KEY_3, ""} }, - { user_command::generictoggle4, {GLFW_KEY_4, ""} }, - { user_command::generictoggle5, {GLFW_KEY_5, ""} }, - { user_command::generictoggle6, {GLFW_KEY_6, ""} }, - { user_command::generictoggle7, {GLFW_KEY_7, ""} }, - { user_command::generictoggle8, {GLFW_KEY_8, ""} }, - { user_command::generictoggle9, {GLFW_KEY_9, ""} }, - { user_command::batterytoggle, {GLFW_KEY_J, ""} }, + { generictoggle0, {GLFW_KEY_0, ""} }, + { generictoggle1, {GLFW_KEY_1, ""} }, + { generictoggle2, {GLFW_KEY_2, ""} }, + { generictoggle3, {GLFW_KEY_3, ""} }, + { generictoggle4, {GLFW_KEY_4, ""} }, + { generictoggle5, {GLFW_KEY_5, ""} }, + { generictoggle6, {GLFW_KEY_6, ""} }, + { generictoggle7, {GLFW_KEY_7, ""} }, + { generictoggle8, {GLFW_KEY_8, ""} }, + { generictoggle9, {GLFW_KEY_9, ""} }, + { batterytoggle, {GLFW_KEY_J, ""} }, // batteryenable, // batterydisable, // cabactivationtoggle, // cabactivationenable, // cabactivationdisable, - { user_command::motorblowerstogglefront, {GLFW_KEY_N | keymodifier::shift, ""} }, - { user_command::motorblowerstogglerear, {GLFW_KEY_M | keymodifier::shift, ""} }, - { user_command::motorblowersdisableall, {GLFW_KEY_M | keymodifier::control, ""} }, + { motorblowerstogglefront, {GLFW_KEY_N | keymodifier::shift, ""} }, + { motorblowerstogglerear, {GLFW_KEY_M | keymodifier::shift, ""} }, + { motorblowersdisableall, {GLFW_KEY_M | keymodifier::control, ""} }, // coolingfanstoggle, // tempomattoggle, // springbraketoggle, @@ -317,14 +318,14 @@ driverkeyboard_input::default_bindings() { // speedcontrolbutton8, // speedcontrolbutton9, // admin_timejump, - { user_command::timejumplarge, {GLFW_KEY_F1 | keymodifier::control, "Big time jump (Debug Mode only)"} }, - { user_command::timejumpsmall, {GLFW_KEY_F1 | keymodifier::shift, "Small time jump (Debug Mode only)"} }, + { timejumplarge, {GLFW_KEY_F1 | keymodifier::control, "Big time jump (Debug Mode only)"} }, + { timejumpsmall, {GLFW_KEY_F1 | keymodifier::shift, "Small time jump (Debug Mode only)"} }, // admin_vehiclemove, - { user_command::vehiclemoveforwards, {GLFW_KEY_LEFT_BRACKET | keymodifier::control, "Move the train forwards (Debug Mode only)"} }, - { user_command::vehiclemovebackwards, {GLFW_KEY_RIGHT_BRACKET | keymodifier::control, "Move the train backwards (Debug Mode only)"} }, - { user_command::vehicleboost, {GLFW_KEY_TAB | keymodifier::control, "Boost the train (Debug Mode only)"} }, - { user_command::debugtoggle, {GLFW_KEY_F12 | keymodifier::control | keymodifier::shift, "Toggle Debug Mode"} }, - { user_command::pausetoggle, {GLFW_KEY_ESCAPE, "Pause the game"} } + { vehiclemoveforwards, {GLFW_KEY_LEFT_BRACKET | keymodifier::control, "Move the train forwards (Debug Mode only)"} }, + { vehiclemovebackwards, {GLFW_KEY_RIGHT_BRACKET | keymodifier::control, "Move the train backwards (Debug Mode only)"} }, + { vehicleboost, {GLFW_KEY_TAB | keymodifier::control, "Boost the train (Debug Mode only)"} }, + { debugtoggle, {GLFW_KEY_F12 | keymodifier::control | keymodifier::shift, "Toggle Debug Mode"} }, + { pausetoggle, {GLFW_KEY_ESCAPE, "Pause the game"} } }; } diff --git a/input/drivermouseinput.cpp b/input/drivermouseinput.cpp index 1b481afe..13e444ad 100644 --- a/input/drivermouseinput.cpp +++ b/input/drivermouseinput.cpp @@ -32,14 +32,15 @@ mouse_slider::bind( user_command const &Command ) { auto const *train { simulation::Train }; TMoverParameters const *vehicle { nullptr }; switch( m_command ) { - case user_command::jointcontrollerset: - case user_command::mastercontrollerset: - case user_command::secondcontrollerset: { + using enum user_command; + case jointcontrollerset: + case mastercontrollerset: + case secondcontrollerset: { vehicle = train ? train->Controlled() : nullptr; break; } - case user_command::trainbrakeset: - case user_command::independentbrakeset: { + case trainbrakeset: + case independentbrakeset: { vehicle = train ? train->Occupied() : nullptr; break; } @@ -356,6 +357,7 @@ drivermouse_input::button( int const Button, int const Action ) { m_pickwaiting = true; GfxRenderer->Pick_Control_Callback( [this, Button, Action, &mousecommand](TSubModel const *controlsubmodel, const glm::vec2 pos) { + using enum user_command; bool pickwaiting = m_pickwaiting; m_pickwaiting = false; @@ -371,7 +373,7 @@ drivermouse_input::button( int const Button, int const Action ) { // if the recognized element under the cursor has a command associated with the pressed button, notify the recipient mousecommand = Button == GLFW_MOUSE_BUTTON_LEFT ? leftbinding : rightbinding; - if( mousecommand == user_command::none ) { + if( mousecommand == none ) { // if we don't have any recognized element under the cursor and the right button was pressed, enter view panning mode if( Button == GLFW_MOUSE_BUTTON_RIGHT ) { m_pickmodepanning = true; @@ -381,38 +383,38 @@ drivermouse_input::button( int const Button, int const Action ) { // check manually for commands which have 'fast' variants launched with shift modifier if( Global.shiftState ) { switch( mousecommand ) { - case user_command::mastercontrollerincrease: { mousecommand = user_command::mastercontrollerincreasefast; break; } - case user_command::mastercontrollerdecrease: { mousecommand = user_command::mastercontrollerdecreasefast; break; } - case user_command::secondcontrollerincrease: { mousecommand = user_command::secondcontrollerincreasefast; break; } - case user_command::secondcontrollerdecrease: { mousecommand = user_command::secondcontrollerdecreasefast; break; } - case user_command::independentbrakeincrease: { mousecommand = user_command::independentbrakeincreasefast; break; } - case user_command::independentbrakedecrease: { mousecommand = user_command::independentbrakedecreasefast; break; } + case mastercontrollerincrease: { mousecommand = mastercontrollerincreasefast; break; } + case mastercontrollerdecrease: { mousecommand = mastercontrollerdecreasefast; break; } + case secondcontrollerincrease: { mousecommand = secondcontrollerincreasefast; break; } + case secondcontrollerdecrease: { mousecommand = secondcontrollerdecreasefast; break; } + case independentbrakeincrease: { mousecommand = independentbrakeincreasefast; break; } + case independentbrakedecrease: { mousecommand = independentbrakedecreasefast; break; } default: { break; } } } switch( mousecommand ) { - case user_command::mastercontrollerincrease: - case user_command::mastercontrollerdecrease: - case user_command::secondcontrollerincrease: - case user_command::secondcontrollerdecrease: - case user_command::trainbrakeincrease: - case user_command::trainbrakedecrease: - case user_command::independentbrakeincrease: - case user_command::independentbrakedecrease: { + case mastercontrollerincrease: + case mastercontrollerdecrease: + case secondcontrollerincrease: + case secondcontrollerdecrease: + case trainbrakeincrease: + case trainbrakedecrease: + case independentbrakeincrease: + case independentbrakedecrease: { // these commands trigger varying repeat rate mode, // which scales the rate based on the distance of the cursor from its point when the command was first issued m_varyingpollrateorigin = m_cursorposition; m_varyingpollrate = true; break; } - case user_command::jointcontrollerset: - case user_command::mastercontrollerset: - case user_command::secondcontrollerset: - case user_command::trainbrakeset: - case user_command::independentbrakeset: { + case jointcontrollerset: + case mastercontrollerset: + case secondcontrollerset: + case trainbrakeset: + case independentbrakeset: { m_slider.bind( mousecommand ); - mousecommand = user_command::none; + mousecommand = none; return; } default: { @@ -486,624 +488,625 @@ drivermouse_input::bindings( std::string const &Control ) const { void drivermouse_input::default_bindings() { + using enum user_command; // pierwsza komenda jest od zwiekszania a druga od zmniejszania - ewentualnie kolejno lewy i prawy przycisk m_buttonbindings = { { "jointctrl:", { - user_command::jointcontrollerset, - user_command::none } }, + jointcontrollerset, + none } }, { "mainctrl:", { - user_command::mastercontrollerset, - user_command::none } }, + mastercontrollerset, + none } }, { "dynamicbrakectrl:", { - user_command::dynamicbrakecontrollerset, - user_command::none } }, + dynamicbrakecontrollerset, + none } }, { "scndctrl:", { - user_command::secondcontrollerset, - user_command::none } }, + secondcontrollerset, + none } }, { "shuntmodepower:", { - user_command::secondcontrollerincrease, - user_command::secondcontrollerdecrease } }, + secondcontrollerincrease, + secondcontrollerdecrease } }, { "tempomat_sw:", { - user_command::tempomattoggle, - user_command::none } }, + tempomattoggle, + none } }, { "tempomatoff_sw:", { - user_command::tempomattoggle, - user_command::none } }, + tempomattoggle, + none } }, { "dirkey:", { - user_command::reverserincrease, - user_command::reverserdecrease } }, + reverserincrease, + reverserdecrease } }, { "dirforward_bt:", { - user_command::reverserforward, - user_command::none } }, + reverserforward, + none } }, { "dirneutral_bt:", { - user_command::reverserneutral, - user_command::none } }, + reverserneutral, + none } }, { "dirbackward_bt:", { - user_command::reverserbackward, - user_command::none } }, + reverserbackward, + none } }, { "brakectrl:", { - user_command::trainbrakeset, - user_command::none } }, + trainbrakeset, + none } }, { "localbrake:", { - user_command::independentbrakeset, - user_command::none } }, + independentbrakeset, + none } }, { "manualbrake:", { - user_command::manualbrakeincrease, - user_command::manualbrakedecrease } }, + manualbrakeincrease, + manualbrakedecrease } }, { "alarmchain:", { - user_command::alarmchaintoggle, - user_command::none } }, + alarmchaintoggle, + none } }, { "alarmchainon:", { - user_command::alarmchainenable, - user_command::none} }, + alarmchainenable, + none} }, { "alarmchainoff:", { - user_command::alarmchainenable, - user_command::none} }, + alarmchainenable, + none} }, { "brakeprofile_sw:", { - user_command::brakeactingspeedincrease, - user_command::brakeactingspeeddecrease } }, + brakeactingspeedincrease, + brakeactingspeeddecrease } }, // TODO: dedicated methods for braking speed switches { "brakeprofileg_sw:", { - user_command::brakeactingspeedsetcargo, - user_command::brakeactingspeedsetpassenger } }, + brakeactingspeedsetcargo, + brakeactingspeedsetpassenger } }, { "brakeprofiler_sw:", { - user_command::brakeactingspeedsetrapid, - user_command::brakeactingspeedsetpassenger } }, + brakeactingspeedsetrapid, + brakeactingspeedsetpassenger } }, { "brakeopmode_sw:", { - user_command::trainbrakeoperationmodeincrease, - user_command::trainbrakeoperationmodedecrease } }, + trainbrakeoperationmodeincrease, + trainbrakeoperationmodedecrease } }, { "maxcurrent_sw:", { - user_command::motoroverloadrelaythresholdtoggle, - user_command::none } }, + motoroverloadrelaythresholdtoggle, + none } }, { "waterpumpbreaker_sw:", { - user_command::waterpumpbreakertoggle, - user_command::none } }, + waterpumpbreakertoggle, + none } }, { "waterpump_sw:", { - user_command::waterpumptoggle, - user_command::none } }, + waterpumptoggle, + none } }, { "waterheaterbreaker_sw:", { - user_command::waterheaterbreakertoggle, - user_command::none } }, + waterheaterbreakertoggle, + none } }, { "waterheater_sw:", { - user_command::waterheatertoggle, - user_command::none } }, + waterheatertoggle, + none } }, { "fuelpump_sw:", { - user_command::fuelpumptoggle, - user_command::none } }, + fuelpumptoggle, + none } }, { "oilpump_sw:", { - user_command::oilpumptoggle, - user_command::none } }, + oilpumptoggle, + none } }, { "motorblowersfront_sw:", { - user_command::motorblowerstogglefront, - user_command::none } }, + motorblowerstogglefront, + none } }, { "motorblowersrear_sw:", { - user_command::motorblowerstogglerear, - user_command::none } }, + motorblowerstogglerear, + none } }, { "motorblowersalloff_sw:", { - user_command::motorblowersdisableall, - user_command::none } }, + motorblowersdisableall, + none } }, { "coolingfans_sw:", { - user_command::coolingfanstoggle, - user_command::none } }, + coolingfanstoggle, + none } }, { "main_off_bt:", { - user_command::linebreakeropen, - user_command::none } }, + linebreakeropen, + none } }, { "main_on_bt:",{ - user_command::linebreakerclose, - user_command::none } }, + linebreakerclose, + none } }, { "security_reset_bt:", { - user_command::alerteracknowledge, - user_command::none } }, + alerteracknowledge, + none } }, { "shp_reset_bt:", { - user_command::cabsignalacknowledge, - user_command::none } }, + cabsignalacknowledge, + none } }, { "releaser_bt:", { - user_command::independentbrakebailoff, - user_command::none } }, + independentbrakebailoff, + none } }, { "springbraketoggle_bt:",{ - user_command::springbraketoggle, - user_command::none } }, + springbraketoggle, + none } }, { "springbrakeon_bt:",{ - user_command::springbrakeenable, - user_command::none } }, + springbrakeenable, + none } }, { "springbrakeoff_bt:",{ - user_command::springbrakedisable, - user_command::none } }, + springbrakedisable, + none } }, { "universalbrake1_bt:",{ - user_command::universalbrakebutton1, - user_command::none } }, + universalbrakebutton1, + none } }, { "universalbrake2_bt:",{ - user_command::universalbrakebutton2, - user_command::none } }, + universalbrakebutton2, + none } }, { "universalbrake3_bt:",{ - user_command::universalbrakebutton3, - user_command::none } }, + universalbrakebutton3, + none } }, { "epbrake_bt:",{ - user_command::epbrakecontroltoggle, - user_command::none } }, + epbrakecontroltoggle, + none } }, { "epbrakeon_bt:",{ - user_command::epbrakecontrolenable, - user_command::none } }, + epbrakecontrolenable, + none } }, { "epbrakeoff_bt:",{ - user_command::epbrakecontroldisable, - user_command::none } }, + epbrakecontroldisable, + none } }, { "sand_bt:", { - user_command::sandboxactivate, - user_command::none } }, + sandboxactivate, + none } }, { "antislip_bt:", { - user_command::wheelspinbrakeactivate, - user_command::none } }, + wheelspinbrakeactivate, + none } }, { "horn_bt:", { - user_command::hornhighactivate, - user_command::hornlowactivate } }, + hornhighactivate, + hornlowactivate } }, { "hornlow_bt:", { - user_command::hornlowactivate, - user_command::none } }, + hornlowactivate, + none } }, { "hornhigh_bt:", { - user_command::hornhighactivate, - user_command::none } }, + hornhighactivate, + none } }, { "whistle_bt:", { - user_command::whistleactivate, - user_command::none } }, + whistleactivate, + none } }, { "fuse_bt:", { - user_command::motoroverloadrelayreset, - user_command::none } }, + motoroverloadrelayreset, + none } }, { "converterfuse_bt:", { - user_command::converteroverloadrelayreset, - user_command::none } }, + converteroverloadrelayreset, + none } }, { "relayreset1_bt:", { - user_command::universalrelayreset1, - user_command::none } }, + universalrelayreset1, + none } }, { "relayreset2_bt:", { - user_command::universalrelayreset2, - user_command::none } }, + universalrelayreset2, + none } }, { "relayreset3_bt:", { - user_command::universalrelayreset3, - user_command::none } }, + universalrelayreset3, + none } }, { "stlinoff_bt:", { - user_command::motorconnectorsopen, - user_command::none } }, + motorconnectorsopen, + none } }, { "doorleftpermit_sw:", { - user_command::doorpermitleft, - user_command::none } }, + doorpermitleft, + none } }, { "doorrightpermit_sw:", { - user_command::doorpermitright, - user_command::none } }, + doorpermitright, + none } }, { "doorpermitpreset_sw:", { - user_command::doorpermitpresetactivatenext, - user_command::doorpermitpresetactivateprevious } }, + doorpermitpresetactivatenext, + doorpermitpresetactivateprevious } }, { "door_left_sw:", { - user_command::doortoggleleft, - user_command::none } }, + doortoggleleft, + none } }, { "door_right_sw:", { - user_command::doortoggleright, - user_command::none } }, + doortoggleright, + none } }, { "doorlefton_sw:", { - user_command::dooropenleft, - user_command::none } }, + dooropenleft, + none } }, { "doorrighton_sw:", { - user_command::dooropenright, - user_command::none } }, + dooropenright, + none } }, { "doorleftoff_sw:", { - user_command::doorcloseleft, - user_command::none } }, + doorcloseleft, + none } }, { "doorrightoff_sw:", { - user_command::doorcloseright, - user_command::none } }, + doorcloseright, + none } }, { "doorallon_sw:", { - user_command::dooropenall, - user_command::none } }, + dooropenall, + none } }, { "dooralloff_sw:", { - user_command::doorcloseall, - user_command::none } }, + doorcloseall, + none } }, { "doorstep_sw:", { - user_command::doorsteptoggle, - user_command::none } }, + doorsteptoggle, + none } }, { "doormode_sw:", { - user_command::doormodetoggle, - user_command::none } }, + doormodetoggle, + none } }, { "mirrors_sw:", { - user_command::mirrorstoggle, - user_command::none } }, + mirrorstoggle, + none } }, { "departure_signal_bt:", { - user_command::departureannounce, - user_command::none } }, + departureannounce, + none } }, { "upperlight_sw:", { - user_command::headlighttoggleupper, - user_command::none } }, + headlighttoggleupper, + none } }, { "leftlight_sw:", { - user_command::headlighttoggleleft, - user_command::none } }, + headlighttoggleleft, + none } }, { "rightlight_sw:", { - user_command::headlighttoggleright, - user_command::none } }, + headlighttoggleright, + none } }, { "dimheadlights_sw:", { - user_command::headlightsdimtoggle, - user_command::none } }, + headlightsdimtoggle, + none } }, {"moderndimmer_sw:", { - user_command::modernlightdimmerincrease, - user_command::modernlightdimmerdecrease } }, + modernlightdimmerincrease, + modernlightdimmerdecrease } }, { "leftend_sw:", { - user_command::redmarkertoggleleft, - user_command::none } }, + redmarkertoggleleft, + none } }, { "rightend_sw:", { - user_command::redmarkertoggleright, - user_command::none } }, + redmarkertoggleright, + none } }, { "lights_sw:", { - user_command::lightspresetactivatenext, - user_command::lightspresetactivateprevious } }, + lightspresetactivatenext, + lightspresetactivateprevious } }, { "rearupperlight_sw:", { - user_command::headlighttogglerearupper, - user_command::none } }, + headlighttogglerearupper, + none } }, { "rearleftlight_sw:", { - user_command::headlighttogglerearleft, - user_command::none } }, + headlighttogglerearleft, + none } }, { "rearrightlight_sw:", { - user_command::headlighttogglerearright, - user_command::none } }, + headlighttogglerearright, + none } }, { "rearleftend_sw:", { - user_command::redmarkertogglerearleft, - user_command::none } }, + redmarkertogglerearleft, + none } }, { "rearrightend_sw:", { - user_command::redmarkertogglerearright, - user_command::none } }, + redmarkertogglerearright, + none } }, { "compressor_sw:", { - user_command::compressortoggle, - user_command::none } }, + compressortoggle, + none } }, { "compressorlocal_sw:", { - user_command::compressortogglelocal, - user_command::none } }, + compressortogglelocal, + none } }, { "compressorlist_sw:", { - user_command::compressorpresetactivatenext, - user_command::compressorpresetactivateprevious } }, + compressorpresetactivatenext, + compressorpresetactivateprevious } }, { "converter_sw:", { - user_command::convertertoggle, - user_command::none } }, + convertertoggle, + none } }, { "converterlocal_sw:", { - user_command::convertertogglelocal, - user_command::none } }, + convertertogglelocal, + none } }, { "converteroff_sw:", { - user_command::convertertoggle, - user_command::none } }, // TODO: dedicated converter shutdown command + convertertoggle, + none } }, // TODO: dedicated converter shutdown command { "main_sw:", { - user_command::linebreakertoggle, - user_command::none } }, + linebreakertoggle, + none } }, { "radio_sw:", { - user_command::radiotoggle, - user_command::none } }, + radiotoggle, + none } }, { "radioon_sw:", { - user_command::radioenable, - user_command::none } }, + radioenable, + none } }, { "radiooff_sw:", { - user_command::radiodisable, - user_command::none } }, + radiodisable, + none } }, { "radiochannel_sw:", { - user_command::radiochannelincrease, - user_command::radiochanneldecrease } }, + radiochannelincrease, + radiochanneldecrease } }, { "radiochannelprev_sw:", { - user_command::radiochanneldecrease, - user_command::none } }, + radiochanneldecrease, + none } }, { "radiochannelnext_sw:", { - user_command::radiochannelincrease, - user_command::none } }, + radiochannelincrease, + none } }, { "radiostop_sw:", { - user_command::radiostopsend, - user_command::none } }, + radiostopsend, + none } }, { "radiostopon_sw:", { - user_command::radiostopenable, - user_command::none } }, + radiostopenable, + none } }, { "radiostopoff_sw:", { - user_command::radiostopdisable, - user_command::none } }, + radiostopdisable, + none } }, { "radiotest_sw:", { - user_command::radiostoptest, - user_command::none } }, + radiostoptest, + none } }, { "radiocall1_sw:", { - user_command::radiocall1send, - user_command::none } }, + radiocall1send, + none } }, { "radiocall3_sw:", { - user_command::radiocall3send, - user_command::none } }, + radiocall3send, + none } }, { "radiovolume_sw:",{ - user_command::radiovolumeincrease, - user_command::radiovolumedecrease } }, + radiovolumeincrease, + radiovolumedecrease } }, { "radiovolumeprev_sw:",{ - user_command::radiovolumedecrease, - user_command::none } }, + radiovolumedecrease, + none } }, { "radiovolumenext_sw:",{ - user_command::radiovolumeincrease, - user_command::none } }, + radiovolumeincrease, + none } }, { "pantfront_sw:", { - user_command::pantographtogglefront, - user_command::none } }, + pantographtogglefront, + none } }, { "pantrear_sw:", { - user_command::pantographtogglerear, - user_command::none } }, + pantographtogglerear, + none } }, { "pantfrontoff_sw:", { - user_command::pantographlowerfront, - user_command::none } }, + pantographlowerfront, + none } }, { "pantrearoff_sw:", { - user_command::pantographlowerrear, - user_command::none } }, + pantographlowerrear, + none } }, { "pantalloff_sw:", { - user_command::pantographlowerall, - user_command::none } }, + pantographlowerall, + none } }, { "pantselected_sw:", { - user_command::pantographtoggleselected, - user_command::none } }, // TBD: bind lowerselected in case of toggle switch + pantographtoggleselected, + none } }, // TBD: bind lowerselected in case of toggle switch { "pantselectedoff_sw:", { - user_command::pantographlowerselected, - user_command::none } }, + pantographlowerselected, + none } }, { "pantselect_sw:", { - user_command::pantographselectnext, - user_command::pantographselectprevious } }, + pantographselectnext, + pantographselectprevious } }, { "pantvalves_sw:", { - user_command::pantographvalvesupdate, - user_command::pantographvalvesoff } }, + pantographvalvesupdate, + pantographvalvesoff } }, { "pantvalvesupdate_bt:", { - user_command::pantographvalvesupdate, - user_command::none}}, + pantographvalvesupdate, + none}}, { "pantvalvesoff_bt:", { - user_command::pantographvalvesoff, - user_command::none}}, + pantographvalvesoff, + none}}, { "pantcompressor_sw:", { - user_command::pantographcompressoractivate, - user_command::none } }, + pantographcompressoractivate, + none } }, { "pantcompressorvalve_sw:", { - user_command::pantographcompressorvalvetoggle, - user_command::none } }, + pantographcompressorvalvetoggle, + none } }, { "trainheating_sw:", { - user_command::heatingtoggle, - user_command::none } }, + heatingtoggle, + none } }, { "signalling_sw:", { - user_command::mubrakingindicatortoggle, - user_command::none } }, + mubrakingindicatortoggle, + none } }, { "door_signalling_sw:", { - user_command::doorlocktoggle, - user_command::none } }, + doorlocktoggle, + none } }, { "nextcurrent_sw:", { - user_command::mucurrentindicatorothersourceactivate, - user_command::none } }, + mucurrentindicatorothersourceactivate, + none } }, { "distancecounter_sw:", { - user_command::distancecounteractivate, - user_command::none } }, + distancecounteractivate, + none } }, { "instrumentlight_sw:", { - user_command::instrumentlighttoggle, - user_command::none } }, + instrumentlighttoggle, + none } }, { "dashboardlight_sw:", { - user_command::dashboardlighttoggle, - user_command::none } }, + dashboardlighttoggle, + none } }, { "dashboardlighton_sw:", { - user_command::dashboardlightenable, - user_command::none } }, + dashboardlightenable, + none } }, { "dashboardlightoff_sw:", { - user_command::dashboardlightdisable, - user_command::none } }, + dashboardlightdisable, + none } }, { "timetablelight_sw:", { - user_command::timetablelighttoggle, - user_command::none } }, + timetablelighttoggle, + none } }, { "timetablelighton_sw:", { - user_command::timetablelightenable, - user_command::none } }, + timetablelightenable, + none } }, { "timetablelightoff_sw:", { - user_command::timetablelightdisable, - user_command::none } }, + timetablelightdisable, + none } }, { "cablight_sw:", { - user_command::interiorlighttoggle, - user_command::none } }, + interiorlighttoggle, + none } }, { "cablightdim_sw:", { - user_command::interiorlightdimtoggle, - user_command::none } }, + interiorlightdimtoggle, + none } }, { "compartmentlights_sw:", { - user_command::compartmentlightstoggle, - user_command::none } }, + compartmentlightstoggle, + none } }, { "compartmentlightson_sw:", { - user_command::compartmentlightsenable, - user_command::none } }, + compartmentlightsenable, + none } }, { "compartmentlightsoff_sw:", { - user_command::compartmentlightsdisable, - user_command::none } }, + compartmentlightsdisable, + none } }, { "battery_sw:", { - user_command::batterytoggle, - user_command::none } }, + batterytoggle, + none } }, { "batteryon_sw:", { - user_command::batteryenable, - user_command::none } }, + batteryenable, + none } }, { "batteryoff_sw:", { - user_command::batterydisable, - user_command::none } }, + batterydisable, + none } }, { "cabactivation_sw:", { - user_command::cabactivationtoggle, - user_command::none } }, + cabactivationtoggle, + none } }, { "couplingdisconnect_sw:",{ - user_command::occupiedcarcouplingdisconnect, - user_command::none } }, + occupiedcarcouplingdisconnect, + none } }, { "couplingdisconnectback_sw:",{ - user_command::occupiedcarcouplingdisconnectback, - user_command::none } }, - {"universal0:", {user_command::generictoggle0, user_command::none}}, - {"universal1:", {user_command::generictoggle1, user_command::none}}, - {"universal2:", {user_command::generictoggle2, user_command::none}}, - {"universal3:", {user_command::generictoggle3, user_command::none}}, - {"universal4:", {user_command::generictoggle4, user_command::none}}, - {"universal5:", {user_command::generictoggle5, user_command::none}}, - {"universal6:", {user_command::generictoggle6, user_command::none}}, - {"universal7:", {user_command::generictoggle7, user_command::none}}, - {"universal8:", {user_command::generictoggle8, user_command::none}}, - {"universal9:", {user_command::generictoggle9, user_command::none}}, - {"universal10:", {user_command::generictoggle10, user_command::none}}, - {"universal11:", {user_command::generictoggle11, user_command::none}}, - {"universal12:", {user_command::generictoggle12, user_command::none}}, - {"universal13:", {user_command::generictoggle13, user_command::none}}, - {"universal14:", {user_command::generictoggle14, user_command::none}}, - {"universal15:", {user_command::generictoggle15, user_command::none}}, - {"universal16:", {user_command::generictoggle16, user_command::none}}, - {"universal17:", {user_command::generictoggle17, user_command::none}}, - {"universal18:", {user_command::generictoggle18, user_command::none}}, - {"universal19:", {user_command::generictoggle19, user_command::none}}, - {"universal20:", {user_command::generictoggle20, user_command::none}}, - {"universal21:", {user_command::generictoggle21, user_command::none}}, - {"universal22:", {user_command::generictoggle22, user_command::none}}, - {"universal23:", {user_command::generictoggle23, user_command::none}}, - {"universal24:", {user_command::generictoggle24, user_command::none}}, - {"universal25:", {user_command::generictoggle25, user_command::none}}, - {"universal26:", {user_command::generictoggle26, user_command::none}}, - {"universal27:", {user_command::generictoggle27, user_command::none}}, - {"universal28:", {user_command::generictoggle28, user_command::none}}, - {"universal29:", {user_command::generictoggle29, user_command::none}}, + occupiedcarcouplingdisconnectback, + none } }, + {"universal0:", {generictoggle0, none}}, + {"universal1:", {generictoggle1, none}}, + {"universal2:", {generictoggle2, none}}, + {"universal3:", {generictoggle3, none}}, + {"universal4:", {generictoggle4, none}}, + {"universal5:", {generictoggle5, none}}, + {"universal6:", {generictoggle6, none}}, + {"universal7:", {generictoggle7, none}}, + {"universal8:", {generictoggle8, none}}, + {"universal9:", {generictoggle9, none}}, + {"universal10:", {generictoggle10, none}}, + {"universal11:", {generictoggle11, none}}, + {"universal12:", {generictoggle12, none}}, + {"universal13:", {generictoggle13, none}}, + {"universal14:", {generictoggle14, none}}, + {"universal15:", {generictoggle15, none}}, + {"universal16:", {generictoggle16, none}}, + {"universal17:", {generictoggle17, none}}, + {"universal18:", {generictoggle18, none}}, + {"universal19:", {generictoggle19, none}}, + {"universal20:", {generictoggle20, none}}, + {"universal21:", {generictoggle21, none}}, + {"universal22:", {generictoggle22, none}}, + {"universal23:", {generictoggle23, none}}, + {"universal24:", {generictoggle24, none}}, + {"universal25:", {generictoggle25, none}}, + {"universal26:", {generictoggle26, none}}, + {"universal27:", {generictoggle27, none}}, + {"universal28:", {generictoggle28, none}}, + {"universal29:", {generictoggle29, none}}, { "speedinc_bt:",{ - user_command::speedcontrolincrease, - user_command::none } }, + speedcontrolincrease, + none } }, { "speeddec_bt:",{ - user_command::speedcontroldecrease, - user_command::none } }, + speedcontroldecrease, + none } }, { "speedctrlpowerinc_bt:",{ - user_command::speedcontrolpowerincrease, - user_command::none } }, + speedcontrolpowerincrease, + none } }, { "speedctrlpowerdec_bt:",{ - user_command::speedcontrolpowerdecrease, - user_command::none } }, + speedcontrolpowerdecrease, + none } }, { "speedbutton0:",{ - user_command::speedcontrolbutton0, - user_command::none } }, + speedcontrolbutton0, + none } }, { "speedbutton1:",{ - user_command::speedcontrolbutton1, - user_command::none } }, + speedcontrolbutton1, + none } }, { "speedbutton2:",{ - user_command::speedcontrolbutton2, - user_command::none } }, + speedcontrolbutton2, + none } }, { "speedbutton3:",{ - user_command::speedcontrolbutton3, - user_command::none } }, + speedcontrolbutton3, + none } }, { "speedbutton4:",{ - user_command::speedcontrolbutton4, - user_command::none } }, + speedcontrolbutton4, + none } }, { "speedbutton5:",{ - user_command::speedcontrolbutton5, - user_command::none } }, + speedcontrolbutton5, + none } }, { "speedbutton6:",{ - user_command::speedcontrolbutton6, - user_command::none } }, + speedcontrolbutton6, + none } }, { "speedbutton7:",{ - user_command::speedcontrolbutton7, - user_command::none } }, + speedcontrolbutton7, + none } }, { "speedbutton8:",{ - user_command::speedcontrolbutton8, - user_command::none } }, + speedcontrolbutton8, + none } }, { "speedbutton9:",{ - user_command::speedcontrolbutton9, - user_command::none } }, + speedcontrolbutton9, + none } }, { "inverterenable1_bt:",{ - user_command::inverterenable1, - user_command::none } }, + inverterenable1, + none } }, { "inverterenable2_bt:",{ - user_command::inverterenable2, - user_command::none } }, + inverterenable2, + none } }, { "inverterenable3_bt:",{ - user_command::inverterenable3, - user_command::none } }, + inverterenable3, + none } }, { "inverterenable4_bt:",{ - user_command::inverterenable4, - user_command::none } }, + inverterenable4, + none } }, { "inverterenable5_bt:",{ - user_command::inverterenable5, - user_command::none } }, + inverterenable5, + none } }, { "inverterenable6_bt:",{ - user_command::inverterenable6, - user_command::none } }, + inverterenable6, + none } }, { "inverterenable7_bt:",{ - user_command::inverterenable7, - user_command::none } }, + inverterenable7, + none } }, { "inverterenable8_bt:",{ - user_command::inverterenable8, - user_command::none } }, + inverterenable8, + none } }, { "inverterenable9_bt:",{ - user_command::inverterenable9, - user_command::none } }, + inverterenable9, + none } }, { "inverterenable10_bt:",{ - user_command::inverterenable10, - user_command::none } }, + inverterenable10, + none } }, { "inverterenable11_bt:",{ - user_command::inverterenable11, - user_command::none } }, + inverterenable11, + none } }, { "inverterenable12_bt:",{ - user_command::inverterenable12, - user_command::none } }, + inverterenable12, + none } }, { "inverterdisable1_bt:",{ - user_command::inverterdisable1, - user_command::none } }, + inverterdisable1, + none } }, { "inverterdisable2_bt:",{ - user_command::inverterdisable2, - user_command::none } }, + inverterdisable2, + none } }, { "inverterdisable3_bt:",{ - user_command::inverterdisable3, - user_command::none } }, + inverterdisable3, + none } }, { "inverterdisable4_bt:",{ - user_command::inverterdisable4, - user_command::none } }, + inverterdisable4, + none } }, { "inverterdisable5_bt:",{ - user_command::inverterdisable5, - user_command::none } }, + inverterdisable5, + none } }, { "inverterdisable6_bt:",{ - user_command::inverterdisable6, - user_command::none } }, + inverterdisable6, + none } }, { "inverterdisable7_bt:",{ - user_command::inverterdisable7, - user_command::none } }, + inverterdisable7, + none } }, { "inverterdisable8_bt:",{ - user_command::inverterdisable8, - user_command::none } }, + inverterdisable8, + none } }, { "inverterdisable9_bt:",{ - user_command::inverterdisable9, - user_command::none } }, + inverterdisable9, + none } }, { "inverterdisable10_bt:",{ - user_command::inverterdisable10, - user_command::none } }, + inverterdisable10, + none } }, { "inverterdisable11_bt:",{ - user_command::inverterdisable11, - user_command::none } }, + inverterdisable11, + none } }, { "inverterdisable12_bt:",{ - user_command::inverterdisable12, - user_command::none } }, + inverterdisable12, + none } }, { "invertertoggle1_bt:",{ - user_command::invertertoggle1, - user_command::none } }, + invertertoggle1, + none } }, { "invertertoggle2_bt:",{ - user_command::invertertoggle2, - user_command::none } }, + invertertoggle2, + none } }, { "invertertoggle3_bt:",{ - user_command::invertertoggle3, - user_command::none } }, + invertertoggle3, + none } }, { "invertertoggle4_bt:",{ - user_command::invertertoggle4, - user_command::none } }, + invertertoggle4, + none } }, { "invertertoggle5_bt:",{ - user_command::invertertoggle5, - user_command::none } }, + invertertoggle5, + none } }, { "invertertoggle6_bt:",{ - user_command::invertertoggle6, - user_command::none } }, + invertertoggle6, + none } }, { "invertertoggle7_bt:",{ - user_command::invertertoggle7, - user_command::none } }, + invertertoggle7, + none } }, { "invertertoggle8_bt:",{ - user_command::invertertoggle8, - user_command::none } }, + invertertoggle8, + none } }, { "invertertoggle9_bt:",{ - user_command::invertertoggle9, - user_command::none } }, + invertertoggle9, + none } }, { "invertertoggle10_bt:",{ - user_command::invertertoggle10, - user_command::none } }, + invertertoggle10, + none } }, { "invertertoggle11_bt:",{ - user_command::invertertoggle11, - user_command::none } }, + invertertoggle11, + none } }, { "invertertoggle12_bt:",{ - user_command::invertertoggle12, - user_command::none } }, + invertertoggle12, + none } }, { "wipers_sw:",{ - user_command::wiperswitchincrease, - user_command::wiperswitchdecrease + wiperswitchincrease, + wiperswitchdecrease } }, }; @@ -1111,16 +1114,17 @@ drivermouse_input::default_bindings() { user_command drivermouse_input::adjust_command( user_command Command ) const { + using enum user_command; if( true == Global.shiftState - && Command != user_command::none ) { + && Command != none ) { switch( Command ) { - case user_command::mastercontrollerincrease: { Command = user_command::mastercontrollerincreasefast; break; } - case user_command::mastercontrollerdecrease: { Command = user_command::mastercontrollerdecreasefast; break; } - case user_command::secondcontrollerincrease: { Command = user_command::secondcontrollerincreasefast; break; } - case user_command::secondcontrollerdecrease: { Command = user_command::secondcontrollerdecreasefast; break; } - case user_command::independentbrakeincrease: { Command = user_command::independentbrakeincreasefast; break; } - case user_command::independentbrakedecrease: { Command = user_command::independentbrakedecreasefast; break; } + case mastercontrollerincrease: { Command = mastercontrollerincreasefast; break; } + case mastercontrollerdecrease: { Command = mastercontrollerdecreasefast; break; } + case secondcontrollerincrease: { Command = secondcontrollerincreasefast; break; } + case secondcontrollerdecrease: { Command = secondcontrollerdecreasefast; break; } + case independentbrakeincrease: { Command = independentbrakeincreasefast; break; } + case independentbrakedecrease: { Command = independentbrakedecreasefast; break; } default: { break; } } } diff --git a/input/editorkeyboardinput.cpp b/input/editorkeyboardinput.cpp index 209ca65a..7f5a03a1 100644 --- a/input/editorkeyboardinput.cpp +++ b/input/editorkeyboardinput.cpp @@ -31,25 +31,26 @@ editorkeyboard_input::apply_scheme() { void editorkeyboard_input::default_bindings() { + using enum user_command; if (EditorSettings.movement() == editorSettings::movement_scheme::legacy) { m_bindingsetups = { - { user_command::moveleft, {GLFW_KEY_LEFT, "Move left"} }, - { user_command::moveright, {GLFW_KEY_RIGHT, "Move right"} }, - { user_command::moveforward, {GLFW_KEY_UP, "Move forwards"} }, - { user_command::moveback, {GLFW_KEY_DOWN, "Move backwards"} }, - { user_command::moveup, {GLFW_KEY_PAGE_UP, "Move up"} }, - { user_command::movedown, {GLFW_KEY_PAGE_DOWN, "Move down"} }, + { moveleft, {GLFW_KEY_LEFT, "Move left"} }, + { moveright, {GLFW_KEY_RIGHT, "Move right"} }, + { moveforward, {GLFW_KEY_UP, "Move forwards"} }, + { moveback, {GLFW_KEY_DOWN, "Move backwards"} }, + { moveup, {GLFW_KEY_PAGE_UP, "Move up"} }, + { movedown, {GLFW_KEY_PAGE_DOWN, "Move down"} }, }; } else { m_bindingsetups = { - { user_command::moveleft, {GLFW_KEY_A, "Move left"} }, - { user_command::moveright, {GLFW_KEY_D, "Move right"} }, - { user_command::moveforward, {GLFW_KEY_W, "Move forwards"} }, - { user_command::moveback, {GLFW_KEY_S, "Move backwards"} }, - { user_command::moveup, {GLFW_KEY_E, "Move up"} }, - { user_command::movedown, {GLFW_KEY_Q, "Move down"} }, + { moveleft, {GLFW_KEY_A, "Move left"} }, + { moveright, {GLFW_KEY_D, "Move right"} }, + { moveforward, {GLFW_KEY_W, "Move forwards"} }, + { moveback, {GLFW_KEY_S, "Move backwards"} }, + { moveup, {GLFW_KEY_E, "Move up"} }, + { movedown, {GLFW_KEY_Q, "Move down"} }, }; } } diff --git a/input/gamepadinput.cpp b/input/gamepadinput.cpp index 3166aae1..784f714c 100644 --- a/input/gamepadinput.cpp +++ b/input/gamepadinput.cpp @@ -228,12 +228,13 @@ gamepad_input::recall_bindings() { std::get<0>( m_inputaxes[ axisindex ].bindings[ controlmode ] ) = bindingtype; // retrieve regular commands associated with the axis and mode switch( bindingtype ) { - case input_type::value: - case input_type::value_invert: { + using enum gamepad_input::input_type; + case value: + case value_invert: { bindingtargets.emplace_back( std::ref( std::get<1>( m_inputaxes[ axisindex ].bindings[ controlmode ] ) ) ); break; } - case input_type::threestate: { + case threestate: { bindingtargets.emplace_back( std::ref( std::get<1>( m_inputaxes[ axisindex ].bindings[ controlmode ] ) ) ); bindingtargets.emplace_back( std::ref( std::get<2>( m_inputaxes[ axisindex ].bindings[ controlmode ] ) ) ); break; @@ -463,12 +464,13 @@ gamepad_input::process_axes() { } // scale passed value according to command type switch( boundcommand1 ) { - case user_command::viewturn: { + using enum user_command; + case viewturn: { param *= 10.0 * ( Timer::GetDeltaRenderTime() * 60.0 ); break; } - case user_command::movehorizontal: - case user_command::movehorizontalfast: { + case movehorizontal: + case movehorizontalfast: { // these expect value in -1:1 range break; } diff --git a/input/keyboardinput.cpp b/input/keyboardinput.cpp index cb3a6100..0d9845b2 100644 --- a/input/keyboardinput.cpp +++ b/input/keyboardinput.cpp @@ -328,6 +328,7 @@ keyboard_input::key( int const Key ) const { void keyboard_input::bind() { + using enum user_command; m_bindings.clear(); for( auto const &[setupcommand, setupbinding] : m_bindingsetups ) { @@ -336,12 +337,12 @@ keyboard_input::bind() { } // cache movement key bindings - m_bindingscache.forward = binding( user_command::moveforward ); - m_bindingscache.back = binding( user_command::moveback ); - m_bindingscache.left = binding( user_command::moveleft ); - m_bindingscache.right = binding( user_command::moveright ); - m_bindingscache.up = binding( user_command::moveup ); - m_bindingscache.down = binding( user_command::movedown ); + m_bindingscache.forward = binding( moveforward ); + m_bindingscache.back = binding( moveback ); + m_bindingscache.left = binding( moveleft ); + m_bindingscache.right = binding( moveright ); + m_bindingscache.up = binding( moveup ); + m_bindingscache.down = binding( movedown ); } int diff --git a/launcher/textures_scanner.cpp b/launcher/textures_scanner.cpp index a3b66c40..1910b4d3 100644 --- a/launcher/textures_scanner.cpp +++ b/launcher/textures_scanner.cpp @@ -60,23 +60,24 @@ void ui::vehicles_bank::parse_entry(const std::string &line) void ui::vehicles_bank::parse_category_entry(const std::string ¶m) { + using enum ui::vehicle_type; static std::unordered_map type_map = { - { 'e', vehicle_type::electric_loco }, - { 's', vehicle_type::diesel_loco }, - { 'p', vehicle_type::steam_loco }, - { 'a', vehicle_type::railcar }, - { 'z', vehicle_type::emu }, - { 'r', vehicle_type::utility }, - { 'd', vehicle_type::draisine }, - { 't', vehicle_type::tram }, - { 'c', vehicle_type::truck }, - { 'b', vehicle_type::bus }, - { 'o', vehicle_type::car }, - { 'h', vehicle_type::man }, - { 'f', vehicle_type::animal }, + { 'e', electric_loco }, + { 's', diesel_loco }, + { 'p', steam_loco }, + { 'a', railcar }, + { 'z', emu }, + { 'r', utility }, + { 'd', draisine }, + { 't', tram }, + { 'c', truck }, + { 'b', bus }, + { 'o', car }, + { 'h', man }, + { 'f', animal }, }; - ctx_type = vehicle_type::unknown; + ctx_type = unknown; std::istringstream stream(param); @@ -89,7 +90,7 @@ void ui::vehicles_bank::parse_category_entry(const std::string ¶m) if (auto it = type_map.find(tok[0]); it != type_map.end()) ctx_type = it->second; else if (tok[0] >= 'A' && tok[0] <= 'Z') - ctx_type = vehicle_type::carriage; + ctx_type = carriage; std::string mini; std::getline(stream, mini, ','); diff --git a/scripting/ladderlogic.cpp b/scripting/ladderlogic.cpp index 362b48af..2e93f51f 100644 --- a/scripting/ladderlogic.cpp +++ b/scripting/ladderlogic.cpp @@ -388,17 +388,18 @@ basic_controller::log_error( std::string const &Error, int const Line ) const { auto basic_controller::guess_element_type_from_name( std::string const &Name ) const -> basic_element::type_e { + using enum plc::basic_element::type_e; auto const [nametype, nameindex]{ split_string_and_number( Name ) }; if( nametype == "t" || nametype == "ton" || nametype.find("timer.") == 0 ) { - return basic_element::type_e::timer; + return timer; } if( nametype == "c" || nametype.find("counter.") == 0 ) { - return basic_element::type_e::counter; + return counter; } - return basic_element::type_e::variable; + return variable; } } // plc diff --git a/utilities/comparison.h b/utilities/comparison.h index 84f797a5..07c0ce02 100644 --- a/utilities/comparison.h +++ b/utilities/comparison.h @@ -27,12 +27,13 @@ enum class comparison_pass { template bool compare( Type_ const Left, Type_ const Right, comparison_operator const Operator ) { switch( Operator ) { - case comparison_operator::equal: { return Left == Right; } - case comparison_operator::not_equal: { return Left != Right; } - case comparison_operator::lt: { return Left < Right; } - case comparison_operator::gt: { return Left > Right; } - case comparison_operator::lt_eq: { return Left <= Right; } - case comparison_operator::gt_eq: { return Left >= Right; } + using enum comparison_operator; + case equal: { return Left == Right; } + case not_equal: { return Left != Right; } + case lt: { return Left < Right; } + case gt: { return Left > Right; } + case lt_eq: { return Left <= Right; } + case gt_eq: { return Left >= Right; } default: { return false; } } } @@ -41,12 +42,13 @@ inline std::string to_string( comparison_operator const Operator ) { switch( Operator ) { - case comparison_operator::equal: { return "=="; } - case comparison_operator::not_equal: { return "!="; } - case comparison_operator::lt: { return "<"; } - case comparison_operator::gt: { return ">"; } - case comparison_operator::lt_eq: { return "<="; } - case comparison_operator::gt_eq: { return ">"; } + using enum comparison_operator; + case equal: { return "=="; } + case not_equal: { return "!="; } + case lt: { return "<"; } + case gt: { return ">"; } + case lt_eq: { return "<="; } + case gt_eq: { return ">"; } default: { return "??"; } } } @@ -54,24 +56,26 @@ to_string( comparison_operator const Operator ) { inline comparison_pass comparison_pass_from_string( std::string const Input ) { - if( Input == "all" ) { return comparison_pass::all; } - else if( Input == "any" ) { return comparison_pass::any; } - else if( Input == "none" ) { return comparison_pass::none; } + using enum comparison_pass; + if( Input == "all" ) { return all; } + else if( Input == "any" ) { return any; } + else if( Input == "none" ) { return none; } - return comparison_pass::all; // legacy default + return all; // legacy default } inline comparison_operator comparison_operator_from_string( std::string const Input ) { - if( Input == "==" ) { return comparison_operator::equal; } - else if( Input == "!=" ) { return comparison_operator::not_equal; } - else if( Input == "<" ) { return comparison_operator::lt; } - else if( Input == ">" ) { return comparison_operator::gt; } - else if( Input == "<=" ) { return comparison_operator::lt_eq; } - else if( Input == ">=" ) { return comparison_operator::gt_eq; } + using enum comparison_operator; + if( Input == "==" ) { return equal; } + else if( Input == "!=" ) { return not_equal; } + else if( Input == "<" ) { return lt; } + else if( Input == ">" ) { return gt; } + else if( Input == "<=" ) { return lt_eq; } + else if( Input == ">=" ) { return gt_eq; } - return comparison_operator::equal; // legacy default + return equal; // legacy default } //--------------------------------------------------------------------------- diff --git a/vehicle/Gauge.cpp b/vehicle/Gauge.cpp index 68248d7d..c5ed123b 100644 --- a/vehicle/Gauge.cpp +++ b/vehicle/Gauge.cpp @@ -240,13 +240,14 @@ TGauge::Load_mapping( cParser &Input, TGauge::scratch_data &Scratchpad ) { if( true == key.empty() || key == "}" ) { return false; } // if not block end then the key is followed by assigned value or sub-block if( key == "type:" ) { + using enum TGaugeType; auto const gaugetype { Input.getToken( true, "\n\r\t ,;" ) }; - m_type = gaugetype == "push" ? TGaugeType::push : - gaugetype == "impulse" ? TGaugeType::push : - gaugetype == "return" ? TGaugeType::push : - gaugetype == "delayed" ? TGaugeType::push_delayed : - gaugetype == "pushtoggle" ? TGaugeType::pushtoggle : - TGaugeType::toggle; // "toggle" and default + m_type = gaugetype == "push" ? push : + gaugetype == "impulse" ? push : + gaugetype == "return" ? push : + gaugetype == "delayed" ? push_delayed : + gaugetype == "pushtoggle" ? pushtoggle : + toggle; // "toggle" and default } else if( key == "soundinc:" ) { m_soundfxincrease.deserialize( Input, sound_type::single ); diff --git a/vehicle/Train.cpp b/vehicle/Train.cpp index 393d5657..c0058b81 100644 --- a/vehicle/Train.cpp +++ b/vehicle/Train.cpp @@ -1020,9 +1020,10 @@ void TTrain::set_train_brake(double const Position) void TTrain::zero_charging_train_brake() { + using enum TBrakeHandle; if (mvOccupied->BrakeCtrlPos == -1 && DynamicObject->Controller != AIdriver && Global.iFeedbackMode < 3 && - (mvOccupied->BrakeHandle == TBrakeHandle::FVel6 || mvOccupied->BrakeHandle == TBrakeHandle::MHZ_EN57 || mvOccupied->BrakeHandle == TBrakeHandle::MHZ_K8P)) + (mvOccupied->BrakeHandle == FVel6 || mvOccupied->BrakeHandle == MHZ_EN57 || mvOccupied->BrakeHandle == MHZ_K8P)) { // Odskakiwanie hamulce EP set_train_brake(0); @@ -3470,6 +3471,7 @@ void TTrain::OnCommand_pantographlowerselected(TTrain *Train, command_data const void TTrain::update_pantograph_valves() { + using enum operation_t; auto const &presets{mvOccupied->PantsPreset.first}; auto &selection{mvOccupied->PantsPreset.second[cab_to_end()]}; @@ -3479,8 +3481,8 @@ void TTrain::update_pantograph_valves() // check desired states for both pantographs; value: whether the pantograph should be raised auto const frontstate{preset & (swapends ? 2 : 1)}; auto const rearstate{preset & (swapends ? 1 : 2)}; - mvOccupied->OperatePantographValve(end::front, frontstate ? operation_t::enable : operation_t::disable); - mvOccupied->OperatePantographValve(end::rear, rearstate ? operation_t::enable : operation_t::disable); + mvOccupied->OperatePantographValve(end::front, frontstate ? enable : disable); + mvOccupied->OperatePantographValve(end::rear, rearstate ? enable : disable); } void TTrain::change_pantograph_selection(int const Change) @@ -10219,33 +10221,35 @@ bool TTrain::CabChange(int iDirection) // wczytywanie pliku z danymi multimedialnymi (dzwieki, kontrolki, kabiny) bool TTrain::LoadMMediaFile(std::string const &asFileName) { + using enum sound_placement; + using enum sound_type; // initialize sounds so potential entries from previous vehicle don't stick around std::unordered_map &, sound_placement, float, sound_type, int, double>> internalsounds = { - {"ctrl:", {dsbNastawnikJazdy, sound_placement::internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, sound_type::single, 0, 100.0}}, - {"ctrlscnd:", {dsbNastawnikBocz, sound_placement::internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, sound_type::single, 0, 100.0}}, - {"reverserkey:", {dsbReverserKey, sound_placement::internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, sound_type::single, 0, 100.0}}, - {"buzzer:", {dsbBuzzer, sound_placement::internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, sound_type::single, 0, 100.0}}, - {"buzzershp:", {dsbBuzzerShp, sound_placement::internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, sound_type::single, 0, 100.0}}, - {"radiostop:", {m_radiostop, sound_placement::internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, sound_type::single, 0, 100.0}}, - {"slipalarm:", {dsbSlipAlarm, sound_placement::internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, sound_type::single, 0, 100.0}}, - {"distancecounter:", {m_distancecounterclear, sound_placement::internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, sound_type::single, 0, 100.0}}, - {"tachoclock:", {dsbHasler, sound_placement::internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, sound_type::single, 0, 100.0}}, - {"switch:", {dsbSwitch, sound_placement::internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, sound_type::single, 0, 100.0}}, - {"pneumaticswitch:", {dsbPneumaticSwitch, sound_placement::internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, sound_type::single, 0, 100.0}}, - {"airsound:", {rsHiss, sound_placement::internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, sound_type::single, sound_parameters::amplitude, 100.0}}, - {"airsound2:", {rsHissU, sound_placement::internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, sound_type::single, sound_parameters::amplitude, 100.0}}, - {"airsound3:", {rsHissE, sound_placement::internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, sound_type::single, sound_parameters::amplitude, 100.0}}, - {"airsound4:", {rsHissX, sound_placement::internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, sound_type::single, sound_parameters::amplitude, 100.0}}, - {"airsound5:", {rsHissT, sound_placement::internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, sound_type::single, sound_parameters::amplitude, 100.0}}, - {"localbrakesound:", {rsSBHiss, sound_placement::internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, sound_type::single, sound_parameters::amplitude, 100.0}}, - {"localbrakesound2:", {rsSBHissU, sound_placement::internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, sound_type::single, sound_parameters::amplitude, 100.0}}, - {"brakesound:", {rsBrake, sound_placement::internal, -1, sound_type::single, sound_parameters::amplitude | sound_parameters::frequency, 100.0}}, - {"fadesound:", {rsFadeSound, sound_placement::internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, sound_type::single, 0, 100.0}}, - {"runningnoise:", {rsRunningNoise, sound_placement::internal, EU07_SOUND_GLOBALRANGE, sound_type::single, sound_parameters::amplitude | sound_parameters::frequency, mvOccupied->Vmax}}, - {"resonancenoise:", {rsResonanceNoise, sound_placement::internal, EU07_SOUND_GLOBALRANGE, sound_type::single, sound_parameters::amplitude | sound_parameters::frequency, mvOccupied->Vmax}}, - {"windsound:", {rsWindSound, sound_placement::internal, EU07_SOUND_GLOBALRANGE, sound_type::single, sound_parameters::amplitude | sound_parameters::frequency, mvOccupied->Vmax}}, - {"huntingnoise:", {rsHuntingNoise, sound_placement::internal, EU07_SOUND_GLOBALRANGE, sound_type::single, sound_parameters::amplitude | sound_parameters::frequency, mvOccupied->Vmax}}, - {"rainsound:", {m_rainsound, sound_placement::internal, -1, sound_type::single, 0, 100.0}}, + {"ctrl:", {dsbNastawnikJazdy, internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, single, 0, 100.0}}, + {"ctrlscnd:", {dsbNastawnikBocz, internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, single, 0, 100.0}}, + {"reverserkey:", {dsbReverserKey, internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, single, 0, 100.0}}, + {"buzzer:", {dsbBuzzer, internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, single, 0, 100.0}}, + {"buzzershp:", {dsbBuzzerShp, internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, single, 0, 100.0}}, + {"radiostop:", {m_radiostop, internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, single, 0, 100.0}}, + {"slipalarm:", {dsbSlipAlarm, internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, single, 0, 100.0}}, + {"distancecounter:", {m_distancecounterclear, internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, single, 0, 100.0}}, + {"tachoclock:", {dsbHasler, internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, single, 0, 100.0}}, + {"switch:", {dsbSwitch, internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, single, 0, 100.0}}, + {"pneumaticswitch:", {dsbPneumaticSwitch, internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, single, 0, 100.0}}, + {"airsound:", {rsHiss, internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, single, sound_parameters::amplitude, 100.0}}, + {"airsound2:", {rsHissU, internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, single, sound_parameters::amplitude, 100.0}}, + {"airsound3:", {rsHissE, internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, single, sound_parameters::amplitude, 100.0}}, + {"airsound4:", {rsHissX, internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, single, sound_parameters::amplitude, 100.0}}, + {"airsound5:", {rsHissT, internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, single, sound_parameters::amplitude, 100.0}}, + {"localbrakesound:", {rsSBHiss, internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, single, sound_parameters::amplitude, 100.0}}, + {"localbrakesound2:", {rsSBHissU, internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, single, sound_parameters::amplitude, 100.0}}, + {"brakesound:", {rsBrake, internal, -1, single, sound_parameters::amplitude | sound_parameters::frequency, 100.0}}, + {"fadesound:", {rsFadeSound, internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, single, 0, 100.0}}, + {"runningnoise:", {rsRunningNoise, internal, EU07_SOUND_GLOBALRANGE, single, sound_parameters::amplitude | sound_parameters::frequency, mvOccupied->Vmax}}, + {"resonancenoise:", {rsResonanceNoise, internal, EU07_SOUND_GLOBALRANGE, single, sound_parameters::amplitude | sound_parameters::frequency, mvOccupied->Vmax}}, + {"windsound:", {rsWindSound, internal, EU07_SOUND_GLOBALRANGE, single, sound_parameters::amplitude | sound_parameters::frequency, mvOccupied->Vmax}}, + {"huntingnoise:", {rsHuntingNoise, internal, EU07_SOUND_GLOBALRANGE, single, sound_parameters::amplitude | sound_parameters::frequency, mvOccupied->Vmax}}, + {"rainsound:", {m_rainsound, internal, -1, single, 0, 100.0}}, }; for (auto &[soundname, soundsource] : internalsounds) { @@ -10292,7 +10296,7 @@ bool TTrain::LoadMMediaFile(std::string const &asFileName) if (!m_rainsound) { sound_source rainsound; - rainsound.deserialize("rainsound_default", sound_type::single); + rainsound.deserialize("rainsound_default", single); rainsound.owner(DynamicObject); m_rainsound = rainsound; } diff --git a/widgets/time.cpp b/widgets/time.cpp index d299d17b..0d4dec35 100644 --- a/widgets/time.cpp +++ b/widgets/time.cpp @@ -18,9 +18,10 @@ void ui::time_panel::render_contents() if (ImGui::Button(STR_C("Apply"))) { - m_relay.post(user_command::setdatetime, (double)yearday, time * 60.0, 1, 0); - m_relay.post(user_command::setweather, fog, overcast, 1, 0); - m_relay.post(user_command::settemperature, temperature, overcast, 1, 0); + using enum user_command; + m_relay.post(setdatetime, (double)yearday, time * 60.0, 1, 0); + m_relay.post(setweather, fog, overcast, 1, 0); + m_relay.post(settemperature, temperature, overcast, 1, 0); } } diff --git a/world/MemCell.cpp b/world/MemCell.cpp index 5f1235f4..b6a79183 100644 --- a/world/MemCell.cpp +++ b/world/MemCell.cpp @@ -51,48 +51,49 @@ void TMemCell::UpdateValues( std::string const &szNewText, double const fNewValu TCommandType TMemCell::CommandCheck() { // rozpoznanie komendy + using enum TCommandType; if( szText == "SetVelocity" ) // najpopularniejsze { - eCommand = TCommandType::cm_SetVelocity; + eCommand = cm_SetVelocity; bCommand = false; // ta komenda nie jest wysyłana } else if( szText == "ShuntVelocity" ) // w tarczach manewrowych { - eCommand = TCommandType::cm_ShuntVelocity; + eCommand = cm_ShuntVelocity; bCommand = false; // ta komenda nie jest wysyłana } else if( szText == "Change_direction" ) // zdarza się { - eCommand = TCommandType::cm_ChangeDirection; + eCommand = cm_ChangeDirection; bCommand = true; // do wysłania } else if( szText == "OutsideStation" ) // zdarza się { - eCommand = TCommandType::cm_OutsideStation; + eCommand = cm_OutsideStation; bCommand = false; // tego nie powinno być w komórce } else if( szText.starts_with("PassengerStopPoint:") ) // porównanie początków { - eCommand = TCommandType::cm_PassengerStopPoint; + eCommand = cm_PassengerStopPoint; bCommand = false; // tego nie powinno być w komórce } else if( szText == "SetProximityVelocity" ) // nie powinno tego być { - eCommand = TCommandType::cm_SetProximityVelocity; + eCommand = cm_SetProximityVelocity; bCommand = false; // ta komenda nie jest wysyłana } else if( szText == "Emergency_brake" ) { - eCommand = TCommandType::cm_EmergencyBrake; + eCommand = cm_EmergencyBrake; bCommand = false; } else if( szText == "CabSignal" ) { - eCommand = TCommandType::cm_SecuritySystemMagnet; + eCommand = cm_SecuritySystemMagnet; bCommand = false; } else { - eCommand = TCommandType::cm_Unknown; // ciąg nierozpoznany (nie jest komendą) + eCommand = cm_Unknown; // ciąg nierozpoznany (nie jest komendą) bCommand = true; // do wysłania } return eCommand; @@ -177,20 +178,22 @@ bool TMemCell::Compare( std::string const &szTestText, double const fTestValue1, } switch( Pass ) { - case comparison_pass::all: { return checkfailed == false; } - case comparison_pass::any: { return checkpassed == true; } - case comparison_pass::none: { return checkpassed == false; } + using enum comparison_pass; + case all: { return checkfailed == false; } + case any: { return checkpassed == true; } + case none: { return checkpassed == false; } default: { return false; } } }; bool TMemCell::IsVelocity() const { // sprawdzenie, czy event odczytu tej komórki ma być do skanowania, czy do kolejkowania - if (eCommand == TCommandType::cm_SetVelocity) + using enum TCommandType; + if (eCommand == cm_SetVelocity) return true; - if (eCommand == TCommandType::cm_ShuntVelocity) + if (eCommand == cm_ShuntVelocity) return true; - return eCommand == TCommandType::cm_SetProximityVelocity; + return eCommand == cm_SetProximityVelocity; }; void TMemCell::StopCommandSent()