| #include <algorithm> |
| #include <chrono> |
| #include <string> |
| #include <regex> |
| #include <cmath> |
| |
| #include "TextEditor.h" |
| |
| #define IMGUI_DEFINE_MATH_OPERATORS |
| #include "imgui.h" // for imGui::GetCurrentWindow() |
| |
| // TODO |
| // - multiline comments vs single-line: latter is blocking start of a ML |
| |
| template<class InputIt1, class InputIt2, class BinaryPredicate> |
| bool equals(InputIt1 first1, InputIt1 last1, |
| InputIt2 first2, InputIt2 last2, BinaryPredicate p) |
| { |
| for (; first1 != last1 && first2 != last2; ++first1, ++first2) |
| { |
| if (!p(*first1, *first2)) |
| return false; |
| } |
| return first1 == last1 && first2 == last2; |
| } |
| |
| TextEditor::TextEditor() |
| : mLineSpacing(1.0f) |
| , mUndoIndex(0) |
| , mTabSize(4) |
| , mOverwrite(false) |
| , mReadOnly(false) |
| , mWithinRender(false) |
| , mScrollToCursor(false) |
| , mScrollToTop(false) |
| , mTextChanged(false) |
| , mColorizerEnabled(true) |
| , mTextStart(20.0f) |
| , mLeftMargin(10) |
| , mCursorPositionChanged(false) |
| , mColorRangeMin(0) |
| , mColorRangeMax(0) |
| , mSelectionMode(SelectionMode::Normal) |
| , mCheckComments(true) |
| , mLastClick(-1.0f) |
| , mHandleKeyboardInputs(true) |
| , mHandleMouseInputs(true) |
| , mIgnoreImGuiChild(false) |
| , mShowWhitespaces(true) |
| , mStartTime(std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count()) |
| { |
| SetPalette(GetDarkPalette()); |
| SetLanguageDefinition(LanguageDefinition::HLSL()); |
| mLines.push_back(Line()); |
| } |
| |
| TextEditor::~TextEditor() |
| { |
| } |
| |
| void TextEditor::SetLanguageDefinition(const LanguageDefinition & aLanguageDef) |
| { |
| mLanguageDefinition = aLanguageDef; |
| mRegexList.clear(); |
| |
| for (auto& r : mLanguageDefinition.mTokenRegexStrings) |
| mRegexList.push_back(std::make_pair(std::regex(r.first, std::regex_constants::optimize), r.second)); |
| |
| Colorize(); |
| } |
| |
| void TextEditor::SetPalette(const Palette & aValue) |
| { |
| mPaletteBase = aValue; |
| } |
| |
| std::string TextEditor::GetText(const Coordinates & aStart, const Coordinates & aEnd) const |
| { |
| std::string result; |
| |
| auto lstart = aStart.mLine; |
| auto lend = aEnd.mLine; |
| auto istart = GetCharacterIndex(aStart); |
| auto iend = GetCharacterIndex(aEnd); |
| size_t s = 0; |
| |
| for (size_t i = lstart; i < lend; i++) |
| s += mLines[i].size(); |
| |
| result.reserve(s + s / 8); |
| |
| while (istart < iend || lstart < lend) |
| { |
| if (lstart >= (int)mLines.size()) |
| break; |
| |
| auto& line = mLines[lstart]; |
| if (istart < (int)line.size()) |
| { |
| result += line[istart].mChar; |
| istart++; |
| } |
| else |
| { |
| istart = 0; |
| ++lstart; |
| result += '\n'; |
| } |
| } |
| |
| return result; |
| } |
| |
| TextEditor::Coordinates TextEditor::GetActualCursorCoordinates() const |
| { |
| return SanitizeCoordinates(mState.mCursorPosition); |
| } |
| |
| TextEditor::Coordinates TextEditor::SanitizeCoordinates(const Coordinates & aValue) const |
| { |
| auto line = aValue.mLine; |
| auto column = aValue.mColumn; |
| if (line >= (int)mLines.size()) |
| { |
| if (mLines.empty()) |
| { |
| line = 0; |
| column = 0; |
| } |
| else |
| { |
| line = (int)mLines.size() - 1; |
| column = GetLineMaxColumn(line); |
| } |
| return Coordinates(line, column); |
| } |
| else |
| { |
| column = mLines.empty() ? 0 : std::min(column, GetLineMaxColumn(line)); |
| return Coordinates(line, column); |
| } |
| } |
| |
| // https://en.wikipedia.org/wiki/UTF-8 |
| // We assume that the char is a standalone character (<128) or a leading byte of an UTF-8 code sequence (non-10xxxxxx code) |
| static int UTF8CharLength(TextEditor::Char c) |
| { |
| if ((c & 0xFE) == 0xFC) |
| return 6; |
| if ((c & 0xFC) == 0xF8) |
| return 5; |
| if ((c & 0xF8) == 0xF0) |
| return 4; |
| else if ((c & 0xF0) == 0xE0) |
| return 3; |
| else if ((c & 0xE0) == 0xC0) |
| return 2; |
| return 1; |
| } |
| |
| // "Borrowed" from ImGui source |
| static inline int ImTextCharToUtf8(char* buf, int buf_size, unsigned int c) |
| { |
| if (c < 0x80) |
| { |
| buf[0] = (char)c; |
| return 1; |
| } |
| if (c < 0x800) |
| { |
| if (buf_size < 2) return 0; |
| buf[0] = (char)(0xc0 + (c >> 6)); |
| buf[1] = (char)(0x80 + (c & 0x3f)); |
| return 2; |
| } |
| if (c >= 0xdc00 && c < 0xe000) |
| { |
| return 0; |
| } |
| if (c >= 0xd800 && c < 0xdc00) |
| { |
| if (buf_size < 4) return 0; |
| buf[0] = (char)(0xf0 + (c >> 18)); |
| buf[1] = (char)(0x80 + ((c >> 12) & 0x3f)); |
| buf[2] = (char)(0x80 + ((c >> 6) & 0x3f)); |
| buf[3] = (char)(0x80 + ((c) & 0x3f)); |
| return 4; |
| } |
| //else if (c < 0x10000) |
| { |
| if (buf_size < 3) return 0; |
| buf[0] = (char)(0xe0 + (c >> 12)); |
| buf[1] = (char)(0x80 + ((c >> 6) & 0x3f)); |
| buf[2] = (char)(0x80 + ((c) & 0x3f)); |
| return 3; |
| } |
| } |
| |
| void TextEditor::Advance(Coordinates & aCoordinates) const |
| { |
| if (aCoordinates.mLine < (int)mLines.size()) |
| { |
| auto& line = mLines[aCoordinates.mLine]; |
| auto cindex = GetCharacterIndex(aCoordinates); |
| |
| if (cindex + 1 < (int)line.size()) |
| { |
| auto delta = UTF8CharLength(line[cindex].mChar); |
| cindex = std::min(cindex + delta, (int)line.size() - 1); |
| } |
| else |
| { |
| ++aCoordinates.mLine; |
| cindex = 0; |
| } |
| aCoordinates.mColumn = GetCharacterColumn(aCoordinates.mLine, cindex); |
| } |
| } |
| |
| void TextEditor::DeleteRange(const Coordinates & aStart, const Coordinates & aEnd) |
| { |
| assert(aEnd >= aStart); |
| assert(!mReadOnly); |
| |
| //printf("D(%d.%d)-(%d.%d)\n", aStart.mLine, aStart.mColumn, aEnd.mLine, aEnd.mColumn); |
| |
| if (aEnd == aStart) |
| return; |
| |
| auto start = GetCharacterIndex(aStart); |
| auto end = GetCharacterIndex(aEnd); |
| |
| if (aStart.mLine == aEnd.mLine) |
| { |
| auto& line = mLines[aStart.mLine]; |
| auto n = GetLineMaxColumn(aStart.mLine); |
| if (aEnd.mColumn >= n) |
| line.erase(line.begin() + start, line.end()); |
| else |
| line.erase(line.begin() + start, line.begin() + end); |
| } |
| else |
| { |
| auto& firstLine = mLines[aStart.mLine]; |
| auto& lastLine = mLines[aEnd.mLine]; |
| |
| firstLine.erase(firstLine.begin() + start, firstLine.end()); |
| lastLine.erase(lastLine.begin(), lastLine.begin() + end); |
| |
| if (aStart.mLine < aEnd.mLine) |
| firstLine.insert(firstLine.end(), lastLine.begin(), lastLine.end()); |
| |
| if (aStart.mLine < aEnd.mLine) |
| RemoveLine(aStart.mLine + 1, aEnd.mLine + 1); |
| } |
| |
| mTextChanged = true; |
| } |
| |
| int TextEditor::InsertTextAt(Coordinates& /* inout */ aWhere, const char * aValue) |
| { |
| assert(!mReadOnly); |
| |
| int cindex = GetCharacterIndex(aWhere); |
| int totalLines = 0; |
| while (*aValue != '\0') |
| { |
| assert(!mLines.empty()); |
| |
| if (*aValue == '\r') |
| { |
| // skip |
| ++aValue; |
| } |
| else if (*aValue == '\n') |
| { |
| if (cindex < (int)mLines[aWhere.mLine].size()) |
| { |
| auto& newLine = InsertLine(aWhere.mLine + 1); |
| auto& line = mLines[aWhere.mLine]; |
| newLine.insert(newLine.begin(), line.begin() + cindex, line.end()); |
| line.erase(line.begin() + cindex, line.end()); |
| } |
| else |
| { |
| InsertLine(aWhere.mLine + 1); |
| } |
| ++aWhere.mLine; |
| aWhere.mColumn = 0; |
| cindex = 0; |
| ++totalLines; |
| ++aValue; |
| } |
| else |
| { |
| auto& line = mLines[aWhere.mLine]; |
| auto d = UTF8CharLength(*aValue); |
| while (d-- > 0 && *aValue != '\0') |
| line.insert(line.begin() + cindex++, Glyph(*aValue++, PaletteIndex::Default)); |
| ++aWhere.mColumn; |
| } |
| |
| mTextChanged = true; |
| } |
| |
| return totalLines; |
| } |
| |
| void TextEditor::AddUndo(UndoRecord& aValue) |
| { |
| assert(!mReadOnly); |
| //printf("AddUndo: (@%d.%d) +\'%s' [%d.%d .. %d.%d], -\'%s', [%d.%d .. %d.%d] (@%d.%d)\n", |
| // aValue.mBefore.mCursorPosition.mLine, aValue.mBefore.mCursorPosition.mColumn, |
| // aValue.mAdded.c_str(), aValue.mAddedStart.mLine, aValue.mAddedStart.mColumn, aValue.mAddedEnd.mLine, aValue.mAddedEnd.mColumn, |
| // aValue.mRemoved.c_str(), aValue.mRemovedStart.mLine, aValue.mRemovedStart.mColumn, aValue.mRemovedEnd.mLine, aValue.mRemovedEnd.mColumn, |
| // aValue.mAfter.mCursorPosition.mLine, aValue.mAfter.mCursorPosition.mColumn |
| // ); |
| |
| mUndoBuffer.resize((size_t)(mUndoIndex + 1)); |
| mUndoBuffer.back() = aValue; |
| ++mUndoIndex; |
| } |
| |
| TextEditor::Coordinates TextEditor::ScreenPosToCoordinates(const ImVec2& aPosition) const |
| { |
| ImVec2 origin = ImGui::GetCursorScreenPos(); |
| ImVec2 local(aPosition.x - origin.x, aPosition.y - origin.y); |
| |
| int lineNo = std::max(0, (int)floor(local.y / mCharAdvance.y)); |
| |
| int columnCoord = 0; |
| |
| if (lineNo >= 0 && lineNo < (int)mLines.size()) |
| { |
| auto& line = mLines.at(lineNo); |
| |
| int columnIndex = 0; |
| float columnX = 0.0f; |
| |
| while ((size_t)columnIndex < line.size()) |
| { |
| float columnWidth = 0.0f; |
| |
| if (line[columnIndex].mChar == '\t') |
| { |
| float spaceSize = ImGui::GetFont()->CalcTextSizeA(ImGui::GetFontSize(), FLT_MAX, -1.0f, " ").x; |
| float oldX = columnX; |
| float newColumnX = (1.0f + std::floor((1.0f + columnX) / (float(mTabSize) * spaceSize))) * (float(mTabSize) * spaceSize); |
| columnWidth = newColumnX - oldX; |
| if (mTextStart + columnX + columnWidth * 0.5f > local.x) |
| break; |
| columnX = newColumnX; |
| columnCoord = (columnCoord / mTabSize) * mTabSize + mTabSize; |
| columnIndex++; |
| } |
| else |
| { |
| char buf[7]; |
| auto d = UTF8CharLength(line[columnIndex].mChar); |
| int i = 0; |
| while (i < 6 && d-- > 0) |
| buf[i++] = line[columnIndex++].mChar; |
| buf[i] = '\0'; |
| columnWidth = ImGui::GetFont()->CalcTextSizeA(ImGui::GetFontSize(), FLT_MAX, -1.0f, buf).x; |
| if (mTextStart + columnX + columnWidth * 0.5f > local.x) |
| break; |
| columnX += columnWidth; |
| columnCoord++; |
| } |
| } |
| } |
| |
| return SanitizeCoordinates(Coordinates(lineNo, columnCoord)); |
| } |
| |
| TextEditor::Coordinates TextEditor::FindWordStart(const Coordinates & aFrom) const |
| { |
| Coordinates at = aFrom; |
| if (at.mLine >= (int)mLines.size()) |
| return at; |
| |
| auto& line = mLines[at.mLine]; |
| auto cindex = GetCharacterIndex(at); |
| |
| if (cindex >= (int)line.size()) |
| return at; |
| |
| while (cindex > 0 && isspace(line[cindex].mChar)) |
| --cindex; |
| |
| auto cstart = (PaletteIndex)line[cindex].mColorIndex; |
| while (cindex > 0) |
| { |
| auto c = line[cindex].mChar; |
| if ((c & 0xC0) != 0x80) // not UTF code sequence 10xxxxxx |
| { |
| if (c <= 32 && isspace(c)) |
| { |
| cindex++; |
| break; |
| } |
| if (cstart != (PaletteIndex)line[size_t(cindex - 1)].mColorIndex) |
| break; |
| } |
| --cindex; |
| } |
| return Coordinates(at.mLine, GetCharacterColumn(at.mLine, cindex)); |
| } |
| |
| TextEditor::Coordinates TextEditor::FindWordEnd(const Coordinates & aFrom) const |
| { |
| Coordinates at = aFrom; |
| if (at.mLine >= (int)mLines.size()) |
| return at; |
| |
| auto& line = mLines[at.mLine]; |
| auto cindex = GetCharacterIndex(at); |
| |
| if (cindex >= (int)line.size()) |
| return at; |
| |
| bool prevspace = (bool)isspace(line[cindex].mChar); |
| auto cstart = (PaletteIndex)line[cindex].mColorIndex; |
| while (cindex < (int)line.size()) |
| { |
| auto c = line[cindex].mChar; |
| auto d = UTF8CharLength(c); |
| if (cstart != (PaletteIndex)line[cindex].mColorIndex) |
| break; |
| |
| if (prevspace != !!isspace(c)) |
| { |
| if (isspace(c)) |
| while (cindex < (int)line.size() && isspace(line[cindex].mChar)) |
| ++cindex; |
| break; |
| } |
| cindex += d; |
| } |
| return Coordinates(aFrom.mLine, GetCharacterColumn(aFrom.mLine, cindex)); |
| } |
| |
| TextEditor::Coordinates TextEditor::FindNextWord(const Coordinates & aFrom) const |
| { |
| Coordinates at = aFrom; |
| if (at.mLine >= (int)mLines.size()) |
| return at; |
| |
| // skip to the next non-word character |
| auto cindex = GetCharacterIndex(aFrom); |
| bool isword = false; |
| bool skip = false; |
| if (cindex < (int)mLines[at.mLine].size()) |
| { |
| auto& line = mLines[at.mLine]; |
| isword = isalnum(line[cindex].mChar); |
| skip = isword; |
| } |
| |
| while (!isword || skip) |
| { |
| if (at.mLine >= mLines.size()) |
| { |
| auto l = std::max(0, (int) mLines.size() - 1); |
| return Coordinates(l, GetLineMaxColumn(l)); |
| } |
| |
| auto& line = mLines[at.mLine]; |
| if (cindex < (int)line.size()) |
| { |
| isword = isalnum(line[cindex].mChar); |
| |
| if (isword && !skip) |
| return Coordinates(at.mLine, GetCharacterColumn(at.mLine, cindex)); |
| |
| if (!isword) |
| skip = false; |
| |
| cindex++; |
| } |
| else |
| { |
| cindex = 0; |
| ++at.mLine; |
| skip = false; |
| isword = false; |
| } |
| } |
| |
| return at; |
| } |
| |
| int TextEditor::GetCharacterIndex(const Coordinates& aCoordinates) const |
| { |
| if (aCoordinates.mLine >= mLines.size()) |
| return -1; |
| auto& line = mLines[aCoordinates.mLine]; |
| int c = 0; |
| int i = 0; |
| for (; i < line.size() && c < aCoordinates.mColumn;) |
| { |
| if (line[i].mChar == '\t') |
| c = (c / mTabSize) * mTabSize + mTabSize; |
| else |
| ++c; |
| i += UTF8CharLength(line[i].mChar); |
| } |
| return i; |
| } |
| |
| int TextEditor::GetCharacterColumn(int aLine, int aIndex) const |
| { |
| if (aLine >= mLines.size()) |
| return 0; |
| auto& line = mLines[aLine]; |
| int col = 0; |
| int i = 0; |
| while (i < aIndex && i < (int)line.size()) |
| { |
| auto c = line[i].mChar; |
| i += UTF8CharLength(c); |
| if (c == '\t') |
| col = (col / mTabSize) * mTabSize + mTabSize; |
| else |
| col++; |
| } |
| return col; |
| } |
| |
| int TextEditor::GetLineCharacterCount(int aLine) const |
| { |
| if (aLine >= mLines.size()) |
| return 0; |
| auto& line = mLines[aLine]; |
| int c = 0; |
| for (unsigned i = 0; i < line.size(); c++) |
| i += UTF8CharLength(line[i].mChar); |
| return c; |
| } |
| |
| int TextEditor::GetLineMaxColumn(int aLine) const |
| { |
| if (aLine >= mLines.size()) |
| return 0; |
| auto& line = mLines[aLine]; |
| int col = 0; |
| for (unsigned i = 0; i < line.size(); ) |
| { |
| auto c = line[i].mChar; |
| if (c == '\t') |
| col = (col / mTabSize) * mTabSize + mTabSize; |
| else |
| col++; |
| i += UTF8CharLength(c); |
| } |
| return col; |
| } |
| |
| bool TextEditor::IsOnWordBoundary(const Coordinates & aAt) const |
| { |
| if (aAt.mLine >= (int)mLines.size() || aAt.mColumn == 0) |
| return true; |
| |
| auto& line = mLines[aAt.mLine]; |
| auto cindex = GetCharacterIndex(aAt); |
| if (cindex >= (int)line.size()) |
| return true; |
| |
| if (mColorizerEnabled) |
| return line[cindex].mColorIndex != line[size_t(cindex - 1)].mColorIndex; |
| |
| return isspace(line[cindex].mChar) != isspace(line[cindex - 1].mChar); |
| } |
| |
| void TextEditor::RemoveLine(int aStart, int aEnd) |
| { |
| assert(!mReadOnly); |
| assert(aEnd >= aStart); |
| assert(mLines.size() > (size_t)(aEnd - aStart)); |
| |
| ErrorMarkers etmp; |
| for (auto& i : mErrorMarkers) |
| { |
| ErrorMarkers::value_type e(i.first >= aStart ? i.first - 1 : i.first, i.second); |
| if (e.first >= aStart && e.first <= aEnd) |
| continue; |
| etmp.insert(e); |
| } |
| mErrorMarkers = std::move(etmp); |
| |
| Breakpoints btmp; |
| for (auto i : mBreakpoints) |
| { |
| if (i >= aStart && i <= aEnd) |
| continue; |
| btmp.insert(i >= aStart ? i - 1 : i); |
| } |
| mBreakpoints = std::move(btmp); |
| |
| mLines.erase(mLines.begin() + aStart, mLines.begin() + aEnd); |
| assert(!mLines.empty()); |
| |
| mTextChanged = true; |
| } |
| |
| void TextEditor::RemoveLine(int aIndex) |
| { |
| assert(!mReadOnly); |
| assert(mLines.size() > 1); |
| |
| ErrorMarkers etmp; |
| for (auto& i : mErrorMarkers) |
| { |
| ErrorMarkers::value_type e(i.first > aIndex ? i.first - 1 : i.first, i.second); |
| if (e.first - 1 == aIndex) |
| continue; |
| etmp.insert(e); |
| } |
| mErrorMarkers = std::move(etmp); |
| |
| Breakpoints btmp; |
| for (auto i : mBreakpoints) |
| { |
| if (i == aIndex) |
| continue; |
| btmp.insert(i >= aIndex ? i - 1 : i); |
| } |
| mBreakpoints = std::move(btmp); |
| |
| mLines.erase(mLines.begin() + aIndex); |
| assert(!mLines.empty()); |
| |
| mTextChanged = true; |
| } |
| |
| TextEditor::Line& TextEditor::InsertLine(int aIndex) |
| { |
| assert(!mReadOnly); |
| |
| auto& result = *mLines.insert(mLines.begin() + aIndex, Line()); |
| |
| ErrorMarkers etmp; |
| for (auto& i : mErrorMarkers) |
| etmp.insert(ErrorMarkers::value_type(i.first >= aIndex ? i.first + 1 : i.first, i.second)); |
| mErrorMarkers = std::move(etmp); |
| |
| Breakpoints btmp; |
| for (auto i : mBreakpoints) |
| btmp.insert(i >= aIndex ? i + 1 : i); |
| mBreakpoints = std::move(btmp); |
| |
| return result; |
| } |
| |
| std::string TextEditor::GetWordUnderCursor() const |
| { |
| auto c = GetCursorPosition(); |
| return GetWordAt(c); |
| } |
| |
| std::string TextEditor::GetWordAt(const Coordinates & aCoords) const |
| { |
| auto start = FindWordStart(aCoords); |
| auto end = FindWordEnd(aCoords); |
| |
| std::string r; |
| |
| auto istart = GetCharacterIndex(start); |
| auto iend = GetCharacterIndex(end); |
| |
| for (auto it = istart; it < iend; ++it) |
| r.push_back(mLines[aCoords.mLine][it].mChar); |
| |
| return r; |
| } |
| |
| ImU32 TextEditor::GetGlyphColor(const Glyph & aGlyph) const |
| { |
| if (!mColorizerEnabled) |
| return mPalette[(int)PaletteIndex::Default]; |
| if (aGlyph.mComment) |
| return mPalette[(int)PaletteIndex::Comment]; |
| if (aGlyph.mMultiLineComment) |
| return mPalette[(int)PaletteIndex::MultiLineComment]; |
| auto const color = mPalette[(int)aGlyph.mColorIndex]; |
| if (aGlyph.mPreprocessor) |
| { |
| const auto ppcolor = mPalette[(int)PaletteIndex::Preprocessor]; |
| const int c0 = ((ppcolor & 0xff) + (color & 0xff)) / 2; |
| const int c1 = (((ppcolor >> 8) & 0xff) + ((color >> 8) & 0xff)) / 2; |
| const int c2 = (((ppcolor >> 16) & 0xff) + ((color >> 16) & 0xff)) / 2; |
| const int c3 = (((ppcolor >> 24) & 0xff) + ((color >> 24) & 0xff)) / 2; |
| return ImU32(c0 | (c1 << 8) | (c2 << 16) | (c3 << 24)); |
| } |
| return color; |
| } |
| |
| void TextEditor::HandleKeyboardInputs() |
| { |
| ImGuiIO& io = ImGui::GetIO(); |
| auto shift = io.KeyShift; |
| auto ctrl = io.ConfigMacOSXBehaviors ? io.KeySuper : io.KeyCtrl; |
| auto alt = io.ConfigMacOSXBehaviors ? io.KeyCtrl : io.KeyAlt; |
| |
| if (ImGui::IsWindowFocused()) |
| { |
| if (ImGui::IsWindowHovered()) |
| ImGui::SetMouseCursor(ImGuiMouseCursor_TextInput); |
| //ImGui::CaptureKeyboardFromApp(true); |
| |
| io.WantCaptureKeyboard = true; |
| io.WantTextInput = true; |
| |
| if (!IsReadOnly() && ctrl && !shift && !alt && ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_Z))) |
| Undo(); |
| else if (!IsReadOnly() && !ctrl && !shift && alt && ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_Backspace))) |
| Undo(); |
| else if (!IsReadOnly() && ctrl && !shift && !alt && ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_Y))) |
| Redo(); |
| else if (!ctrl && !alt && ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_UpArrow))) |
| MoveUp(1, shift); |
| else if (!ctrl && !alt && ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_DownArrow))) |
| MoveDown(1, shift); |
| else if (!alt && ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_LeftArrow))) |
| MoveLeft(1, shift, ctrl); |
| else if (!alt && ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_RightArrow))) |
| MoveRight(1, shift, ctrl); |
| else if (!alt && ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_PageUp))) |
| MoveUp(GetPageSize() - 4, shift); |
| else if (!alt && ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_PageDown))) |
| MoveDown(GetPageSize() - 4, shift); |
| else if (!alt && ctrl && ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_Home))) |
| MoveTop(shift); |
| else if (ctrl && !alt && ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_End))) |
| MoveBottom(shift); |
| else if (!ctrl && !alt && ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_Home))) |
| MoveHome(shift); |
| else if (!ctrl && !alt && ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_End))) |
| MoveEnd(shift); |
| else if (!IsReadOnly() && !ctrl && !shift && !alt && ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_Delete))) |
| Delete(); |
| else if (!IsReadOnly() && !ctrl && !shift && !alt && ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_Backspace))) |
| Backspace(); |
| else if (!ctrl && !shift && !alt && ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_Insert))) |
| mOverwrite ^= true; |
| else if (ctrl && !shift && !alt && ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_Insert))) |
| Copy(); |
| else if (ctrl && !shift && !alt && ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_C))) |
| Copy(); |
| else if (!IsReadOnly() && !ctrl && shift && !alt && ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_Insert))) |
| Paste(); |
| else if (!IsReadOnly() && ctrl && !shift && !alt && ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_V))) |
| Paste(); |
| else if (ctrl && !shift && !alt && ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_X))) |
| Cut(); |
| else if (!ctrl && shift && !alt && ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_Delete))) |
| Cut(); |
| else if (ctrl && !shift && !alt && ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_A))) |
| SelectAll(); |
| else if (!IsReadOnly() && !ctrl && !shift && !alt && ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_Enter))) |
| EnterCharacter('\n', false); |
| else if (!IsReadOnly() && !ctrl && !alt && ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_Tab))) |
| EnterCharacter('\t', shift); |
| |
| if (!IsReadOnly() && !io.InputQueueCharacters.empty()) |
| { |
| for (int i = 0; i < io.InputQueueCharacters.Size; i++) |
| { |
| auto c = io.InputQueueCharacters[i]; |
| if (c != 0 && (c == '\n' || c >= 32)) |
| EnterCharacter(c, shift); |
| } |
| io.InputQueueCharacters.resize(0); |
| } |
| } |
| } |
| |
| void TextEditor::HandleMouseInputs() |
| { |
| ImGuiIO& io = ImGui::GetIO(); |
| auto shift = io.KeyShift; |
| auto ctrl = io.ConfigMacOSXBehaviors ? io.KeySuper : io.KeyCtrl; |
| auto alt = io.ConfigMacOSXBehaviors ? io.KeyCtrl : io.KeyAlt; |
| |
| if (ImGui::IsWindowHovered()) |
| { |
| if (!shift && !alt) |
| { |
| auto click = ImGui::IsMouseClicked(0); |
| auto doubleClick = ImGui::IsMouseDoubleClicked(0); |
| auto t = ImGui::GetTime(); |
| auto tripleClick = click && !doubleClick && (mLastClick != -1.0f && (t - mLastClick) < io.MouseDoubleClickTime); |
| |
| /* |
| Left mouse button triple click |
| */ |
| |
| if (tripleClick) |
| { |
| if (!ctrl) |
| { |
| mState.mCursorPosition = mInteractiveStart = mInteractiveEnd = ScreenPosToCoordinates(ImGui::GetMousePos()); |
| mSelectionMode = SelectionMode::Line; |
| SetSelection(mInteractiveStart, mInteractiveEnd, mSelectionMode); |
| } |
| |
| mLastClick = -1.0f; |
| } |
| |
| /* |
| Left mouse button double click |
| */ |
| |
| else if (doubleClick) |
| { |
| if (!ctrl) |
| { |
| mState.mCursorPosition = mInteractiveStart = mInteractiveEnd = ScreenPosToCoordinates(ImGui::GetMousePos()); |
| if (mSelectionMode == SelectionMode::Line) |
| mSelectionMode = SelectionMode::Normal; |
| else |
| mSelectionMode = SelectionMode::Word; |
| SetSelection(mInteractiveStart, mInteractiveEnd, mSelectionMode); |
| } |
| |
| mLastClick = (float)ImGui::GetTime(); |
| } |
| |
| /* |
| Left mouse button click |
| */ |
| else if (click) |
| { |
| mState.mCursorPosition = mInteractiveStart = mInteractiveEnd = ScreenPosToCoordinates(ImGui::GetMousePos()); |
| if (ctrl) |
| mSelectionMode = SelectionMode::Word; |
| else |
| mSelectionMode = SelectionMode::Normal; |
| SetSelection(mInteractiveStart, mInteractiveEnd, mSelectionMode); |
| |
| mLastClick = (float)ImGui::GetTime(); |
| } |
| // Mouse left button dragging (=> update selection) |
| else if (ImGui::IsMouseDragging(0) && ImGui::IsMouseDown(0)) |
| { |
| io.WantCaptureMouse = true; |
| mState.mCursorPosition = mInteractiveEnd = ScreenPosToCoordinates(ImGui::GetMousePos()); |
| SetSelection(mInteractiveStart, mInteractiveEnd, mSelectionMode); |
| } |
| } |
| } |
| } |
| |
| void TextEditor::Render() |
| { |
| /* Compute mCharAdvance regarding to scaled font size (Ctrl + mouse wheel)*/ |
| const float fontSize = ImGui::GetFont()->CalcTextSizeA(ImGui::GetFontSize(), FLT_MAX, -1.0f, "#", nullptr, nullptr).x; |
| mCharAdvance = ImVec2(fontSize, ImGui::GetTextLineHeightWithSpacing() * mLineSpacing); |
| |
| /* Update palette with the current alpha from style */ |
| for (int i = 0; i < (int)PaletteIndex::Max; ++i) |
| { |
| auto color = ImGui::ColorConvertU32ToFloat4(mPaletteBase[i]); |
| color.w *= ImGui::GetStyle().Alpha; |
| mPalette[i] = ImGui::ColorConvertFloat4ToU32(color); |
| } |
| |
| assert(mLineBuffer.empty()); |
| |
| auto contentSize = ImGui::GetWindowContentRegionMax(); |
| auto drawList = ImGui::GetWindowDrawList(); |
| float longest(mTextStart); |
| |
| if (mScrollToTop) |
| { |
| mScrollToTop = false; |
| ImGui::SetScrollY(0.f); |
| } |
| |
| ImVec2 cursorScreenPos = ImGui::GetCursorScreenPos(); |
| auto scrollX = ImGui::GetScrollX(); |
| auto scrollY = ImGui::GetScrollY(); |
| |
| auto lineNo = (int)floor(scrollY / mCharAdvance.y); |
| auto globalLineMax = (int)mLines.size(); |
| auto lineMax = std::max(0, std::min((int)mLines.size() - 1, lineNo + (int)floor((scrollY + contentSize.y) / mCharAdvance.y))); |
| |
| // Deduce mTextStart by evaluating mLines size (global lineMax) plus two spaces as text width |
| char buf[16]; |
| snprintf(buf, 16, " %d ", globalLineMax); |
| mTextStart = ImGui::GetFont()->CalcTextSizeA(ImGui::GetFontSize(), FLT_MAX, -1.0f, buf, nullptr, nullptr).x + mLeftMargin; |
| |
| if (!mLines.empty()) |
| { |
| float spaceSize = ImGui::GetFont()->CalcTextSizeA(ImGui::GetFontSize(), FLT_MAX, -1.0f, " ", nullptr, nullptr).x; |
| |
| while (lineNo <= lineMax) |
| { |
| ImVec2 lineStartScreenPos = ImVec2(cursorScreenPos.x, cursorScreenPos.y + lineNo * mCharAdvance.y); |
| ImVec2 textScreenPos = ImVec2(lineStartScreenPos.x + mTextStart, lineStartScreenPos.y); |
| |
| auto& line = mLines[lineNo]; |
| longest = std::max(mTextStart + TextDistanceToLineStart(Coordinates(lineNo, GetLineMaxColumn(lineNo))), longest); |
| auto columnNo = 0; |
| Coordinates lineStartCoord(lineNo, 0); |
| Coordinates lineEndCoord(lineNo, GetLineMaxColumn(lineNo)); |
| |
| // Draw selection for the current line |
| float sstart = -1.0f; |
| float ssend = -1.0f; |
| |
| assert(mState.mSelectionStart <= mState.mSelectionEnd); |
| if (mState.mSelectionStart <= lineEndCoord) |
| sstart = mState.mSelectionStart > lineStartCoord ? TextDistanceToLineStart(mState.mSelectionStart) : 0.0f; |
| if (mState.mSelectionEnd > lineStartCoord) |
| ssend = TextDistanceToLineStart(mState.mSelectionEnd < lineEndCoord ? mState.mSelectionEnd : lineEndCoord); |
| |
| if (mState.mSelectionEnd.mLine > lineNo) |
| ssend += mCharAdvance.x; |
| |
| if (sstart != -1 && ssend != -1 && sstart < ssend) |
| { |
| ImVec2 vstart(lineStartScreenPos.x + mTextStart + sstart, lineStartScreenPos.y); |
| ImVec2 vend(lineStartScreenPos.x + mTextStart + ssend, lineStartScreenPos.y + mCharAdvance.y); |
| drawList->AddRectFilled(vstart, vend, mPalette[(int)PaletteIndex::Selection]); |
| } |
| |
| // Draw breakpoints |
| auto start = ImVec2(lineStartScreenPos.x + scrollX, lineStartScreenPos.y); |
| |
| if (mBreakpoints.count(lineNo + 1) != 0) |
| { |
| auto end = ImVec2(lineStartScreenPos.x + contentSize.x + 2.0f * scrollX, lineStartScreenPos.y + mCharAdvance.y); |
| drawList->AddRectFilled(start, end, mPalette[(int)PaletteIndex::Breakpoint]); |
| } |
| |
| // Draw error markers |
| auto errorIt = mErrorMarkers.find(lineNo + 1); |
| if (errorIt != mErrorMarkers.end()) |
| { |
| auto end = ImVec2(lineStartScreenPos.x + contentSize.x + 2.0f * scrollX, lineStartScreenPos.y + mCharAdvance.y); |
| drawList->AddRectFilled(start, end, mPalette[(int)PaletteIndex::ErrorMarker]); |
| |
| if (ImGui::IsMouseHoveringRect(lineStartScreenPos, end)) |
| { |
| ImGui::BeginTooltip(); |
| ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1.0f, 0.2f, 0.2f, 1.0f)); |
| ImGui::Text("Error at line %d:", errorIt->first); |
| ImGui::PopStyleColor(); |
| ImGui::Separator(); |
| ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1.0f, 1.0f, 0.2f, 1.0f)); |
| ImGui::Text("%s", errorIt->second.c_str()); |
| ImGui::PopStyleColor(); |
| ImGui::EndTooltip(); |
| } |
| } |
| |
| // Draw line number (right aligned) |
| snprintf(buf, 16, "%d ", lineNo + 1); |
| |
| auto lineNoWidth = ImGui::GetFont()->CalcTextSizeA(ImGui::GetFontSize(), FLT_MAX, -1.0f, buf, nullptr, nullptr).x; |
| drawList->AddText(ImVec2(lineStartScreenPos.x + mTextStart - lineNoWidth, lineStartScreenPos.y), mPalette[(int)PaletteIndex::LineNumber], buf); |
| |
| if (mState.mCursorPosition.mLine == lineNo) |
| { |
| auto focused = ImGui::IsWindowFocused(); |
| |
| // Highlight the current line (where the cursor is) |
| if (!HasSelection()) |
| { |
| auto end = ImVec2(start.x + contentSize.x + scrollX, start.y + mCharAdvance.y); |
| drawList->AddRectFilled(start, end, mPalette[(int)(focused ? PaletteIndex::CurrentLineFill : PaletteIndex::CurrentLineFillInactive)]); |
| drawList->AddRect(start, end, mPalette[(int)PaletteIndex::CurrentLineEdge], 1.0f); |
| } |
| |
| // Render the cursor |
| if (focused) |
| { |
| auto timeEnd = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count(); |
| auto elapsed = timeEnd - mStartTime; |
| if (elapsed > 400) |
| { |
| float width = 1.0f; |
| auto cindex = GetCharacterIndex(mState.mCursorPosition); |
| float cx = TextDistanceToLineStart(mState.mCursorPosition); |
| |
| if (mOverwrite && cindex < (int)line.size()) |
| { |
| auto c = line[cindex].mChar; |
| if (c == '\t') |
| { |
| auto x = (1.0f + std::floor((1.0f + cx) / (float(mTabSize) * spaceSize))) * (float(mTabSize) * spaceSize); |
| width = x - cx; |
| } |
| else |
| { |
| char buf2[2]; |
| buf2[0] = line[cindex].mChar; |
| buf2[1] = '\0'; |
| width = ImGui::GetFont()->CalcTextSizeA(ImGui::GetFontSize(), FLT_MAX, -1.0f, buf2).x; |
| } |
| } |
| ImVec2 cstart(textScreenPos.x + cx, lineStartScreenPos.y); |
| ImVec2 cend(textScreenPos.x + cx + width, lineStartScreenPos.y + mCharAdvance.y); |
| drawList->AddRectFilled(cstart, cend, mPalette[(int)PaletteIndex::Cursor]); |
| if (elapsed > 800) |
| mStartTime = timeEnd; |
| } |
| } |
| } |
| |
| // Render colorized text |
| auto prevColor = line.empty() ? mPalette[(int)PaletteIndex::Default] : GetGlyphColor(line[0]); |
| ImVec2 bufferOffset; |
| |
| for (int i = 0; i < line.size();) |
| { |
| auto& glyph = line[i]; |
| auto color = GetGlyphColor(glyph); |
| |
| if ((color != prevColor || glyph.mChar == '\t' || glyph.mChar == ' ') && !mLineBuffer.empty()) |
| { |
| const ImVec2 newOffset(textScreenPos.x + bufferOffset.x, textScreenPos.y + bufferOffset.y); |
| drawList->AddText(newOffset, prevColor, mLineBuffer.c_str()); |
| auto textSize = ImGui::GetFont()->CalcTextSizeA(ImGui::GetFontSize(), FLT_MAX, -1.0f, mLineBuffer.c_str(), nullptr, nullptr); |
| bufferOffset.x += textSize.x; |
| mLineBuffer.clear(); |
| } |
| prevColor = color; |
| |
| if (glyph.mChar == '\t') |
| { |
| auto oldX = bufferOffset.x; |
| bufferOffset.x = (1.0f + std::floor((1.0f + bufferOffset.x) / (float(mTabSize) * spaceSize))) * (float(mTabSize) * spaceSize); |
| ++i; |
| |
| if (mShowWhitespaces) |
| { |
| const auto s = ImGui::GetFontSize(); |
| const auto x1 = textScreenPos.x + oldX + 1.0f; |
| const auto x2 = textScreenPos.x + bufferOffset.x - 1.0f; |
| const auto y = textScreenPos.y + bufferOffset.y + s * 0.5f; |
| const ImVec2 p1(x1, y); |
| const ImVec2 p2(x2, y); |
| const ImVec2 p3(x2 - s * 0.2f, y - s * 0.2f); |
| const ImVec2 p4(x2 - s * 0.2f, y + s * 0.2f); |
| drawList->AddLine(p1, p2, 0x90909090); |
| drawList->AddLine(p2, p3, 0x90909090); |
| drawList->AddLine(p2, p4, 0x90909090); |
| } |
| } |
| else if (glyph.mChar == ' ') |
| { |
| if (mShowWhitespaces) |
| { |
| const auto s = ImGui::GetFontSize(); |
| const auto x = textScreenPos.x + bufferOffset.x + spaceSize * 0.5f; |
| const auto y = textScreenPos.y + bufferOffset.y + s * 0.5f; |
| drawList->AddCircleFilled(ImVec2(x, y), 1.5f, 0x80808080, 4); |
| } |
| bufferOffset.x += spaceSize; |
| i++; |
| } |
| else |
| { |
| auto l = UTF8CharLength(glyph.mChar); |
| while (l-- > 0) |
| mLineBuffer.push_back(line[i++].mChar); |
| } |
| ++columnNo; |
| } |
| |
| if (!mLineBuffer.empty()) |
| { |
| const ImVec2 newOffset(textScreenPos.x + bufferOffset.x, textScreenPos.y + bufferOffset.y); |
| drawList->AddText(newOffset, prevColor, mLineBuffer.c_str()); |
| mLineBuffer.clear(); |
| } |
| |
| ++lineNo; |
| } |
| |
| // Draw a tooltip on known identifiers/preprocessor symbols |
| if (ImGui::IsMousePosValid()) |
| { |
| auto id = GetWordAt(ScreenPosToCoordinates(ImGui::GetMousePos())); |
| if (!id.empty()) |
| { |
| auto it = mLanguageDefinition.mIdentifiers.find(id); |
| if (it != mLanguageDefinition.mIdentifiers.end()) |
| { |
| ImGui::BeginTooltip(); |
| ImGui::TextUnformatted(it->second.mDeclaration.c_str()); |
| ImGui::EndTooltip(); |
| } |
| else |
| { |
| auto pi = mLanguageDefinition.mPreprocIdentifiers.find(id); |
| if (pi != mLanguageDefinition.mPreprocIdentifiers.end()) |
| { |
| ImGui::BeginTooltip(); |
| ImGui::TextUnformatted(pi->second.mDeclaration.c_str()); |
| ImGui::EndTooltip(); |
| } |
| } |
| } |
| } |
| } |
| |
| |
| ImGui::Dummy(ImVec2((longest + 2), mLines.size() * mCharAdvance.y)); |
| |
| if (mScrollToCursor) |
| { |
| EnsureCursorVisible(); |
| ImGui::SetWindowFocus(); |
| mScrollToCursor = false; |
| } |
| } |
| |
| void TextEditor::Render(const char* aTitle, const ImVec2& aSize, bool aBorder) |
| { |
| mWithinRender = true; |
| mTextChanged = false; |
| mCursorPositionChanged = false; |
| |
| ImGui::PushStyleColor(ImGuiCol_ChildBg, ImGui::ColorConvertU32ToFloat4(mPalette[(int)PaletteIndex::Background])); |
| ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(0.0f, 0.0f)); |
| if (!mIgnoreImGuiChild) |
| ImGui::BeginChild(aTitle, aSize, aBorder, ImGuiWindowFlags_HorizontalScrollbar | ImGuiWindowFlags_AlwaysHorizontalScrollbar | ImGuiWindowFlags_NoMove); |
| |
| if (mHandleKeyboardInputs) |
| { |
| HandleKeyboardInputs(); |
| ImGui::PushAllowKeyboardFocus(true); |
| } |
| |
| if (mHandleMouseInputs) |
| HandleMouseInputs(); |
| |
| ColorizeInternal(); |
| Render(); |
| |
| if (mHandleKeyboardInputs) |
| ImGui::PopAllowKeyboardFocus(); |
| |
| if (!mIgnoreImGuiChild) |
| ImGui::EndChild(); |
| |
| ImGui::PopStyleVar(); |
| ImGui::PopStyleColor(); |
| |
| mWithinRender = false; |
| } |
| |
| void TextEditor::SetText(const std::string & aText) |
| { |
| mLines.clear(); |
| mLines.emplace_back(Line()); |
| for (auto chr : aText) |
| { |
| if (chr == '\r') |
| { |
| // ignore the carriage return character |
| } |
| else if (chr == '\n') |
| mLines.emplace_back(Line()); |
| else |
| { |
| mLines.back().emplace_back(Glyph(chr, PaletteIndex::Default)); |
| } |
| } |
| |
| mTextChanged = true; |
| mScrollToTop = true; |
| |
| mUndoBuffer.clear(); |
| mUndoIndex = 0; |
| |
| Colorize(); |
| } |
| |
| void TextEditor::SetTextLines(const std::vector<std::string> & aLines) |
| { |
| mLines.clear(); |
| |
| if (aLines.empty()) |
| { |
| mLines.emplace_back(Line()); |
| } |
| else |
| { |
| mLines.resize(aLines.size()); |
| |
| for (size_t i = 0; i < aLines.size(); ++i) |
| { |
| const std::string & aLine = aLines[i]; |
| |
| mLines[i].reserve(aLine.size()); |
| for (size_t j = 0; j < aLine.size(); ++j) |
| mLines[i].emplace_back(Glyph(aLine[j], PaletteIndex::Default)); |
| } |
| } |
| |
| mTextChanged = true; |
| mScrollToTop = true; |
| |
| mUndoBuffer.clear(); |
| mUndoIndex = 0; |
| |
| Colorize(); |
| } |
| |
| void TextEditor::EnterCharacter(ImWchar aChar, bool aShift) |
| { |
| assert(!mReadOnly); |
| |
| UndoRecord u; |
| |
| u.mBefore = mState; |
| |
| if (HasSelection()) |
| { |
| if (aChar == '\t' && mState.mSelectionStart.mLine != mState.mSelectionEnd.mLine) |
| { |
| |
| auto start = mState.mSelectionStart; |
| auto end = mState.mSelectionEnd; |
| auto originalEnd = end; |
| |
| if (start > end) |
| std::swap(start, end); |
| start.mColumn = 0; |
| // end.mColumn = end.mLine < mLines.size() ? mLines[end.mLine].size() : 0; |
| if (end.mColumn == 0 && end.mLine > 0) |
| --end.mLine; |
| if (end.mLine >= (int)mLines.size()) |
| end.mLine = mLines.empty() ? 0 : (int)mLines.size() - 1; |
| end.mColumn = GetLineMaxColumn(end.mLine); |
| |
| //if (end.mColumn >= GetLineMaxColumn(end.mLine)) |
| // end.mColumn = GetLineMaxColumn(end.mLine) - 1; |
| |
| u.mRemovedStart = start; |
| u.mRemovedEnd = end; |
| u.mRemoved = GetText(start, end); |
| |
| bool modified = false; |
| |
| for (int i = start.mLine; i <= end.mLine; i++) |
| { |
| auto& line = mLines[i]; |
| if (aShift) |
| { |
| if (!line.empty()) |
| { |
| if (line.front().mChar == '\t') |
| { |
| line.erase(line.begin()); |
| modified = true; |
| } |
| else |
| { |
| for (int j = 0; j < mTabSize && !line.empty() && line.front().mChar == ' '; j++) |
| { |
| line.erase(line.begin()); |
| modified = true; |
| } |
| } |
| } |
| } |
| else |
| { |
| line.insert(line.begin(), Glyph('\t', TextEditor::PaletteIndex::Background)); |
| modified = true; |
| } |
| } |
| |
| if (modified) |
| { |
| start = Coordinates(start.mLine, GetCharacterColumn(start.mLine, 0)); |
| Coordinates rangeEnd; |
| if (originalEnd.mColumn != 0) |
| { |
| end = Coordinates(end.mLine, GetLineMaxColumn(end.mLine)); |
| rangeEnd = end; |
| u.mAdded = GetText(start, end); |
| } |
| else |
| { |
| end = Coordinates(originalEnd.mLine, 0); |
| rangeEnd = Coordinates(end.mLine - 1, GetLineMaxColumn(end.mLine - 1)); |
| u.mAdded = GetText(start, rangeEnd); |
| } |
| |
| u.mAddedStart = start; |
| u.mAddedEnd = rangeEnd; |
| u.mAfter = mState; |
| |
| mState.mSelectionStart = start; |
| mState.mSelectionEnd = end; |
| AddUndo(u); |
| |
| mTextChanged = true; |
| |
| EnsureCursorVisible(); |
| } |
| |
| return; |
| } // c == '\t' |
| else |
| { |
| u.mRemoved = GetSelectedText(); |
| u.mRemovedStart = mState.mSelectionStart; |
| u.mRemovedEnd = mState.mSelectionEnd; |
| DeleteSelection(); |
| } |
| } // HasSelection |
| |
| auto coord = GetActualCursorCoordinates(); |
| u.mAddedStart = coord; |
| |
| assert(!mLines.empty()); |
| |
| if (aChar == '\n') |
| { |
| InsertLine(coord.mLine + 1); |
| auto& line = mLines[coord.mLine]; |
| auto& newLine = mLines[coord.mLine + 1]; |
| |
| if (mLanguageDefinition.mAutoIndentation) |
| for (size_t it = 0; it < line.size() && isascii(line[it].mChar) && isblank(line[it].mChar); ++it) |
| newLine.push_back(line[it]); |
| |
| const size_t whitespaceSize = newLine.size(); |
| auto cindex = GetCharacterIndex(coord); |
| newLine.insert(newLine.end(), line.begin() + cindex, line.end()); |
| line.erase(line.begin() + cindex, line.begin() + line.size()); |
| SetCursorPosition(Coordinates(coord.mLine + 1, GetCharacterColumn(coord.mLine + 1, (int)whitespaceSize))); |
| u.mAdded = (char)aChar; |
| } |
| else |
| { |
| char buf[7]; |
| int e = ImTextCharToUtf8(buf, 7, aChar); |
| if (e > 0) |
| { |
| buf[e] = '\0'; |
| auto& line = mLines[coord.mLine]; |
| auto cindex = GetCharacterIndex(coord); |
| |
| if (mOverwrite && cindex < (int)line.size()) |
| { |
| auto d = UTF8CharLength(line[cindex].mChar); |
| |
| u.mRemovedStart = mState.mCursorPosition; |
| u.mRemovedEnd = Coordinates(coord.mLine, GetCharacterColumn(coord.mLine, cindex + d)); |
| |
| while (d-- > 0 && cindex < (int)line.size()) |
| { |
| u.mRemoved += line[cindex].mChar; |
| line.erase(line.begin() + cindex); |
| } |
| } |
| |
| for (auto p = buf; *p != '\0'; p++, ++cindex) |
| line.insert(line.begin() + cindex, Glyph(*p, PaletteIndex::Default)); |
| u.mAdded = buf; |
| |
| SetCursorPosition(Coordinates(coord.mLine, GetCharacterColumn(coord.mLine, cindex))); |
| } |
| else |
| return; |
| } |
| |
| mTextChanged = true; |
| |
| u.mAddedEnd = GetActualCursorCoordinates(); |
| u.mAfter = mState; |
| |
| AddUndo(u); |
| |
| Colorize(coord.mLine - 1, 3); |
| EnsureCursorVisible(); |
| } |
| |
| void TextEditor::SetReadOnly(bool aValue) |
| { |
| mReadOnly = aValue; |
| } |
| |
| void TextEditor::SetColorizerEnable(bool aValue) |
| { |
| mColorizerEnabled = aValue; |
| } |
| |
| void TextEditor::SetCursorPosition(const Coordinates & aPosition) |
| { |
| if (mState.mCursorPosition != aPosition) |
| { |
| mState.mCursorPosition = aPosition; |
| mCursorPositionChanged = true; |
| EnsureCursorVisible(); |
| } |
| } |
| |
| void TextEditor::SetSelectionStart(const Coordinates & aPosition) |
| { |
| mState.mSelectionStart = SanitizeCoordinates(aPosition); |
| if (mState.mSelectionStart > mState.mSelectionEnd) |
| std::swap(mState.mSelectionStart, mState.mSelectionEnd); |
| } |
| |
| void TextEditor::SetSelectionEnd(const Coordinates & aPosition) |
| { |
| mState.mSelectionEnd = SanitizeCoordinates(aPosition); |
| if (mState.mSelectionStart > mState.mSelectionEnd) |
| std::swap(mState.mSelectionStart, mState.mSelectionEnd); |
| } |
| |
| void TextEditor::SetSelection(const Coordinates & aStart, const Coordinates & aEnd, SelectionMode aMode) |
| { |
| auto oldSelStart = mState.mSelectionStart; |
| auto oldSelEnd = mState.mSelectionEnd; |
| |
| mState.mSelectionStart = SanitizeCoordinates(aStart); |
| mState.mSelectionEnd = SanitizeCoordinates(aEnd); |
| if (mState.mSelectionStart > mState.mSelectionEnd) |
| std::swap(mState.mSelectionStart, mState.mSelectionEnd); |
| |
| switch (aMode) |
| { |
| case TextEditor::SelectionMode::Normal: |
| break; |
| case TextEditor::SelectionMode::Word: |
| { |
| mState.mSelectionStart = FindWordStart(mState.mSelectionStart); |
| if (!IsOnWordBoundary(mState.mSelectionEnd)) |
| mState.mSelectionEnd = FindWordEnd(FindWordStart(mState.mSelectionEnd)); |
| break; |
| } |
| case TextEditor::SelectionMode::Line: |
| { |
| const auto lineNo = mState.mSelectionEnd.mLine; |
| const auto lineSize = (size_t)lineNo < mLines.size() ? mLines[lineNo].size() : 0; |
| mState.mSelectionStart = Coordinates(mState.mSelectionStart.mLine, 0); |
| mState.mSelectionEnd = Coordinates(lineNo, GetLineMaxColumn(lineNo)); |
| break; |
| } |
| default: |
| break; |
| } |
| |
| if (mState.mSelectionStart != oldSelStart || |
| mState.mSelectionEnd != oldSelEnd) |
| mCursorPositionChanged = true; |
| } |
| |
| void TextEditor::SetTabSize(int aValue) |
| { |
| mTabSize = std::max(0, std::min(32, aValue)); |
| } |
| |
| void TextEditor::InsertText(const std::string & aValue) |
| { |
| InsertText(aValue.c_str()); |
| } |
| |
| void TextEditor::InsertText(const char * aValue) |
| { |
| if (aValue == nullptr) |
| return; |
| |
| auto pos = GetActualCursorCoordinates(); |
| auto start = std::min(pos, mState.mSelectionStart); |
| int totalLines = pos.mLine - start.mLine; |
| |
| totalLines += InsertTextAt(pos, aValue); |
| |
| SetSelection(pos, pos); |
| SetCursorPosition(pos); |
| Colorize(start.mLine - 1, totalLines + 2); |
| } |
| |
| void TextEditor::DeleteSelection() |
| { |
| assert(mState.mSelectionEnd >= mState.mSelectionStart); |
| |
| if (mState.mSelectionEnd == mState.mSelectionStart) |
| return; |
| |
| DeleteRange(mState.mSelectionStart, mState.mSelectionEnd); |
| |
| SetSelection(mState.mSelectionStart, mState.mSelectionStart); |
| SetCursorPosition(mState.mSelectionStart); |
| Colorize(mState.mSelectionStart.mLine, 1); |
| } |
| |
| void TextEditor::MoveUp(int aAmount, bool aSelect) |
| { |
| auto oldPos = mState.mCursorPosition; |
| mState.mCursorPosition.mLine = std::max(0, mState.mCursorPosition.mLine - aAmount); |
| if (oldPos != mState.mCursorPosition) |
| { |
| if (aSelect) |
| { |
| if (oldPos == mInteractiveStart) |
| mInteractiveStart = mState.mCursorPosition; |
| else if (oldPos == mInteractiveEnd) |
| mInteractiveEnd = mState.mCursorPosition; |
| else |
| { |
| mInteractiveStart = mState.mCursorPosition; |
| mInteractiveEnd = oldPos; |
| } |
| } |
| else |
| mInteractiveStart = mInteractiveEnd = mState.mCursorPosition; |
| SetSelection(mInteractiveStart, mInteractiveEnd); |
| |
| EnsureCursorVisible(); |
| } |
| } |
| |
| void TextEditor::MoveDown(int aAmount, bool aSelect) |
| { |
| assert(mState.mCursorPosition.mColumn >= 0); |
| auto oldPos = mState.mCursorPosition; |
| mState.mCursorPosition.mLine = std::max(0, std::min((int)mLines.size() - 1, mState.mCursorPosition.mLine + aAmount)); |
| |
| if (mState.mCursorPosition != oldPos) |
| { |
| if (aSelect) |
| { |
| if (oldPos == mInteractiveEnd) |
| mInteractiveEnd = mState.mCursorPosition; |
| else if (oldPos == mInteractiveStart) |
| mInteractiveStart = mState.mCursorPosition; |
| else |
| { |
| mInteractiveStart = oldPos; |
| mInteractiveEnd = mState.mCursorPosition; |
| } |
| } |
| else |
| mInteractiveStart = mInteractiveEnd = mState.mCursorPosition; |
| SetSelection(mInteractiveStart, mInteractiveEnd); |
| |
| EnsureCursorVisible(); |
| } |
| } |
| |
| static bool IsUTFSequence(char c) |
| { |
| return (c & 0xC0) == 0x80; |
| } |
| |
| void TextEditor::MoveLeft(int aAmount, bool aSelect, bool aWordMode) |
| { |
| if (mLines.empty()) |
| return; |
| |
| auto oldPos = mState.mCursorPosition; |
| mState.mCursorPosition = GetActualCursorCoordinates(); |
| auto line = mState.mCursorPosition.mLine; |
| auto cindex = GetCharacterIndex(mState.mCursorPosition); |
| |
| while (aAmount-- > 0) |
| { |
| if (cindex == 0) |
| { |
| if (line > 0) |
| { |
| --line; |
| if ((int)mLines.size() > line) |
| cindex = (int)mLines[line].size(); |
| else |
| cindex = 0; |
| } |
| } |
| else |
| { |
| --cindex; |
| if (cindex > 0) |
| { |
| if ((int)mLines.size() > line) |
| { |
| while (cindex > 0 && IsUTFSequence(mLines[line][cindex].mChar)) |
| --cindex; |
| } |
| } |
| } |
| |
| mState.mCursorPosition = Coordinates(line, GetCharacterColumn(line, cindex)); |
| if (aWordMode) |
| { |
| mState.mCursorPosition = FindWordStart(mState.mCursorPosition); |
| cindex = GetCharacterIndex(mState.mCursorPosition); |
| } |
| } |
| |
| mState.mCursorPosition = Coordinates(line, GetCharacterColumn(line, cindex)); |
| |
| assert(mState.mCursorPosition.mColumn >= 0); |
| if (aSelect) |
| { |
| if (oldPos == mInteractiveStart) |
| mInteractiveStart = mState.mCursorPosition; |
| else if (oldPos == mInteractiveEnd) |
| mInteractiveEnd = mState.mCursorPosition; |
| else |
| { |
| mInteractiveStart = mState.mCursorPosition; |
| mInteractiveEnd = oldPos; |
| } |
| } |
| else |
| mInteractiveStart = mInteractiveEnd = mState.mCursorPosition; |
| SetSelection(mInteractiveStart, mInteractiveEnd, aSelect && aWordMode ? SelectionMode::Word : SelectionMode::Normal); |
| |
| EnsureCursorVisible(); |
| } |
| |
| void TextEditor::MoveRight(int aAmount, bool aSelect, bool aWordMode) |
| { |
| auto oldPos = mState.mCursorPosition; |
| |
| if (mLines.empty() || oldPos.mLine >= mLines.size()) |
| return; |
| |
| auto cindex = GetCharacterIndex(mState.mCursorPosition); |
| while (aAmount-- > 0) |
| { |
| auto lindex = mState.mCursorPosition.mLine; |
| auto& line = mLines[lindex]; |
| |
| if (cindex >= line.size()) |
| { |
| if (mState.mCursorPosition.mLine < mLines.size() - 1) |
| { |
| mState.mCursorPosition.mLine = std::max(0, std::min((int)mLines.size() - 1, mState.mCursorPosition.mLine + 1)); |
| mState.mCursorPosition.mColumn = 0; |
| } |
| else |
| return; |
| } |
| else |
| { |
| cindex += UTF8CharLength(line[cindex].mChar); |
| mState.mCursorPosition = Coordinates(lindex, GetCharacterColumn(lindex, cindex)); |
| if (aWordMode) |
| mState.mCursorPosition = FindNextWord(mState.mCursorPosition); |
| } |
| } |
| |
| if (aSelect) |
| { |
| if (oldPos == mInteractiveEnd) |
| mInteractiveEnd = SanitizeCoordinates(mState.mCursorPosition); |
| else if (oldPos == mInteractiveStart) |
| mInteractiveStart = mState.mCursorPosition; |
| else |
| { |
| mInteractiveStart = oldPos; |
| mInteractiveEnd = mState.mCursorPosition; |
| } |
| } |
| else |
| mInteractiveStart = mInteractiveEnd = mState.mCursorPosition; |
| SetSelection(mInteractiveStart, mInteractiveEnd, aSelect && aWordMode ? SelectionMode::Word : SelectionMode::Normal); |
| |
| EnsureCursorVisible(); |
| } |
| |
| void TextEditor::MoveTop(bool aSelect) |
| { |
| auto oldPos = mState.mCursorPosition; |
| SetCursorPosition(Coordinates(0, 0)); |
| |
| if (mState.mCursorPosition != oldPos) |
| { |
| if (aSelect) |
| { |
| mInteractiveEnd = oldPos; |
| mInteractiveStart = mState.mCursorPosition; |
| } |
| else |
| mInteractiveStart = mInteractiveEnd = mState.mCursorPosition; |
| SetSelection(mInteractiveStart, mInteractiveEnd); |
| } |
| } |
| |
| void TextEditor::TextEditor::MoveBottom(bool aSelect) |
| { |
| auto oldPos = GetCursorPosition(); |
| auto newPos = Coordinates((int)mLines.size() - 1, 0); |
| SetCursorPosition(newPos); |
| if (aSelect) |
| { |
| mInteractiveStart = oldPos; |
| mInteractiveEnd = newPos; |
| } |
| else |
| mInteractiveStart = mInteractiveEnd = newPos; |
| SetSelection(mInteractiveStart, mInteractiveEnd); |
| } |
| |
| void TextEditor::MoveHome(bool aSelect) |
| { |
| auto oldPos = mState.mCursorPosition; |
| SetCursorPosition(Coordinates(mState.mCursorPosition.mLine, 0)); |
| |
| if (mState.mCursorPosition != oldPos) |
| { |
| if (aSelect) |
| { |
| if (oldPos == mInteractiveStart) |
| mInteractiveStart = mState.mCursorPosition; |
| else if (oldPos == mInteractiveEnd) |
| mInteractiveEnd = mState.mCursorPosition; |
| else |
| { |
| mInteractiveStart = mState.mCursorPosition; |
| mInteractiveEnd = oldPos; |
| } |
| } |
| else |
| mInteractiveStart = mInteractiveEnd = mState.mCursorPosition; |
| SetSelection(mInteractiveStart, mInteractiveEnd); |
| } |
| } |
| |
| void TextEditor::MoveEnd(bool aSelect) |
| { |
| auto oldPos = mState.mCursorPosition; |
| SetCursorPosition(Coordinates(mState.mCursorPosition.mLine, GetLineMaxColumn(oldPos.mLine))); |
| |
| if (mState.mCursorPosition != oldPos) |
| { |
| if (aSelect) |
| { |
| if (oldPos == mInteractiveEnd) |
| mInteractiveEnd = mState.mCursorPosition; |
| else if (oldPos == mInteractiveStart) |
| mInteractiveStart = mState.mCursorPosition; |
| else |
| { |
| mInteractiveStart = oldPos; |
| mInteractiveEnd = mState.mCursorPosition; |
| } |
| } |
| else |
| mInteractiveStart = mInteractiveEnd = mState.mCursorPosition; |
| SetSelection(mInteractiveStart, mInteractiveEnd); |
| } |
| } |
| |
| void TextEditor::Delete() |
| { |
| assert(!mReadOnly); |
| |
| if (mLines.empty()) |
| return; |
| |
| UndoRecord u; |
| u.mBefore = mState; |
| |
| if (HasSelection()) |
| { |
| u.mRemoved = GetSelectedText(); |
| u.mRemovedStart = mState.mSelectionStart; |
| u.mRemovedEnd = mState.mSelectionEnd; |
| |
| DeleteSelection(); |
| } |
| else |
| { |
| auto pos = GetActualCursorCoordinates(); |
| SetCursorPosition(pos); |
| auto& line = mLines[pos.mLine]; |
| |
| if (pos.mColumn == GetLineMaxColumn(pos.mLine)) |
| { |
| if (pos.mLine == (int)mLines.size() - 1) |
| return; |
| |
| u.mRemoved = '\n'; |
| u.mRemovedStart = u.mRemovedEnd = GetActualCursorCoordinates(); |
| Advance(u.mRemovedEnd); |
| |
| auto& nextLine = mLines[pos.mLine + 1]; |
| line.insert(line.end(), nextLine.begin(), nextLine.end()); |
| RemoveLine(pos.mLine + 1); |
| } |
| else |
| { |
| auto cindex = GetCharacterIndex(pos); |
| u.mRemovedStart = u.mRemovedEnd = GetActualCursorCoordinates(); |
| u.mRemovedEnd.mColumn++; |
| u.mRemoved = GetText(u.mRemovedStart, u.mRemovedEnd); |
| |
| auto d = UTF8CharLength(line[cindex].mChar); |
| while (d-- > 0 && cindex < (int)line.size()) |
| line.erase(line.begin() + cindex); |
| } |
| |
| mTextChanged = true; |
| |
| Colorize(pos.mLine, 1); |
| } |
| |
| u.mAfter = mState; |
| AddUndo(u); |
| } |
| |
| void TextEditor::Backspace() |
| { |
| assert(!mReadOnly); |
| |
| if (mLines.empty()) |
| return; |
| |
| UndoRecord u; |
| u.mBefore = mState; |
| |
| if (HasSelection()) |
| { |
| u.mRemoved = GetSelectedText(); |
| u.mRemovedStart = mState.mSelectionStart; |
| u.mRemovedEnd = mState.mSelectionEnd; |
| |
| DeleteSelection(); |
| } |
| else |
| { |
| auto pos = GetActualCursorCoordinates(); |
| SetCursorPosition(pos); |
| |
| if (mState.mCursorPosition.mColumn == 0) |
| { |
| if (mState.mCursorPosition.mLine == 0) |
| return; |
| |
| u.mRemoved = '\n'; |
| u.mRemovedStart = u.mRemovedEnd = Coordinates(pos.mLine - 1, GetLineMaxColumn(pos.mLine - 1)); |
| Advance(u.mRemovedEnd); |
| |
| auto& line = mLines[mState.mCursorPosition.mLine]; |
| auto& prevLine = mLines[mState.mCursorPosition.mLine - 1]; |
| auto prevSize = GetLineMaxColumn(mState.mCursorPosition.mLine - 1); |
| prevLine.insert(prevLine.end(), line.begin(), line.end()); |
| |
| ErrorMarkers etmp; |
| for (auto& i : mErrorMarkers) |
| etmp.insert(ErrorMarkers::value_type(i.first - 1 == mState.mCursorPosition.mLine ? i.first - 1 : i.first, i.second)); |
| mErrorMarkers = std::move(etmp); |
| |
| RemoveLine(mState.mCursorPosition.mLine); |
| --mState.mCursorPosition.mLine; |
| mState.mCursorPosition.mColumn = prevSize; |
| } |
| else |
| { |
| auto& line = mLines[mState.mCursorPosition.mLine]; |
| auto cindex = GetCharacterIndex(pos) - 1; |
| auto cend = cindex + 1; |
| while (cindex > 0 && IsUTFSequence(line[cindex].mChar)) |
| --cindex; |
| |
| //if (cindex > 0 && UTF8CharLength(line[cindex].mChar) > 1) |
| // --cindex; |
| |
| u.mRemovedStart = u.mRemovedEnd = GetActualCursorCoordinates(); |
| --u.mRemovedStart.mColumn; |
| --mState.mCursorPosition.mColumn; |
| |
| while (cindex < line.size() && cend-- > cindex) |
| { |
| u.mRemoved += line[cindex].mChar; |
| line.erase(line.begin() + cindex); |
| } |
| } |
| |
| mTextChanged = true; |
| |
| EnsureCursorVisible(); |
| Colorize(mState.mCursorPosition.mLine, 1); |
| } |
| |
| u.mAfter = mState; |
| AddUndo(u); |
| } |
| |
| void TextEditor::SelectWordUnderCursor() |
| { |
| auto c = GetCursorPosition(); |
| SetSelection(FindWordStart(c), FindWordEnd(c)); |
| } |
| |
| void TextEditor::SelectAll() |
| { |
| SetSelection(Coordinates(0, 0), Coordinates((int)mLines.size(), 0)); |
| } |
| |
| bool TextEditor::HasSelection() const |
| { |
| return mState.mSelectionEnd > mState.mSelectionStart; |
| } |
| |
| void TextEditor::Copy() |
| { |
| if (HasSelection()) |
| { |
| ImGui::SetClipboardText(GetSelectedText().c_str()); |
| } |
| else |
| { |
| if (!mLines.empty()) |
| { |
| std::string str; |
| auto& line = mLines[GetActualCursorCoordinates().mLine]; |
| for (auto& g : line) |
| str.push_back(g.mChar); |
| ImGui::SetClipboardText(str.c_str()); |
| } |
| } |
| } |
| |
| void TextEditor::Cut() |
| { |
| if (IsReadOnly()) |
| { |
| Copy(); |
| } |
| else |
| { |
| if (HasSelection()) |
| { |
| UndoRecord u; |
| u.mBefore = mState; |
| u.mRemoved = GetSelectedText(); |
| u.mRemovedStart = mState.mSelectionStart; |
| u.mRemovedEnd = mState.mSelectionEnd; |
| |
| Copy(); |
| DeleteSelection(); |
| |
| u.mAfter = mState; |
| AddUndo(u); |
| } |
| } |
| } |
| |
| void TextEditor::Paste() |
| { |
| if (IsReadOnly()) |
| return; |
| |
| auto clipText = ImGui::GetClipboardText(); |
| if (clipText != nullptr && strlen(clipText) > 0) |
| { |
| UndoRecord u; |
| u.mBefore = mState; |
| |
| if (HasSelection()) |
| { |
| u.mRemoved = GetSelectedText(); |
| u.mRemovedStart = mState.mSelectionStart; |
| u.mRemovedEnd = mState.mSelectionEnd; |
| DeleteSelection(); |
| } |
| |
| u.mAdded = clipText; |
| u.mAddedStart = GetActualCursorCoordinates(); |
| |
| InsertText(clipText); |
| |
| u.mAddedEnd = GetActualCursorCoordinates(); |
| u.mAfter = mState; |
| AddUndo(u); |
| } |
| } |
| |
| bool TextEditor::CanUndo() const |
| { |
| return !mReadOnly && mUndoIndex > 0; |
| } |
| |
| bool TextEditor::CanRedo() const |
| { |
| return !mReadOnly && mUndoIndex < (int)mUndoBuffer.size(); |
| } |
| |
| void TextEditor::Undo(int aSteps) |
| { |
| while (CanUndo() && aSteps-- > 0) |
| mUndoBuffer[--mUndoIndex].Undo(this); |
| } |
| |
| void TextEditor::Redo(int aSteps) |
| { |
| while (CanRedo() && aSteps-- > 0) |
| mUndoBuffer[mUndoIndex++].Redo(this); |
| } |
| |
| const TextEditor::Palette & TextEditor::GetDarkPalette() |
| { |
| const static Palette p = { { |
| 0xff7f7f7f, // Default |
| 0xffd69c56, // Keyword |
| 0xff00ff00, // Number |
| 0xff7070e0, // String |
| 0xff70a0e0, // Char literal |
| 0xffffffff, // Punctuation |
| 0xff408080, // Preprocessor |
| 0xffaaaaaa, // Identifier |
| 0xff9bc64d, // Known identifier |
| 0xffc040a0, // Preproc identifier |
| 0xff206020, // Comment (single line) |
| 0xff406020, // Comment (multi line) |
| 0xff101010, // Background |
| 0xffe0e0e0, // Cursor |
| 0x80a06020, // Selection |
| 0x800020ff, // ErrorMarker |
| 0x40f08000, // Breakpoint |
| 0xff707000, // Line number |
| 0x40000000, // Current line fill |
| 0x40808080, // Current line fill (inactive) |
| 0x40a0a0a0, // Current line edge |
| } }; |
| return p; |
| } |
| |
| const TextEditor::Palette & TextEditor::GetLightPalette() |
| { |
| const static Palette p = { { |
| 0xff7f7f7f, // None |
| 0xffff0c06, // Keyword |
| 0xff008000, // Number |
| 0xff2020a0, // String |
| 0xff304070, // Char literal |
| 0xff000000, // Punctuation |
| 0xff406060, // Preprocessor |
| 0xff404040, // Identifier |
| 0xff606010, // Known identifier |
| 0xffc040a0, // Preproc identifier |
| 0xff205020, // Comment (single line) |
| 0xff405020, // Comment (multi line) |
| 0xffffffff, // Background |
| 0xff000000, // Cursor |
| 0x80600000, // Selection |
| 0xa00010ff, // ErrorMarker |
| 0x80f08000, // Breakpoint |
| 0xff505000, // Line number |
| 0x40000000, // Current line fill |
| 0x40808080, // Current line fill (inactive) |
| 0x40000000, // Current line edge |
| } }; |
| return p; |
| } |
| |
| const TextEditor::Palette & TextEditor::GetRetroBluePalette() |
| { |
| const static Palette p = { { |
| 0xff00ffff, // None |
| 0xffffff00, // Keyword |
| 0xff00ff00, // Number |
| 0xff808000, // String |
| 0xff808000, // Char literal |
| 0xffffffff, // Punctuation |
| 0xff008000, // Preprocessor |
| 0xff00ffff, // Identifier |
| 0xffffffff, // Known identifier |
| 0xffff00ff, // Preproc identifier |
| 0xff808080, // Comment (single line) |
| 0xff404040, // Comment (multi line) |
| 0xff800000, // Background |
| 0xff0080ff, // Cursor |
| 0x80ffff00, // Selection |
| 0xa00000ff, // ErrorMarker |
| 0x80ff8000, // Breakpoint |
| 0xff808000, // Line number |
| 0x40000000, // Current line fill |
| 0x40808080, // Current line fill (inactive) |
| 0x40000000, // Current line edge |
| } }; |
| return p; |
| } |
| |
| |
| std::string TextEditor::GetText() const |
| { |
| return GetText(Coordinates(), Coordinates((int)mLines.size(), 0)); |
| } |
| |
| std::vector<std::string> TextEditor::GetTextLines() const |
| { |
| std::vector<std::string> result; |
| |
| result.reserve(mLines.size()); |
| |
| for (auto & line : mLines) |
| { |
| std::string text; |
| |
| text.resize(line.size()); |
| |
| for (size_t i = 0; i < line.size(); ++i) |
| text[i] = line[i].mChar; |
| |
| result.emplace_back(std::move(text)); |
| } |
| |
| return result; |
| } |
| |
| std::string TextEditor::GetSelectedText() const |
| { |
| return GetText(mState.mSelectionStart, mState.mSelectionEnd); |
| } |
| |
| std::string TextEditor::GetCurrentLineText()const |
| { |
| auto lineLength = GetLineMaxColumn(mState.mCursorPosition.mLine); |
| return GetText( |
| Coordinates(mState.mCursorPosition.mLine, 0), |
| Coordinates(mState.mCursorPosition.mLine, lineLength)); |
| } |
| |
| void TextEditor::ProcessInputs() |
| { |
| } |
| |
| void TextEditor::Colorize(int aFromLine, int aLines) |
| { |
| int toLine = aLines == -1 ? (int)mLines.size() : std::min((int)mLines.size(), aFromLine + aLines); |
| mColorRangeMin = std::min(mColorRangeMin, aFromLine); |
| mColorRangeMax = std::max(mColorRangeMax, toLine); |
| mColorRangeMin = std::max(0, mColorRangeMin); |
| mColorRangeMax = std::max(mColorRangeMin, mColorRangeMax); |
| mCheckComments = true; |
| } |
| |
| void TextEditor::ColorizeRange(int aFromLine, int aToLine) |
| { |
| if (mLines.empty() || aFromLine >= aToLine) |
| return; |
| |
| std::string buffer; |
| std::cmatch results; |
| std::string id; |
| |
| int endLine = std::max(0, std::min((int)mLines.size(), aToLine)); |
| for (int i = aFromLine; i < endLine; ++i) |
| { |
| auto& line = mLines[i]; |
| |
| if (line.empty()) |
| continue; |
| |
| buffer.resize(line.size()); |
| for (size_t j = 0; j < line.size(); ++j) |
| { |
| auto& col = line[j]; |
| buffer[j] = col.mChar; |
| col.mColorIndex = PaletteIndex::Default; |
| } |
| |
| const char * bufferBegin = &buffer.front(); |
| const char * bufferEnd = bufferBegin + buffer.size(); |
| |
| auto last = bufferEnd; |
| |
| for (auto first = bufferBegin; first != last; ) |
| { |
| const char * token_begin = nullptr; |
| const char * token_end = nullptr; |
| PaletteIndex token_color = PaletteIndex::Default; |
| |
| bool hasTokenizeResult = false; |
| |
| if (mLanguageDefinition.mTokenize != nullptr) |
| { |
| if (mLanguageDefinition.mTokenize(first, last, token_begin, token_end, token_color)) |
| hasTokenizeResult = true; |
| } |
| |
| if (hasTokenizeResult == false) |
| { |
| // todo : remove |
| //printf("using regex for %.*s\n", first + 10 < last ? 10 : int(last - first), first); |
| |
| for (auto& p : mRegexList) |
| { |
| if (std::regex_search(first, last, results, p.first, std::regex_constants::match_continuous)) |
| { |
| hasTokenizeResult = true; |
| |
| auto& v = *results.begin(); |
| token_begin = v.first; |
| token_end = v.second; |
| token_color = p.second; |
| break; |
| } |
| } |
| } |
| |
| if (hasTokenizeResult == false) |
| { |
| first++; |
| } |
| else |
| { |
| const size_t token_length = token_end - token_begin; |
| |
| if (token_color == PaletteIndex::Identifier) |
| { |
| id.assign(token_begin, token_end); |
| |
| // todo : allmost all language definitions use lower case to specify keywords, so shouldn't this use ::tolower ? |
| if (!mLanguageDefinition.mCaseSensitive) |
| std::transform(id.begin(), id.end(), id.begin(), ::toupper); |
| |
| if (!line[first - bufferBegin].mPreprocessor) |
| { |
| if (mLanguageDefinition.mKeywords.count(id) != 0) |
| token_color = PaletteIndex::Keyword; |
| else if (mLanguageDefinition.mIdentifiers.count(id) != 0) |
| token_color = PaletteIndex::KnownIdentifier; |
| else if (mLanguageDefinition.mPreprocIdentifiers.count(id) != 0) |
| token_color = PaletteIndex::PreprocIdentifier; |
| } |
| else |
| { |
| if (mLanguageDefinition.mPreprocIdentifiers.count(id) != 0) |
| token_color = PaletteIndex::PreprocIdentifier; |
| } |
| } |
| |
| for (size_t j = 0; j < token_length; ++j) |
| line[(token_begin - bufferBegin) + j].mColorIndex = token_color; |
| |
| first = token_end; |
| } |
| } |
| } |
| } |
| |
| void TextEditor::ColorizeInternal() |
| { |
| if (mLines.empty() || !mColorizerEnabled) |
| return; |
| |
| if (mCheckComments) |
| { |
| auto endLine = mLines.size(); |
| auto endIndex = 0; |
| auto commentStartLine = endLine; |
| auto commentStartIndex = endIndex; |
| auto withinString = false; |
| auto withinSingleLineComment = false; |
| auto withinPreproc = false; |
| auto firstChar = true; // there is no other non-whitespace characters in the line before |
| auto concatenate = false; // '\' on the very end of the line |
| auto currentLine = 0; |
| auto currentIndex = 0; |
| while (currentLine < endLine || currentIndex < endIndex) |
| { |
| auto& line = mLines[currentLine]; |
| |
| if (currentIndex == 0 && !concatenate) |
| { |
| withinSingleLineComment = false; |
| withinPreproc = false; |
| firstChar = true; |
| } |
| |
| concatenate = false; |
| |
| if (!line.empty()) |
| { |
| auto& g = line[currentIndex]; |
| auto c = g.mChar; |
| |
| if (c != mLanguageDefinition.mPreprocChar && !isspace(c)) |
| firstChar = false; |
| |
| if (currentIndex == (int)line.size() - 1 && line[line.size() - 1].mChar == '\\') |
| concatenate = true; |
| |
| bool inComment = (commentStartLine < currentLine || (commentStartLine == currentLine && commentStartIndex <= currentIndex)); |
| |
| if (withinString) |
| { |
| line[currentIndex].mMultiLineComment = inComment; |
| |
| if (c == '\"') |
| { |
| if (currentIndex + 1 < (int)line.size() && line[currentIndex + 1].mChar == '\"') |
| { |
| currentIndex += 1; |
| if (currentIndex < (int)line.size()) |
| line[currentIndex].mMultiLineComment = inComment; |
| } |
| else |
| withinString = false; |
| } |
| else if (c == '\\') |
| { |
| currentIndex += 1; |
| if (currentIndex < (int)line.size()) |
| line[currentIndex].mMultiLineComment = inComment; |
| } |
| } |
| else |
| { |
| if (firstChar && c == mLanguageDefinition.mPreprocChar) |
| withinPreproc = true; |
| |
| if (c == '\"') |
| { |
| withinString = true; |
| line[currentIndex].mMultiLineComment = inComment; |
| } |
| else |
| { |
| auto pred = [](const char& a, const Glyph& b) { return a == b.mChar; }; |
| auto from = line.begin() + currentIndex; |
| auto& startStr = mLanguageDefinition.mCommentStart; |
| auto& singleStartStr = mLanguageDefinition.mSingleLineComment; |
| |
| if (singleStartStr.size() > 0 && |
| currentIndex + singleStartStr.size() <= line.size() && |
| equals(singleStartStr.begin(), singleStartStr.end(), from, from + singleStartStr.size(), pred)) |
| { |
| withinSingleLineComment = true; |
| } |
| else if (!withinSingleLineComment && currentIndex + startStr.size() <= line.size() && |
| equals(startStr.begin(), startStr.end(), from, from + startStr.size(), pred)) |
| { |
| commentStartLine = currentLine; |
| commentStartIndex = currentIndex; |
| } |
| |
| inComment = inComment = (commentStartLine < currentLine || (commentStartLine == currentLine && commentStartIndex <= currentIndex)); |
| |
| line[currentIndex].mMultiLineComment = inComment; |
| line[currentIndex].mComment = withinSingleLineComment; |
| |
| auto& endStr = mLanguageDefinition.mCommentEnd; |
| if (currentIndex + 1 >= (int)endStr.size() && |
| equals(endStr.begin(), endStr.end(), from + 1 - endStr.size(), from + 1, pred)) |
| { |
| commentStartIndex = endIndex; |
| commentStartLine = endLine; |
| } |
| } |
| } |
| line[currentIndex].mPreprocessor = withinPreproc; |
| currentIndex += UTF8CharLength(c); |
| if (currentIndex >= (int)line.size()) |
| { |
| currentIndex = 0; |
| ++currentLine; |
| } |
| } |
| else |
| { |
| currentIndex = 0; |
| ++currentLine; |
| } |
| } |
| mCheckComments = false; |
| } |
| |
| if (mColorRangeMin < mColorRangeMax) |
| { |
| const int increment = (mLanguageDefinition.mTokenize == nullptr) ? 10 : 10000; |
| const int to = std::min(mColorRangeMin + increment, mColorRangeMax); |
| ColorizeRange(mColorRangeMin, to); |
| mColorRangeMin = to; |
| |
| if (mColorRangeMax == mColorRangeMin) |
| { |
| mColorRangeMin = std::numeric_limits<int>::max(); |
| mColorRangeMax = 0; |
| } |
| return; |
| } |
| } |
| |
| float TextEditor::TextDistanceToLineStart(const Coordinates& aFrom) const |
| { |
| auto& line = mLines[aFrom.mLine]; |
| float distance = 0.0f; |
| float spaceSize = ImGui::GetFont()->CalcTextSizeA(ImGui::GetFontSize(), FLT_MAX, -1.0f, " ", nullptr, nullptr).x; |
| int colIndex = GetCharacterIndex(aFrom); |
| for (size_t it = 0u; it < line.size() && it < colIndex; ) |
| { |
| if (line[it].mChar == '\t') |
| { |
| distance = (1.0f + std::floor((1.0f + distance) / (float(mTabSize) * spaceSize))) * (float(mTabSize) * spaceSize); |
| ++it; |
| } |
| else |
| { |
| auto d = UTF8CharLength(line[it].mChar); |
| char tempCString[7]; |
| int i = 0; |
| for (; i < 6 && d-- > 0 && it < (int)line.size(); i++, it++) |
| tempCString[i] = line[it].mChar; |
| |
| tempCString[i] = '\0'; |
| distance += ImGui::GetFont()->CalcTextSizeA(ImGui::GetFontSize(), FLT_MAX, -1.0f, tempCString, nullptr, nullptr).x; |
| } |
| } |
| |
| return distance; |
| } |
| |
| void TextEditor::EnsureCursorVisible() |
| { |
| if (!mWithinRender) |
| { |
| mScrollToCursor = true; |
| return; |
| } |
| |
| float scrollX = ImGui::GetScrollX(); |
| float scrollY = ImGui::GetScrollY(); |
| |
| auto height = ImGui::GetWindowHeight(); |
| auto width = ImGui::GetWindowWidth(); |
| |
| auto top = 1 + (int)ceil(scrollY / mCharAdvance.y); |
| auto bottom = (int)ceil((scrollY + height) / mCharAdvance.y); |
| |
| auto left = (int)ceil(scrollX / mCharAdvance.x); |
| auto right = (int)ceil((scrollX + width) / mCharAdvance.x); |
| |
| auto pos = GetActualCursorCoordinates(); |
| auto len = TextDistanceToLineStart(pos); |
| |
| if (pos.mLine < top) |
| ImGui::SetScrollY(std::max(0.0f, (pos.mLine - 1) * mCharAdvance.y)); |
| if (pos.mLine > bottom - 4) |
| ImGui::SetScrollY(std::max(0.0f, (pos.mLine + 4) * mCharAdvance.y - height)); |
| if (len + mTextStart < left + 4) |
| ImGui::SetScrollX(std::max(0.0f, len + mTextStart - 4)); |
| if (len + mTextStart > right - 4) |
| ImGui::SetScrollX(std::max(0.0f, len + mTextStart + 4 - width)); |
| } |
| |
| int TextEditor::GetPageSize() const |
| { |
| auto height = ImGui::GetWindowHeight() - 20.0f; |
| return (int)floor(height / mCharAdvance.y); |
| } |
| |
| TextEditor::UndoRecord::UndoRecord( |
| const std::string& aAdded, |
| const TextEditor::Coordinates aAddedStart, |
| const TextEditor::Coordinates aAddedEnd, |
| const std::string& aRemoved, |
| const TextEditor::Coordinates aRemovedStart, |
| const TextEditor::Coordinates aRemovedEnd, |
| TextEditor::EditorState& aBefore, |
| TextEditor::EditorState& aAfter) |
| : mAdded(aAdded) |
| , mAddedStart(aAddedStart) |
| , mAddedEnd(aAddedEnd) |
| , mRemoved(aRemoved) |
| , mRemovedStart(aRemovedStart) |
| , mRemovedEnd(aRemovedEnd) |
| , mBefore(aBefore) |
| , mAfter(aAfter) |
| { |
| assert(mAddedStart <= mAddedEnd); |
| assert(mRemovedStart <= mRemovedEnd); |
| } |
| |
| void TextEditor::UndoRecord::Undo(TextEditor * aEditor) |
| { |
| if (!mAdded.empty()) |
| { |
| aEditor->DeleteRange(mAddedStart, mAddedEnd); |
| aEditor->Colorize(mAddedStart.mLine - 1, mAddedEnd.mLine - mAddedStart.mLine + 2); |
| } |
| |
| if (!mRemoved.empty()) |
| { |
| auto start = mRemovedStart; |
| aEditor->InsertTextAt(start, mRemoved.c_str()); |
| aEditor->Colorize(mRemovedStart.mLine - 1, mRemovedEnd.mLine - mRemovedStart.mLine + 2); |
| } |
| |
| aEditor->mState = mBefore; |
| aEditor->EnsureCursorVisible(); |
| |
| } |
| |
| void TextEditor::UndoRecord::Redo(TextEditor * aEditor) |
| { |
| if (!mRemoved.empty()) |
| { |
| aEditor->DeleteRange(mRemovedStart, mRemovedEnd); |
| aEditor->Colorize(mRemovedStart.mLine - 1, mRemovedEnd.mLine - mRemovedStart.mLine + 1); |
| } |
| |
| if (!mAdded.empty()) |
| { |
| auto start = mAddedStart; |
| aEditor->InsertTextAt(start, mAdded.c_str()); |
| aEditor->Colorize(mAddedStart.mLine - 1, mAddedEnd.mLine - mAddedStart.mLine + 1); |
| } |
| |
| aEditor->mState = mAfter; |
| aEditor->EnsureCursorVisible(); |
| } |
| |
| static bool TokenizeCStyleString(const char * in_begin, const char * in_end, const char *& out_begin, const char *& out_end) |
| { |
| const char * p = in_begin; |
| |
| if (*p == '"') |
| { |
| p++; |
| |
| while (p < in_end) |
| { |
| // handle end of string |
| if (*p == '"') |
| { |
| out_begin = in_begin; |
| out_end = p + 1; |
| return true; |
| } |
| |
| // handle escape character for " |
| if (*p == '\\' && p + 1 < in_end && p[1] == '"') |
| p++; |
| |
| p++; |
| } |
| } |
| |
| return false; |
| } |
| |
| static bool TokenizeCStyleCharacterLiteral(const char * in_begin, const char * in_end, const char *& out_begin, const char *& out_end) |
| { |
| const char * p = in_begin; |
| |
| if (*p == '\'') |
| { |
| p++; |
| |
| // handle escape characters |
| if (p < in_end && *p == '\\') |
| p++; |
| |
| if (p < in_end) |
| p++; |
| |
| // handle end of character literal |
| if (p < in_end && *p == '\'') |
| { |
| out_begin = in_begin; |
| out_end = p + 1; |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| static bool TokenizeCStyleIdentifier(const char * in_begin, const char * in_end, const char *& out_begin, const char *& out_end) |
| { |
| const char * p = in_begin; |
| |
| if ((*p >= 'a' && *p <= 'z') || (*p >= 'A' && *p <= 'Z') || *p == '_') |
| { |
| p++; |
| |
| while ((p < in_end) && ((*p >= 'a' && *p <= 'z') || (*p >= 'A' && *p <= 'Z') || (*p >= '0' && *p <= '9') || *p == '_')) |
| p++; |
| |
| out_begin = in_begin; |
| out_end = p; |
| return true; |
| } |
| |
| return false; |
| } |
| |
| static bool TokenizeCStyleNumber(const char * in_begin, const char * in_end, const char *& out_begin, const char *& out_end) |
| { |
| const char * p = in_begin; |
| |
| const bool startsWithNumber = *p >= '0' && *p <= '9'; |
| |
| if (*p != '+' && *p != '-' && !startsWithNumber) |
| return false; |
| |
| p++; |
| |
| bool hasNumber = startsWithNumber; |
| |
| while (p < in_end && (*p >= '0' && *p <= '9')) |
| { |
| hasNumber = true; |
| |
| p++; |
| } |
| |
| if (hasNumber == false) |
| return false; |
| |
| bool isFloat = false; |
| bool isHex = false; |
| bool isBinary = false; |
| |
| if (p < in_end) |
| { |
| if (*p == '.') |
| { |
| isFloat = true; |
| |
| p++; |
| |
| while (p < in_end && (*p >= '0' && *p <= '9')) |
| p++; |
| } |
| else if (*p == 'x' || *p == 'X') |
| { |
| // hex formatted integer of the type 0xef80 |
| |
| isHex = true; |
| |
| p++; |
| |
| while (p < in_end && ((*p >= '0' && *p <= '9') || (*p >= 'a' && *p <= 'f') || (*p >= 'A' && *p <= 'F'))) |
| p++; |
| } |
| else if (*p == 'b' || *p == 'B') |
| { |
| // binary formatted integer of the type 0b01011101 |
| |
| isBinary = true; |
| |
| p++; |
| |
| while (p < in_end && (*p >= '0' && *p <= '1')) |
| p++; |
| } |
| } |
| |
| if (isHex == false && isBinary == false) |
| { |
| // floating point exponent |
| if (p < in_end && (*p == 'e' || *p == 'E')) |
| { |
| isFloat = true; |
| |
| p++; |
| |
| if (p < in_end && (*p == '+' || *p == '-')) |
| p++; |
| |
| bool hasDigits = false; |
| |
| while (p < in_end && (*p >= '0' && *p <= '9')) |
| { |
| hasDigits = true; |
| |
| p++; |
| } |
| |
| if (hasDigits == false) |
| return false; |
| } |
| |
| // single precision floating point type |
| if (p < in_end && *p == 'f') |
| p++; |
| } |
| |
| if (isFloat == false) |
| { |
| // integer size type |
| while (p < in_end && (*p == 'u' || *p == 'U' || *p == 'l' || *p == 'L')) |
| p++; |
| } |
| |
| out_begin = in_begin; |
| out_end = p; |
| return true; |
| } |
| |
| static bool TokenizeCStylePunctuation(const char * in_begin, const char * in_end, const char *& out_begin, const char *& out_end) |
| { |
| (void)in_end; |
| |
| switch (*in_begin) |
| { |
| case '[': |
| case ']': |
| case '{': |
| case '}': |
| case '!': |
| case '%': |
| case '^': |
| case '&': |
| case '*': |
| case '(': |
| case ')': |
| case '-': |
| case '+': |
| case '=': |
| case '~': |
| case '|': |
| case '<': |
| case '>': |
| case '?': |
| case ':': |
| case '/': |
| case ';': |
| case ',': |
| case '.': |
| out_begin = in_begin; |
| out_end = in_begin + 1; |
| return true; |
| } |
| |
| return false; |
| } |
| |
| const TextEditor::LanguageDefinition& TextEditor::LanguageDefinition::CPlusPlus() |
| { |
| static bool inited = false; |
| static LanguageDefinition langDef; |
| if (!inited) |
| { |
| static const char* const cppKeywords[] = { |
| "alignas", "alignof", "and", "and_eq", "asm", "atomic_cancel", "atomic_commit", "atomic_noexcept", "auto", "bitand", "bitor", "bool", "break", "case", "catch", "char", "char16_t", "char32_t", "class", |
| "compl", "concept", "const", "constexpr", "const_cast", "continue", "decltype", "default", "delete", "do", "double", "dynamic_cast", "else", "enum", "explicit", "export", "extern", "false", "float", |
| "for", "friend", "goto", "if", "import", "inline", "int", "long", "module", "mutable", "namespace", "new", "noexcept", "not", "not_eq", "nullptr", "operator", "or", "or_eq", "private", "protected", "public", |
| "register", "reinterpret_cast", "requires", "return", "short", "signed", "sizeof", "static", "static_assert", "static_cast", "struct", "switch", "synchronized", "template", "this", "thread_local", |
| "throw", "true", "try", "typedef", "typeid", "typename", "union", "unsigned", "using", "virtual", "void", "volatile", "wchar_t", "while", "xor", "xor_eq" |
| }; |
| for (auto& k : cppKeywords) |
| langDef.mKeywords.insert(k); |
| |
| static const char* const identifiers[] = { |
| "abort", "abs", "acos", "asin", "atan", "atexit", "atof", "atoi", "atol", "ceil", "clock", "cosh", "ctime", "div", "exit", "fabs", "floor", "fmod", "getchar", "getenv", "isalnum", "isalpha", "isdigit", "isgraph", |
| "ispunct", "isspace", "isupper", "kbhit", "log10", "log2", "log", "memcmp", "modf", "pow", "printf", "sprintf", "snprintf", "putchar", "putenv", "puts", "rand", "remove", "rename", "sinh", "sqrt", "srand", "strcat", "strcmp", "strerror", "time", "tolower", "toupper", |
| "std", "string", "vector", "map", "unordered_map", "set", "unordered_set", "min", "max" |
| }; |
| for (auto& k : identifiers) |
| { |
| Identifier id; |
| id.mDeclaration = "Built-in function"; |
| langDef.mIdentifiers.insert(std::make_pair(std::string(k), id)); |
| } |
| |
| langDef.mTokenize = [](const char * in_begin, const char * in_end, const char *& out_begin, const char *& out_end, PaletteIndex & paletteIndex) -> bool |
| { |
| paletteIndex = PaletteIndex::Max; |
| |
| while (in_begin < in_end && isascii(*in_begin) && isblank(*in_begin)) |
| in_begin++; |
| |
| if (in_begin == in_end) |
| { |
| out_begin = in_end; |
| out_end = in_end; |
| paletteIndex = PaletteIndex::Default; |
| } |
| else if (TokenizeCStyleString(in_begin, in_end, out_begin, out_end)) |
| paletteIndex = PaletteIndex::String; |
| else if (TokenizeCStyleCharacterLiteral(in_begin, in_end, out_begin, out_end)) |
| paletteIndex = PaletteIndex::CharLiteral; |
| else if (TokenizeCStyleIdentifier(in_begin, in_end, out_begin, out_end)) |
| paletteIndex = PaletteIndex::Identifier; |
| else if (TokenizeCStyleNumber(in_begin, in_end, out_begin, out_end)) |
| paletteIndex = PaletteIndex::Number; |
| else if (TokenizeCStylePunctuation(in_begin, in_end, out_begin, out_end)) |
| paletteIndex = PaletteIndex::Punctuation; |
| |
| return paletteIndex != PaletteIndex::Max; |
| }; |
| |
| langDef.mCommentStart = "/*"; |
| langDef.mCommentEnd = "*/"; |
| langDef.mSingleLineComment = "//"; |
| |
| langDef.mCaseSensitive = true; |
| langDef.mAutoIndentation = true; |
| |
| langDef.mName = "C++"; |
| |
| inited = true; |
| } |
| return langDef; |
| } |
| |
| const TextEditor::LanguageDefinition& TextEditor::LanguageDefinition::HLSL() |
| { |
| static bool inited = false; |
| static LanguageDefinition langDef; |
| if (!inited) |
| { |
| static const char* const keywords[] = { |
| "AppendStructuredBuffer", "asm", "asm_fragment", "BlendState", "bool", "break", "Buffer", "ByteAddressBuffer", "case", "cbuffer", "centroid", "class", "column_major", "compile", "compile_fragment", |
| "CompileShader", "const", "continue", "ComputeShader", "ConsumeStructuredBuffer", "default", "DepthStencilState", "DepthStencilView", "discard", "do", "double", "DomainShader", "dword", "else", |
| "export", "extern", "false", "float", "for", "fxgroup", "GeometryShader", "groupshared", "half", "Hullshader", "if", "in", "inline", "inout", "InputPatch", "int", "interface", "line", "lineadj", |
| "linear", "LineStream", "matrix", "min16float", "min10float", "min16int", "min12int", "min16uint", "namespace", "nointerpolation", "noperspective", "NULL", "out", "OutputPatch", "packoffset", |
| "pass", "pixelfragment", "PixelShader", "point", "PointStream", "precise", "RasterizerState", "RenderTargetView", "return", "register", "row_major", "RWBuffer", "RWByteAddressBuffer", "RWStructuredBuffer", |
| "RWTexture1D", "RWTexture1DArray", "RWTexture2D", "RWTexture2DArray", "RWTexture3D", "sample", "sampler", "SamplerState", "SamplerComparisonState", "shared", "snorm", "stateblock", "stateblock_state", |
| "static", "string", "struct", "switch", "StructuredBuffer", "tbuffer", "technique", "technique10", "technique11", "texture", "Texture1D", "Texture1DArray", "Texture2D", "Texture2DArray", "Texture2DMS", |
| "Texture2DMSArray", "Texture3D", "TextureCube", "TextureCubeArray", "true", "typedef", "triangle", "triangleadj", "TriangleStream", "uint", "uniform", "unorm", "unsigned", "vector", "vertexfragment", |
| "VertexShader", "void", "volatile", "while", |
| "bool1","bool2","bool3","bool4","double1","double2","double3","double4", "float1", "float2", "float3", "float4", "int1", "int2", "int3", "int4", "in", "out", "inout", |
| "uint1", "uint2", "uint3", "uint4", "dword1", "dword2", "dword3", "dword4", "half1", "half2", "half3", "half4", |
| "float1x1","float2x1","float3x1","float4x1","float1x2","float2x2","float3x2","float4x2", |
| "float1x3","float2x3","float3x3","float4x3","float1x4","float2x4","float3x4","float4x4", |
| "half1x1","half2x1","half3x1","half4x1","half1x2","half2x2","half3x2","half4x2", |
| "half1x3","half2x3","half3x3","half4x3","half1x4","half2x4","half3x4","half4x4", |
| }; |
| for (auto& k : keywords) |
| langDef.mKeywords.insert(k); |
| |
| static const char* const identifiers[] = { |
| "abort", "abs", "acos", "all", "AllMemoryBarrier", "AllMemoryBarrierWithGroupSync", "any", "asdouble", "asfloat", "asin", "asint", "asint", "asuint", |
| "asuint", "atan", "atan2", "ceil", "CheckAccessFullyMapped", "clamp", "clip", "cos", "cosh", "countbits", "cross", "D3DCOLORtoUBYTE4", "ddx", |
| "ddx_coarse", "ddx_fine", "ddy", "ddy_coarse", "ddy_fine", "degrees", "determinant", "DeviceMemoryBarrier", "DeviceMemoryBarrierWithGroupSync", |
| "distance", "dot", "dst", "errorf", "EvaluateAttributeAtCentroid", "EvaluateAttributeAtSample", "EvaluateAttributeSnapped", "exp", "exp2", |
| "f16tof32", "f32tof16", "faceforward", "firstbithigh", "firstbitlow", "floor", "fma", "fmod", "frac", "frexp", "fwidth", "GetRenderTargetSampleCount", |
| "GetRenderTargetSamplePosition", "GroupMemoryBarrier", "GroupMemoryBarrierWithGroupSync", "InterlockedAdd", "InterlockedAnd", "InterlockedCompareExchange", |
| "InterlockedCompareStore", "InterlockedExchange", "InterlockedMax", "InterlockedMin", "InterlockedOr", "InterlockedXor", "isfinite", "isinf", "isnan", |
| "ldexp", "length", "lerp", "lit", "log", "log10", "log2", "mad", "max", "min", "modf", "msad4", "mul", "noise", "normalize", "pow", "printf", |
| "Process2DQuadTessFactorsAvg", "Process2DQuadTessFactorsMax", "Process2DQuadTessFactorsMin", "ProcessIsolineTessFactors", "ProcessQuadTessFactorsAvg", |
| "ProcessQuadTessFactorsMax", "ProcessQuadTessFactorsMin", "ProcessTriTessFactorsAvg", "ProcessTriTessFactorsMax", "ProcessTriTessFactorsMin", |
| "radians", "rcp", "reflect", "refract", "reversebits", "round", "rsqrt", "saturate", "sign", "sin", "sincos", "sinh", "smoothstep", "sqrt", "step", |
| "tan", "tanh", "tex1D", "tex1D", "tex1Dbias", "tex1Dgrad", "tex1Dlod", "tex1Dproj", "tex2D", "tex2D", "tex2Dbias", "tex2Dgrad", "tex2Dlod", "tex2Dproj", |
| "tex3D", "tex3D", "tex3Dbias", "tex3Dgrad", "tex3Dlod", "tex3Dproj", "texCUBE", "texCUBE", "texCUBEbias", "texCUBEgrad", "texCUBElod", "texCUBEproj", "transpose", "trunc" |
| }; |
| for (auto& k : identifiers) |
| { |
| Identifier id; |
| id.mDeclaration = "Built-in function"; |
| langDef.mIdentifiers.insert(std::make_pair(std::string(k), id)); |
| } |
| |
| langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("[ \\t]*#[ \\t]*[a-zA-Z_]+", PaletteIndex::Preprocessor)); |
| langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("L?\\\"(\\\\.|[^\\\"])*\\\"", PaletteIndex::String)); |
| langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("\\'\\\\?[^\\']\\'", PaletteIndex::CharLiteral)); |
| langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("[+-]?([0-9]+([.][0-9]*)?|[.][0-9]+)([eE][+-]?[0-9]+)?[fF]?", PaletteIndex::Number)); |
| langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("[+-]?[0-9]+[Uu]?[lL]?[lL]?", PaletteIndex::Number)); |
| langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("0[0-7]+[Uu]?[lL]?[lL]?", PaletteIndex::Number)); |
| langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("0[xX][0-9a-fA-F]+[uU]?[lL]?[lL]?", PaletteIndex::Number)); |
| langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("[a-zA-Z_][a-zA-Z0-9_]*", PaletteIndex::Identifier)); |
| langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("[\\[\\]\\{\\}\\!\\%\\^\\&\\*\\(\\)\\-\\+\\=\\~\\|\\<\\>\\?\\/\\;\\,\\.]", PaletteIndex::Punctuation)); |
| |
| langDef.mCommentStart = "/*"; |
| langDef.mCommentEnd = "*/"; |
| langDef.mSingleLineComment = "//"; |
| |
| langDef.mCaseSensitive = true; |
| langDef.mAutoIndentation = true; |
| |
| langDef.mName = "HLSL"; |
| |
| inited = true; |
| } |
| return langDef; |
| } |
| |
| const TextEditor::LanguageDefinition& TextEditor::LanguageDefinition::GLSL() |
| { |
| static bool inited = false; |
| static LanguageDefinition langDef; |
| if (!inited) |
| { |
| static const char* const keywords[] = { |
| "auto", "break", "case", "char", "const", "continue", "default", "do", "double", "else", "enum", "extern", "float", "for", "goto", "if", "inline", "int", "long", "register", "restrict", "return", "short", |
| "signed", "sizeof", "static", "struct", "switch", "typedef", "union", "unsigned", "void", "volatile", "while", "_Alignas", "_Alignof", "_Atomic", "_Bool", "_Complex", "_Generic", "_Imaginary", |
| "_Noreturn", "_Static_assert", "_Thread_local" |
| }; |
| for (auto& k : keywords) |
| langDef.mKeywords.insert(k); |
| |
| static const char* const identifiers[] = { |
| "abort", "abs", "acos", "asin", "atan", "atexit", "atof", "atoi", "atol", "ceil", "clock", "cosh", "ctime", "div", "exit", "fabs", "floor", "fmod", "getchar", "getenv", "isalnum", "isalpha", "isdigit", "isgraph", |
| "ispunct", "isspace", "isupper", "kbhit", "log10", "log2", "log", "memcmp", "modf", "pow", "putchar", "putenv", "puts", "rand", "remove", "rename", "sinh", "sqrt", "srand", "strcat", "strcmp", "strerror", "time", "tolower", "toupper" |
| }; |
| for (auto& k : identifiers) |
| { |
| Identifier id; |
| id.mDeclaration = "Built-in function"; |
| langDef.mIdentifiers.insert(std::make_pair(std::string(k), id)); |
| } |
| |
| langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("[ \\t]*#[ \\t]*[a-zA-Z_]+", PaletteIndex::Preprocessor)); |
| langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("L?\\\"(\\\\.|[^\\\"])*\\\"", PaletteIndex::String)); |
| langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("\\'\\\\?[^\\']\\'", PaletteIndex::CharLiteral)); |
| langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("[+-]?([0-9]+([.][0-9]*)?|[.][0-9]+)([eE][+-]?[0-9]+)?[fF]?", PaletteIndex::Number)); |
| langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("[+-]?[0-9]+[Uu]?[lL]?[lL]?", PaletteIndex::Number)); |
| langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("0[0-7]+[Uu]?[lL]?[lL]?", PaletteIndex::Number)); |
| langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("0[xX][0-9a-fA-F]+[uU]?[lL]?[lL]?", PaletteIndex::Number)); |
| langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("[a-zA-Z_][a-zA-Z0-9_]*", PaletteIndex::Identifier)); |
| langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("[\\[\\]\\{\\}\\!\\%\\^\\&\\*\\(\\)\\-\\+\\=\\~\\|\\<\\>\\?\\/\\;\\,\\.]", PaletteIndex::Punctuation)); |
| |
| langDef.mCommentStart = "/*"; |
| langDef.mCommentEnd = "*/"; |
| langDef.mSingleLineComment = "//"; |
| |
| langDef.mCaseSensitive = true; |
| langDef.mAutoIndentation = true; |
| |
| langDef.mName = "GLSL"; |
| |
| inited = true; |
| } |
| return langDef; |
| } |
| |
| const TextEditor::LanguageDefinition& TextEditor::LanguageDefinition::C() |
| { |
| static bool inited = false; |
| static LanguageDefinition langDef; |
| if (!inited) |
| { |
| static const char* const keywords[] = { |
| "auto", "break", "case", "char", "const", "continue", "default", "do", "double", "else", "enum", "extern", "float", "for", "goto", "if", "inline", "int", "long", "register", "restrict", "return", "short", |
| "signed", "sizeof", "static", "struct", "switch", "typedef", "union", "unsigned", "void", "volatile", "while", "_Alignas", "_Alignof", "_Atomic", "_Bool", "_Complex", "_Generic", "_Imaginary", |
| "_Noreturn", "_Static_assert", "_Thread_local" |
| }; |
| for (auto& k : keywords) |
| langDef.mKeywords.insert(k); |
| |
| static const char* const identifiers[] = { |
| "abort", "abs", "acos", "asin", "atan", "atexit", "atof", "atoi", "atol", "ceil", "clock", "cosh", "ctime", "div", "exit", "fabs", "floor", "fmod", "getchar", "getenv", "isalnum", "isalpha", "isdigit", "isgraph", |
| "ispunct", "isspace", "isupper", "kbhit", "log10", "log2", "log", "memcmp", "modf", "pow", "putchar", "putenv", "puts", "rand", "remove", "rename", "sinh", "sqrt", "srand", "strcat", "strcmp", "strerror", "time", "tolower", "toupper" |
| }; |
| for (auto& k : identifiers) |
| { |
| Identifier id; |
| id.mDeclaration = "Built-in function"; |
| langDef.mIdentifiers.insert(std::make_pair(std::string(k), id)); |
| } |
| |
| langDef.mTokenize = [](const char * in_begin, const char * in_end, const char *& out_begin, const char *& out_end, PaletteIndex & paletteIndex) -> bool |
| { |
| paletteIndex = PaletteIndex::Max; |
| |
| while (in_begin < in_end && isascii(*in_begin) && isblank(*in_begin)) |
| in_begin++; |
| |
| if (in_begin == in_end) |
| { |
| out_begin = in_end; |
| out_end = in_end; |
| paletteIndex = PaletteIndex::Default; |
| } |
| else if (TokenizeCStyleString(in_begin, in_end, out_begin, out_end)) |
| paletteIndex = PaletteIndex::String; |
| else if (TokenizeCStyleCharacterLiteral(in_begin, in_end, out_begin, out_end)) |
| paletteIndex = PaletteIndex::CharLiteral; |
| else if (TokenizeCStyleIdentifier(in_begin, in_end, out_begin, out_end)) |
| paletteIndex = PaletteIndex::Identifier; |
| else if (TokenizeCStyleNumber(in_begin, in_end, out_begin, out_end)) |
| paletteIndex = PaletteIndex::Number; |
| else if (TokenizeCStylePunctuation(in_begin, in_end, out_begin, out_end)) |
| paletteIndex = PaletteIndex::Punctuation; |
| |
| return paletteIndex != PaletteIndex::Max; |
| }; |
| |
| langDef.mCommentStart = "/*"; |
| langDef.mCommentEnd = "*/"; |
| langDef.mSingleLineComment = "//"; |
| |
| langDef.mCaseSensitive = true; |
| langDef.mAutoIndentation = true; |
| |
| langDef.mName = "C"; |
| |
| inited = true; |
| } |
| return langDef; |
| } |
| |
| const TextEditor::LanguageDefinition& TextEditor::LanguageDefinition::SQL() |
| { |
| static bool inited = false; |
| static LanguageDefinition langDef; |
| if (!inited) |
| { |
| static const char* const keywords[] = { |
| "ADD", "EXCEPT", "PERCENT", "ALL", "EXEC", "PLAN", "ALTER", "EXECUTE", "PRECISION", "AND", "EXISTS", "PRIMARY", "ANY", "EXIT", "PRINT", "AS", "FETCH", "PROC", "ASC", "FILE", "PROCEDURE", |
| "AUTHORIZATION", "FILLFACTOR", "PUBLIC", "BACKUP", "FOR", "RAISERROR", "BEGIN", "FOREIGN", "READ", "BETWEEN", "FREETEXT", "READTEXT", "BREAK", "FREETEXTTABLE", "RECONFIGURE", |
| "BROWSE", "FROM", "REFERENCES", "BULK", "FULL", "REPLICATION", "BY", "FUNCTION", "RESTORE", "CASCADE", "GOTO", "RESTRICT", "CASE", "GRANT", "RETURN", "CHECK", "GROUP", "REVOKE", |
| "CHECKPOINT", "HAVING", "RIGHT", "CLOSE", "HOLDLOCK", "ROLLBACK", "CLUSTERED", "IDENTITY", "ROWCOUNT", "COALESCE", "IDENTITY_INSERT", "ROWGUIDCOL", "COLLATE", "IDENTITYCOL", "RULE", |
| "COLUMN", "IF", "SAVE", "COMMIT", "IN", "SCHEMA", "COMPUTE", "INDEX", "SELECT", "CONSTRAINT", "INNER", "SESSION_USER", "CONTAINS", "INSERT", "SET", "CONTAINSTABLE", "INTERSECT", "SETUSER", |
| "CONTINUE", "INTO", "SHUTDOWN", "CONVERT", "IS", "SOME", "CREATE", "JOIN", "STATISTICS", "CROSS", "KEY", "SYSTEM_USER", "CURRENT", "KILL", "TABLE", "CURRENT_DATE", "LEFT", "TEXTSIZE", |
| "CURRENT_TIME", "LIKE", "THEN", "CURRENT_TIMESTAMP", "LINENO", "TO", "CURRENT_USER", "LOAD", "TOP", "CURSOR", "NATIONAL", "TRAN", "DATABASE", "NOCHECK", "TRANSACTION", |
| "DBCC", "NONCLUSTERED", "TRIGGER", "DEALLOCATE", "NOT", "TRUNCATE", "DECLARE", "NULL", "TSEQUAL", "DEFAULT", "NULLIF", "UNION", "DELETE", "OF", "UNIQUE", "DENY", "OFF", "UPDATE", |
| "DESC", "OFFSETS", "UPDATETEXT", "DISK", "ON", "USE", "DISTINCT", "OPEN", "USER", "DISTRIBUTED", "OPENDATASOURCE", "VALUES", "DOUBLE", "OPENQUERY", "VARYING","DROP", "OPENROWSET", "VIEW", |
| "DUMMY", "OPENXML", "WAITFOR", "DUMP", "OPTION", "WHEN", "ELSE", "OR", "WHERE", "END", "ORDER", "WHILE", "ERRLVL", "OUTER", "WITH", "ESCAPE", "OVER", "WRITETEXT" |
| }; |
| |
| for (auto& k : keywords) |
| langDef.mKeywords.insert(k); |
| |
| static const char* const identifiers[] = { |
| "ABS", "ACOS", "ADD_MONTHS", "ASCII", "ASCIISTR", "ASIN", "ATAN", "ATAN2", "AVG", "BFILENAME", "BIN_TO_NUM", "BITAND", "CARDINALITY", "CASE", "CAST", "CEIL", |
| "CHARTOROWID", "CHR", "COALESCE", "COMPOSE", "CONCAT", "CONVERT", "CORR", "COS", "COSH", "COUNT", "COVAR_POP", "COVAR_SAMP", "CUME_DIST", "CURRENT_DATE", |
| "CURRENT_TIMESTAMP", "DBTIMEZONE", "DECODE", "DECOMPOSE", "DENSE_RANK", "DUMP", "EMPTY_BLOB", "EMPTY_CLOB", "EXP", "EXTRACT", "FIRST_VALUE", "FLOOR", "FROM_TZ", "GREATEST", |
| "GROUP_ID", "HEXTORAW", "INITCAP", "INSTR", "INSTR2", "INSTR4", "INSTRB", "INSTRC", "LAG", "LAST_DAY", "LAST_VALUE", "LEAD", "LEAST", "LENGTH", "LENGTH2", "LENGTH4", |
| "LENGTHB", "LENGTHC", "LISTAGG", "LN", "LNNVL", "LOCALTIMESTAMP", "LOG", "LOWER", "LPAD", "LTRIM", "MAX", "MEDIAN", "MIN", "MOD", "MONTHS_BETWEEN", "NANVL", "NCHR", |
| "NEW_TIME", "NEXT_DAY", "NTH_VALUE", "NULLIF", "NUMTODSINTERVAL", "NUMTOYMINTERVAL", "NVL", "NVL2", "POWER", "RANK", "RAWTOHEX", "REGEXP_COUNT", "REGEXP_INSTR", |
| "REGEXP_REPLACE", "REGEXP_SUBSTR", "REMAINDER", "REPLACE", "ROUND", "ROWNUM", "RPAD", "RTRIM", "SESSIONTIMEZONE", "SIGN", "SIN", "SINH", |
| "SOUNDEX", "SQRT", "STDDEV", "SUBSTR", "SUM", "SYS_CONTEXT", "SYSDATE", "SYSTIMESTAMP", "TAN", "TANH", "TO_CHAR", "TO_CLOB", "TO_DATE", "TO_DSINTERVAL", "TO_LOB", |
| "TO_MULTI_BYTE", "TO_NCLOB", "TO_NUMBER", "TO_SINGLE_BYTE", "TO_TIMESTAMP", "TO_TIMESTAMP_TZ", "TO_YMINTERVAL", "TRANSLATE", "TRIM", "TRUNC", "TZ_OFFSET", "UID", "UPPER", |
| "USER", "USERENV", "VAR_POP", "VAR_SAMP", "VARIANCE", "VSIZE " |
| }; |
| for (auto& k : identifiers) |
| { |
| Identifier id; |
| id.mDeclaration = "Built-in function"; |
| langDef.mIdentifiers.insert(std::make_pair(std::string(k), id)); |
| } |
| |
| langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("L?\\\"(\\\\.|[^\\\"])*\\\"", PaletteIndex::String)); |
| langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("\\\'[^\\\']*\\\'", PaletteIndex::String)); |
| langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("[+-]?([0-9]+([.][0-9]*)?|[.][0-9]+)([eE][+-]?[0-9]+)?[fF]?", PaletteIndex::Number)); |
| langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("[+-]?[0-9]+[Uu]?[lL]?[lL]?", PaletteIndex::Number)); |
| langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("0[0-7]+[Uu]?[lL]?[lL]?", PaletteIndex::Number)); |
| langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("0[xX][0-9a-fA-F]+[uU]?[lL]?[lL]?", PaletteIndex::Number)); |
| langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("[a-zA-Z_][a-zA-Z0-9_]*", PaletteIndex::Identifier)); |
| langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("[\\[\\]\\{\\}\\!\\%\\^\\&\\*\\(\\)\\-\\+\\=\\~\\|\\<\\>\\?\\/\\;\\,\\.]", PaletteIndex::Punctuation)); |
| |
| langDef.mCommentStart = "/*"; |
| langDef.mCommentEnd = "*/"; |
| langDef.mSingleLineComment = "//"; |
| |
| langDef.mCaseSensitive = false; |
| langDef.mAutoIndentation = false; |
| |
| langDef.mName = "SQL"; |
| |
| inited = true; |
| } |
| return langDef; |
| } |
| |
| const TextEditor::LanguageDefinition& TextEditor::LanguageDefinition::AngelScript() |
| { |
| static bool inited = false; |
| static LanguageDefinition langDef; |
| if (!inited) |
| { |
| static const char* const keywords[] = { |
| "and", "abstract", "auto", "bool", "break", "case", "cast", "class", "const", "continue", "default", "do", "double", "else", "enum", "false", "final", "float", "for", |
| "from", "funcdef", "function", "get", "if", "import", "in", "inout", "int", "interface", "int8", "int16", "int32", "int64", "is", "mixin", "namespace", "not", |
| "null", "or", "out", "override", "private", "protected", "return", "set", "shared", "super", "switch", "this ", "true", "typedef", "uint", "uint8", "uint16", "uint32", |
| "uint64", "void", "while", "xor" |
| }; |
| |
| for (auto& k : keywords) |
| langDef.mKeywords.insert(k); |
| |
| static const char* const identifiers[] = { |
| "cos", "sin", "tab", "acos", "asin", "atan", "atan2", "cosh", "sinh", "tanh", "log", "log10", "pow", "sqrt", "abs", "ceil", "floor", "fraction", "closeTo", "fpFromIEEE", "fpToIEEE", |
| "complex", "opEquals", "opAddAssign", "opSubAssign", "opMulAssign", "opDivAssign", "opAdd", "opSub", "opMul", "opDiv" |
| }; |
| for (auto& k : identifiers) |
| { |
| Identifier id; |
| id.mDeclaration = "Built-in function"; |
| langDef.mIdentifiers.insert(std::make_pair(std::string(k), id)); |
| } |
| |
| langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("L?\\\"(\\\\.|[^\\\"])*\\\"", PaletteIndex::String)); |
| langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("\\'\\\\?[^\\']\\'", PaletteIndex::String)); |
| langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("[+-]?([0-9]+([.][0-9]*)?|[.][0-9]+)([eE][+-]?[0-9]+)?[fF]?", PaletteIndex::Number)); |
| langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("[+-]?[0-9]+[Uu]?[lL]?[lL]?", PaletteIndex::Number)); |
| langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("0[0-7]+[Uu]?[lL]?[lL]?", PaletteIndex::Number)); |
| langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("0[xX][0-9a-fA-F]+[uU]?[lL]?[lL]?", PaletteIndex::Number)); |
| langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("[a-zA-Z_][a-zA-Z0-9_]*", PaletteIndex::Identifier)); |
| langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("[\\[\\]\\{\\}\\!\\%\\^\\&\\*\\(\\)\\-\\+\\=\\~\\|\\<\\>\\?\\/\\;\\,\\.]", PaletteIndex::Punctuation)); |
| |
| langDef.mCommentStart = "/*"; |
| langDef.mCommentEnd = "*/"; |
| langDef.mSingleLineComment = "//"; |
| |
| langDef.mCaseSensitive = true; |
| langDef.mAutoIndentation = true; |
| |
| langDef.mName = "AngelScript"; |
| |
| inited = true; |
| } |
| return langDef; |
| } |
| |
| const TextEditor::LanguageDefinition& TextEditor::LanguageDefinition::Lua() |
| { |
| static bool inited = false; |
| static LanguageDefinition langDef; |
| if (!inited) |
| { |
| static const char* const keywords[] = { |
| "and", "break", "do", "", "else", "elseif", "end", "false", "for", "function", "if", "in", "", "local", "nil", "not", "or", "repeat", "return", "then", "true", "until", "while" |
| }; |
| |
| for (auto& k : keywords) |
| langDef.mKeywords.insert(k); |
| |
| static const char* const identifiers[] = { |
| "assert", "collectgarbage", "dofile", "error", "getmetatable", "ipairs", "loadfile", "load", "loadstring", "next", "pairs", "pcall", "print", "rawequal", "rawlen", "rawget", "rawset", |
| "select", "setmetatable", "tonumber", "tostring", "type", "xpcall", "_G", "_VERSION","arshift", "band", "bnot", "bor", "bxor", "btest", "extract", "lrotate", "lshift", "replace", |
| "rrotate", "rshift", "create", "resume", "running", "status", "wrap", "yield", "isyieldable", "debug","getuservalue", "gethook", "getinfo", "getlocal", "getregistry", "getmetatable", |
| "getupvalue", "upvaluejoin", "upvalueid", "setuservalue", "sethook", "setlocal", "setmetatable", "setupvalue", "traceback", "close", "flush", "input", "lines", "open", "output", "popen", |
| "read", "tmpfile", "type", "write", "close", "flush", "lines", "read", "seek", "setvbuf", "write", "__gc", "__tostring", "abs", "acos", "asin", "atan", "ceil", "cos", "deg", "exp", "tointeger", |
| "floor", "fmod", "ult", "log", "max", "min", "modf", "rad", "random", "randomseed", "sin", "sqrt", "string", "tan", "type", "atan2", "cosh", "sinh", "tanh", |
| "pow", "frexp", "ldexp", "log10", "pi", "huge", "maxinteger", "mininteger", "loadlib", "searchpath", "seeall", "preload", "cpath", "path", "searchers", "loaded", "module", "require", "clock", |
| "date", "difftime", "execute", "exit", "getenv", "remove", "rename", "setlocale", "time", "tmpname", "byte", "char", "dump", "find", "format", "gmatch", "gsub", "len", "lower", "match", "rep", |
| "reverse", "sub", "upper", "pack", "packsize", "unpack", "concat", "maxn", "insert", "pack", "unpack", "remove", "move", "sort", "offset", "codepoint", "char", "len", "codes", "charpattern", |
| "coroutine", "table", "io", "os", "string", "utf8", "bit32", "math", "debug", "package" |
| }; |
| for (auto& k : identifiers) |
| { |
| Identifier id; |
| id.mDeclaration = "Built-in function"; |
| langDef.mIdentifiers.insert(std::make_pair(std::string(k), id)); |
| } |
| |
| langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("L?\\\"(\\\\.|[^\\\"])*\\\"", PaletteIndex::String)); |
| langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("\\\'[^\\\']*\\\'", PaletteIndex::String)); |
| langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("0[xX][0-9a-fA-F]+[uU]?[lL]?[lL]?", PaletteIndex::Number)); |
| langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("[+-]?([0-9]+([.][0-9]*)?|[.][0-9]+)([eE][+-]?[0-9]+)?[fF]?", PaletteIndex::Number)); |
| langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("[+-]?[0-9]+[Uu]?[lL]?[lL]?", PaletteIndex::Number)); |
| langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("[a-zA-Z_][a-zA-Z0-9_]*", PaletteIndex::Identifier)); |
| langDef.mTokenRegexStrings.push_back(std::make_pair<std::string, PaletteIndex>("[\\[\\]\\{\\}\\!\\%\\^\\&\\*\\(\\)\\-\\+\\=\\~\\|\\<\\>\\?\\/\\;\\,\\.]", PaletteIndex::Punctuation)); |
| |
| langDef.mCommentStart = "--[["; |
| langDef.mCommentEnd = "]]"; |
| langDef.mSingleLineComment = "--"; |
| |
| langDef.mCaseSensitive = true; |
| langDef.mAutoIndentation = false; |
| |
| langDef.mName = "Lua"; |
| |
| inited = true; |
| } |
| return langDef; |
| } |