Replaced pattern editor with BalazsJako's ImGuiColorTextEdit

CMakeLists.txt

@@ -46,6 +46,7 @@ add_executable(ImHex
         libs/ImGui/source/imgui_impl_glfw.cpp
         libs/ImGui/source/imgui_impl_opengl3.cpp
         libs/ImGui/source/ImGuiFileBrowser.cpp
+        libs/ImGui/source/TextEditor.cpp
 
         resource.rc
         )

include/views/view_pattern.hpp

@@ -12,6 +12,7 @@
 
 
 #include "ImGuiFileBrowser.h"
+#include "TextEditor.h"
 
 namespace hex {
 
@@ -24,12 +25,11 @@ namespace hex {
         void createView() override;
 
     private:
-        char *m_buffer = nullptr;
-
         std::vector<lang::PatternData*> &m_patternData;
         prv::Provider* &m_dataProvider;
         bool m_windowOpen = true;
 
+        TextEditor m_textEditor;
         imgui_addons::ImGuiFileBrowser m_fileBrowser;
 
         void clearPatternData();

libs/ImGui/include/TextEditor.h

@@ -0,0 +1,395 @@
+#pragma once
+
+#include <string>
+#include <vector>
+#include <array>
+#include <memory>
+#include <unordered_set>
+#include <unordered_map>
+#include <map>
+#include <regex>
+#include "imgui.h"
+
+class TextEditor
+{
+public:
+	enum class PaletteIndex
+	{
+		Default,
+		Keyword,
+		Number,
+		String,
+		CharLiteral,
+		Punctuation,
+		Preprocessor,
+		Identifier,
+		KnownIdentifier,
+		PreprocIdentifier,
+		Comment,
+		MultiLineComment,
+		Background,
+		Cursor,
+		Selection,
+		ErrorMarker,
+		Breakpoint,
+		LineNumber,
+		CurrentLineFill,
+		CurrentLineFillInactive,
+		CurrentLineEdge,
+		Max
+	};
+
+	enum class SelectionMode
+	{
+		Normal,
+		Word,
+		Line
+	};
+
+	struct Breakpoint
+	{
+		int mLine;
+		bool mEnabled;
+		std::string mCondition;
+
+		Breakpoint()
+			: mLine(-1)
+			, mEnabled(false)
+		{}
+	};
+
+	// Represents a character coordinate from the user's point of view,
+	// i. e. consider an uniform grid (assuming fixed-width font) on the
+	// screen as it is rendered, and each cell has its own coordinate, starting from 0.
+	// Tabs are counted as [1..mTabSize] count empty spaces, depending on
+	// how many space is necessary to reach the next tab stop.
+	// For example, coordinate (1, 5) represents the character 'B' in a line "\tABC", when mTabSize = 4,
+	// because it is rendered as "    ABC" on the screen.
+	struct Coordinates
+	{
+		int mLine, mColumn;
+		Coordinates() : mLine(0), mColumn(0) {}
+		Coordinates(int aLine, int aColumn) : mLine(aLine), mColumn(aColumn)
+		{
+			assert(aLine >= 0);
+			assert(aColumn >= 0);
+		}
+		static Coordinates Invalid() { static Coordinates invalid(-1, -1); return invalid; }
+
+		bool operator ==(const Coordinates& o) const
+		{
+			return
+				mLine == o.mLine &&
+				mColumn == o.mColumn;
+		}
+
+		bool operator !=(const Coordinates& o) const
+		{
+			return
+				mLine != o.mLine ||
+				mColumn != o.mColumn;
+		}
+
+		bool operator <(const Coordinates& o) const
+		{
+			if (mLine != o.mLine)
+				return mLine < o.mLine;
+			return mColumn < o.mColumn;
+		}
+
+		bool operator >(const Coordinates& o) const
+		{
+			if (mLine != o.mLine)
+				return mLine > o.mLine;
+			return mColumn > o.mColumn;
+		}
+
+		bool operator <=(const Coordinates& o) const
+		{
+			if (mLine != o.mLine)
+				return mLine < o.mLine;
+			return mColumn <= o.mColumn;
+		}
+
+		bool operator >=(const Coordinates& o) const
+		{
+			if (mLine != o.mLine)
+				return mLine > o.mLine;
+			return mColumn >= o.mColumn;
+		}
+	};
+
+	struct Identifier
+	{
+		Coordinates mLocation;
+		std::string mDeclaration;
+	};
+
+	typedef std::string String;
+	typedef std::unordered_map<std::string, Identifier> Identifiers;
+	typedef std::unordered_set<std::string> Keywords;
+	typedef std::map<int, std::string> ErrorMarkers;
+	typedef std::unordered_set<int> Breakpoints;
+	typedef std::array<ImU32, (unsigned)PaletteIndex::Max> Palette;
+	typedef uint8_t Char;
+
+	struct Glyph
+	{
+		Char mChar;
+		PaletteIndex mColorIndex = PaletteIndex::Default;
+		bool mComment : 1;
+		bool mMultiLineComment : 1;
+		bool mPreprocessor : 1;
+
+		Glyph(Char aChar, PaletteIndex aColorIndex) : mChar(aChar), mColorIndex(aColorIndex),
+			mComment(false), mMultiLineComment(false), mPreprocessor(false) {}
+	};
+
+	typedef std::vector<Glyph> Line;
+	typedef std::vector<Line> Lines;
+
+	struct LanguageDefinition
+	{
+		typedef std::pair<std::string, PaletteIndex> TokenRegexString;
+		typedef std::vector<TokenRegexString> TokenRegexStrings;
+		typedef bool(*TokenizeCallback)(const char * in_begin, const char * in_end, const char *& out_begin, const char *& out_end, PaletteIndex & paletteIndex);
+
+		std::string mName;
+		Keywords mKeywords;
+		Identifiers mIdentifiers;
+		Identifiers mPreprocIdentifiers;
+		std::string mCommentStart, mCommentEnd, mSingleLineComment;
+		char mPreprocChar;
+		bool mAutoIndentation;
+
+		TokenizeCallback mTokenize;
+
+		TokenRegexStrings mTokenRegexStrings;
+
+		bool mCaseSensitive;
+
+		LanguageDefinition()
+			: mPreprocChar('#'), mAutoIndentation(true), mTokenize(nullptr), mCaseSensitive(true)
+		{
+		}
+
+		static const LanguageDefinition& CPlusPlus();
+		static const LanguageDefinition& HLSL();
+		static const LanguageDefinition& GLSL();
+		static const LanguageDefinition& C();
+		static const LanguageDefinition& SQL();
+		static const LanguageDefinition& AngelScript();
+		static const LanguageDefinition& Lua();
+	};
+
+	TextEditor();
+	~TextEditor();
+
+	void SetLanguageDefinition(const LanguageDefinition& aLanguageDef);
+	const LanguageDefinition& GetLanguageDefinition() const { return mLanguageDefinition; }
+
+	const Palette& GetPalette() const { return mPaletteBase; }
+	void SetPalette(const Palette& aValue);
+
+	void SetErrorMarkers(const ErrorMarkers& aMarkers) { mErrorMarkers = aMarkers; }
+	void SetBreakpoints(const Breakpoints& aMarkers) { mBreakpoints = aMarkers; }
+
+	void Render(const char* aTitle, const ImVec2& aSize = ImVec2(), bool aBorder = false);
+	void SetText(const std::string& aText);
+	std::string GetText() const;
+
+	void SetTextLines(const std::vector<std::string>& aLines);
+	std::vector<std::string> GetTextLines() const;
+
+	std::string GetSelectedText() const;
+	std::string GetCurrentLineText()const;
+
+	int GetTotalLines() const { return (int)mLines.size(); }
+	bool IsOverwrite() const { return mOverwrite; }
+
+	void SetReadOnly(bool aValue);
+	bool IsReadOnly() const { return mReadOnly; }
+	bool IsTextChanged() const { return mTextChanged; }
+	bool IsCursorPositionChanged() const { return mCursorPositionChanged; }
+
+	bool IsColorizerEnabled() const { return mColorizerEnabled; }
+	void SetColorizerEnable(bool aValue);
+
+	Coordinates GetCursorPosition() const { return GetActualCursorCoordinates(); }
+	void SetCursorPosition(const Coordinates& aPosition);
+
+	inline void SetHandleMouseInputs    (bool aValue){ mHandleMouseInputs    = aValue;}
+	inline bool IsHandleMouseInputsEnabled() const { return mHandleKeyboardInputs; }
+
+	inline void SetHandleKeyboardInputs (bool aValue){ mHandleKeyboardInputs = aValue;}
+	inline bool IsHandleKeyboardInputsEnabled() const { return mHandleKeyboardInputs; }
+
+	inline void SetImGuiChildIgnored    (bool aValue){ mIgnoreImGuiChild     = aValue;}
+	inline bool IsImGuiChildIgnored() const { return mIgnoreImGuiChild; }
+
+	inline void SetShowWhitespaces(bool aValue) { mShowWhitespaces = aValue; }
+	inline bool IsShowingWhitespaces() const { return mShowWhitespaces; }
+
+	void SetTabSize(int aValue);
+	inline int GetTabSize() const { return mTabSize; }
+
+	void InsertText(const std::string& aValue);
+	void InsertText(const char* aValue);
+
+	void MoveUp(int aAmount = 1, bool aSelect = false);
+	void MoveDown(int aAmount = 1, bool aSelect = false);
+	void MoveLeft(int aAmount = 1, bool aSelect = false, bool aWordMode = false);
+	void MoveRight(int aAmount = 1, bool aSelect = false, bool aWordMode = false);
+	void MoveTop(bool aSelect = false);
+	void MoveBottom(bool aSelect = false);
+	void MoveHome(bool aSelect = false);
+	void MoveEnd(bool aSelect = false);
+
+	void SetSelectionStart(const Coordinates& aPosition);
+	void SetSelectionEnd(const Coordinates& aPosition);
+	void SetSelection(const Coordinates& aStart, const Coordinates& aEnd, SelectionMode aMode = SelectionMode::Normal);
+	void SelectWordUnderCursor();
+	void SelectAll();
+	bool HasSelection() const;
+
+	void Copy();
+	void Cut();
+	void Paste();
+	void Delete();
+
+	bool CanUndo() const;
+	bool CanRedo() const;
+	void Undo(int aSteps = 1);
+	void Redo(int aSteps = 1);
+
+	static const Palette& GetDarkPalette();
+	static const Palette& GetLightPalette();
+	static const Palette& GetRetroBluePalette();
+
+private:
+	typedef std::vector<std::pair<std::regex, PaletteIndex>> RegexList;
+
+	struct EditorState
+	{
+		Coordinates mSelectionStart;
+		Coordinates mSelectionEnd;
+		Coordinates mCursorPosition;
+	};
+
+	class UndoRecord
+	{
+	public:
+		UndoRecord() {}
+		~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);
+
+		void Undo(TextEditor* aEditor);
+		void Redo(TextEditor* aEditor);
+
+		std::string mAdded;
+		Coordinates mAddedStart;
+		Coordinates mAddedEnd;
+
+		std::string mRemoved;
+		Coordinates mRemovedStart;
+		Coordinates mRemovedEnd;
+
+		EditorState mBefore;
+		EditorState mAfter;
+	};
+
+	typedef std::vector<UndoRecord> UndoBuffer;
+
+	void ProcessInputs();
+	void Colorize(int aFromLine = 0, int aCount = -1);
+	void ColorizeRange(int aFromLine = 0, int aToLine = 0);
+	void ColorizeInternal();
+	float TextDistanceToLineStart(const Coordinates& aFrom) const;
+	void EnsureCursorVisible();
+	int GetPageSize() const;
+	std::string GetText(const Coordinates& aStart, const Coordinates& aEnd) const;
+	Coordinates GetActualCursorCoordinates() const;
+	Coordinates SanitizeCoordinates(const Coordinates& aValue) const;
+	void Advance(Coordinates& aCoordinates) const;
+	void DeleteRange(const Coordinates& aStart, const Coordinates& aEnd);
+	int InsertTextAt(Coordinates& aWhere, const char* aValue);
+	void AddUndo(UndoRecord& aValue);
+	Coordinates ScreenPosToCoordinates(const ImVec2& aPosition) const;
+	Coordinates FindWordStart(const Coordinates& aFrom) const;
+	Coordinates FindWordEnd(const Coordinates& aFrom) const;
+	Coordinates FindNextWord(const Coordinates& aFrom) const;
+	int GetCharacterIndex(const Coordinates& aCoordinates) const;
+	int GetCharacterColumn(int aLine, int aIndex) const;
+	int GetLineCharacterCount(int aLine) const;
+	int GetLineMaxColumn(int aLine) const;
+	bool IsOnWordBoundary(const Coordinates& aAt) const;
+	void RemoveLine(int aStart, int aEnd);
+	void RemoveLine(int aIndex);
+	Line& InsertLine(int aIndex);
+	void EnterCharacter(ImWchar aChar, bool aShift);
+	void Backspace();
+	void DeleteSelection();
+	std::string GetWordUnderCursor() const;
+	std::string GetWordAt(const Coordinates& aCoords) const;
+	ImU32 GetGlyphColor(const Glyph& aGlyph) const;
+
+	void HandleKeyboardInputs();
+	void HandleMouseInputs();
+	void Render();
+
+	float mLineSpacing;
+	Lines mLines;
+	EditorState mState;
+	UndoBuffer mUndoBuffer;
+	int mUndoIndex;
+
+	int mTabSize;
+	bool mOverwrite;
+	bool mReadOnly;
+	bool mWithinRender;
+	bool mScrollToCursor;
+	bool mScrollToTop;
+	bool mTextChanged;
+	bool mColorizerEnabled;
+	float mTextStart;                   // position (in pixels) where a code line starts relative to the left of the TextEditor.
+	int  mLeftMargin;
+	bool mCursorPositionChanged;
+	int mColorRangeMin, mColorRangeMax;
+	SelectionMode mSelectionMode;
+	bool mHandleKeyboardInputs;
+	bool mHandleMouseInputs;
+	bool mIgnoreImGuiChild;
+	bool mShowWhitespaces;
+
+	Palette mPaletteBase;
+	Palette mPalette;
+	LanguageDefinition mLanguageDefinition;
+	RegexList mRegexList;
+
+	bool mCheckComments;
+	Breakpoints mBreakpoints;
+	ErrorMarkers mErrorMarkers;
+	ImVec2 mCharAdvance;
+	Coordinates mInteractiveStart, mInteractiveEnd;
+	std::string mLineBuffer;
+	uint64_t mStartTime;
+
+	float mLastClick;
+};
+
+bool TokenizeCStyleString(const char * in_begin, const char * in_end, const char *& out_begin, const char *& out_end);
+bool TokenizeCStyleCharacterLiteral(const char * in_begin, const char * in_end, const char *& out_begin, const char *& out_end);
+bool TokenizeCStyleIdentifier(const char * in_begin, const char * in_end, const char *& out_begin, const char *& out_end);
+bool TokenizeCStyleNumber(const char * in_begin, const char * in_end, const char *& out_begin, const char *& out_end);
+bool TokenizeCStylePunctuation(const char * in_begin, const char * in_end, const char *& out_begin, const char *& out_end);

source/views/view_help.cpp

@@ -31,6 +31,7 @@ namespace hex {
             ImGui::BulletText("ImGui by ocornut");
             ImGui::BulletText("imgui_club by ocornut");
             ImGui::BulletText("ImGui-Addons by gallickgunner");
+            ImGui::BulletText("ImGuiColorTextEdit by BalazsJako");
             ImGui::NewLine();
             ImGui::BulletText("GNU libmagic");
             ImGui::BulletText("OpenSSL libcrypto");

source/views/view_pattern.cpp

@@ -9,15 +9,71 @@
 
 namespace hex {
 
+    static const TextEditor::LanguageDefinition& PatternLanguage() {
+        static bool initialized = false;
+        static TextEditor::LanguageDefinition langDef;
+        if (!initialized) {
+            static const char* const keywords[] = {
+                "using", "struct", "enum"
+            };
+            for (auto& k : keywords)
+                langDef.mKeywords.insert(k);
+
+            static const char* const builtInTypes[] = {
+                    "u8", "u16", "u32", "u64", "u128",
+                    "s8", "s16", "s32", "s64", "s128",
+                    "float", "double"
+            };
+            for (auto& k : builtInTypes) {
+                TextEditor::Identifier id;
+                id.mDeclaration = "Built-in type";
+                langDef.mIdentifiers.insert(std::make_pair(std::string(k), id));
+            }
+
+            langDef.mTokenize = [](const char * inBegin, const char * inEnd, const char *& outBegin, const char *& outEnd, TextEditor::PaletteIndex & paletteIndex) -> bool {
+                paletteIndex = TextEditor::PaletteIndex::Max;
+
+                while (inBegin < inEnd && isascii(*inBegin) && isblank(*inBegin))
+                    inBegin++;
+
+                if (inBegin == inEnd) {
+                    outBegin = inEnd;
+                    outEnd = inEnd;
+                    paletteIndex = TextEditor::PaletteIndex::Default;
+                }
+                else if (TokenizeCStyleIdentifier(inBegin, inEnd, outBegin, outEnd))
+                    paletteIndex = TextEditor::PaletteIndex::Identifier;
+                else if (TokenizeCStyleNumber(inBegin, inEnd, outBegin, outEnd))
+                    paletteIndex = TextEditor::PaletteIndex::Number;
+
+                return paletteIndex != TextEditor::PaletteIndex::Max;
+            };
+
+            langDef.mCommentStart = "/*";
+            langDef.mCommentEnd = "*/";
+            langDef.mSingleLineComment = "//";
+
+            langDef.mCaseSensitive = true;
+            langDef.mAutoIndentation = true;
+            langDef.mPreprocChar = '#';
+
+            langDef.mName = "Pattern Language";
+
+            initialized = true;
+        }
+        return langDef;
+    }
+
+
     ViewPattern::ViewPattern(prv::Provider* &dataProvider, std::vector<lang::PatternData*> &patternData)
         : View(), m_dataProvider(dataProvider), m_patternData(patternData) {
 
-        this->m_buffer = new char[0xFF'FFFF];
+        this->m_textEditor.SetLanguageDefinition(PatternLanguage());
-        std::memset(this->m_buffer, 0x00, 0xFF'FFFF);
+        this->m_textEditor.SetShowWhitespaces(false);
     }
+
     ViewPattern::~ViewPattern() {
-        if (this->m_buffer != nullptr)
+
-            delete[] this->m_buffer;
     }
 
     void ViewPattern::createMenu() {
@@ -39,25 +95,7 @@ namespace hex {
             return;
 
         if (ImGui::Begin("Pattern", &this->m_windowOpen, ImGuiWindowFlags_None)) {
-            if (this->m_buffer != nullptr && this->m_dataProvider != nullptr && this->m_dataProvider->isReadable()) {
+            this->m_textEditor.Render("Pattern");
-                ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(0, 0));
-                ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(0, 0));
-
-                auto size = ImGui::GetWindowSize();
-                size.y -= 50;
-                ImGui::InputTextMultiline("Pattern", this->m_buffer, 0xFFFF, size,
-                                          ImGuiInputTextFlags_AllowTabInput | ImGuiInputTextFlags_CallbackEdit,
-                                          [](ImGuiInputTextCallbackData *data) -> int {
-                                              auto _this = static_cast<ViewPattern *>(data->UserData);
-
-                                              _this->parsePattern(data->Buf);
-
-                                              return 0;
-                                          }, this
-                );
-
-                ImGui::PopStyleVar(2);
-            }
         }
         ImGui::End();
 
@@ -66,20 +104,23 @@ namespace hex {
             FILE *file = fopen(this->m_fileBrowser.selected_path.c_str(), "rb");
 
             if (file != nullptr) {
+                char *buffer;
                 fseek(file, 0, SEEK_END);
                 size_t size = ftell(file);
                 rewind(file);
 
-                if (size >= 0xFF'FFFF) {
+                buffer = new char[size + 1];
-                    fclose(file);
+
-                    return;
+                fread(buffer, size, 1, file);
-                }
+                buffer[size] = 0x00;
 
-                fread(this->m_buffer, size, 1, file);
 
                 fclose(file);
 
-                this->parsePattern(this->m_buffer);
+                this->parsePattern(buffer);
+                this->m_textEditor.SetText(buffer);
+
+                delete[] buffer;
             }
         }
     }