// load text into document and reset subsystems

document.setText(text);

transactions.reset();

bracketeer.reset();

colorizer.updateEntireDocument(document, language);

cursors.clearAll();

clearMarkers();

makeCursorVisible();

showMatchingBracketsChanged = false;

languageChanged = false;

// get current transaction version

auto transActionVersion = transactions.getVersion();

// update color palette (if required)

if (paletteAlpha != ImGui::GetStyle().Alpha) {

updatePalette();

}

// get font information and determine horizontal offsets for line numbers, decorations and text

font = ImGui::GetFont();

fontSize = ImGui::GetFontSize();

glyphSize = ImVec2(ImGui::CalcTextSize("#").x, ImGui::GetTextLineHeightWithSpacing() * lineSpacing);

lineNumberLeftOffset = leftMargin * glyphSize.x;

if (showLineNumbers) {

int digits = static_cast<int>(std::log10(document.lineCount() + 1) + 1.0f);

lineNumberRightOffset = lineNumberLeftOffset + digits * glyphSize.x;

decorationOffset = lineNumberRightOffset + decorationMargin * glyphSize.x;

} else {

lineNumberRightOffset = lineNumberLeftOffset;

decorationOffset = lineNumberLeftOffset;

}

if (decoratorWidth > 0.0f) {

textOffset = decorationOffset + decoratorWidth + decorationMargin * glyphSize.x;

} else if (decoratorWidth < 0.0f) {

textOffset = decorationOffset + (-decoratorWidth + decorationMargin) * glyphSize.x;

} else {

textOffset = decorationOffset + textMargin * glyphSize.x;

}

// get current position and total/visible editor size

auto pos = ImGui::GetCursorScreenPos();

auto totalSize = ImVec2(textOffset + document.getMaxColumn() * glyphSize.x + cursorWidth, document.size() * glyphSize.y);

auto region = ImGui::GetContentRegionAvail();

auto visibleSize = ImGui::CalcItemSize(size, region.x, region.y); // messing with Dear ImGui internals

// see if we have scrollbars

float scrollbarSize = ImGui::GetStyle().ScrollbarSize;

verticalScrollBarSize = (totalSize.y > visibleSize.y) ? scrollbarSize : 0.0f;

horizontalScrollBarSize = (totalSize.x > visibleSize.x) ? scrollbarSize : 0.0f;

// determine visible lines and columns

visibleWidth = visibleSize.x - textOffset - verticalScrollBarSize;

visibleColumns = std::max(static_cast<int>(std::ceil(visibleWidth / glyphSize.x)), 0);

visibleHeight = visibleSize.y - horizontalScrollBarSize;

visibleLines = std::max(static_cast<int>(std::ceil(visibleHeight / glyphSize.y)), 0);

// determine scrolling requirements

float scrollX = -1.0f;

float scrollY = -1.0f;

// ensure cursor is visible (if requested)

if (ensureCursorIsVisible) {

auto cursor = cursors.getCurrent().getInteractiveEnd();

if (cursor.line <= firstVisibleLine + 1) {

scrollY = std::max(0.0f, (cursor.line - 2.0f) * glyphSize.y);

} else if (cursor.line >= lastVisibleLine - 1) {

scrollY = std::max(0.0f, (cursor.line + 2.0f) * glyphSize.y - visibleHeight);

}

if (cursor.column <= firstVisibleColumn + 1) {

scrollX = std::max(0.0f, (cursor.column - 2.0f) * glyphSize.x);

} else if (cursor.column >= lastVisibleColumn - 1) {

scrollX = std::max(0.0f, (cursor.column + 2.0f) * glyphSize.x - visibleWidth);

}

ensureCursorIsVisible = false;

}

// scroll to specified line (if required)

if (scrollToLineNumber >= 0) {

scrollToLineNumber = std::min(scrollToLineNumber, document.lineCount());

scrollX = 0.0f;

switch (scrollToAlignment) {

case Scroll::alignTop:

scrollY = std::max(0.0f, static_cast<float>(scrollToLineNumber) * glyphSize.y);

break;

case Scroll::alignMiddle:

scrollY = std::max(0.0f, static_cast<float>(scrollToLineNumber - visibleLines / 2) * glyphSize.y);

break;

case Scroll::alignBottom:

scrollY = std::max(0.0f, static_cast<float>(scrollToLineNumber - (visibleLines - 1)) * glyphSize.y);

break;

}

scrollToLineNumber = -1;

}

// set scroll (if required)

if (scrollX >= 0.0f || scrollY >= 0.0f) {

ImGui::SetNextWindowScroll(ImVec2(scrollX, scrollY));

}

// ensure editor has focus (if required)

if (focusOnEditor) {

ImGui::SetNextWindowFocus();

focusOnEditor = false;

}

// start a new child window

// this must be done before we handle keyboard and mouse interactions to ensure correct Dear ImGui context

