openMSX
ImGuiConsole.cc
Go to the documentation of this file.
1#include "ImGuiConsole.hh"
2
3#include "ImGuiCpp.hh"
4#include "ImGuiManager.hh"
5#include "ImGuiUtils.hh"
6
7#include "BooleanSetting.hh"
8#include "CliComm.hh"
9#include "Completer.hh"
10#include "FileContext.hh"
11#include "FileException.hh"
12#include "FileOperations.hh"
14#include "Interpreter.hh"
15#include "Reactor.hh"
16#include "TclParser.hh"
17#include "Version.hh"
18
19#include "narrow.hh"
20#include "strCat.hh"
21#include "utf8_unchecked.hh"
22#include "xrange.hh"
23
24#include <imgui.h>
25#include <imgui_internal.h> // Hack: see below
26#include <imgui_stdlib.h>
27
28#include <fstream>
29
30namespace openmsx {
31
32using namespace std::literals;
33
34static constexpr std::string_view PROMPT_NEW = "> ";
35static constexpr std::string_view PROMPT_CONT = "| ";
36static constexpr std::string_view PROMPT_BUSY = "*busy*";
37
39 : ImGuiPart(manager_)
40 , consoleSetting(
41 manager.getReactor().getCommandController(), "console",
42 "turns console display on/off", false, Setting::Save::NO)
43 , history(1000)
44 , lines(1000)
45 , prompt(PROMPT_NEW)
46{
47 loadHistory();
48
51 consoleSetting.attach(*this);
52
53 const auto& fullVersion = Version::full();
54 print(fullVersion);
55 print(std::string(fullVersion.size(), '-'));
56 print("\n"
57 "General information about openMSX is available at http://openmsx.org.\n"
58 "\n"
59 "Type 'help' to see a list of available commands.\n"
60 "Or read the Console Command Reference in the manual.\n"
61 "\n");
62}
63
65{
66 consoleSetting.detach(*this);
67}
68
69void ImGuiConsole::save(ImGuiTextBuffer& buf)
70{
71 savePersistent(buf, *this, persistentElements);
72}
73
74void ImGuiConsole::loadLine(std::string_view name, zstring_view value)
75{
76 loadOnePersistent(name, value, *this, persistentElements);
77}
78
79void ImGuiConsole::print(std::string_view text, imColor color)
80{
81 do {
82 auto pos = text.find('\n');
83 newLineConsole(ConsoleLine(std::string(text.substr(0, pos)), color));
84 if (pos == std::string_view::npos) break;
85 text.remove_prefix(pos + 1); // skip newline
86 } while (!text.empty());
87}
88
89void ImGuiConsole::newLineConsole(ConsoleLine line)
90{
91 auto addLine = [&](ConsoleLine&& l) {
92 if (lines.full()) lines.pop_front();
93 lines.push_back(std::move(l));
94 };
95
96 if (wrap) {
97 do {
98 auto rest = line.splitAtColumn(columns);
99 addLine(std::move(line));
100 line = std::move(rest);
101 } while (!line.str().empty());
102 } else {
103 addLine(std::move(line));
104 }
105
106 scrollToBottom = true;
107}
108
109static void drawLine(const ConsoleLine& line)
110{
111 auto n = line.numChunks();
112 for (auto i : xrange(n)) {
113 im::StyleColor(ImGuiCol_Text, getColor(line.chunkColor(i)), [&]{
114 ImGui::TextUnformatted(line.chunkText(i));
115 if (i != (n - 1)) ImGui::SameLine(0.0f, 0.0f);
116 });
117 }
118}
119
121{
122 bool reclaimFocus = show && !wasShown; // window appears
123 wasShown = show;
124 if (!show) return;
125
126 ImGui::SetNextWindowSize(ImVec2(520, 600), ImGuiCond_FirstUseEver);
127 im::Window("Console", &show, [&]{
129
130 // Reserve enough left-over height for 1 separator + 1 input text
131 const auto& style = ImGui::GetStyle();
132 const float footerHeightToReserve = style.ItemSpacing.y +
133 ImGui::GetFrameHeightWithSpacing();
134
135 bool scrollUp = ImGui::Shortcut(ImGuiKey_PageUp);
136 bool scrollDown = ImGui::Shortcut(ImGuiKey_PageDown);
137 im::Child("ScrollingRegion", ImVec2(0, -footerHeightToReserve), 0,
138 ImGuiWindowFlags_HorizontalScrollbar, [&]{
140 if (ImGui::Selectable("Clear")) {
141 lines.clear();
142 }
143 ImGui::Checkbox("Wrap (new) output", &wrap);
144 });
145
146 im::StyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(4, 1), [&]{ // Tighten spacing
147 im::ListClipper(lines.size(), [&](int i) {
148 drawLine(lines[i]);
149 });
150 });
151
152 // Keep up at the bottom of the scroll region if we were already
153 // at the bottom at the beginning of the frame.
154 if (scrollToBottom || (ImGui::GetScrollY() >= ImGui::GetScrollMaxY())) {
155 scrollToBottom = false;
156 ImGui::SetScrollHereY(1.0f);
157 }
158
159 auto scrollDelta = ImGui::GetWindowHeight() * 0.5f;
160 if (scrollUp) {
161 ImGui::SetScrollY(std::max(ImGui::GetScrollY() - scrollDelta, 0.0f));
162 }
163 if (scrollDown) {
164 ImGui::SetScrollY(std::min(ImGui::GetScrollY() + scrollDelta, ImGui::GetScrollMaxY()));
165 }
166
167 // recalculate the number of columns
168 auto width = ImGui::GetContentRegionMax().x;
169 auto charWidth = ImGui::CalcTextSize("M"sv).x;
170 columns = narrow_cast<unsigned>(width / charWidth);
171 });
172 ImGui::Separator();
173
174 // Command-line
175 ImGui::AlignTextToFramePadding();
177 ImGui::SameLine(0.0f, 0.0f);
178
179 ImGui::SetNextItemWidth(-FLT_MIN); // full window width
180 // Hack: see below
181 auto cursorScrnPos = ImGui::GetCursorScreenPos();
182 auto itemWidth = ImGui::CalcItemWidth();
183
184 ImGuiInputTextFlags flags = ImGuiInputTextFlags_EnterReturnsTrue |
185 ImGuiInputTextFlags_EscapeClearsAll |
186 ImGuiInputTextFlags_CallbackEdit |
187 ImGuiInputTextFlags_CallbackCompletion |
188 ImGuiInputTextFlags_CallbackHistory;
189 bool enter = false;
190 im::StyleColor(ImGuiCol_Text, 0x00000000, [&]{ // transparent, see HACK below
191 enter = ImGui::InputTextWithHint("##Input", "enter command", &inputBuf, flags, &textEditCallbackStub, this);
192 });
193 if (enter && (prompt != PROMPT_BUSY)) {
194 // print command in output buffer, with prompt prepended
195 ConsoleLine cmdLine(prompt);
196 cmdLine.addLine(coloredInputBuf);
197 newLineConsole(std::move(cmdLine));
198
199 // append (partial) command to a possibly multi-line command
200 strAppend(commandBuffer, inputBuf, '\n');
201
202 putHistory(std::move(inputBuf));
203 saveHistory(); // save at this point already, so that we don't lose history in case of a crash
204 inputBuf.clear();
205 coloredInputBuf.clear();
206 historyPos = -1;
207 historyBackupLine.clear();
208
209 auto& commandController = manager.getReactor().getGlobalCommandController();
210 if (commandController.isComplete(commandBuffer)) {
211 // Normally the busy prompt is NOT shown (not even briefly
212 // because the screen is not redrawn), though for some commands
213 // that potentially take a long time to execute, we explicitly
214 // do redraw.
215 prompt = PROMPT_BUSY;
216
217 manager.executeDelayed(TclObject(commandBuffer),
218 [this](const TclObject& result) {
219 if (const auto& s = result.getString(); !s.empty()) {
220 this->print(s);
221 }
222 prompt = PROMPT_NEW;
223 },
224 [this](const std::string& error) {
225 this->print(error, imColor::ERROR);
226 prompt = PROMPT_NEW;
227 });
228 commandBuffer.clear();
229 } else {
230 prompt = PROMPT_CONT;
231 }
232 reclaimFocus = true;
233 }
234 ImGui::SetItemDefaultFocus();
235
236 if (reclaimFocus ||
237 (ImGui::IsWindowFocused(ImGuiFocusedFlags_ChildWindows) &&
238 !ImGui::IsPopupOpen(nullptr, ImGuiPopupFlags_AnyPopupId) &&
239 !ImGui::IsAnyItemActive() && !ImGui::IsMouseClicked(0) && !ImGui::IsMouseClicked(1))) {
240 ImGui::SetKeyboardFocusHere(-1); // focus the InputText widget
241 }
242
243 // Hack: currently ImGui::InputText() does not support colored text.
244 // Though there are plans to extend this. See:
245 // https://github.com/ocornut/imgui/pull/3130
246 // https://github.com/ocornut/imgui/issues/902
247 // To work around this limitation, we use ImGui::InputText() as-is,
248 // but then overdraw the text using the correct colors. This works,
249 // but it's fragile because it depends on some internal implementation
250 // details. More specifically: the scroll-position. And obtaining this
251 // information required stuff from <imgui_internal.h>.
252 const auto* font = ImGui::GetFont();
253 auto fontSize = ImGui::GetFontSize();
254 gl::vec2 frameSize(itemWidth, fontSize + style.FramePadding.y * 2.0f);
255 gl::vec2 topLeft = cursorScrnPos;
256 gl::vec2 bottomRight = topLeft + frameSize;
257 gl::vec2 drawPos = topLeft + gl::vec2(style.FramePadding);
258 ImVec4 clipRect = gl::vec4(topLeft, bottomRight);
259 auto* drawList = ImGui::GetWindowDrawList();
260 auto charWidth = ImGui::GetFont()->GetCharAdvance('A'); // assumes fixed-width font
261 if (ImGui::IsItemActive()) {
262 auto id = ImGui::GetID("##Input");
263 if (const auto* state = ImGui::GetInputTextState(id)) { // Internal API !!!
264 // adjust for scroll
265 drawPos.x -= state->ScrollX;
266 // redraw cursor (it was drawn transparent before)
267 bool cursorIsVisible = (state->CursorAnim <= 0.0f) || ImFmod(state->CursorAnim, 1.20f) <= 0.80f;
268 if (cursorIsVisible) {
269 // This assumes a single line and fixed-width font
270 gl::vec2 cursorOffset(float(state->GetCursorPos()) * charWidth, 0.0f);
271 gl::vec2 cursorScreenPos = ImTrunc(drawPos + cursorOffset);
272 ImRect cursorScreenRect(cursorScreenPos.x, cursorScreenPos.y - 0.5f, cursorScreenPos.x + 1.0f, cursorScreenPos.y + fontSize - 1.5f);
273 if (cursorScreenRect.Overlaps(clipRect)) {
274 drawList->AddLine(cursorScreenRect.Min, cursorScreenRect.GetBL(), getColor(imColor::TEXT));
275 }
276 }
277 }
278 }
279 for (auto i : xrange(coloredInputBuf.numChunks())) {
280 auto text = coloredInputBuf.chunkText(i);
281 auto rgba = getColor(coloredInputBuf.chunkColor(i));
282 const char* begin = text.data();
283 const char* end = begin + text.size();
284 drawList->AddText(font, fontSize, drawPos, rgba, begin, end, 0.0f, &clipRect);
285 // avoid ImGui::CalcTextSize(): it's off-by-one for sizes >= 256 pixels
286 drawPos.x += charWidth * float(utf8::unchecked::distance(begin, end));
287 }
288 });
289}
290
291int ImGuiConsole::textEditCallbackStub(ImGuiInputTextCallbackData* data)
292{
293 auto* console = static_cast<ImGuiConsole*>(data->UserData);
294 return console->textEditCallback(data);
295}
296
297int ImGuiConsole::textEditCallback(ImGuiInputTextCallbackData* data)
298{
299 switch (data->EventFlag) {
300 case ImGuiInputTextFlags_CallbackCompletion: {
301 std::string_view oldLine{data->Buf, narrow<size_t>(data->BufTextLen)};
302 std::string_view front = utf8::unchecked::substr(oldLine, 0, data->CursorPos);
303 std::string_view back = utf8::unchecked::substr(oldLine, data->CursorPos);
304
305 auto& commandController = manager.getReactor().getGlobalCommandController();
306 std::string newFront = commandController.tabCompletion(front);
307 historyBackupLine = strCat(std::move(newFront), back);
308 historyPos = -1;
309
310 data->DeleteChars(0, data->BufTextLen);
311 data->InsertChars(0, historyBackupLine.c_str());
312
313 colorize(historyBackupLine);
314 break;
315 }
316 case ImGuiInputTextFlags_CallbackHistory: {
317 bool match = false;
318 if (data->EventKey == ImGuiKey_UpArrow) {
319 while (!match && (historyPos < narrow<int>(history.size() - 1))) {
320 ++historyPos;
321 match = history[historyPos].starts_with(historyBackupLine);
322 }
323 } else if ((data->EventKey == ImGuiKey_DownArrow) && (historyPos != -1)) {
324 while (!match) {
325 if (--historyPos == -1) break;
326 match = history[historyPos].starts_with(historyBackupLine);
327 }
328 }
329 if (match || (historyPos == -1)) {
330 const auto& historyStr = (historyPos >= 0) ? history[historyPos] : historyBackupLine;
331 data->DeleteChars(0, data->BufTextLen);
332 data->InsertChars(0, historyStr.c_str());
333 colorize(std::string_view{data->Buf, narrow<size_t>(data->BufTextLen)});
334 }
335 break;
336 }
337 case ImGuiInputTextFlags_CallbackEdit: {
338 historyBackupLine.assign(data->Buf, narrow<size_t>(data->BufTextLen));
339 historyPos = -1;
340 colorize(historyBackupLine);
341 break;
342 }
343 }
344 return 0;
345}
346
347void ImGuiConsole::colorize(std::string_view line)
348{
349 TclParser parser = manager.getInterpreter().parse(line);
350 const auto& colors = parser.getColors();
351 assert(colors.size() == line.size());
352
353 coloredInputBuf.clear();
354 size_t pos = 0;
355 while (pos != colors.size()) {
356 char col = colors[pos];
357 size_t pos2 = pos++;
358 while ((pos != colors.size()) && (colors[pos] == col)) {
359 ++pos;
360 }
361 imColor color = [&] {
362 switch (col) {
363 using enum imColor;
364 case 'E': return ERROR;
365 case 'c': return COMMENT;
366 case 'v': return VARIABLE;
367 case 'l': return LITERAL;
368 case 'p': return PROC;
369 case 'o': return OPERATOR;
370 default: return TEXT; // other
371 }
372 }();
373 coloredInputBuf.addChunk(line.substr(pos2, pos - pos2), color);
374 }
375}
376
377void ImGuiConsole::putHistory(std::string command)
378{
379 if (command.empty()) return;
380 if (!history.empty() && (history.front() == command)) {
381 return;
382 }
383 if (history.full()) history.pop_back();
384 history.push_front(std::move(command));
385}
386
387void ImGuiConsole::saveHistory()
388{
389 try {
390 std::ofstream outputFile;
392 userFileContext("console").resolveCreate("history.txt"));
393 if (!outputFile) {
394 throw FileException("Error while saving the console history.");
395 }
396 for (const auto& s : view::reverse(history)) {
397 outputFile << s << '\n';
398 }
399 } catch (FileException& e) {
400 manager.getCliComm().printWarning(e.getMessage());
401 }
402}
403
404void ImGuiConsole::loadHistory()
405{
406 try {
407 std::ifstream inputFile(
408 userFileContext("console").resolveCreate("history.txt"));
409 std::string line;
410 while (inputFile) {
411 getline(inputFile, line);
412 putHistory(line);
413 }
414 } catch (FileException&) {
415 // Error while loading the console history, ignore
416 }
417}
418
419void ImGuiConsole::output(std::string_view text)
420{
421 print(text);
422}
423
424unsigned ImGuiConsole::getOutputColumns() const
425{
426 return columns;
427}
428
429void ImGuiConsole::update(const Setting& /*setting*/) noexcept
430{
431 show = consoleSetting.getBoolean();
432 if (!show) {
433 // Close the console via the 'console' setting. Typically this
434 // means via the F10 hotkey (or possibly by typing 'set console
435 // off' in the console).
436 //
437 // Give focus to the main openMSX window.
438 //
439 // This makes the following scenario work:
440 // * You were controlling the MSX, e.g. playing a game.
441 // * You press F10 to open the console.
442 // * You type a command (e.g. swap a game disk, for some people
443 // the console is still more convenient and/or faster than the
444 // new media menu).
445 // * You press F10 again to close the console
446 // * At this point the focus should go back to the main openMSX
447 // window (so that MSX input works).
448 SDL_SetWindowInputFocus(SDL_GetWindowFromID(WindowEvent::getMainWindowId()));
449 ImGui::SetWindowFocus(nullptr);
450 }
451}
452
453} // namespace openmsx
const std::string & getColors() const
Ouput: a string of equal length of the input command where each character indicates the type of the c...
Definition TclParser.hh:29
void push_front(T2 &&t)
size_t size() const
void printWarning(std::string_view message)
Definition CliComm.cc:12
static void setOutput(InterpreterOutput *output_)
Definition Completer.hh:72
This class represents a single text line in the console.
void addLine(const ConsoleLine &ln)
Append another line (possibly containing multiple chunks).
std::string_view chunkText(size_t i) const
Get the text for the i-th chunk.
imColor chunkColor(size_t i) const
Get the color for the i-th chunk.
void addChunk(std::string_view text, imColor color=imColor::TEXT)
Append a chunk with a (different) color.
void clear()
Reinitialize to an empty line.
size_t numChunks() const
Get the number of different chunks.
std::string tabCompletion(std::string_view command)
Complete the given command.
void paint(MSXMotherBoard *motherBoard) override
void save(ImGuiTextBuffer &buf) override
ImGuiConsole(ImGuiManager &manager)
void loadLine(std::string_view name, zstring_view value) override
Interpreter & getInterpreter()
void executeDelayed(std::function< void()> action)
ImGuiManager & manager
Definition ImGuiPart.hh:30
void setOutput(InterpreterOutput *output_)
TclParser parse(std::string_view command)
GlobalCommandController & getGlobalCommandController()
Definition Reactor.hh:92
void detach(Observer< T > &observer)
Definition Subject.hh:60
void attach(Observer< T > &observer)
Definition Subject.hh:54
zstring_view getString() const
Definition TclObject.cc:141
static std::string full()
Definition Version.cc:8
static uint32_t getMainWindowId()
Definition Event.hh:218
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
constexpr double e
Definition Math.hh:21
vecN< 2, float > vec2
Definition gl_vec.hh:178
vecN< 4, float > vec4
Definition gl_vec.hh:180
void Window(const char *name, bool *p_open, ImGuiWindowFlags flags, std::invocable<> auto next)
Definition ImGuiCpp.hh:63
void StyleVar(ImGuiStyleVar idx, float val, std::invocable<> auto next)
Definition ImGuiCpp.hh:190
void PopupContextWindow(const char *str_id, ImGuiPopupFlags popup_flags, std::invocable<> auto next)
Definition ImGuiCpp.hh:442
void StyleColor(bool active, Args &&...args)
Definition ImGuiCpp.hh:175
void Child(const char *str_id, const ImVec2 &size, ImGuiChildFlags child_flags, ImGuiWindowFlags window_flags, std::invocable<> auto next)
Definition ImGuiCpp.hh:110
void ListClipper(size_t count, int forceIndex, float lineHeight, std::invocable< int > auto next)
Definition ImGuiCpp.hh:542
void openOfStream(std::ofstream &stream, zstring_view filename)
Open an ofstream in a platform-independent manner.
This file implemented 3 utility functions:
Definition Autofire.cc:11
bool loadOnePersistent(std::string_view name, zstring_view value, C &c, const std::tuple< Elements... > &tup)
void savePersistent(ImGuiTextBuffer &buf, C &c, const std::tuple< Elements... > &tup)
std::optional< bool > match(const BooleanInput &binding, const Event &event, function_ref< int(JoystickId)> getJoyDeadZone)
ImU32 getColor(imColor col)
const FileContext & userFileContext()
std::string_view substr(std::string_view utf8, std::string_view::size_type first=0, std::string_view::size_type len=std::string_view::npos)
auto distance(octet_iterator first, octet_iterator last)
Definition view.hh:15
constexpr auto reverse(Range &&range)
Definition view.hh:514
std::string strCat()
Definition strCat.hh:703
void strAppend(std::string &result, Ts &&...ts)
Definition strCat.hh:752
constexpr auto xrange(T e)
Definition xrange.hh:132
constexpr auto begin(const zstring_view &x)
constexpr auto end(const zstring_view &x)