openMSX
ImGuiSettings.cc
Go to the documentation of this file.
1#include "ImGuiSettings.hh"
2
3#include "ImGuiCpp.hh"
4#include "ImGuiManager.hh"
5#include "ImGuiMessages.hh"
6#include "ImGuiOsdIcons.hh"
7#include "ImGuiSoundChip.hh"
8#include "ImGuiUtils.hh"
9
10#include "BooleanInput.hh"
11#include "BooleanSetting.hh"
12#include "CPUCore.hh"
13#include "Display.hh"
14#include "EventDistributor.hh"
15#include "FileContext.hh"
16#include "FilenameSetting.hh"
17#include "FloatSetting.hh"
19#include "GlobalSettings.hh"
20#include "InputEventFactory.hh"
22#include "IntegerSetting.hh"
23#include "JoyMega.hh"
24#include "KeyCodeSetting.hh"
25#include "KeyboardSettings.hh"
26#include "Mixer.hh"
27#include "MSXCPU.hh"
29#include "MSXJoystick.hh"
30#include "MSXMotherBoard.hh"
31#include "ProxySetting.hh"
32#include "R800.hh"
33#include "Reactor.hh"
34#include "ReadOnlySetting.hh"
35#include "SettingsManager.hh"
36#include "StringSetting.hh"
37#include "Version.hh"
38#include "VideoSourceSetting.hh"
39#include "Z80.hh"
40
41#include "checked_cast.hh"
42#include "foreach_file.hh"
43#include "narrow.hh"
44#include "StringOp.hh"
45#include "unreachable.hh"
46#include "zstring_view.hh"
47
48#include <imgui.h>
49#include <imgui_stdlib.h>
50
51#include <SDL.h>
52
53#include <optional>
54
55using namespace std::literals;
56
57namespace openmsx {
58
60{
61 deinitListener();
62}
63
64void ImGuiSettings::save(ImGuiTextBuffer& buf)
65{
66 savePersistent(buf, *this, persistentElements);
67}
68
69void ImGuiSettings::loadLine(std::string_view name, zstring_view value)
70{
71 loadOnePersistent(name, value, *this, persistentElements);
72}
73
75{
76 setStyle();
77}
78
79void ImGuiSettings::setStyle() const
80{
81 switch (selectedStyle) {
82 case 0: ImGui::StyleColorsDark(); break;
83 case 1: ImGui::StyleColorsLight(); break;
84 case 2: ImGui::StyleColorsClassic(); break;
85 }
86 setColors(selectedStyle);
87}
88
89// Returns the currently pressed key-chord, or 'ImGuiKey_None' if no
90// (non-modifier) key is pressed.
91// If more than (non-modifier) one key is pressed, this returns an arbitrary key
92// (in the current implementation the one with lowest index).
93[[nodiscard]] static ImGuiKeyChord getCurrentlyPressedKeyChord()
94{
95 static constexpr auto mods = std::array{
96 ImGuiKey_LeftCtrl, ImGuiKey_LeftShift, ImGuiKey_LeftAlt, ImGuiKey_LeftSuper,
97 ImGuiKey_RightCtrl, ImGuiKey_RightShift, ImGuiKey_RightAlt, ImGuiKey_RightSuper,
98 ImGuiKey_ReservedForModCtrl, ImGuiKey_ReservedForModShift, ImGuiKey_ReservedForModAlt,
99 ImGuiKey_ReservedForModSuper, ImGuiKey_MouseLeft, ImGuiKey_MouseRight, ImGuiKey_MouseMiddle,
100 ImGuiKey_MouseX1, ImGuiKey_MouseX2, ImGuiKey_MouseWheelX, ImGuiKey_MouseWheelY,
101 };
102 for (int key = ImGuiKey_NamedKey_BEGIN; key < ImGuiKey_NamedKey_END; ++key) {
103 // This is O(M*N), if needed could be optimized to be O(M+N).
104 if (contains(mods, key)) continue; // skip: mods can't be primary keys in a KeyChord
105 if (ImGui::IsKeyPressed(static_cast<ImGuiKey>(key))) {
106 const ImGuiIO& io = ImGui::GetIO();
107 return key
108 | (io.KeyCtrl ? ImGuiMod_Ctrl : 0)
109 | (io.KeyShift ? ImGuiMod_Shift : 0)
110 | (io.KeyAlt ? ImGuiMod_Alt : 0)
111 | (io.KeySuper ? ImGuiMod_Super : 0);
112 }
113 }
114 return ImGuiKey_None;
115}
116
118{
119 bool openConfirmPopup = false;
120
121 im::Menu("Settings", [&]{
122 auto& reactor = manager.getReactor();
123 auto& globalSettings = reactor.getGlobalSettings();
124 auto& renderSettings = reactor.getDisplay().getRenderSettings();
125 const auto& settingsManager = reactor.getGlobalCommandController().getSettingsManager();
126 const auto& hotKey = reactor.getHotKey();
127
128 im::Menu("Video", [&]{
129 im::TreeNode("Look and feel", ImGuiTreeNodeFlags_DefaultOpen, [&]{
130 auto& scaler = renderSettings.getScaleAlgorithmSetting();
131 ComboBox("Scaler", scaler);
132 im::Indent([&]{
133 struct AlgoEnable {
135 bool hasScanline;
136 bool hasBlur;
137 };
139 static constexpr std::array algoEnables = {
140 // scanline / blur
141 AlgoEnable{SIMPLE, true, true },
142 AlgoEnable{SCALE, false, false},
143 AlgoEnable{HQ, false, false},
144 AlgoEnable{HQLITE, false, false},
145 AlgoEnable{RGBTRIPLET, true, true },
146 AlgoEnable{TV, true, false},
147 };
148 auto it = ranges::find(algoEnables, scaler.getEnum(), &AlgoEnable::algo);
149 assert(it != algoEnables.end());
150 im::Disabled(!it->hasScanline, [&]{
151 SliderInt("Scanline (%)", renderSettings.getScanlineSetting());
152 });
153 im::Disabled(!it->hasBlur, [&]{
154 SliderInt("Blur (%)", renderSettings.getBlurSetting());
155 });
156 });
157
158 SliderInt("Scale factor", renderSettings.getScaleFactorSetting());
159 Checkbox(hotKey, "Deinterlace", renderSettings.getDeinterlaceSetting());
160 Checkbox(hotKey, "Deflicker", renderSettings.getDeflickerSetting());
161 });
162 im::TreeNode("Colors", ImGuiTreeNodeFlags_DefaultOpen, [&]{
163 SliderFloat("Noise (%)", renderSettings.getNoiseSetting());
164 SliderFloat("Brightness", renderSettings.getBrightnessSetting());
165 SliderFloat("Contrast", renderSettings.getContrastSetting());
166 SliderFloat("Gamma", renderSettings.getGammaSetting());
167 SliderInt("Glow (%)", renderSettings.getGlowSetting());
168 if (auto* monitor = dynamic_cast<Setting*>(settingsManager.findSetting("monitor_type"))) {
169 ComboBox("Monitor type", *monitor, [](std::string s) {
170 ranges::replace(s, '_', ' ');
171 return s;
172 });
173 }
174 });
175 im::TreeNode("Shape", ImGuiTreeNodeFlags_DefaultOpen, [&]{
176 SliderFloat("Horizontal stretch", renderSettings.getHorizontalStretchSetting(), "%.0f");
177 ComboBox("Display deformation", renderSettings.getDisplayDeformSetting());
178 });
179 im::TreeNode("Misc", ImGuiTreeNodeFlags_DefaultOpen, [&]{
180 Checkbox(hotKey, "Full screen", renderSettings.getFullScreenSetting());
181 if (motherBoard) {
182 ComboBox("Video source to display", motherBoard->getVideoSource());
183 }
184 Checkbox(hotKey, "VSync", renderSettings.getVSyncSetting());
185 SliderInt("Minimum frame-skip", renderSettings.getMinFrameSkipSetting()); // TODO: either leave out this setting, or add a tooltip like, "Leave on 0 unless you use a very slow device and want regular frame skipping");
186 SliderInt("Maximum frame-skip", renderSettings.getMaxFrameSkipSetting()); // TODO: either leave out this setting or add a tooltip like "On slow devices, skip no more than this amount of frames to keep emulation on time.");
187 });
188 im::TreeNode("Advanced (for debugging)", [&]{ // default collapsed
189 Checkbox(hotKey, "Enforce VDP sprites-per-line limit", renderSettings.getLimitSpritesSetting());
190 Checkbox(hotKey, "Disable sprites", renderSettings.getDisableSpritesSetting());
191 ComboBox("Way to handle too fast VDP access", renderSettings.getTooFastAccessSetting());
192 ComboBox("Emulate VDP command timing", renderSettings.getCmdTimingSetting());
193 });
194 });
195 im::Menu("Sound", [&]{
196 auto& mixer = reactor.getMixer();
197 auto& muteSetting = mixer.getMuteSetting();
198 im::Disabled(muteSetting.getBoolean(), [&]{
199 SliderInt("Master volume", mixer.getMasterVolume());
200 });
201 Checkbox(hotKey, "Mute", muteSetting);
202 ImGui::Separator();
203 static constexpr std::array resamplerToolTips = {
204 EnumToolTip{"hq", "best quality, uses more CPU"},
205 EnumToolTip{"blip", "good speed/quality tradeoff"},
206 EnumToolTip{"fast", "fast but low quality"},
207 };
208 ComboBox("Resampler", globalSettings.getResampleSetting(), resamplerToolTips);
209 ImGui::Separator();
210
211 ImGui::MenuItem("Show sound chip settings", nullptr, &manager.soundChip->showSoundChipSettings);
212 });
213 im::Menu("Speed", [&]{
214 im::TreeNode("Emulation", ImGuiTreeNodeFlags_DefaultOpen, [&]{
215 ImGui::SameLine();
216 HelpMarker("These control the speed of the whole MSX machine, "
217 "the running MSX software can't tell the difference.");
218
219 auto& speedManager = globalSettings.getSpeedManager();
220 auto& fwdSetting = speedManager.getFastForwardSetting();
221 int fastForward = fwdSetting.getBoolean() ? 1 : 0;
222 ImGui::TextUnformatted("Speed:"sv);
223 ImGui::SameLine();
224 bool fwdChanged = ImGui::RadioButton("normal", &fastForward, 0);
225 ImGui::SameLine();
226 fwdChanged |= ImGui::RadioButton("fast forward", &fastForward, 1);
227 if (auto fastForwardShortCut = getShortCutForCommand(reactor.getHotKey(), "toggle fastforward");
228 !fastForwardShortCut.empty()) {
229 HelpMarker(strCat("Use '", fastForwardShortCut ,"' to quickly toggle between these two"));
230 }
231 if (fwdChanged) {
232 fwdSetting.setBoolean(fastForward != 0);
233 }
234 im::Indent([&]{
235 im::Disabled(fastForward != 0, [&]{
236 SliderInt("Speed (%)", speedManager.getSpeedSetting());
237 });
238 im::Disabled(fastForward != 1, [&]{
239 SliderInt("Fast forward speed (%)", speedManager.getFastForwardSpeedSetting());
240 });
241 });
242 Checkbox(hotKey, "Go full speed when loading", globalSettings.getThrottleManager().getFullSpeedLoadingSetting());
243 });
244 if (motherBoard) {
245 im::TreeNode("MSX devices", ImGuiTreeNodeFlags_DefaultOpen, [&]{
246 ImGui::SameLine();
247 HelpMarker("These control the speed of the specific components in the MSX machine. "
248 "So the relative speed between components can change. "
249 "And this may lead the emulation problems.");
250
251 MSXCPU& cpu = motherBoard->getCPU();
252 auto showFreqSettings = [&](std::string_view name, auto* core) {
253 if (!core) return;
254 auto& locked = core->getFreqLockedSetting();
255 auto& value = core->getFreqValueSetting();
256 // Note: GUI shows "UNlocked", while the actual settings is "locked"
257 bool unlocked = !locked.getBoolean();
258 if (ImGui::Checkbox(tmpStrCat("unlock custom ", name, " frequency").c_str(), &unlocked)) {
259 locked.setBoolean(!unlocked);
260 }
261 simpleToolTip([&]{ return locked.getDescription(); });
262 im::Indent([&]{
263 im::Disabled(!unlocked, [&]{
264 float fval = float(value.getInt()) / 1.0e6f;
265 if (ImGui::InputFloat(tmpStrCat("frequency (MHz)##", name).c_str(), &fval, 0.01f, 1.0f, "%.2f")) {
266 value.setInt(int(fval * 1.0e6f));
267 }
268 im::PopupContextItem(tmpStrCat("freq-context##", name).c_str(), [&]{
269 const char* F358 = name == "Z80" ? "3.58 MHz (default)"
270 : "3.58 MHz";
271 if (ImGui::Selectable(F358)) {
272 value.setInt(3'579'545);
273 }
274 if (ImGui::Selectable("5.37 MHz")) {
275 value.setInt(5'369'318);
276 }
277 const char* F716 = name == "R800" ? "7.16 MHz (default)"
278 : "7.16 MHz";
279 if (ImGui::Selectable(F716)) {
280 value.setInt(7'159'090);
281 }
282
283 });
284 HelpMarker("Right-click to select commonly used values");
285 });
286 });
287 };
288 showFreqSettings("Z80", cpu.getZ80());
289 showFreqSettings("R800", cpu.getR800()); // might be nullptr
290 });
291 }
292 });
293 im::Menu("Input", [&]{
294 static constexpr std::array kbdModeToolTips = {
295 EnumToolTip{"CHARACTER", "Tries to understand the character you are typing and then attempts to type that character using the current MSX keyboard. May not work very well when using a non-US host keyboard."},
296 EnumToolTip{"KEY", "Tries to map a key you press to the corresponding MSX key"},
297 EnumToolTip{"POSITIONAL", "Tries to map the keyboard key positions to the MSX keyboard key positions"},
298 };
299 if (motherBoard) {
300 const auto& controller = motherBoard->getMSXCommandController();
301 if (auto* turbo = dynamic_cast<IntegerSetting*>(controller.findSetting("renshaturbo"))) {
302 SliderInt("Ren Sha Turbo (%)", *turbo);
303 }
304 if (auto* mappingModeSetting = dynamic_cast<EnumSetting<KeyboardSettings::MappingMode>*>(controller.findSetting("kbd_mapping_mode"))) {
305 ComboBox("Keyboard mapping mode", *mappingModeSetting, kbdModeToolTips);
306 }
307 }
308 ImGui::MenuItem("Configure MSX joysticks...", nullptr, &showConfigureJoystick);
309 });
310 im::Menu("GUI", [&]{
311 auto getExistingLayouts = [] {
312 std::vector<std::string> names;
313 for (auto context = userDataFileContext("layouts");
314 const auto& path : context.getPaths()) {
315 foreach_file(path, [&](const std::string& fullName, std::string_view name) {
316 if (name.ends_with(".ini")) {
317 names.emplace_back(fullName);
318 }
319 });
320 }
322 return names;
323 };
324 auto listExistingLayouts = [&](const std::vector<std::string>& names) {
325 std::optional<std::pair<std::string, std::string>> selectedLayout;
326 im::ListBox("##select-layout", [&]{
327 for (const auto& name : names) {
328 auto displayName = std::string(FileOperations::stripExtension(FileOperations::getFilename(name)));
329 if (ImGui::Selectable(displayName.c_str())) {
330 selectedLayout = std::pair{name, displayName};
331 }
333 if (ImGui::MenuItem("delete")) {
334 confirmText = strCat("Delete layout: ", displayName);
335 confirmAction = [name]{ FileOperations::unlink(name); };
336 openConfirmPopup = true;
337 }
338 });
339 }
340 });
341 return selectedLayout;
342 };
343 im::Menu("Save layout", [&]{
344 if (auto names = getExistingLayouts(); !names.empty()) {
345 ImGui::TextUnformatted("Existing layouts"sv);
346 if (auto selectedLayout = listExistingLayouts(names)) {
347 const auto& [name, displayName] = *selectedLayout;
348 saveLayoutName = displayName;
349 }
350 }
351 ImGui::TextUnformatted("Enter name:"sv);
352 ImGui::InputText("##save-layout-name", &saveLayoutName);
353 ImGui::SameLine();
354 im::Disabled(saveLayoutName.empty(), [&]{
355 if (ImGui::Button("Save as")) {
356 (void)reactor.getDisplay().getWindowPosition(); // to save up-to-date window position
357 ImGui::CloseCurrentPopup();
358
359 auto filename = FileOperations::parseCommandFileArgument(
360 saveLayoutName, "layouts", "", ".ini");
361 if (FileOperations::exists(filename)) {
362 confirmText = strCat("Overwrite layout: ", saveLayoutName);
363 confirmAction = [filename]{
364 ImGui::SaveIniSettingsToDisk(filename.c_str());
365 };
366 openConfirmPopup = true;
367 } else {
368 ImGui::SaveIniSettingsToDisk(filename.c_str());
369 }
370 }
371 });
372 });
373 im::Menu("Restore layout", [&]{
374 ImGui::TextUnformatted("Select layout"sv);
375 auto names = getExistingLayouts();
376 if (auto selectedLayout = listExistingLayouts(names)) {
377 const auto& [name, displayName] = *selectedLayout;
378 manager.loadIniFile = name;
379 ImGui::CloseCurrentPopup();
380 }
381 });
382 im::Menu("Select style", [&]{
383 std::optional<int> newStyle;
384 static constexpr std::array names = {"Dark", "Light", "Classic"}; // must be in sync with setStyle()
385 for (auto i : xrange(narrow<int>(names.size()))) {
386 if (ImGui::Selectable(names[i], selectedStyle == i)) {
387 newStyle = i;
388 }
389 }
390 if (newStyle) {
391 selectedStyle = *newStyle;
392 setStyle();
393 }
394 });
395 ImGui::MenuItem("Select font...", nullptr, &showFont);
396 ImGui::MenuItem("Edit shortcuts...", nullptr, &showShortcut);
397 });
398 im::Menu("Misc", [&]{
399 ImGui::MenuItem("Configure OSD icons...", nullptr, &manager.osdIcons->showConfigureIcons);
400 ImGui::MenuItem("Fade out menu bar", nullptr, &manager.menuFade);
401 ImGui::MenuItem("Show status bar", nullptr, &manager.statusBarVisible);
402 ImGui::MenuItem("Configure messages...", nullptr, &manager.messages->configureWindow.open);
403 });
404 ImGui::Separator();
405 im::Menu("Advanced", [&]{
406 ImGui::TextUnformatted("All settings"sv);
407 ImGui::Separator();
408 std::vector<Setting*> settings;
409 for (auto* setting : settingsManager.getAllSettings()) {
410 if (dynamic_cast<ProxySetting*>(setting)) continue;
411 if (dynamic_cast<ReadOnlySetting*>(setting)) continue;
412 settings.push_back(checked_cast<Setting*>(setting));
413 }
415 for (auto* setting : settings) {
416 if (auto* bSetting = dynamic_cast<BooleanSetting*>(setting)) {
417 Checkbox(hotKey, *bSetting);
418 } else if (auto* iSetting = dynamic_cast<IntegerSetting*>(setting)) {
419 SliderInt(*iSetting);
420 } else if (auto* fSetting = dynamic_cast<FloatSetting*>(setting)) {
421 SliderFloat(*fSetting);
422 } else if (auto* sSetting = dynamic_cast<StringSetting*>(setting)) {
423 InputText(*sSetting);
424 } else if (auto* fnSetting = dynamic_cast<FilenameSetting*>(setting)) {
425 InputText(*fnSetting); // TODO
426 } else if (auto* kSetting = dynamic_cast<KeyCodeSetting*>(setting)) {
427 InputText(*kSetting); // TODO
428 } else if (dynamic_cast<EnumSettingBase*>(setting)) {
430 } else if (auto* vSetting = dynamic_cast<VideoSourceSetting*>(setting)) {
431 ComboBox(*vSetting);
432 } else {
433 assert(false);
434 }
435 }
436 if (!Version::RELEASE) {
437 ImGui::Separator();
438 ImGui::Checkbox("ImGui Demo Window", &showDemoWindow);
439 HelpMarker("Show the ImGui demo window.\n"
440 "This is purely to demonstrate the ImGui capabilities.\n"
441 "There is no connection with any openMSX functionality.");
442 }
443 });
444 });
445 if (showDemoWindow) {
446 ImGui::ShowDemoWindow(&showDemoWindow);
447 }
448
449 const auto confirmTitle = "Confirm##settings";
450 if (openConfirmPopup) {
451 ImGui::OpenPopup(confirmTitle);
452 }
453 im::PopupModal(confirmTitle, nullptr, ImGuiWindowFlags_AlwaysAutoResize, [&]{
454 ImGui::TextUnformatted(confirmText);
455
456 bool close = false;
457 if (ImGui::Button("Ok")) {
458 confirmAction();
459 close = true;
460 }
461 ImGui::SameLine();
462 close |= ImGui::Button("Cancel");
463 if (close) {
464 ImGui::CloseCurrentPopup();
465 confirmAction = {};
466 }
467 });
468}
469
471
472// joystick is 0..3
473[[nodiscard]] static std::string settingName(unsigned joystick)
474{
475 return (joystick < 2) ? strCat("msxjoystick", joystick + 1, "_config")
476 : strCat("joymega", joystick - 1, "_config");
477}
478
479// joystick is 0..3
480[[nodiscard]] static std::string joystickToGuiString(unsigned joystick)
481{
482 return (joystick < 2) ? strCat("MSX joystick ", joystick + 1)
483 : strCat("JoyMega controller ", joystick - 1);
484}
485
486[[nodiscard]] static std::string toGuiString(const BooleanInput& input, const JoystickManager& joystickManager)
487{
488 return std::visit(overloaded{
489 [](const BooleanKeyboard& k) {
490 return strCat("keyboard key ", SDLKey::toString(k.getKeyCode()));
491 },
492 [](const BooleanMouseButton& m) {
493 return strCat("mouse button ", m.getButton());
494 },
495 [&](const BooleanJoystickButton& j) {
496 return strCat(joystickManager.getDisplayName(j.getJoystick()), " button ", j.getButton());
497 },
498 [&](const BooleanJoystickHat& h) {
499 return strCat(joystickManager.getDisplayName(h.getJoystick()), " D-pad ", h.getHat(), ' ', toString(h.getValue()));
500 },
501 [&](const BooleanJoystickAxis& a) {
502 return strCat(joystickManager.getDisplayName(a.getJoystick()),
503 " stick axis ", a.getAxis(), ", ",
504 (a.getDirection() == BooleanJoystickAxis::Direction::POS ? "positive" : "negative"), " direction");
505 }
506 }, input);
507}
508
509[[nodiscard]] static bool insideCircle(gl::vec2 mouse, gl::vec2 center, float radius)
510{
511 auto delta = center - mouse;
512 return gl::sum(delta * delta) <= (radius * radius);
513}
514[[nodiscard]] static bool between(float x, float min, float max)
515{
516 return (min <= x) && (x <= max);
517}
518
519struct Rectangle {
522};
523[[nodiscard]] static bool insideRectangle(gl::vec2 mouse, Rectangle r)
524{
525 return between(mouse.x, r.topLeft.x, r.bottomRight.x) &&
526 between(mouse.y, r.topLeft.y, r.bottomRight.y);
527}
528
529
530static constexpr auto fractionDPad = 1.0f / 3.0f;
531static constexpr auto thickness = 3.0f;
532
533static void drawDPad(gl::vec2 center, float size, std::span<const uint8_t, 4> hovered, int hoveredRow)
534{
535 const auto F = fractionDPad;
536 std::array<std::array<ImVec2, 5 + 1>, 4> points = {
537 std::array<ImVec2, 5 + 1>{ // UP
538 center + size * gl::vec2{ 0, 0},
539 center + size * gl::vec2{-F, -F},
540 center + size * gl::vec2{-F, -1},
541 center + size * gl::vec2{ F, -1},
542 center + size * gl::vec2{ F, -F},
543 center + size * gl::vec2{ 0, 0},
544 },
545 std::array<ImVec2, 5 + 1>{ // DOWN
546 center + size * gl::vec2{ 0, 0},
547 center + size * gl::vec2{ F, F},
548 center + size * gl::vec2{ F, 1},
549 center + size * gl::vec2{-F, 1},
550 center + size * gl::vec2{-F, F},
551 center + size * gl::vec2{ 0, 0},
552 },
553 std::array<ImVec2, 5 + 1>{ // LEFT
554 center + size * gl::vec2{ 0, 0},
555 center + size * gl::vec2{-F, F},
556 center + size * gl::vec2{-1, F},
557 center + size * gl::vec2{-1, -F},
558 center + size * gl::vec2{-F, -F},
559 center + size * gl::vec2{ 0, 0},
560 },
561 std::array<ImVec2, 5 + 1>{ // RIGHT
562 center + size * gl::vec2{ 0, 0},
563 center + size * gl::vec2{ F, -F},
564 center + size * gl::vec2{ 1, -F},
565 center + size * gl::vec2{ 1, F},
566 center + size * gl::vec2{ F, F},
567 center + size * gl::vec2{ 0, 0},
568 },
569 };
570
571 auto* drawList = ImGui::GetWindowDrawList();
572 auto hoverColor = ImGui::GetColorU32(ImGuiCol_ButtonHovered);
573
574 auto color = getColor(imColor::TEXT);
575 for (auto i : xrange(4)) {
576 if (hovered[i] || (hoveredRow == i)) {
577 drawList->AddConvexPolyFilled(points[i].data(), 5, hoverColor);
578 }
579 drawList->AddPolyline(points[i].data(), 5 + 1, color, 0, thickness);
580 }
581}
582
583static void drawFilledCircle(gl::vec2 center, float radius, bool fill)
584{
585 auto* drawList = ImGui::GetWindowDrawList();
586 if (fill) {
587 auto hoverColor = ImGui::GetColorU32(ImGuiCol_ButtonHovered);
588 drawList->AddCircleFilled(center, radius, hoverColor);
589 }
590 auto color = getColor(imColor::TEXT);
591 drawList->AddCircle(center, radius, color, 0, thickness);
592}
593static void drawFilledRectangle(Rectangle r, float corner, bool fill)
594{
595 auto* drawList = ImGui::GetWindowDrawList();
596 if (fill) {
597 auto hoverColor = ImGui::GetColorU32(ImGuiCol_ButtonHovered);
598 drawList->AddRectFilled(r.topLeft, r.bottomRight, hoverColor, corner);
599 }
600 auto color = getColor(imColor::TEXT);
601 drawList->AddRect(r.topLeft, r.bottomRight, color, corner, 0, thickness);
602}
603
604static void drawLetterA(gl::vec2 center)
605{
606 auto* drawList = ImGui::GetWindowDrawList();
607 auto tr = [&](gl::vec2 p) { return center + p; };
608 const std::array<ImVec2, 3> lines = { tr({-6, 7}), tr({0, -7}), tr({6, 7}) };
609 auto color = getColor(imColor::TEXT);
610 drawList->AddPolyline(lines.data(), lines.size(), color, 0, thickness);
611 drawList->AddLine(tr({-3, 1}), tr({3, 1}), color, thickness);
612}
613static void drawLetterB(gl::vec2 center)
614{
615 auto* drawList = ImGui::GetWindowDrawList();
616 auto tr = [&](gl::vec2 p) { return center + p; };
617 const std::array<ImVec2, 4> lines = { tr({1, -7}), tr({-4, -7}), tr({-4, 7}), tr({2, 7}) };
618 auto color = getColor(imColor::TEXT);
619 drawList->AddPolyline(lines.data(), lines.size(), color, 0, thickness);
620 drawList->AddLine(tr({-4, -1}), tr({2, -1}), color, thickness);
621 drawList->AddBezierQuadratic(tr({1, -7}), tr({4, -7}), tr({4, -4}), color, thickness);
622 drawList->AddBezierQuadratic(tr({4, -4}), tr({4, -1}), tr({1, -1}), color, thickness);
623 drawList->AddBezierQuadratic(tr({2, -1}), tr({6, -1}), tr({6, 3}), color, thickness);
624 drawList->AddBezierQuadratic(tr({6, 3}), tr({6, 7}), tr({2, 7}), color, thickness);
625}
626static void drawLetterC(gl::vec2 center)
627{
628 auto* drawList = ImGui::GetWindowDrawList();
629 auto tr = [&](gl::vec2 p) { return center + p; };
630 auto color = getColor(imColor::TEXT);
631 drawList->AddBezierCubic(tr({5, -5}), tr({-8, -16}), tr({-8, 16}), tr({5, 5}), color, thickness);
632}
633static void drawLetterX(gl::vec2 center)
634{
635 auto* drawList = ImGui::GetWindowDrawList();
636 auto tr = [&](gl::vec2 p) { return center + p; };
637 auto color = getColor(imColor::TEXT);
638 drawList->AddLine(tr({-4, -6}), tr({4, 6}), color, thickness);
639 drawList->AddLine(tr({-4, 6}), tr({4, -6}), color, thickness);
640}
641static void drawLetterY(gl::vec2 center)
642{
643 auto* drawList = ImGui::GetWindowDrawList();
644 auto tr = [&](gl::vec2 p) { return center + p; };
645 auto color = getColor(imColor::TEXT);
646 drawList->AddLine(tr({-4, -6}), tr({0, 0}), color, thickness);
647 drawList->AddLine(tr({-4, 6}), tr({4, -6}), color, thickness);
648}
649static void drawLetterZ(gl::vec2 center)
650{
651 auto* drawList = ImGui::GetWindowDrawList();
652 auto tr = [&](gl::vec2 p) { return center + p; };
653 const std::array<ImVec2, 4> linesZ2 = { tr({-4, -6}), tr({4, -6}), tr({-4, 6}), tr({4, 6}) };
654 auto color = getColor(imColor::TEXT);
655 drawList->AddPolyline(linesZ2.data(), 4, color, 0, thickness);
656}
657
658namespace msxjoystick {
659
661
662static constexpr std::array<zstring_view, NUM_BUTTONS> buttonNames = {
663 "Up", "Down", "Left", "Right", "A", "B" // show in the GUI
664};
665static constexpr std::array<zstring_view, NUM_BUTTONS> keyNames = {
666 "UP", "DOWN", "LEFT", "RIGHT", "A", "B" // keys in Tcl dict
667};
668
669// Customize joystick look
670static constexpr auto boundingBox = gl::vec2{300.0f, 100.0f};
671static constexpr auto radius = 20.0f;
672static constexpr auto corner = 10.0f;
673static constexpr auto centerA = gl::vec2{200.0f, 50.0f};
674static constexpr auto centerB = gl::vec2{260.0f, 50.0f};
675static constexpr auto centerDPad = gl::vec2{50.0f, 50.0f};
676static constexpr auto sizeDPad = 30.0f;
677
678[[nodiscard]] static std::vector<uint8_t> buttonsHovered(gl::vec2 mouse)
679{
680 std::vector<uint8_t> result(NUM_BUTTONS); // false
681 auto mouseDPad = (mouse - centerDPad) * (1.0f / sizeDPad);
682 if (insideRectangle(mouseDPad, Rectangle{{-1, -1}, {1, 1}}) &&
683 (between(mouseDPad.x, -fractionDPad, fractionDPad) ||
684 between(mouseDPad.y, -fractionDPad, fractionDPad))) { // mouse over d-pad
685 bool t1 = mouseDPad.x < mouseDPad.y;
686 bool t2 = mouseDPad.x < -mouseDPad.y;
687 result[UP] = !t1 && t2;
688 result[DOWN] = t1 && !t2;
689 result[LEFT] = t1 && t2;
690 result[RIGHT] = !t1 && !t2;
691 }
692 result[TRIG_A] = insideCircle(mouse, centerA, radius);
693 result[TRIG_B] = insideCircle(mouse, centerB, radius);
694 return result;
695}
696
697static void draw(gl::vec2 scrnPos, std::span<uint8_t> hovered, int hoveredRow)
698{
699 auto* drawList = ImGui::GetWindowDrawList();
700
701 auto color = getColor(imColor::TEXT);
702 drawList->AddRect(scrnPos, scrnPos + boundingBox, color, corner, 0, thickness);
703
704 drawDPad(scrnPos + centerDPad, sizeDPad, subspan<4>(hovered), hoveredRow);
705
706 auto scrnCenterA = scrnPos + centerA;
707 drawFilledCircle(scrnCenterA, radius, hovered[TRIG_A] || (hoveredRow == TRIG_A));
708 drawLetterA(scrnCenterA);
709
710 auto scrnCenterB = scrnPos + centerB;
711 drawFilledCircle(scrnCenterB, radius, hovered[TRIG_B] || (hoveredRow == TRIG_B));
712 drawLetterB(scrnCenterB);
713}
714
715} // namespace msxjoystick
716
717namespace joymega {
718
719enum {UP, DOWN, LEFT, RIGHT,
720 TRIG_A, TRIG_B, TRIG_C,
723 NUM_BUTTONS};
724
725static constexpr std::array<zstring_view, NUM_BUTTONS> buttonNames = { // show in the GUI
726 "Up", "Down", "Left", "Right",
727 "A", "B", "C",
728 "X", "Y", "Z",
729 "Select", "Start",
730};
731static constexpr std::array<zstring_view, NUM_BUTTONS> keyNames = { // keys in Tcl dict
732 "UP", "DOWN", "LEFT", "RIGHT",
733 "A", "B", "C",
734 "X", "Y", "Z",
735 "SELECT", "START",
736};
737
738// Customize joystick look
739static constexpr auto thickness = 3.0f;
740static constexpr auto boundingBox = gl::vec2{300.0f, 158.0f};
741static constexpr auto centerA = gl::vec2{205.0f, 109.9f};
742static constexpr auto centerB = gl::vec2{235.9f, 93.5f};
743static constexpr auto centerC = gl::vec2{269.7f, 83.9f};
744static constexpr auto centerX = gl::vec2{194.8f, 75.2f};
745static constexpr auto centerY = gl::vec2{223.0f, 61.3f};
746static constexpr auto centerZ = gl::vec2{252.2f, 52.9f};
747static constexpr auto selectBox = Rectangle{gl::vec2{130.0f, 60.0f}, gl::vec2{160.0f, 70.0f}};
748static constexpr auto startBox = Rectangle{gl::vec2{130.0f, 86.0f}, gl::vec2{160.0f, 96.0f}};
749static constexpr auto radiusABC = 16.2f;
750static constexpr auto radiusXYZ = 12.2f;
751static constexpr auto centerDPad = gl::vec2{65.6f, 82.7f};
752static constexpr auto sizeDPad = 34.0f;
753static constexpr auto fractionDPad = 1.0f / 3.0f;
754
755[[nodiscard]] static std::vector<uint8_t> buttonsHovered(gl::vec2 mouse)
756{
757 std::vector<uint8_t> result(NUM_BUTTONS); // false
758 auto mouseDPad = (mouse - centerDPad) * (1.0f / sizeDPad);
759 if (insideRectangle(mouseDPad, Rectangle{{-1, -1}, {1, 1}}) &&
760 (between(mouseDPad.x, -fractionDPad, fractionDPad) ||
761 between(mouseDPad.y, -fractionDPad, fractionDPad))) { // mouse over d-pad
762 bool t1 = mouseDPad.x < mouseDPad.y;
763 bool t2 = mouseDPad.x < -mouseDPad.y;
764 result[UP] = !t1 && t2;
765 result[DOWN] = t1 && !t2;
766 result[LEFT] = t1 && t2;
767 result[RIGHT] = !t1 && !t2;
768 }
769 result[TRIG_A] = insideCircle(mouse, centerA, radiusABC);
770 result[TRIG_B] = insideCircle(mouse, centerB, radiusABC);
771 result[TRIG_C] = insideCircle(mouse, centerC, radiusABC);
772 result[TRIG_X] = insideCircle(mouse, centerX, radiusXYZ);
773 result[TRIG_Y] = insideCircle(mouse, centerY, radiusXYZ);
774 result[TRIG_Z] = insideCircle(mouse, centerZ, radiusXYZ);
775 result[TRIG_START] = insideRectangle(mouse, startBox);
776 result[TRIG_SELECT] = insideRectangle(mouse, selectBox);
777 return result;
778}
779
780static void draw(gl::vec2 scrnPos, std::span<uint8_t> hovered, int hoveredRow)
781{
782 auto* drawList = ImGui::GetWindowDrawList();
783 auto tr = [&](gl::vec2 p) { return scrnPos + p; };
784 auto color = getColor(imColor::TEXT);
785
786 auto drawBezierCurve = [&](std::span<const gl::vec2> points, float thick = 1.0f) {
787 assert((points.size() % 2) == 0);
788 for (size_t i = 0; i < points.size() - 2; i += 2) {
789 auto ap = points[i + 0];
790 auto ad = points[i + 1];
791 auto bp = points[i + 2];
792 auto bd = points[i + 3];
793 drawList->AddBezierCubic(tr(ap), tr(ap + ad), tr(bp - bd), tr(bp), color, thick);
794 }
795 };
796
797 std::array outLine = {
798 gl::vec2{150.0f, 0.0f}, gl::vec2{ 23.1f, 0.0f},
799 gl::vec2{258.3f, 30.3f}, gl::vec2{ 36.3f, 26.4f},
800 gl::vec2{300.0f, 107.0f}, gl::vec2{ 0.0f, 13.2f},
801 gl::vec2{285.2f, 145.1f}, gl::vec2{ -9.9f, 9.9f},
802 gl::vec2{255.3f, 157.4f}, gl::vec2{ -9.0f, 0.0f},
803 gl::vec2{206.0f, 141.8f}, gl::vec2{-16.2f, -5.6f},
804 gl::vec2{150.0f, 131.9f}, gl::vec2{-16.5f, 0.0f},
805 gl::vec2{ 94.0f, 141.8f}, gl::vec2{-16.2f, 5.6f},
806 gl::vec2{ 44.7f, 157.4f}, gl::vec2{ -9.0f, 0.0f},
807 gl::vec2{ 14.8f, 145.1f}, gl::vec2{ -9.9f, -9.9f},
808 gl::vec2{ 0.0f, 107.0f}, gl::vec2{ 0.0f, -13.2f},
809 gl::vec2{ 41.7f, 30.3f}, gl::vec2{ 36.3f, -26.4f},
810 gl::vec2{150.0f, 0.0f}, gl::vec2{ 23.1f, 0.0f}, // closed loop
811 };
812 drawBezierCurve(outLine, thickness);
813
814 drawDPad(tr(centerDPad), sizeDPad, subspan<4>(hovered), hoveredRow);
815 drawList->AddCircle(tr(centerDPad), 43.0f, color);
816 std::array dPadCurve = {
817 gl::vec2{77.0f, 33.0f}, gl::vec2{ 69.2f, 0.0f},
818 gl::vec2{54.8f, 135.2f}, gl::vec2{-66.9f, 0.0f},
819 gl::vec2{77.0f, 33.0f}, gl::vec2{ 69.2f, 0.0f},
820 };
821 drawBezierCurve(dPadCurve);
822
823 drawFilledCircle(tr(centerA), radiusABC, hovered[TRIG_A] || (hoveredRow == TRIG_A));
824 drawLetterA(tr(centerA));
825 drawFilledCircle(tr(centerB), radiusABC, hovered[TRIG_B] || (hoveredRow == TRIG_B));
826 drawLetterB(tr(centerB));
827 drawFilledCircle(tr(centerC), radiusABC, hovered[TRIG_C] || (hoveredRow == TRIG_C));
828 drawLetterC(tr(centerC));
829 drawFilledCircle(tr(centerX), radiusXYZ, hovered[TRIG_X] || (hoveredRow == TRIG_X));
830 drawLetterX(tr(centerX));
831 drawFilledCircle(tr(centerY), radiusXYZ, hovered[TRIG_Y] || (hoveredRow == TRIG_Y));
832 drawLetterY(tr(centerY));
833 drawFilledCircle(tr(centerZ), radiusXYZ, hovered[TRIG_Z] || (hoveredRow == TRIG_Z));
834 drawLetterZ(tr(centerZ));
835 std::array buttonCurve = {
836 gl::vec2{221.1f, 28.9f}, gl::vec2{ 80.1f, 0.0f},
837 gl::vec2{236.9f, 139.5f}, gl::vec2{-76.8f, 0.0f},
838 gl::vec2{221.1f, 28.9f}, gl::vec2{ 80.1f, 0.0f},
839 };
840 drawBezierCurve(buttonCurve);
841
842 auto corner = (selectBox.bottomRight.y - selectBox.topLeft.y) * 0.5f;
843 auto trR = [&](Rectangle r) { return Rectangle{tr(r.topLeft), tr(r.bottomRight)}; };
844 drawFilledRectangle(trR(selectBox), corner, hovered[TRIG_SELECT] || (hoveredRow == TRIG_SELECT));
845 drawList->AddText(ImGui::GetFont(), ImGui::GetFontSize(), tr({123.0f, 46.0f}), color, "Select");
846 drawFilledRectangle(trR(startBox), corner, hovered[TRIG_START] || (hoveredRow == TRIG_START));
847 drawList->AddText(ImGui::GetFont(), ImGui::GetFontSize(), tr({128.0f, 97.0f}), color, "Start");
848}
849
850} // namespace joymega
851
852void ImGuiSettings::paintJoystick(MSXMotherBoard& motherBoard)
853{
854 ImGui::SetNextWindowSize(gl::vec2{316, 323}, ImGuiCond_FirstUseEver);
855 im::Window("Configure MSX joysticks", &showConfigureJoystick, [&]{
856 ImGui::SetNextItemWidth(13.0f * ImGui::GetFontSize());
857 im::Combo("Select joystick", joystickToGuiString(joystick).c_str(), [&]{
858 for (const auto& j : xrange(4)) {
859 if (ImGui::Selectable(joystickToGuiString(j).c_str())) {
860 joystick = j;
861 }
862 }
863 });
864
865 const auto& joystickManager = manager.getReactor().getInputEventGenerator().getJoystickManager();
866 const auto& controller = motherBoard.getMSXCommandController();
867 auto* setting = dynamic_cast<StringSetting*>(controller.findSetting(settingName(joystick)));
868 if (!setting) return;
869 auto& interp = setting->getInterpreter();
870 TclObject bindings = setting->getValue();
871
872 gl::vec2 scrnPos = ImGui::GetCursorScreenPos();
873 gl::vec2 mouse = gl::vec2(ImGui::GetIO().MousePos) - scrnPos;
874
875 // Check if buttons are hovered
876 bool msxOrMega = joystick < 2;
877 auto hovered = msxOrMega ? msxjoystick::buttonsHovered(mouse)
878 : joymega ::buttonsHovered(mouse);
879 const auto numButtons = hovered.size();
880 using SP = std::span<const zstring_view>;
881 auto keyNames = msxOrMega ? SP{msxjoystick::keyNames}
882 : SP{joymega ::keyNames};
883 auto buttonNames = msxOrMega ? SP{msxjoystick::buttonNames}
884 : SP{joymega ::buttonNames};
885
886 // Any joystick button clicked?
887 std::optional<int> addAction;
888 std::optional<int> removeAction;
889 if (ImGui::IsMouseReleased(ImGuiMouseButton_Left)) {
890 for (auto i : xrange(numButtons)) {
891 if (hovered[i]) addAction = narrow<int>(i);
892 }
893 }
894
895 ImGui::Dummy(msxOrMega ? msxjoystick::boundingBox : joymega::boundingBox); // reserve space for joystick drawing
896
897 // Draw table
898 int hoveredRow = -1;
899 const auto& style = ImGui::GetStyle();
900 auto textHeight = ImGui::GetTextLineHeight();
901 float rowHeight = 2.0f * style.FramePadding.y + textHeight;
902 float bottomHeight = style.ItemSpacing.y + 2.0f * style.FramePadding.y + textHeight;
903 im::Table("##joystick-table", 2, ImGuiTableFlags_SizingFixedFit | ImGuiTableFlags_ScrollX, {0.0f, -bottomHeight}, [&]{
904 im::ID_for_range(numButtons, [&](int i) {
905 TclObject key(keyNames[i]);
906 TclObject bindingList = bindings.getDictValue(interp, key);
907 if (ImGui::TableNextColumn()) {
908 auto pos = ImGui::GetCursorPos();
909 ImGui::Selectable("##row", hovered[i], ImGuiSelectableFlags_SpanAllColumns | ImGuiSelectableFlags_AllowOverlap, ImVec2(0, rowHeight));
910 if (ImGui::IsItemHovered()) {
911 hoveredRow = i;
912 }
913
914 ImGui::SetCursorPos(pos);
915 ImGui::AlignTextToFramePadding();
916 ImGui::TextUnformatted(buttonNames[i]);
917 }
918 if (ImGui::TableNextColumn()) {
919 if (ImGui::Button("Add")) {
920 addAction = i;
921 }
922 ImGui::SameLine();
923 auto numBindings = bindingList.size();
924 im::Disabled(numBindings == 0, [&]{
925 if (ImGui::Button("Remove")) {
926 if (numBindings == 1) {
927 bindings.setDictValue(interp, key, TclObject{});
928 setting->setValue(bindings);
929 } else {
930 removeAction = i;
931 }
932 }
933 });
934 ImGui::SameLine();
935 if (numBindings == 0) {
936 ImGui::TextDisabled("no bindings");
937 } else {
938 size_t lastBindingIndex = numBindings - 1;
939 size_t bindingIndex = 0;
940 for (auto binding: bindingList) {
941 ImGui::TextUnformatted(binding);
942 simpleToolTip(toGuiString(*parseBooleanInput(binding), joystickManager));
943 if (bindingIndex < lastBindingIndex) {
944 ImGui::SameLine();
946 ImGui::SameLine();
947 }
948 ++bindingIndex;
949 }
950 }
951 }
952 });
953 });
954 msxOrMega ? msxjoystick::draw(scrnPos, hovered, hoveredRow)
955 : joymega ::draw(scrnPos, hovered, hoveredRow);
956
957 if (ImGui::Button("Default bindings...")) {
958 ImGui::OpenPopup("bindings");
959 }
960 im::Popup("bindings", [&]{
961 auto addOrSet = [&](auto getBindings) {
962 if (ImGui::MenuItem("Add to current bindings")) {
963 // merge 'newBindings' into 'bindings'
964 auto newBindings = getBindings();
965 for (auto k : xrange(int(numButtons))) {
966 TclObject key(keyNames[k]);
967 TclObject dstList = bindings.getDictValue(interp, key);
968 TclObject srcList = newBindings.getDictValue(interp, key);
969 // This is O(N^2), but that's fine (here).
970 for (auto b : srcList) {
971 if (!contains(dstList, b)) {
972 dstList.addListElement(b);
973 }
974 }
975 bindings.setDictValue(interp, key, dstList);
976 }
977 setting->setValue(bindings);
978 }
979 if (ImGui::MenuItem("Replace current bindings")) {
980 setting->setValue(getBindings());
981 }
982 };
983 im::Menu("Keyboard", [&]{
984 addOrSet([] {
985 return TclObject(TclObject::MakeDictTag{},
986 "UP", makeTclList("keyb Up"),
987 "DOWN", makeTclList("keyb Down"),
988 "LEFT", makeTclList("keyb Left"),
989 "RIGHT", makeTclList("keyb Right"),
990 "A", makeTclList("keyb Space"),
991 "B", makeTclList("keyb M"));
992 });
993 });
994 for (auto joyId : joystickManager.getConnectedJoysticks()) {
995 im::Menu(joystickManager.getDisplayName(joyId).c_str(), [&]{
996 addOrSet([&]{
997 return msxOrMega
998 ? MSXJoystick::getDefaultConfig(joyId, joystickManager)
999 : JoyMega::getDefaultConfig(joyId, joystickManager);
1000 });
1001 });
1002 }
1003 });
1004
1005 // Popup for 'Add'
1006 static constexpr auto addTitle = "Waiting for input";
1007 if (addAction) {
1008 popupForKey = *addAction;
1009 popupTimeout = 5.0f;
1010 initListener();
1011 ImGui::OpenPopup(addTitle);
1012 }
1013 im::PopupModal(addTitle, nullptr, ImGuiWindowFlags_NoSavedSettings, [&]{
1014 auto close = [&]{
1015 ImGui::CloseCurrentPopup();
1016 popupForKey = unsigned(-1);
1017 deinitListener();
1018 };
1019 if (popupForKey >= numButtons) {
1020 close();
1021 return;
1022 }
1023
1024 ImGui::Text("Enter event for joystick button '%s'", buttonNames[popupForKey].c_str());
1025 ImGui::Text("Or press ESC to cancel. Timeout in %d seconds.", int(popupTimeout));
1026
1027 popupTimeout -= ImGui::GetIO().DeltaTime;
1028 if (popupTimeout <= 0.0f) {
1029 close();
1030 }
1031 });
1032
1033 // Popup for 'Remove'
1034 if (removeAction) {
1035 popupForKey = *removeAction;
1036 ImGui::OpenPopup("remove");
1037 }
1038 im::Popup("remove", [&]{
1039 auto close = [&]{
1040 ImGui::CloseCurrentPopup();
1041 popupForKey = unsigned(-1);
1042 };
1043 if (popupForKey >= numButtons) {
1044 close();
1045 return;
1046 }
1047 TclObject key(keyNames[popupForKey]);
1048 TclObject bindingList = bindings.getDictValue(interp, key);
1049
1050 unsigned remove = -1u;
1051 unsigned counter = 0;
1052 for (const auto& b : bindingList) {
1053 if (ImGui::Selectable(b.c_str())) {
1054 remove = counter;
1055 }
1056 simpleToolTip(toGuiString(*parseBooleanInput(b), joystickManager));
1057 ++counter;
1058 }
1059 if (remove != unsigned(-1)) {
1060 bindingList.removeListIndex(interp, remove);
1061 bindings.setDictValue(interp, key, bindingList);
1062 setting->setValue(bindings);
1063 close();
1064 }
1065
1066 if (ImGui::Selectable("all bindings")) {
1067 bindings.setDictValue(interp, key, TclObject{});
1068 setting->setValue(bindings);
1069 close();
1070 }
1071 });
1072 });
1073}
1074
1075void ImGuiSettings::paintFont()
1076{
1077 im::Window("Select font", &showFont, [&]{
1078 auto selectFilename = [&](FilenameSetting& setting, float width) {
1079 auto display = [](std::string_view name) {
1080 if (name.ends_with(".gz" )) name.remove_suffix(3);
1081 if (name.ends_with(".ttf")) name.remove_suffix(4);
1082 return std::string(name);
1083 };
1084 auto current = setting.getString();
1085 ImGui::SetNextItemWidth(width);
1086 im::Combo(tmpStrCat("##", setting.getBaseName()).c_str(), display(current).c_str(), [&]{
1087 for (const auto& font : getAvailableFonts()) {
1088 if (ImGui::Selectable(display(font).c_str(), current == font)) {
1089 setting.setString(font);
1090 }
1091 }
1092 });
1093 };
1094 auto selectSize = [](IntegerSetting& setting) {
1095 auto display = [](int s) { return strCat(s); };
1096 auto current = setting.getInt();
1097 ImGui::SetNextItemWidth(4.0f * ImGui::GetFontSize());
1098 im::Combo(tmpStrCat("##", setting.getBaseName()).c_str(), display(current).c_str(), [&]{
1099 for (int size : {9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 20, 22, 24, 26, 28, 30, 32}) {
1100 if (ImGui::Selectable(display(size).c_str(), current == size)) {
1101 setting.setInt(size);
1102 }
1103 }
1104 });
1105 };
1106
1107 auto pos = ImGui::CalcTextSize("Monospace").x + 2.0f * ImGui::GetStyle().ItemSpacing.x;
1108 auto width = 12.0f * ImGui::GetFontSize(); // filename ComboBox (boxes are drawn with different font, but we want same width)
1109
1110 ImGui::AlignTextToFramePadding();
1111 ImGui::TextUnformatted("Normal");
1112 ImGui::SameLine(pos);
1113 selectFilename(manager.fontPropFilename, width);
1114 ImGui::SameLine();
1115 selectSize(manager.fontPropSize);
1116 HelpMarker("You can install more fonts by copying .ttf file(s) to your \"<openmsx>/share/skins\" directory.");
1117
1118 ImGui::AlignTextToFramePadding();
1119 ImGui::TextUnformatted("Monospace");
1120 ImGui::SameLine(pos);
1121 im::Font(manager.fontMono, [&]{
1122 selectFilename(manager.fontMonoFilename, width);
1123 });
1124 ImGui::SameLine();
1125 selectSize(manager.fontMonoSize);
1126 HelpMarker("Some GUI elements (e.g. the console) require a monospaced font.");
1127 });
1128}
1129
1130[[nodiscard]] static std::string formatShortcutWithAnnotations(const Shortcuts::Shortcut& shortcut)
1131{
1132 auto result = getKeyChordName(shortcut.keyChord);
1133 // don't show the 'ALWAYS_xxx' values
1134 if (shortcut.type == Shortcuts::Type::GLOBAL) result += ", global";
1135 return result;
1136}
1137
1138[[nodiscard]] static gl::vec2 buttonSize(std::string_view text, float defaultSize_)
1139{
1140 const auto& style = ImGui::GetStyle();
1141 auto textSize = ImGui::CalcTextSize(text).x + 2.0f * style.FramePadding.x;
1142 auto defaultSize = ImGui::GetFontSize() * defaultSize_;
1143 return {std::max(textSize, defaultSize), 0.0f};
1144}
1145
1146void ImGuiSettings::paintEditShortcut()
1147{
1148 using enum Shortcuts::Type;
1149
1150 bool editShortcutWindow = editShortcutId != Shortcuts::ID::INVALID;
1151 if (!editShortcutWindow) return;
1152
1153 im::Window("Edit shortcut", &editShortcutWindow, ImGuiWindowFlags_AlwaysAutoResize, [&]{
1154 auto& shortcuts = manager.getShortcuts();
1155 auto shortcut = shortcuts.getShortcut(editShortcutId);
1156
1157 im::Table("table", 2, [&]{
1158 ImGui::TableSetupColumn("", ImGuiTableColumnFlags_WidthFixed);
1159 ImGui::TableSetupColumn("", ImGuiTableColumnFlags_WidthStretch);
1160
1161 if (ImGui::TableNextColumn()) {
1162 ImGui::AlignTextToFramePadding();
1164 }
1165 static constexpr auto waitKeyTitle = "Waiting for key";
1166 if (ImGui::TableNextColumn()) {
1167 auto text = getKeyChordName(shortcut.keyChord);
1168 if (ImGui::Button(text.c_str(), buttonSize(text, 4.0f))) {
1169 popupTimeout = 10.0f;
1171 ImGui::OpenPopup(waitKeyTitle);
1172 }
1173 }
1174 bool isOpen = true;
1175 im::PopupModal(waitKeyTitle, &isOpen, ImGuiWindowFlags_NoSavedSettings | ImGuiWindowFlags_AlwaysAutoResize, [&]{
1176 ImGui::Text("Enter key combination for shortcut '%s'",
1177 Shortcuts::getShortcutDescription(editShortcutId).c_str());
1178 ImGui::Text("Timeout in %d seconds.", int(popupTimeout));
1179
1180 popupTimeout -= ImGui::GetIO().DeltaTime;
1181 if (!isOpen || popupTimeout <= 0.0f) {
1182 ImGui::CloseCurrentPopup();
1183 }
1184 if (auto keyChord = getCurrentlyPressedKeyChord(); keyChord != ImGuiKey_None) {
1185 shortcut.keyChord = keyChord;
1186 shortcuts.setShortcut(editShortcutId, shortcut);
1187 editShortcutWindow = false;
1188 ImGui::CloseCurrentPopup();
1189 }
1190 });
1191
1192 if (shortcut.type == one_of(LOCAL, GLOBAL)) { // don't edit the 'ALWAYS_xxx' values
1193 if (ImGui::TableNextColumn()) {
1194 ImGui::AlignTextToFramePadding();
1195 ImGui::TextUnformatted("global");
1196 }
1197 if (ImGui::TableNextColumn()) {
1198 bool global = shortcut.type == GLOBAL;
1199 if (ImGui::Checkbox("##global", &global)) {
1200 shortcut.type = global ? GLOBAL : LOCAL;
1201 shortcuts.setShortcut(editShortcutId, shortcut);
1202 }
1204 "Global shortcuts react when any GUI window has focus.\n"
1205 "Local shortcuts only react when the specific GUI window has focus.\n"sv);
1206 }
1207 }
1208 });
1209 ImGui::Separator();
1210 const auto& defaultShortcut = Shortcuts::getDefaultShortcut(editShortcutId);
1211 im::Disabled(shortcut == defaultShortcut, [&]{
1212 if (ImGui::Button("Restore default")) {
1213 shortcuts.setShortcut(editShortcutId, defaultShortcut);
1214 editShortcutWindow = false;
1215 }
1216 simpleToolTip([&]{ return formatShortcutWithAnnotations(defaultShortcut); });
1217 });
1218
1219 ImGui::SameLine();
1220 im::Disabled(shortcut == Shortcuts::Shortcut{}, [&]{
1221 if (ImGui::Button("Set None")) {
1222 shortcuts.setShortcut(editShortcutId, Shortcuts::Shortcut{});
1223 editShortcutWindow = false;
1224 }
1225 simpleToolTip("Set no binding for this shortcut"sv);
1226 });
1227 });
1228 if (!editShortcutWindow) editShortcutId = Shortcuts::ID::INVALID;
1229}
1230
1231void ImGuiSettings::paintShortcut()
1232{
1233 im::Window("Edit shortcuts", &showShortcut, [&]{
1234 int flags = ImGuiTableFlags_Resizable
1235 | ImGuiTableFlags_RowBg
1236 | ImGuiTableFlags_NoBordersInBodyUntilResize
1237 | ImGuiTableFlags_SizingStretchProp;
1238 im::Table("table", 2, flags, {-FLT_MIN, 0.0f}, [&]{
1239 ImGui::TableSetupColumn("description");
1240 ImGui::TableSetupColumn("key");
1241
1242 const auto& shortcuts = manager.getShortcuts();
1243 im::ID_for_range(to_underlying(Shortcuts::ID::NUM), [&](int i) {
1244 auto id = static_cast<Shortcuts::ID>(i);
1245 auto shortcut = shortcuts.getShortcut(id);
1246
1247 if (ImGui::TableNextColumn()) {
1248 ImGui::AlignTextToFramePadding();
1249 ImGui::TextUnformatted(Shortcuts::getShortcutDescription(id));
1250 }
1251 if (ImGui::TableNextColumn()) {
1252 auto text = formatShortcutWithAnnotations(shortcut);
1253 if (ImGui::Button(text.c_str(), buttonSize(text, 9.0f))) {
1254 editShortcutId = id;
1256 }
1257 }
1258 });
1259 });
1260 });
1261 paintEditShortcut();
1262}
1263
1264void ImGuiSettings::paint(MSXMotherBoard* motherBoard)
1265{
1266 if (selectedStyle < 0) {
1267 // triggers when loading "imgui.ini" did not select a style
1268 selectedStyle = 0; // dark (also the default (recommended) Dear ImGui style)
1269 setStyle();
1270 }
1271 if (motherBoard && showConfigureJoystick) paintJoystick(*motherBoard);
1272 if (showFont) paintFont();
1273 if (showShortcut) paintShortcut();
1274}
1275
1276std::span<const std::string> ImGuiSettings::getAvailableFonts()
1277{
1278 if (availableFonts.empty()) {
1279 for (const auto& context = systemFileContext();
1280 const auto& path : context.getPaths()) {
1281 foreach_file(FileOperations::join(path, "skins"), [&](const std::string& /*fullName*/, std::string_view name) {
1282 if (name.ends_with(".ttf.gz") || name.ends_with(".ttf")) {
1283 availableFonts.emplace_back(name);
1284 }
1285 });
1286 }
1287 // sort and remove duplicates
1288 ranges::sort(availableFonts);
1289 availableFonts.erase(ranges::unique(availableFonts), end(availableFonts));
1290 }
1291 return availableFonts;
1292}
1293
1294bool ImGuiSettings::signalEvent(const Event& event)
1295{
1296 bool msxOrMega = joystick < 2;
1297 using SP = std::span<const zstring_view>;
1298 auto keyNames = msxOrMega ? SP{msxjoystick::keyNames}
1299 : SP{joymega ::keyNames};
1300 if (const auto numButtons = keyNames.size(); popupForKey >= numButtons) {
1301 deinitListener();
1302 return false; // don't block
1303 }
1304
1305 bool escape = false;
1306 if (const auto* keyDown = get_event_if<KeyDownEvent>(event)) {
1307 escape = keyDown->getKeyCode() == SDLK_ESCAPE;
1308 }
1309 if (!escape) {
1310 auto getJoyDeadZone = [&](JoystickId joyId) {
1311 const auto& joyMan = manager.getReactor().getInputEventGenerator().getJoystickManager();
1312 const auto* setting = joyMan.getJoyDeadZoneSetting(joyId);
1313 return setting ? setting->getInt() : 0;
1314 };
1315 auto b = captureBooleanInput(event, getJoyDeadZone);
1316 if (!b) return true; // keep popup active
1317 auto bs = toString(*b);
1318
1319 auto* motherBoard = manager.getReactor().getMotherBoard();
1320 if (!motherBoard) return true;
1321 const auto& controller = motherBoard->getMSXCommandController();
1322 auto* setting = dynamic_cast<StringSetting*>(controller.findSetting(settingName(joystick)));
1323 if (!setting) return true;
1324 auto& interp = setting->getInterpreter();
1325
1326 TclObject bindings = setting->getValue();
1327 TclObject key(keyNames[popupForKey]);
1328 TclObject bindingList = bindings.getDictValue(interp, key);
1329
1330 if (!contains(bindingList, bs)) {
1331 bindingList.addListElement(bs);
1332 bindings.setDictValue(interp, key, bindingList);
1333 setting->setValue(bindings);
1334 }
1335 }
1336
1337 popupForKey = unsigned(-1); // close popup
1338 return true; // block event
1339}
1340
1341void ImGuiSettings::initListener()
1342{
1343 if (listening) return;
1344 listening = true;
1345
1346 auto& distributor = manager.getReactor().getEventDistributor();
1347 // highest priority (higher than HOTKEY and IMGUI)
1348 using enum EventType;
1349 for (auto type : {KEY_DOWN, MOUSE_BUTTON_DOWN,
1351 distributor.registerEventListener(type, *this);
1352 }
1353}
1354
1355void ImGuiSettings::deinitListener()
1356{
1357 if (!listening) return;
1358 listening = false;
1359
1360 auto& distributor = manager.getReactor().getEventDistributor();
1361 using enum EventType;
1362 for (auto type : {JOY_AXIS_MOTION, JOY_HAT, JOY_BUTTON_DOWN,
1364 distributor.unregisterEventListener(type, *this);
1365 }
1366}
1367
1368} // namespace openmsx
BaseSetting * setting
uintptr_t id
const char * c_str() const
std::string_view getBaseName() const
Definition Setting.hh:38
A Setting with a floating point value.
std::unique_ptr< ImGuiSoundChip > soundChip
std::unique_ptr< ImGuiMessages > messages
std::unique_ptr< ImGuiOsdIcons > osdIcons
ImGuiManager & manager
Definition ImGuiPart.hh:30
void save(ImGuiTextBuffer &buf) override
void showMenu(MSXMotherBoard *motherBoard) override
void loadLine(std::string_view name, zstring_view value) override
void loadEnd() override
A Setting with an integer value.
auto * getR800()
Definition MSXCPU.hh:155
auto * getZ80()
Definition MSXCPU.hh:154
VideoSourceSetting & getVideoSource()
MSXCommandController & getMSXCommandController()
GlobalSettings & getGlobalSettings()
Definition Reactor.hh:118
ScaleAlgorithm
Scaler algorithm.
static const bool RELEASE
Definition Version.hh:12
Like std::string_view, but with the extra guarantee that it refers to a zero-terminated string.
auto CalcTextSize(std::string_view str)
Definition ImGuiUtils.hh:37
void TextUnformatted(const std::string &str)
Definition ImGuiUtils.hh:24
vecN< 2, float > vec2
Definition gl_vec.hh:178
constexpr T sum(const vecN< N, T > &x)
Definition gl_vec.hh:343
constexpr vecN< N, T > max(const vecN< N, T > &x, const vecN< N, T > &y)
Definition gl_vec.hh:320
void Table(const char *str_id, int column, ImGuiTableFlags flags, const ImVec2 &outer_size, float inner_width, std::invocable<> auto next)
Definition ImGuiCpp.hh:459
void Window(const char *name, bool *p_open, ImGuiWindowFlags flags, std::invocable<> auto next)
Definition ImGuiCpp.hh:63
void PopupContextItem(const char *str_id, ImGuiPopupFlags popup_flags, std::invocable<> auto next)
Definition ImGuiCpp.hh:425
bool TreeNode(const char *label, ImGuiTreeNodeFlags flags, std::invocable<> auto next)
Definition ImGuiCpp.hh:306
void Combo(const char *label, const char *preview_value, ImGuiComboFlags flags, std::invocable<> auto next)
Definition ImGuiCpp.hh:293
void ListBox(const char *label, const ImVec2 &size, std::invocable<> auto next)
Definition ImGuiCpp.hh:332
void PopupModal(const char *name, bool *p_open, ImGuiWindowFlags flags, std::invocable<> auto next)
Definition ImGuiCpp.hh:408
bool Menu(const char *label, bool enabled, std::invocable<> auto next)
Definition ImGuiCpp.hh:363
void Disabled(bool b, std::invocable<> auto next)
Definition ImGuiCpp.hh:510
void Font(ImFont *font, std::invocable<> auto next)
Definition ImGuiCpp.hh:131
void Indent(float indent_w, std::invocable<> auto next)
Definition ImGuiCpp.hh:224
void Popup(const char *str_id, ImGuiWindowFlags flags, std::invocable<> auto next)
Definition ImGuiCpp.hh:395
void ID_for_range(int count, std::invocable< int > auto next)
Definition ImGuiCpp.hh:281
string_view stripExtension(string_view path)
Returns the path without extension.
string_view getFilename(string_view path)
Returns the file portion of a path name.
int unlink(zstring_view path)
Call unlink() in a platform-independent manner.
This file implemented 3 utility functions:
Definition Autofire.cc:11
const FileContext & systemFileContext()
std::optional< BooleanInput > captureBooleanInput(const Event &event, function_ref< int(JoystickId)> getJoyDeadZone)
EventType
Definition Event.hh:454
bool Checkbox(const HotKey &hotKey, BooleanSetting &setting)
Definition ImGuiUtils.cc:81
bool SliderFloat(FloatSetting &setting, const char *format, ImGuiSliderFlags flags)
void centerNextWindowOverCurrent()
bool SliderInt(IntegerSetting &setting, ImGuiSliderFlags flags)
void ComboBox(const char *label, Setting &setting, function_ref< std::string(const std::string &)> displayValue, EnumToolTips toolTips)
bool loadOnePersistent(std::string_view name, zstring_view value, C &c, const std::tuple< Elements... > &tup)
void simpleToolTip(std::string_view desc)
Definition ImGuiUtils.hh:77
void savePersistent(ImGuiTextBuffer &buf, C &c, const std::tuple< Elements... > &tup)
std::string getShortCutForCommand(const HotKey &hotkey, std::string_view command)
void HelpMarker(std::string_view desc)
Definition ImGuiUtils.cc:23
std::optional< BooleanInput > parseBooleanInput(std::string_view text)
bool InputText(Setting &setting)
ImU32 getColor(imColor col)
void setColors(int style)
std::string getKeyChordName(ImGuiKeyChord keyChord)
std::string toString(const BooleanInput &input)
bool foreach_file(std::string path, FileAction fileAction)
TclObject makeTclList(Args &&... args)
Definition TclObject.hh:293
FileContext userDataFileContext(string_view subDir)
auto unique(ForwardRange &&range)
Definition ranges.hh:224
auto remove(ForwardRange &&range, const T &value)
Definition ranges.hh:291
auto find(InputRange &&range, const T &value)
Definition ranges.hh:162
constexpr void replace(ForwardRange &&range, const T &old_value, const T &new_value)
Definition ranges.hh:303
constexpr void sort(RandomAccessRange &&range)
Definition ranges.hh:51
size_t size(std::string_view utf8)
constexpr auto to_underlying(E e) noexcept
Definition stl.hh:465
constexpr bool contains(ITER first, ITER last, const VAL &val)
Check if a range contains a given value, using linear search.
Definition stl.hh:32
std::string strCat()
Definition strCat.hh:703
TemporaryString tmpStrCat(Ts &&... ts)
Definition strCat.hh:742
constexpr auto xrange(T e)
Definition xrange.hh:132
constexpr auto end(const zstring_view &x)