ImGui::SetNextWindowContentSize(totalSize);

ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(0.0f, 0.0f));

ImGui::PushStyleColor(ImGuiCol_ChildBg, ImGui::ColorConvertU32ToFloat4(palette.get(Color::background)));

ImGui::BeginChild(title, size, border, ImGuiWindowFlags_NoMove | ImGuiWindowFlags_HorizontalScrollbar | ImGuiWindowFlags_NoNavInputs);

// handle keyboard and mouse inputs

handleKeyboardInputs();

handleMouseInteractions();

// ensure cursors are up to date (sort and merge if required)

if (cursors.anyHasUpdate()) {

cursors.update();

}

// recolorize entire document and reset brackets (if required)

if (showMatchingBracketsChanged || languageChanged) {

colorizer.updateEntireDocument(document, language);

bracketeer.reset();

}

// was document changed during this frame?

auto documentChanged = document.isUpdated();

if (language) {

if (documentChanged) {

// recolorize updated lines

colorizer.updateChangedLines(document, language);

}

if (showMatchingBrackets && (documentChanged || showMatchingBracketsChanged || languageChanged)) {

// rebuild bracket list

bracketeer.update(document);

}

}

// reset changed states

showMatchingBracketsChanged = false;

languageChanged = false;

// determine view parameters

firstVisibleColumn = std::max(static_cast<int>(std::floor(ImGui::GetScrollX() / glyphSize.x)), 0);

lastVisibleColumn = static_cast<int>(std::floor((ImGui::GetScrollX() + visibleWidth) / glyphSize.x));

firstVisibleLine = std::max(static_cast<int>(std::floor(ImGui::GetScrollY() / glyphSize.y)), 0);

lastVisibleLine = std::min(static_cast<int>(std::floor((ImGui::GetScrollY() + visibleHeight) / glyphSize.y)), document.lineCount() - 1);

// render editor parts

renderSelections();

renderMarkers();

renderMatchingBrackets();

renderText();

renderCursors();

renderMargin();

renderLineNumbers();

renderDecorations();

renderScrollbarMiniMap();

renderPanScrollIndicator();

if (ImGui::BeginPopup("LineNumberContextMenu")) {

lineNumberContextMenuCallback(contextMenuLine);

ImGui::EndPopup();

}

if (ImGui::BeginPopup("TextContextMenu")) {

textContextMenuCallback(contextMenuLine, contextMenuColumn);

ImGui::EndPopup();

}

// render find/replace popup

renderFindReplace(pos, visibleSize.x - verticalScrollBarSize);

// render autocomplete popup

if (autocomplete.render(document, cursors, language, textOffset, glyphSize)) {

// user picked a suggestion so insert it

auto start = autocomplete.getStart();

auto end = document.findWordEnd(start, true);

auto replacement = autocomplete.getReplacement();

replaceSectionText(start, end, replacement);

}

// handle change tracking if there is a change callback in place

if (delayedChangeCallback) {

if (delayedChangeDetected) {

if (std::chrono::system_clock::now() > delayedChangeReportTime) {

delayedChangeCallback();

delayedChangeDetected = false;

}

} else if (transactions.getVersion() != transActionVersion) {

delayedChangeDetected = true;

delayedChangeReportTime = std::chrono::system_clock::now() + delayedChangeDelay;

}

}

ImGui::EndChild();

ImGui::PopStyleColor();

ImGui::PopStyleVar();

auto drawList = ImGui::GetWindowDrawList();

ImVec2 cursorScreenPos = ImGui::GetCursorScreenPos();

// draw background for selections

for (auto& cursor : cursors) {

if (cursor.hasSelection()) {

auto start = cursor.getSelectionStart();

auto end = cursor.getSelectionEnd();

if (end.line >= firstVisibleLine && start.line <= lastVisibleLine) {

auto first = std::max(start.line, firstVisibleLine);

auto last = std::min(end.line, lastVisibleLine);

for (auto line = first; line <= last; line++) {

auto x = cursorScreenPos.x + textOffset;

auto left = x + (line == first ? start.column : 0) * glyphSize.x;

auto right = x + (line == last ? end.column : document[line].maxColumn) * glyphSize.x;

auto y = cursorScreenPos.y + line * glyphSize.y;

drawList->AddRectFilled(ImVec2(left, y), ImVec2(right, y + glyphSize.y), palette.get(Color::selection));

}

}

}

}

