mirrors/ladybird
1
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-01-24 02:03:06 -05:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Libraries/LibGUI/GTextDocument.h

176 lines
5.5 KiB
C
Raw Normal View History

LibGUI: Move GTextDocument out of GTextEditor The idea here is to decouple the document from the editor widget so you could have multiple editors being views onto the same document. This doesn't work yet, since the document and editor are coupled in various ways still (including a per-line back-pointer to the editor.)
2019-10-27 16:10:07 +01:00
#pragma once
LibGUI: Support multiple GTextEditors editing the same GTextDocument With this patch, you can now assign the same GTextDocument to multiple GTextEditor widgets via GTextEditor::set_document(). The editors have independent cursors and selection, but all changes are shared, and immediately propagate to all editors. This is very unoptimized and will do lots of unnecessary invalidation, especially line re-wrapping and repainting over and over again.
2019-10-27 19:36:59 +01:00
#include <AK/Badge.h>
LibGUI: Move visual line metadata from GTextDocument to GTextEditor This patch decouples GTextDocument and GTextDocumentLine from the line wrapping functionality of GTextEditor. This should basically make it possible to have multiple GTextEditors editing the same GTextDocument. Of course, that will require a bit more work since there's no paint invalidation yet.
2019-10-27 18:00:07 +01:00
#include <AK/HashTable.h>
LibGUI: Move GTextDocument out of GTextEditor The idea here is to decouple the document from the editor widget so you could have multiple editors being views onto the same document. This doesn't work yet, since the document and editor are coupled in various ways still (including a per-line back-pointer to the editor.)
2019-10-27 16:10:07 +01:00
#include <AK/NonnullOwnPtrVector.h>
#include <AK/NonnullRefPtr.h>
#include <AK/RefCounted.h>
LibGUI: Move the undo stack from GTextEditor to GTextDocument Since the same document can be edited by multiple editors, we need to keep the undo stack with the document for coherency.
2019-11-30 13:05:17 +01:00
#include <LibCore/CTimer.h>
LibGUI: Move GTextDocument out of GTextEditor The idea here is to decouple the document from the editor widget so you could have multiple editors being views onto the same document. This doesn't work yet, since the document and editor are coupled in various ways still (including a per-line back-pointer to the editor.)
2019-10-27 16:10:07 +01:00
#include <LibDraw/Color.h>
#include <LibDraw/Font.h>
#include <LibGUI/GTextRange.h>
LibGUI: Add GUndoStack and GCommand classes This patch converts the undo stack from GTextDocument into GUndoStack, and GTextDocumentUndoCommand now inherits from GCommand. Let's turn this into a generic mechanism that can be used to implement undo/redo in any application. :^)
2019-11-30 15:36:17 +01:00
#include <LibGUI/GUndoStack.h>
LibGUI: Move GTextDocument out of GTextEditor The idea here is to decouple the document from the editor widget so you could have multiple editors being views onto the same document. This doesn't work yet, since the document and editor are coupled in various ways still (including a per-line back-pointer to the editor.)
2019-10-27 16:10:07 +01:00
class GTextEditor;
LibGUI: Move the undo stack from GTextEditor to GTextDocument Since the same document can be edited by multiple editors, we need to keep the undo stack with the document for coherency.
2019-11-30 13:05:17 +01:00
class GTextDocument;
LibGUI: Move GTextDocument out of GTextEditor The idea here is to decouple the document from the editor widget so you could have multiple editors being views onto the same document. This doesn't work yet, since the document and editor are coupled in various ways still (including a per-line back-pointer to the editor.)
2019-10-27 16:10:07 +01:00
class GTextDocumentLine;
struct GTextDocumentSpan {
GTextRange range;
Color color;
HackStudio+LibGUI: Implement matching curly brace highlighting This works for C++ syntax highlighted text documents by caching the C++ token type in a new "arbitrary data" member of GTextDocumentSpan. When the cursor is placed immediately before a '{' or immediately after a '}', we highlight both of these brace buddies by changing their corresponding spans to have a different background color. ..and spans can also now have a custom background color. :^)
2019-11-18 19:10:06 +01:00
Optional<Color> background_color;
GTextEditor: Allow GTextDocumentSpans to be "skippable" Setting the is_skippable flag on a GTextDocumentSpan will now cause the cursor to skip over that span when moving with Ctrl+Left/Right.
2019-11-15 20:36:45 +01:00
bool is_skippable { false };
LibGUI: Move GTextDocument out of GTextEditor The idea here is to decouple the document from the editor widget so you could have multiple editors being views onto the same document. This doesn't work yet, since the document and editor are coupled in various ways still (including a per-line back-pointer to the editor.)
2019-10-27 16:10:07 +01:00
const Font* font { nullptr };
HackStudio+LibGUI: Implement matching curly brace highlighting This works for C++ syntax highlighted text documents by caching the C++ token type in a new "arbitrary data" member of GTextDocumentSpan. When the cursor is placed immediately before a '{' or immediately after a '}', we highlight both of these brace buddies by changing their corresponding spans to have a different background color. ..and spans can also now have a custom background color. :^)
2019-11-18 19:10:06 +01:00
void* data { nullptr };
LibGUI: Move GTextDocument out of GTextEditor The idea here is to decouple the document from the editor widget so you could have multiple editors being views onto the same document. This doesn't work yet, since the document and editor are coupled in various ways still (including a per-line back-pointer to the editor.)
2019-10-27 16:10:07 +01:00
};
LibGUI: Add GUndoStack and GCommand classes This patch converts the undo stack from GTextDocument into GUndoStack, and GTextDocumentUndoCommand now inherits from GCommand. Let's turn this into a generic mechanism that can be used to implement undo/redo in any application. :^)
2019-11-30 15:36:17 +01:00
class GTextDocumentUndoCommand : public GCommand {
LibGUI: Move the undo stack from GTextEditor to GTextDocument Since the same document can be edited by multiple editors, we need to keep the undo stack with the document for coherency.
2019-11-30 13:05:17 +01:00
public:
GTextDocumentUndoCommand(GTextDocument&);
virtual ~GTextDocumentUndoCommand();
protected:
GTextDocument& m_document;
};
LibGUI: Consolidate and simplify commands used for insertion/removal This patch adds InsertTextCommand and RemoveTextCommand. These two commands are used to ... insert and remove text :^) The bulk of the logic is moved into GTextDocument, and we now use the command's redo() virtual to perform the action. Or in other words, when you type into the text editor, we create an InsertTextCommand, push it onto the undo stack, and call redo() on it immediately. That's how the text gets inserted. This makes it quite easy to implement more commands, as there is no distinction between a redo() and the initial application.
2019-11-30 16:50:24 +01:00
class InsertTextCommand : public GTextDocumentUndoCommand {
LibGUI: Move the undo stack from GTextEditor to GTextDocument Since the same document can be edited by multiple editors, we need to keep the undo stack with the document for coherency.
2019-11-30 13:05:17 +01:00
public:
LibGUI: Consolidate and simplify commands used for insertion/removal This patch adds InsertTextCommand and RemoveTextCommand. These two commands are used to ... insert and remove text :^) The bulk of the logic is moved into GTextDocument, and we now use the command's redo() virtual to perform the action. Or in other words, when you type into the text editor, we create an InsertTextCommand, push it onto the undo stack, and call redo() on it immediately. That's how the text gets inserted. This makes it quite easy to implement more commands, as there is no distinction between a redo() and the initial application.
2019-11-30 16:50:24 +01:00
InsertTextCommand(GTextDocument&, const String&, const GTextPosition&);
LibGUI: Move the undo stack from GTextEditor to GTextDocument Since the same document can be edited by multiple editors, we need to keep the undo stack with the document for coherency.
2019-11-30 13:05:17 +01:00
virtual void undo() override;
virtual void redo() override;
private:
LibGUI: Consolidate and simplify commands used for insertion/removal This patch adds InsertTextCommand and RemoveTextCommand. These two commands are used to ... insert and remove text :^) The bulk of the logic is moved into GTextDocument, and we now use the command's redo() virtual to perform the action. Or in other words, when you type into the text editor, we create an InsertTextCommand, push it onto the undo stack, and call redo() on it immediately. That's how the text gets inserted. This makes it quite easy to implement more commands, as there is no distinction between a redo() and the initial application.
2019-11-30 16:50:24 +01:00
String m_text;
GTextRange m_range;
LibGUI: Move the undo stack from GTextEditor to GTextDocument Since the same document can be edited by multiple editors, we need to keep the undo stack with the document for coherency.
2019-11-30 13:05:17 +01:00
};
LibGUI: Consolidate and simplify commands used for insertion/removal This patch adds InsertTextCommand and RemoveTextCommand. These two commands are used to ... insert and remove text :^) The bulk of the logic is moved into GTextDocument, and we now use the command's redo() virtual to perform the action. Or in other words, when you type into the text editor, we create an InsertTextCommand, push it onto the undo stack, and call redo() on it immediately. That's how the text gets inserted. This makes it quite easy to implement more commands, as there is no distinction between a redo() and the initial application.
2019-11-30 16:50:24 +01:00
class RemoveTextCommand : public GTextDocumentUndoCommand {
LibGUI: Move the undo stack from GTextEditor to GTextDocument Since the same document can be edited by multiple editors, we need to keep the undo stack with the document for coherency.
2019-11-30 13:05:17 +01:00
public:
LibGUI: Consolidate and simplify commands used for insertion/removal This patch adds InsertTextCommand and RemoveTextCommand. These two commands are used to ... insert and remove text :^) The bulk of the logic is moved into GTextDocument, and we now use the command's redo() virtual to perform the action. Or in other words, when you type into the text editor, we create an InsertTextCommand, push it onto the undo stack, and call redo() on it immediately. That's how the text gets inserted. This makes it quite easy to implement more commands, as there is no distinction between a redo() and the initial application.
2019-11-30 16:50:24 +01:00
RemoveTextCommand(GTextDocument&, const String&, const GTextRange&);
LibGUI: Move the undo stack from GTextEditor to GTextDocument Since the same document can be edited by multiple editors, we need to keep the undo stack with the document for coherency.
2019-11-30 13:05:17 +01:00
virtual void undo() override;
virtual void redo() override;
private:
LibGUI: Consolidate and simplify commands used for insertion/removal This patch adds InsertTextCommand and RemoveTextCommand. These two commands are used to ... insert and remove text :^) The bulk of the logic is moved into GTextDocument, and we now use the command's redo() virtual to perform the action. Or in other words, when you type into the text editor, we create an InsertTextCommand, push it onto the undo stack, and call redo() on it immediately. That's how the text gets inserted. This makes it quite easy to implement more commands, as there is no distinction between a redo() and the initial application.
2019-11-30 16:50:24 +01:00
String m_text;
GTextRange m_range;
LibGUI: Move the undo stack from GTextEditor to GTextDocument Since the same document can be edited by multiple editors, we need to keep the undo stack with the document for coherency.
2019-11-30 13:05:17 +01:00
};
LibGUI: Move GTextDocument out of GTextEditor The idea here is to decouple the document from the editor widget so you could have multiple editors being views onto the same document. This doesn't work yet, since the document and editor are coupled in various ways still (including a per-line back-pointer to the editor.)
2019-10-27 16:10:07 +01:00
class GTextDocument : public RefCounted<GTextDocument> {
public:
LibGUI: Move text search functions from GTextEditor to GTextDocument Also add a find_all() that retuns a Vector<GTextRange> and simply does a find_next() loop, returning all the matching ranges.
2019-11-01 19:19:39 +01:00
enum class SearchShouldWrap {
No = 0,
Yes
};
LibGUI: Move visual line metadata from GTextDocument to GTextEditor This patch decouples GTextDocument and GTextDocumentLine from the line wrapping functionality of GTextEditor. This should basically make it possible to have multiple GTextEditors editing the same GTextDocument. Of course, that will require a bit more work since there's no paint invalidation yet.
2019-10-27 18:00:07 +01:00
class Client {
public:
virtual ~Client();
virtual void document_did_append_line() = 0;
AK: Use size_t for the length of strings Using int was a mistake. This patch changes String, StringImpl, StringView and StringBuilder to use size_t instead of int for lengths. Obviously a lot of code needs to change as a result of this.
2019-12-09 17:45:40 +01:00
virtual void document_did_insert_line(size_t) = 0;
virtual void document_did_remove_line(size_t) = 0;
LibGUI: Move visual line metadata from GTextDocument to GTextEditor This patch decouples GTextDocument and GTextDocumentLine from the line wrapping functionality of GTextEditor. This should basically make it possible to have multiple GTextEditors editing the same GTextDocument. Of course, that will require a bit more work since there's no paint invalidation yet.
2019-10-27 18:00:07 +01:00
virtual void document_did_remove_all_lines() = 0;
LibGUI: Support multiple GTextEditors editing the same GTextDocument With this patch, you can now assign the same GTextDocument to multiple GTextEditor widgets via GTextEditor::set_document(). The editors have independent cursors and selection, but all changes are shared, and immediately propagate to all editors. This is very unoptimized and will do lots of unnecessary invalidation, especially line re-wrapping and repainting over and over again.
2019-10-27 19:36:59 +01:00
virtual void document_did_change() = 0;
LibGUI: Don't recompute line-wrapping over and over during set_text() This makes the TextEditor start up fast for large files again.
2019-11-23 17:41:14 +01:00
virtual void document_did_set_text() = 0;
LibGUI: Move the undo stack from GTextEditor to GTextDocument Since the same document can be edited by multiple editors, we need to keep the undo stack with the document for coherency.
2019-11-30 13:05:17 +01:00
virtual void document_did_set_cursor(const GTextPosition&) = 0;
LibGUI: Move visual line metadata from GTextDocument to GTextEditor This patch decouples GTextDocument and GTextDocumentLine from the line wrapping functionality of GTextEditor. This should basically make it possible to have multiple GTextEditors editing the same GTextDocument. Of course, that will require a bit more work since there's no paint invalidation yet.
2019-10-27 18:00:07 +01:00
};
static NonnullRefPtr<GTextDocument> create(Client* client = nullptr)
LibGUI: Move GTextDocument out of GTextEditor The idea here is to decouple the document from the editor widget so you could have multiple editors being views onto the same document. This doesn't work yet, since the document and editor are coupled in various ways still (including a per-line back-pointer to the editor.)
2019-10-27 16:10:07 +01:00
{
LibGUI: Move visual line metadata from GTextDocument to GTextEditor This patch decouples GTextDocument and GTextDocumentLine from the line wrapping functionality of GTextEditor. This should basically make it possible to have multiple GTextEditors editing the same GTextDocument. Of course, that will require a bit more work since there's no paint invalidation yet.
2019-10-27 18:00:07 +01:00
return adopt(*new GTextDocument(client));
LibGUI: Move GTextDocument out of GTextEditor The idea here is to decouple the document from the editor widget so you could have multiple editors being views onto the same document. This doesn't work yet, since the document and editor are coupled in various ways still (including a per-line back-pointer to the editor.)
2019-10-27 16:10:07 +01:00
}
AK: Use size_t for the length of strings Using int was a mistake. This patch changes String, StringImpl, StringView and StringBuilder to use size_t instead of int for lengths. Obviously a lot of code needs to change as a result of this.
2019-12-09 17:45:40 +01:00
size_t line_count() const { return (size_t)m_lines.size(); }
const GTextDocumentLine& line(size_t line_index) const { return m_lines[(int)line_index]; }
GTextDocumentLine& line(size_t line_index) { return m_lines[(int)line_index]; }
LibGUI: Move GTextDocument out of GTextEditor The idea here is to decouple the document from the editor widget so you could have multiple editors being views onto the same document. This doesn't work yet, since the document and editor are coupled in various ways still (including a per-line back-pointer to the editor.)
2019-10-27 16:10:07 +01:00
void set_spans(const Vector<GTextDocumentSpan>& spans) { m_spans = spans; }
void set_text(const StringView&);
const NonnullOwnPtrVector<GTextDocumentLine>& lines() const { return m_lines; }
NonnullOwnPtrVector<GTextDocumentLine>& lines() { return m_lines; }
bool has_spans() const { return !m_spans.is_empty(); }
const Vector<GTextDocumentSpan>& spans() const { return m_spans; }
AK: Use size_t for the length of strings Using int was a mistake. This patch changes String, StringImpl, StringView and StringBuilder to use size_t instead of int for lengths. Obviously a lot of code needs to change as a result of this.
2019-12-09 17:45:40 +01:00
void set_span_at_index(size_t index, GTextDocumentSpan span) { m_spans[(int)index] = move(span); }
LibGUI: Move GTextDocument out of GTextEditor The idea here is to decouple the document from the editor widget so you could have multiple editors being views onto the same document. This doesn't work yet, since the document and editor are coupled in various ways still (including a per-line back-pointer to the editor.)
2019-10-27 16:10:07 +01:00
LibGUI: Move visual line metadata from GTextDocument to GTextEditor This patch decouples GTextDocument and GTextDocumentLine from the line wrapping functionality of GTextEditor. This should basically make it possible to have multiple GTextEditors editing the same GTextDocument. Of course, that will require a bit more work since there's no paint invalidation yet.
2019-10-27 18:00:07 +01:00
void append_line(NonnullOwnPtr<GTextDocumentLine>);
AK: Use size_t for the length of strings Using int was a mistake. This patch changes String, StringImpl, StringView and StringBuilder to use size_t instead of int for lengths. Obviously a lot of code needs to change as a result of this.
2019-12-09 17:45:40 +01:00
void remove_line(size_t line_index);
LibGUI: Move visual line metadata from GTextDocument to GTextEditor This patch decouples GTextDocument and GTextDocumentLine from the line wrapping functionality of GTextEditor. This should basically make it possible to have multiple GTextEditors editing the same GTextDocument. Of course, that will require a bit more work since there's no paint invalidation yet.
2019-10-27 18:00:07 +01:00
void remove_all_lines();
AK: Use size_t for the length of strings Using int was a mistake. This patch changes String, StringImpl, StringView and StringBuilder to use size_t instead of int for lengths. Obviously a lot of code needs to change as a result of this.
2019-12-09 17:45:40 +01:00
void insert_line(size_t line_index, NonnullOwnPtr<GTextDocumentLine>);
LibGUI: Move visual line metadata from GTextDocument to GTextEditor This patch decouples GTextDocument and GTextDocumentLine from the line wrapping functionality of GTextEditor. This should basically make it possible to have multiple GTextEditors editing the same GTextDocument. Of course, that will require a bit more work since there's no paint invalidation yet.
2019-10-27 18:00:07 +01:00
void register_client(Client&);
void unregister_client(Client&);
LibGUI: Support multiple GTextEditors editing the same GTextDocument With this patch, you can now assign the same GTextDocument to multiple GTextEditor widgets via GTextEditor::set_document(). The editors have independent cursors and selection, but all changes are shared, and immediately propagate to all editors. This is very unoptimized and will do lots of unnecessary invalidation, especially line re-wrapping and repainting over and over again.
2019-10-27 19:36:59 +01:00
void update_views(Badge<GTextDocumentLine>);
LibGUI: Add GTextDocument::text_in_range(GTextRange) This function returns a String containing the text in a given range. GTextEditor::selected_text() is now just a wrapper around this.
2019-10-29 21:36:47 +01:00
String text_in_range(const GTextRange&) const;
LibGUI: Move text search functions from GTextEditor to GTextDocument Also add a find_all() that retuns a Vector<GTextRange> and simply does a find_next() loop, returning all the matching ranges.
2019-11-01 19:19:39 +01:00
Vector<GTextRange> find_all(const StringView& needle) const;
GTextRange find_next(const StringView&, const GTextPosition& start = {}, SearchShouldWrap = SearchShouldWrap::Yes) const;
GTextRange find_previous(const StringView&, const GTextPosition& start = {}, SearchShouldWrap = SearchShouldWrap::Yes) const;
GTextPosition next_position_after(const GTextPosition&, SearchShouldWrap = SearchShouldWrap::Yes) const;
GTextPosition previous_position_before(const GTextPosition&, SearchShouldWrap = SearchShouldWrap::Yes) const;
char character_at(const GTextPosition&) const;
GTextEditor: Allow GTextDocumentSpans to be "skippable" Setting the is_skippable flag on a GTextDocumentSpan will now cause the cursor to skip over that span when moving with Ctrl+Left/Right.
2019-11-15 20:36:45 +01:00
Optional<GTextDocumentSpan> first_non_skippable_span_before(const GTextPosition&) const;
Optional<GTextDocumentSpan> first_non_skippable_span_after(const GTextPosition&) const;
LibGUI: Move the undo stack from GTextEditor to GTextDocument Since the same document can be edited by multiple editors, we need to keep the undo stack with the document for coherency.
2019-11-30 13:05:17 +01:00
void add_to_undo_stack(NonnullOwnPtr<GTextDocumentUndoCommand>);
LibGUI: Add GUndoStack and GCommand classes This patch converts the undo stack from GTextDocument into GUndoStack, and GTextDocumentUndoCommand now inherits from GCommand. Let's turn this into a generic mechanism that can be used to implement undo/redo in any application. :^)
2019-11-30 15:36:17 +01:00
bool can_undo() const { return m_undo_stack.can_undo(); }
bool can_redo() const { return m_undo_stack.can_redo(); }
LibGUI: Move the undo stack from GTextEditor to GTextDocument Since the same document can be edited by multiple editors, we need to keep the undo stack with the document for coherency.
2019-11-30 13:05:17 +01:00
void undo();
void redo();
void notify_did_change();
void set_all_cursors(const GTextPosition&);
LibGUI: Consolidate and simplify commands used for insertion/removal This patch adds InsertTextCommand and RemoveTextCommand. These two commands are used to ... insert and remove text :^) The bulk of the logic is moved into GTextDocument, and we now use the command's redo() virtual to perform the action. Or in other words, when you type into the text editor, we create an InsertTextCommand, push it onto the undo stack, and call redo() on it immediately. That's how the text gets inserted. This makes it quite easy to implement more commands, as there is no distinction between a redo() and the initial application.
2019-11-30 16:50:24 +01:00
GTextPosition insert_at(const GTextPosition&, char);
GTextPosition insert_at(const GTextPosition&, const StringView&);
void remove(const GTextRange&);
LibGUI: Move GTextDocument out of GTextEditor The idea here is to decouple the document from the editor widget so you could have multiple editors being views onto the same document. This doesn't work yet, since the document and editor are coupled in various ways still (including a per-line back-pointer to the editor.)
2019-10-27 16:10:07 +01:00
private:
LibGUI: Move visual line metadata from GTextDocument to GTextEditor This patch decouples GTextDocument and GTextDocumentLine from the line wrapping functionality of GTextEditor. This should basically make it possible to have multiple GTextEditors editing the same GTextDocument. Of course, that will require a bit more work since there's no paint invalidation yet.
2019-10-27 18:00:07 +01:00
explicit GTextDocument(Client* client);
LibGUI: Move GTextDocument out of GTextEditor The idea here is to decouple the document from the editor widget so you could have multiple editors being views onto the same document. This doesn't work yet, since the document and editor are coupled in various ways still (including a per-line back-pointer to the editor.)
2019-10-27 16:10:07 +01:00
LibGUI: Move the undo stack from GTextEditor to GTextDocument Since the same document can be edited by multiple editors, we need to keep the undo stack with the document for coherency.
2019-11-30 13:05:17 +01:00
void update_undo_timer();
LibGUI: Move GTextDocument out of GTextEditor The idea here is to decouple the document from the editor widget so you could have multiple editors being views onto the same document. This doesn't work yet, since the document and editor are coupled in various ways still (including a per-line back-pointer to the editor.)
2019-10-27 16:10:07 +01:00
NonnullOwnPtrVector<GTextDocumentLine> m_lines;
Vector<GTextDocumentSpan> m_spans;
LibGUI: Move visual line metadata from GTextDocument to GTextEditor This patch decouples GTextDocument and GTextDocumentLine from the line wrapping functionality of GTextEditor. This should basically make it possible to have multiple GTextEditors editing the same GTextDocument. Of course, that will require a bit more work since there's no paint invalidation yet.
2019-10-27 18:00:07 +01:00
HashTable<Client*> m_clients;
LibGUI: Don't recompute line-wrapping over and over during set_text() This makes the TextEditor start up fast for large files again.
2019-11-23 17:41:14 +01:00
bool m_client_notifications_enabled { true };
LibGUI: Move the undo stack from GTextEditor to GTextDocument Since the same document can be edited by multiple editors, we need to keep the undo stack with the document for coherency.
2019-11-30 13:05:17 +01:00
LibGUI: Add GUndoStack and GCommand classes This patch converts the undo stack from GTextDocument into GUndoStack, and GTextDocumentUndoCommand now inherits from GCommand. Let's turn this into a generic mechanism that can be used to implement undo/redo in any application. :^)
2019-11-30 15:36:17 +01:00
GUndoStack m_undo_stack;
LibGUI: Move the undo stack from GTextEditor to GTextDocument Since the same document can be edited by multiple editors, we need to keep the undo stack with the document for coherency.
2019-11-30 13:05:17 +01:00
RefPtr<CTimer> m_undo_timer;
LibGUI: Move GTextDocument out of GTextEditor The idea here is to decouple the document from the editor widget so you could have multiple editors being views onto the same document. This doesn't work yet, since the document and editor are coupled in various ways still (including a per-line back-pointer to the editor.)
2019-10-27 16:10:07 +01:00
};
class GTextDocumentLine {
friend class GTextEditor;
friend class GTextDocument;
public:
LibGUI: Support multiple GTextEditors editing the same GTextDocument With this patch, you can now assign the same GTextDocument to multiple GTextEditor widgets via GTextEditor::set_document(). The editors have independent cursors and selection, but all changes are shared, and immediately propagate to all editors. This is very unoptimized and will do lots of unnecessary invalidation, especially line re-wrapping and repainting over and over again.
2019-10-27 19:36:59 +01:00
explicit GTextDocumentLine(GTextDocument&);
explicit GTextDocumentLine(GTextDocument&, const StringView&);
LibGUI: Move GTextDocument out of GTextEditor The idea here is to decouple the document from the editor widget so you could have multiple editors being views onto the same document. This doesn't work yet, since the document and editor are coupled in various ways still (including a per-line back-pointer to the editor.)
2019-10-27 16:10:07 +01:00
AK: Use size_t for the length of strings Using int was a mistake. This patch changes String, StringImpl, StringView and StringBuilder to use size_t instead of int for lengths. Obviously a lot of code needs to change as a result of this.
2019-12-09 17:45:40 +01:00
StringView view() const { return { characters(), (size_t)length() }; }
LibGUI: Move GTextDocument out of GTextEditor The idea here is to decouple the document from the editor widget so you could have multiple editors being views onto the same document. This doesn't work yet, since the document and editor are coupled in various ways still (including a per-line back-pointer to the editor.)
2019-10-27 16:10:07 +01:00
const char* characters() const { return m_text.data(); }
AK: Use size_t for the length of strings Using int was a mistake. This patch changes String, StringImpl, StringView and StringBuilder to use size_t instead of int for lengths. Obviously a lot of code needs to change as a result of this.
2019-12-09 17:45:40 +01:00
size_t length() const { return (size_t)m_text.size() - 1; }
LibGUI: Support multiple GTextEditors editing the same GTextDocument With this patch, you can now assign the same GTextDocument to multiple GTextEditor widgets via GTextEditor::set_document(). The editors have independent cursors and selection, but all changes are shared, and immediately propagate to all editors. This is very unoptimized and will do lots of unnecessary invalidation, especially line re-wrapping and repainting over and over again.
2019-10-27 19:36:59 +01:00
void set_text(GTextDocument&, const StringView&);
void append(GTextDocument&, char);
void prepend(GTextDocument&, char);
AK: Use size_t for the length of strings Using int was a mistake. This patch changes String, StringImpl, StringView and StringBuilder to use size_t instead of int for lengths. Obviously a lot of code needs to change as a result of this.
2019-12-09 17:45:40 +01:00
void insert(GTextDocument&, size_t index, char);
void remove(GTextDocument&, size_t index);
void append(GTextDocument&, const char*, size_t);
void truncate(GTextDocument&, size_t length);
LibGUI: Support multiple GTextEditors editing the same GTextDocument With this patch, you can now assign the same GTextDocument to multiple GTextEditor widgets via GTextEditor::set_document(). The editors have independent cursors and selection, but all changes are shared, and immediately propagate to all editors. This is very unoptimized and will do lots of unnecessary invalidation, especially line re-wrapping and repainting over and over again.
2019-10-27 19:36:59 +01:00
void clear(GTextDocument&);
AK: Use size_t for the length of strings Using int was a mistake. This patch changes String, StringImpl, StringView and StringBuilder to use size_t instead of int for lengths. Obviously a lot of code needs to change as a result of this.
2019-12-09 17:45:40 +01:00
size_t first_non_whitespace_column() const;
LibGUI: Move GTextDocument out of GTextEditor The idea here is to decouple the document from the editor widget so you could have multiple editors being views onto the same document. This doesn't work yet, since the document and editor are coupled in various ways still (including a per-line back-pointer to the editor.)
2019-10-27 16:10:07 +01:00
private:
// NOTE: This vector is null terminated.
Vector<char> m_text;
};
Reference in a new issue Copy permalink