if (markers.size()) {

auto drawList = ImGui::GetWindowDrawList();

ImVec2 cursorScreenPos = ImGui::GetCursorScreenPos();

for (int line = firstVisibleLine; line <= lastVisibleLine; line++) {

if (document[line].marker) {

auto& marker = markers[document[line].marker - 1];

auto y = cursorScreenPos.y + line * glyphSize.y;

if (((marker.lineNumberColor >> IM_COL32_A_SHIFT) & 0xFF) != 0) {

auto left = cursorScreenPos.x + lineNumberLeftOffset;

auto right = cursorScreenPos.x + lineNumberRightOffset;

auto start = ImVec2(left, y);

auto end = ImVec2(right, y + glyphSize.y);

drawList->AddRectFilled(start, end, marker.lineNumberColor);

if (marker.lineNumberTooltip.size() && ImGui::IsMouseHoveringRect(start, end)) {

ImGui::PushStyleColor(ImGuiCol_PopupBg, marker.lineNumberColor);

ImGui::BeginTooltip();

ImGui::TextUnformatted(marker.lineNumberTooltip.c_str());

ImGui::EndTooltip();

ImGui::PopStyleColor();

}

}

if (((marker.textColor >> IM_COL32_A_SHIFT) & 0xFF) != 0) {

auto left = cursorScreenPos.x + textOffset;

auto right = left + lastVisibleColumn * glyphSize.x;

auto start = ImVec2(left, y);

auto end = ImVec2(right, y + glyphSize.y);

drawList->AddRectFilled(start, end, marker.textColor);

if (marker.textTooltip.size() && ImGui::IsMouseHoveringRect(start, end)) {

ImGui::PushStyleColor(ImGuiCol_PopupBg, marker.textColor);

ImGui::BeginTooltip();

ImGui::TextUnformatted(marker.textTooltip.c_str());

ImGui::EndTooltip();

ImGui::PopStyleColor();

}

}

}

}

}

if (showMatchingBrackets) {

if (bracketeer.size()) {

auto drawList = ImGui::GetWindowDrawList();

ImVec2 cursorScreenPos = ImGui::GetCursorScreenPos();

// render bracket pair lines

for (auto& bracket : bracketeer) {

if ((bracket.end.line - bracket.start.line) > 1 &&

bracket.start.line <= lastVisibleLine &&

bracket.end.line > firstVisibleLine) {

auto lineX = cursorScreenPos.x + textOffset + std::min(bracket.start.column, bracket.end.column) * glyphSize.x;

auto startY = cursorScreenPos.y + (bracket.start.line + 1) * glyphSize.y;

auto endY = cursorScreenPos.y + bracket.end.line * glyphSize.y;

drawList->AddLine(ImVec2(lineX, startY), ImVec2(lineX, endY), palette.get(Color::whitespace), 1.0f);

}

}

// render active bracket pair

auto active = bracketeer.getEnclosingBrackets(cursors.getMain().getInteractiveEnd());

if (active != bracketeer.end() &&

active->start.line <= lastVisibleLine &&

active->end.line > firstVisibleLine) {

auto x1 = cursorScreenPos.x + textOffset + active->start.column * glyphSize.x;

auto y1 = cursorScreenPos.y + active->start.line * glyphSize.y;

drawList->AddRectFilled(ImVec2(x1, y1), ImVec2(x1 + glyphSize.x, y1 + glyphSize.y), palette.get(Color::matchingBracketBackground));

auto x2 = cursorScreenPos.x + textOffset + active->end.column * glyphSize.x;

auto y2 = cursorScreenPos.y + active->end.line * glyphSize.y;

drawList->AddRectFilled(ImVec2(x2, y2), ImVec2(x2 + glyphSize.x, y2 + glyphSize.y), palette.get(Color::matchingBracketBackground));

if (active->end.line - active->start.line > 1) {

auto lineX = std::min(x1, x2);

drawList->AddLine(ImVec2(lineX, y1 + glyphSize.y), ImVec2(lineX, y2), palette.get(Color::matchingBracketActive), 1.0f);

}

}

}

}

auto drawList = ImGui::GetWindowDrawList();

ImVec2 cursorScreenPos = ImGui::GetCursorScreenPos();

ImVec2 lineScreenPos = cursorScreenPos + ImVec2(textOffset, firstVisibleLine * glyphSize.y);

auto tabSize = document.getTabSize();

auto firstRenderableColumn = (firstVisibleColumn / tabSize) * tabSize;

for (int i = firstVisibleLine; i <= lastVisibleLine; i++) {

auto& line = document[i];

// draw colored glyphs for current line

auto column = firstRenderableColumn;

auto index = document.getIndex(line, column);

auto lineSize = line.size();

while (index < lineSize && column <= lastVisibleColumn) {

auto& glyph = line[index];

auto codepoint = glyph.codepoint;

ImVec2 glyphPos{lineScreenPos.x + column * glyphSize.x, lineScreenPos.y};

if (codepoint == '\t') {

if (showTabs) {

const auto x1 = glyphPos.x + glyphSize.x * 0.3f;

const auto y = glyphPos.y + fontSize * 0.5f;

const auto x2 = glyphPos.x + glyphSize.x;

ImVec2 p1, p2, p3, p4;

p1 = ImVec2(x1, y);

p2 = ImVec2(x2, y);

p3 = ImVec2(x2 - fontSize * 0.16f, y - fontSize * 0.16f);

p4 = ImVec2(x2 - fontSize * 0.16f, y + fontSize * 0.16f);

drawList->AddLine(p1, p2, palette.get(Color::whitespace));

drawList->AddLine(p2, p3, palette.get(Color::whitespace));

drawList->AddLine(p2, p4, palette.get(Color::whitespace));

}

} else if (codepoint == ' ') {

if (showSpaces) {

const auto x = glyphPos.x + glyphSize.x * 0.5f;

const auto y = glyphPos.y + fontSize * 0.5f;

drawList->AddCircleFilled(ImVec2(x, y), 1.5f, palette.get(Color::whitespace), 4);

}

} else {

font->RenderChar(drawList, fontSize, glyphPos, palette.get(glyph.color), codepoint);

}

index++;

column += (codepoint == '\t') ? tabSize - (column % tabSize) : 1;

}

lineScreenPos.y += glyphSize.y;

}

// update cursor animation timer

cursorAnimationTimer = std::fmod(cursorAnimationTimer + ImGui::GetIO().DeltaTime, 1.0f);

if (ImGui::IsWindowFocused()) {

ImVec2 cursorScreenPos = ImGui::GetCursorScreenPos();

if (!ImGui::GetIO().ConfigInputTextCursorBlink || cursorAnimationTimer < 0.5f) {

auto drawList = ImGui::GetWindowDrawList();

for (auto& cursor : cursors) {

auto pos = cursor.getInteractiveEnd();

if (pos.line >= firstVisibleLine && pos.line <= lastVisibleLine) {

auto x = cursorScreenPos.x + textOffset + pos.column * glyphSize.x - 1;

auto y = cursorScreenPos.y + pos.line * glyphSize.y;

drawList->AddRectFilled(ImVec2(x, y), ImVec2(x + cursorWidth, y + glyphSize.y), palette.get(Color::cursor));

}

}

}

// notify OS of text input position for advanced Input Method Editor (IME)

// this is required for the SDL3 backend as it will not report text input events unless we do this

// see https://github.com/ocornut/imgui/issues/8584 for details

if (!readOnly) {

auto context = ImGui::GetCurrentContext();

context->PlatformImeData.WantVisible = true;

context->PlatformImeData.WantTextInput = true;

context->PlatformImeData.InputPos = ImVec2(cursorScreenPos.x - 1.0f, cursorScreenPos.y - context->FontSize);

context->PlatformImeData.InputLineHeight = context->FontSize;

context->PlatformImeData.ViewportId = ImGui::GetCurrentWindow()->Viewport->ID;

}

}

if ((decoratorWidth != 0.0f && decoratorCallback) || showLineNumbers) {

// erase background in case we are scrolling horizontally

if (ImGui::GetScrollX() > 0.0f) {

ImGui::GetWindowDrawList()->AddRectFilled(

ImGui::GetWindowPos(),

ImGui::GetWindowPos() + ImVec2(textOffset, ImGui::GetWindowSize().y),

palette.get(Color::background));

}

}

if (showLineNumbers) {

auto drawList = ImGui::GetWindowDrawList();

auto cursorScreenPos = ImGui::GetCursorScreenPos();

auto curserLine = cursors.getCurrent().getInteractiveEnd().line;

auto position = ImVec2(ImGui::GetWindowPos().x + lineNumberRightOffset, cursorScreenPos.y);

for (int i = firstVisibleLine; i <= lastVisibleLine; i++) {

auto width = static_cast<int>(std::log10(i + 1) + 1.0f) * glyphSize.x;

auto foreground = (i == curserLine) ? Color::currentLineNumber : Color::lineNumber;

auto number = std::to_string(i + 1);

drawList->AddText(position + ImVec2(-width, i * glyphSize.y), palette.get(foreground), number.c_str());

}

}

if (decoratorWidth != 0.0f && decoratorCallback) {

auto cursorScreenPos = ImGui::GetCursorScreenPos();

auto position = ImVec2(ImGui::GetWindowPos().x + decorationOffset, cursorScreenPos.y + glyphSize.y * firstVisibleLine);

auto widthInPixels = (decoratorWidth < 0.0f) ? -decoratorWidth * glyphSize.x: decoratorWidth;

Decorator decorator{0, widthInPixels, glyphSize.y, glyphSize, nullptr};

for (int i = firstVisibleLine; i <= lastVisibleLine; i++) {

decorator.line = i;

decorator.userData = document.getUserData(i);

ImGui::SetCursorScreenPos(position);

ImGui::PushID(i);

decoratorCallback(decorator);

ImGui::PopID();

position.y += glyphSize.y;

}

ImGui::SetCursorScreenPos(cursorScreenPos);

}

// based on https://github.com/ocornut/imgui/issues/3114

// messing with Dear ImGui internals

if (showScrollbarMiniMap) {

auto window = ImGui::GetCurrentWindow();

if (window->ScrollbarY) {

auto drawList = ImGui::GetWindowDrawList();

auto rect = ImGui::GetWindowScrollbarRect(window, ImGuiAxis_Y);

auto lineHeight = rect.GetHeight() / static_cast<float>(document.size());

auto offset = (rect.Max.x - rect.Min.x) * 0.3f;

auto left = rect.Min.x + offset;

auto right = rect.Max.x - offset;

drawList->PushClipRect(rect.Min, rect.Max, false);

// render cursor locations

for (auto& cursor : cursors) {

auto begin = cursor.getSelectionStart();

auto end = cursor.getSelectionEnd();

auto ly1 = std::round(rect.Min.y + begin.line * lineHeight);

auto ly2 = std::round(rect.Min.y + (end.line + 1) * lineHeight);

drawList->AddRectFilled(ImVec2(left, ly1), ImVec2(right, ly2), palette.get(Color::selection));

}

// render marker locations

if (markers.size()) {

for (size_t line = 0; line < document.size(); line++) {

if (document[line].marker) {

auto color = markers[document[line].marker - 1].textColor;

if (!color) {

color = markers[document[line].marker - 1].lineNumberColor;

}

auto ly = std::round(rect.Min.y + line * lineHeight);

drawList->AddRectFilled(ImVec2(left, ly), ImVec2(right, ly + lineHeight), color);

}

}

}

drawList->PopClipRect();

}

}

if (showPanScrollIndicator && (panning || scrolling)) {

auto drawList = ImGui::GetWindowDrawList();

auto center =ImGui::GetWindowPos() + ImGui::GetWindowSize() / 2.0f;

static constexpr int alpha = 160;

drawList->AddCircleFilled(center, 20.0f, IM_COL32(255, 255, 255, alpha));

drawList->AddCircle(center, 5.0f, IM_COL32(0, 0, 0, alpha), 0, 2.0f);

drawList->AddTriangle(

ImVec2(center.x - 15.0f, center.y),

ImVec2(center.x - 8.0f, center.y - 4.0f),

ImVec2(center.x - 8.0f, center.y + 4.0f),

IM_COL32(0, 0, 0, alpha),

2.0f);

drawList->AddTriangle(

ImVec2(center.x + 15.0f, center.y),

ImVec2(center.x + 8.0f, center.y - 4.0f),

ImVec2(center.x + 8.0f, center.y + 4.0f),

IM_COL32(0, 0, 0, alpha),

2.0f);

drawList->AddTriangle(

ImVec2(center.x, center.y - 15.0f),

ImVec2(center.x - 4.0f, center.y - 8.0f),

ImVec2(center.x + 4.0f, center.y - 8.0f),

IM_COL32(0, 0, 0, alpha),

2.0f);

drawList->AddTriangle(

ImVec2(center.x, center.y + 15.0f),

ImVec2(center.x - 4.0f, center.y + 8.0f),

ImVec2(center.x + 4.0f, center.y + 8.0f),

IM_COL32(0, 0, 0, alpha),

2.0f);

}

if (ImGui::IsWindowFocused()) {

auto& io = ImGui::GetIO();

io.WantCaptureKeyboard = true;

io.WantTextInput = true;

// get state of modifier keys

auto shift = ImGui::IsKeyDown(ImGuiMod_Shift);

auto ctrl = ImGui::IsKeyDown(ImGuiMod_Ctrl);

auto alt = ImGui::IsKeyDown(ImGuiMod_Alt);

auto isNoModifiers = !ctrl && !shift && !alt;

auto isShortcut = ctrl && !shift && !alt;

auto isShiftShortcut = ctrl && shift && !alt;

auto isOptionalShiftShortcut = ctrl && !alt;

auto isAltOnly = !ctrl && !shift && alt;

auto isShiftOnly = !ctrl && shift && !alt;

auto isOptionalShift = !ctrl && !alt;

auto isOptionalAlt = !ctrl && !shift;

#if __APPLE__

// Dear ImGui switches the Cmd(Super) and Ctrl keys on MacOS

auto super = ImGui::IsKeyDown(ImGuiMod_Super);

auto isCtrlShift = !ctrl && shift && !alt && super;

auto isOptionalAltShift = !ctrl;

#else

auto isShiftAlt = !ctrl && shift && alt;

auto isOptionalCtrlShift = !alt;

#endif

// ignore specific keys when autocomplete is active, they will be handled later

if (autocomplete.isActive() && autocomplete.isSpecialKeyPressed()) {

return;

}

// cursor movements and selections

if (isOptionalShift && ImGui::IsKeyPressed(ImGuiKey_UpArrow)) { moveUp(1, shift); }

else if (isOptionalShift && ImGui::IsKeyPressed(ImGuiKey_DownArrow)) { moveDown(1, shift); }

#if __APPLE__

else if (isCtrlShift && ImGui::IsKeyPressed(ImGuiKey_LeftArrow)) { shrinkSelectionsToCurlyBrackets(); }

else if (isCtrlShift && ImGui::IsKeyPressed(ImGuiKey_RightArrow)) { growSelectionsToCurlyBrackets(); }

else if (isOptionalAltShift && ImGui::IsKeyPressed(ImGuiKey_LeftArrow)) { moveLeft(shift, alt); }

else if (isOptionalAltShift && ImGui::IsKeyPressed(ImGuiKey_RightArrow)) { moveRight(shift, alt); }

#else

else if (isShiftAlt && ImGui::IsKeyPressed(ImGuiKey_LeftArrow)) { shrinkSelectionsToCurlyBrackets(); }

else if (isShiftAlt && ImGui::IsKeyPressed(ImGuiKey_RightArrow)) { growSelectionsToCurlyBrackets(); }

else if (isOptionalCtrlShift && ImGui::IsKeyPressed(ImGuiKey_LeftArrow)) { moveLeft(shift, ctrl); }

else if (isOptionalCtrlShift && ImGui::IsKeyPressed(ImGuiKey_RightArrow)) { moveRight(shift, ctrl); }

#endif

else if (isOptionalShift && ImGui::IsKeyPressed(ImGuiKey_PageUp)) { moveUp(visibleLines - 2, shift); }

else if (isOptionalShift && ImGui::IsKeyPressed(ImGuiKey_PageDown)) { moveDown(visibleLines - 2, shift); }

else if (isOptionalShiftShortcut && ImGui::IsKeyPressed(ImGuiKey_UpArrow)) { moveToTop(shift); }

else if (isOptionalShiftShortcut && ImGui::IsKeyPressed(ImGuiKey_Home)) { moveToTop(shift); }

else if (isOptionalShiftShortcut && ImGui::IsKeyPressed(ImGuiKey_DownArrow)) { moveToBottom(shift); }

else if (isOptionalShiftShortcut && ImGui::IsKeyPressed(ImGuiKey_End)) { moveToBottom(shift); }

else if (isOptionalShift && ImGui::IsKeyPressed(ImGuiKey_Home)) { moveToStartOfLine(shift); }

else if (isOptionalShift && ImGui::IsKeyPressed(ImGuiKey_End)) { moveToEndOfLine(shift); }

else if (isShortcut && ImGui::IsKeyPressed(ImGuiKey_A)) { selectAll(); }

else if (isShortcut && ImGui::IsKeyPressed(ImGuiKey_D) && cursors.currentCursorHasSelection()) { addNextOccurrence(); }

// clipboard operations

else if (isShortcut && ImGui::IsKeyPressed(ImGuiKey_X)) { cut(); }

else if (isShiftOnly && ImGui::IsKeyPressed(ImGuiKey_Delete)) { cut(); }

else if (isShortcut && ImGui::IsKeyPressed(ImGuiKey_C)) { copy() ;}

else if (isShortcut && ImGui::IsKeyPressed(ImGuiKey_Insert)) { copy(); }

else if (!readOnly && isShortcut && ImGui::IsKeyPressed(ImGuiKey_V)) { paste(); }

else if (!readOnly && isShiftOnly && ImGui::IsKeyPressed(ImGuiKey_Insert)) { paste(); }

else if (!readOnly && isShortcut && ImGui::IsKeyPressed(ImGuiKey_Z)) { undo(); }

else if (!readOnly && isShiftShortcut && ImGui::IsKeyPressed(ImGuiKey_Z)) { redo(); }

else if (!readOnly && isShortcut && ImGui::IsKeyPressed(ImGuiKey_Y)) { redo(); }

// remove text

else if (!readOnly && isOptionalAlt && ImGui::IsKeyPressed(ImGuiKey_Delete)) { handleDelete(alt); }

else if (!readOnly && isOptionalAlt && ImGui::IsKeyPressed(ImGuiKey_Backspace)) { handleBackspace(alt); }

else if (!readOnly && isShiftShortcut && ImGui::IsKeyPressed(ImGuiKey_K)) { removeSelectedLines(); }

// text manipulation

else if (!readOnly && isShortcut && ImGui::IsKeyPressed(ImGuiKey_LeftBracket)) { deindentLines(); }

else if (!readOnly && isShortcut && ImGui::IsKeyPressed(ImGuiKey_RightBracket)) { indentLines(); }

else if (!readOnly && isAltOnly && ImGui::IsKeyPressed(ImGuiKey_UpArrow)) { moveUpLines(); }

else if (!readOnly && isAltOnly && ImGui::IsKeyPressed(ImGuiKey_DownArrow)) { moveDownLines(); }

else if (!readOnly && language && isShortcut && ImGui::IsKeyPressed(ImGuiKey_Slash)) { toggleComments(); }

// find/replace support

else if (isShortcut && ImGui::IsKeyPressed(ImGuiKey_F)) {

if (autocomplete.isActive()) {

autocomplete.cancel();

findCancelledAutocomplete = true;

}

openFindReplace();

}

else if (isShiftShortcut && ImGui::IsKeyPressed(ImGuiKey_F)) { findAll(); }

else if (isShortcut && ImGui::IsKeyPressed(ImGuiKey_G)) { findNext(); }

// autocomplete support

else if (!readOnly && ImGui::IsKeyChordPressed(autocomplete.getTriggerShortcut())) {

// don't activate if we have multiple cursors active

if (cursors.hasMultiple()) {

// TODO: inform user

} else {

if (autocomplete.startShortcut(cursors)) {

makeCursorVisible();

}

}

}

// change insert mode

else if (isNoModifiers && ImGui::IsKeyPressed(ImGuiKey_Insert)) { overwrite = !overwrite; }

// handle new line

else if (!readOnly && isNoModifiers && (ImGui::IsKeyPressed(ImGuiKey_Enter) || ImGui::IsKeyPressed(ImGuiKey_KeypadEnter))) { handleCharacter('\n'); }

else if (!readOnly && isShortcut && (ImGui::IsKeyPressed(ImGuiKey_Enter) || ImGui::IsKeyPressed(ImGuiKey_KeypadEnter))) { insertLineBelow(); }

else if (!readOnly && isShiftShortcut && (ImGui::IsKeyPressed(ImGuiKey_Enter) || ImGui::IsKeyPressed(ImGuiKey_KeypadEnter))) { insertLineAbove(); }

// handle tabs

else if (!readOnly && isOptionalShift && ImGui::IsKeyPressed(ImGuiKey_Tab)) {

if (cursors.anyHasSelection()) {

if (shift) {

deindentLines();

} else {

indentLines();

}

} else {

handleCharacter('\t');

}

}

// handle escape key

else if (ImGui::IsKeyPressed(ImGuiKey_Escape)) {

if (autocomplete.isActive()) {

autocomplete.cancel();

} else if (findReplaceVisible) {

closeFindReplace();

} else if (cursors.hasMultiple()) {

cursors.clearAdditional();

}

}

// handle regular text

if (!io.InputQueueCharacters.empty()) {

// ignore Ctrl inputs, but need to allow Alt+Ctrl as some keyboards (e.g. German) use AltGR (which is Alt+Ctrl) to input certain characters

if (!(io.KeyCtrl && !io.KeyAlt) && !readOnly) {

for (auto i = 0; i < io.InputQueueCharacters.size(); i++) {

auto character = io.InputQueueCharacters[i];

if (character == '\n' || character >= 32) {

handleCharacter(character);

}

}

}

io.InputQueueCharacters.resize(0);

}

}

// handle middle mouse button modes

panning &= panMode && ImGui::IsMouseDown(ImGuiMouseButton_Middle);

auto absoluteMousePos = ImGui::GetMousePos() - ImGui::GetWindowPos();

if (panning && ImGui::IsMouseDragging(ImGuiMouseButton_Middle)) {

// handle middle mouse button panning

auto windowSize = ImGui::GetWindowSize();

auto mouseDelta = ImGui::GetMouseDragDelta(ImGuiMouseButton_Middle);

float dragFactor = ImGui::GetIO().DeltaTime * 15.0f;

ImVec2 autoPanMargin(glyphSize.x * 4.0f, glyphSize.y * 2.0f);

if (absoluteMousePos.x < textOffset + autoPanMargin.x) {

mouseDelta.x = (absoluteMousePos.x - (textOffset + autoPanMargin.x)) * dragFactor;

} else if (absoluteMousePos.x > windowSize.x - verticalScrollBarSize - autoPanMargin.x) {

mouseDelta.x = (absoluteMousePos.x - (windowSize.x - verticalScrollBarSize - autoPanMargin.x)) * dragFactor;

}

if (absoluteMousePos.y < autoPanMargin.y) {

mouseDelta.y = (absoluteMousePos.y - autoPanMargin.y) * dragFactor;

} else if (absoluteMousePos.y > windowSize.y - horizontalScrollBarSize - autoPanMargin.y) {

mouseDelta.y = (absoluteMousePos.y - (windowSize.y - horizontalScrollBarSize - autoPanMargin.y)) * dragFactor;

}

ImGui::SetScrollX(ImGui::GetScrollX() - mouseDelta.x);

ImGui::SetScrollY(ImGui::GetScrollY() - mouseDelta.y);

ImGui::ResetMouseDragDelta(ImGuiMouseButton_Middle);

} else if (scrolling) {

// handle middle mouse button scrolling

float deadzone = glyphSize.x;

auto offset = scrollStart - absoluteMousePos;

offset.x = (offset.x < 0.0f) ? std::min(offset.x + deadzone, 0.0f) : std::max(offset.x - deadzone, 0.0f);

offset.y = (offset.y < 0.0f) ? std::min(offset.y + deadzone, 0.0f) : std::max(offset.y - deadzone, 0.0f);

float scrollFactor = ImGui::GetIO().DeltaTime * 5.0f;

offset *= scrollFactor;

ImGui::SetScrollX(ImGui::GetScrollX() - offset.x);

ImGui::SetScrollY(ImGui::GetScrollY() - offset.y);

if (ImGui::IsMouseClicked(ImGuiMouseButton_Left) ||

ImGui::IsMouseClicked(ImGuiMouseButton_Middle) ||

ImGui::IsMouseClicked(ImGuiMouseButton_Right)) {

scrolling = false;

}

// ignore other interactions when the editor is not hovered

} else if (ImGui::IsWindowHovered()) {

auto io = ImGui::GetIO();

auto mousePos = ImGui::GetMousePos() - ImGui::GetCursorScreenPos();

bool overLineNumbers = showLineNumbers && (absoluteMousePos.x > lineNumberLeftOffset) && (absoluteMousePos.x < lineNumberRightOffset);

bool overText = mousePos.x - ImGui::GetScrollX() > textOffset;

Coordinate glyphCoordinate;

Coordinate cursorCoordinate;

document.normalizeCoordinate(

mousePos.y / glyphSize.y,

(mousePos.x - textOffset) / glyphSize.x,

glyphCoordinate,

cursorCoordinate);

// show text cursor if required

if (ImGui::IsWindowFocused() && overText) {

ImGui::SetMouseCursor(ImGuiMouseCursor_TextInput);

}

if (ImGui::IsMouseDragging(ImGuiMouseButton_Left)) {

// update selection with dragging left mouse button

io.WantCaptureMouse = true;

if (overLineNumbers) {

auto& cursor = cursors.getCurrent();

auto start = Coordinate(cursorCoordinate.line, 0);

auto end = document.getDown(start);

cursor.update(cursor.getInteractiveEnd() < cursor.getInteractiveStart() ? start : end);

} else {

cursors.updateCurrentCursor(cursorCoordinate);

}

makeCursorVisible();

} else if (ImGui::IsMouseClicked(ImGuiMouseButton_Middle)) {

// start panning/scrolling mode on middle mouse click

if (panMode) {

panning = true;

} else {

scrolling = true;

scrollStart = absoluteMousePos;

}

} else if (ImGui::IsMouseClicked(ImGuiMouseButton_Right)) {

// handle right clicks by setting up context menu (if required)

if (overLineNumbers && lineNumberContextMenuCallback) {

contextMenuLine = glyphCoordinate.line;

ImGui::OpenPopup("LineNumberContextMenu");

} else if (overText && textContextMenuCallback) {

contextMenuLine = glyphCoordinate.line;

contextMenuColumn = glyphCoordinate.column;

ImGui::OpenPopup("TextContextMenu");

}

} else if (ImGui::IsMouseClicked(ImGuiMouseButton_Left)) {

// handle left mouse button actions

auto click = ImGui::IsMouseClicked(ImGuiMouseButton_Left);

auto doubleClick = ImGui::IsMouseDoubleClicked(ImGuiMouseButton_Left);

auto now = static_cast<float>(ImGui::GetTime());

auto tripleClick = click && !doubleClick && (lastClickTime != -1.0f && (now - lastClickTime) < io.MouseDoubleClickTime);

if (click || doubleClick || tripleClick) {

lastClickTime = tripleClick ? -1.0f : now;

}

if (tripleClick) {

// left mouse button triple click

if (overText) {

auto start = document.getStartOfLine(cursorCoordinate);

auto end = document.getDown(start);

cursors.updateCurrentCursor(start, end);

}

} else if (doubleClick) {

// left mouse button double click

if (overText) {

auto codepoint = document.getCodePoint(glyphCoordinate);

bool handled = false;

// select bracketed section (if required)

if (CodePoint::isBracketOpener(codepoint)) {

auto brackets = bracketeer.getEnclosingBrackets(document.getRight(glyphCoordinate));

if (brackets != bracketeer.end()) {

if (ImGui::IsKeyDown(ImGuiMod_Shift)) {

cursors.setCursor(brackets->start, document.getRight(brackets->end));

} else {

cursors.setCursor(document.getRight(brackets->start), brackets->end);

}

handled = true;

}

} else if (CodePoint::isBracketCloser(codepoint)) {

auto brackets = bracketeer.getEnclosingBrackets(glyphCoordinate);

if (brackets != bracketeer.end()) {

cursors.setCursor(brackets->start, document.getRight(brackets->end));

handled = true;

}

}

// select "word" if it wasn't a bracketed section

// includes whitespace and operator sequences as well

if (!handled && !document.isEndOfLine(glyphCoordinate)) {

auto start = document.findWordStart(glyphCoordinate);

auto end = document.findWordEnd(glyphCoordinate);

cursors.updateCurrentCursor(start, end);

}

}