EditorCell.h

Go to the documentation of this file.

// -*- mode: c++; c-file-style: "linux"; c-basic-offset: 2; indent-tabs-mode: nil -*-
//
//  Copyright (C) 2006-2015 Andrej Vodopivec <andrej.vodopivec@gmail.com>
//            (C) 2012 Doug Ilijev <doug.ilijev@gmail.com>
//            (C) 2014-2015 Gunter Königsmann <wxMaxima@physikbuch.de>
//
//  This program is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2 of the License, or
//  (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//
//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software
//  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//
//  SPDX-License-Identifier: GPL-2.0+
 
#ifndef EDITORCELL_H
#define EDITORCELL_H
 
#include "Cell.h"
#include "FontAttribs.h"
#include "MaximaTokenizer.h"
#include "TextFormat.h"
#include <wx/dataobj.h>
#include <array>
#include <optional>
#include <vector>
#include <algorithm>
#include <list>
#include <unordered_map>
#include <utility>
 
struct BidiRun;
 
class EditorCell : public Cell
{
private:
#if wxUSE_ACCESSIBILITY
  wxAccStatus GetName (int childId, wxString *name) const override;
  wxAccStatus GetDescription(int childId, wxString *description) const override;
  wxAccStatus GetFocus (int *childId, Cell **child) const override;
  wxAccStatus GetDefaultAction(int childId, wxString *actionName) const override;
  wxAccStatus GetValue (int childId, wxString *strValue) const override;
  wxAccStatus GetRole (int childId, wxAccRole *role) const override;
  wxAccStatus GetState (int childId, long *state) const override;
#endif
 
public:
  EditorCell(GroupCell *group, Configuration *config, wxString text = {});
  EditorCell(GroupCell *group, const EditorCell &cell);
 
  static std::unique_ptr<EditorCell> Create(GroupCell *group,
                                            Configuration *config, CellType type,
                                            wxString text = {});
 
  static bool IsCodeType(CellType type);
 
  virtual bool IsCodeEditor() const { return false; }
  void UpdateSelectionString();
  // The selection/cursor setters clamp their argument to a valid index into the
  // current text via ClampToText(), so m_selectionStart / m_selectionEnd are
  // always in [0, m_text.Length()] (e.g. CursorMove(-n) past the start clamps to
  // 0 instead of wrapping a size_t to a huge value). The getters below keep a
  // defensive std::min as well, because the text can still shrink *after* a
  // selection was set without the selection being updated.
  void SetSelection(size_t start, size_t end){m_selectionStart = ClampToText(start); m_selectionEnd = ClampToText(end); UpdateSelectionString();}
  bool SelectionActive() const {return m_selectionStart != m_selectionEnd;}
  void ClearSelection() {SelectionEnd(SelectionEnd());}
  void SelectionStart(size_t start) {m_selectionStart = ClampToText(start); UpdateSelectionString();}
  void SelectionEnd(size_t end) {m_selectionEnd = ClampToText(end); UpdateSelectionString();}
  size_t SelectionStart() const {return std::min(m_selectionStart, m_text.Length());}
  size_t SelectionEnd() const {return std::min(m_selectionEnd, m_text.Length());}
  size_t SelectionLeft() const {return std::min(SelectionStart(), SelectionEnd());}
  size_t SelectionRight() const {return std::max(SelectionStart(), SelectionEnd());}
  size_t SelectionLength() const {return(SelectionEnd()-SelectionStart());}
  void  SelectionLength(size_t length) {SelectionEnd(SelectionStart() + length);  UpdateSelectionString();}
  void CursorMove(long long increment) {m_selectionEnd = ClampToText(static_cast<long long>(m_selectionEnd) + increment);
    m_selectionStart = m_selectionEnd; UpdateSelectionString();}
  size_t CursorPosition() const {return std::min(m_selectionEnd, m_text.Length());}
  void CursorPosition(size_t pos) {m_selectionStart = ClampToText(pos);
    m_selectionEnd = m_selectionStart; UpdateSelectionString();}
  const CellTypeInfo &GetInfo() override;
  std::unique_ptr<Cell> Copy(GroupCell *group) const override;
 
  // cppcheck-suppress duplInheritedMember
  EditorCell *GetPrevious() const { return dynamic_cast<EditorCell*>(Cell::GetPrevious()); }
  // cppcheck-suppress duplInheritedMember
  EditorCell *GetNext() const { return dynamic_cast<EditorCell*>(Cell::GetNext()); }
 
  void InsertEscCommand(const wxString &txt) {
    InsertText(InterpretEscapeString(txt));
  }
 
  wxString GetFullCommandUnderCursor();
 
  void AddDrawParameter(wxString param);
 
  void AutoAnswer(bool autoAnswer){m_autoAnswer = autoAnswer;}
 
  void SearchStartedHere(size_t index) const;
  void SearchStartedHere() const;
  void MouseSelectionStartedHere() const;
  void KeyboardSelectionStartedHere() const;
 
  const auto &GetWordList() const { return m_wordList; }
 
  static wxString NormalizeLineEndings(const wxString &input_);
 
  static wxString EscapeHTMLChars(wxString input);
 
  static wxString PrependNBSP(wxString input);
 
  void Recalculate(const AFontSize fontsize) const override;
 
  using Cell::SetCurrentPoint;
  void SetCurrentPoint(wxPoint point) const override;
  virtual void Draw(wxDC *dc, wxDC *antialiassingDC) override;
 
  wxString ToHTML() const;
  wxString ToMatlab() const override;
  wxString ToMatlab(bool dontLimitToSelection) const;
  wxString ToRTF() const override;
  wxString ToString() const override;
  wxString ToString(bool dontLimitToSelection) const;
  wxString ToTeX() const override;
  wxString ToXML() const override;
 
  const wxFont &GetFont() const {
    return m_configuration->GetStyle(GetTextStyle())->GetFont(m_fontSize_Scaled);
  }
  const wxFont &GetFont(TextFormat::Format format) const;
  void SetFont(wxDC *dc) const;
 
  void SetForeground(wxDC *dc);
 
  void SetValue(const wxString &text) override;
 
  const wxString &GetValue() const override { return m_text; }
 
  bool CanFormat() const { return !IsCodeEditor(); }
  const TextFormat::Formats &GetFormats() const;
  void SetFormats(TextFormat::Formats formats);
  bool HasFormat(TextFormat::Format flag) const;
  bool ToggleFormat(TextFormat::Format flag);
  void SetUnknownLineAttributes(std::vector<std::pair<wxString, wxString>> attributes);
  void CopyFormatsFrom(const EditorCell &source);
  wxString SelectionToXML() const;
  wxString FormattedRTF(size_t start, size_t end, bool markDown) const;
  wxString FormattedHTML(size_t start, size_t end) const;
  wxString SelectionToRTF() const;
  wxString SelectionToHTML() const;
  bool InsertXML(const wxString &xml);
  bool InsertHTML(const wxString &html, wxString plainText = wxEmptyString);
  static wxDataFormat FormattedTextDataFormat();
 
  const std::vector<std::size_t> &GetSoftBreaks() const { return m_softBreaks; }
 
  void SetDiffHighlights(std::vector<std::pair<std::size_t, std::size_t>> ranges) {
    m_diffHighlights = std::move(ranges);
    m_diffHighlightsTextLength = m_text.Length();
  }
  const std::vector<std::pair<std::size_t, std::size_t>> &GetDiffHighlights() const {
    return m_diffHighlights;
  }
 
  void AddErrorStatement(std::size_t start, std::size_t end);
  void AddErrorSpot(std::size_t start, std::size_t end);
  void ClearErrorMarks();
  const std::vector<std::pair<std::size_t, std::size_t>> &GetErrorStatements() const;
  const std::vector<std::pair<std::size_t, std::size_t>> &GetErrorSpots() const;
  bool ErrorMarksValid() const {
    return m_errorMarks && (m_text == m_errorMarks->text);
  }
 
  void StyleText() const;
  void StyleTextCode() const;
  void StyleTextTexts() const;
 
protected:
  virtual void StyleTypedText() const;
 
  virtual wxString PreprocessNewValue(const wxString &text,
                                      std::size_t &cursorPos) const;
 
  virtual wxString XMLTypeAttribute() const;
 
public:
  void Reset();
 
  void ProcessEvent(wxKeyEvent &event) override;
 
  bool ActivateCursor();
 
  void DeactivateCursor();
 
  size_t BeginningOfLine(size_t pos) const;
 
  size_t EndOfLine(size_t pos);
 
  bool AddEnding() override;
 
  void PositionToXY(size_t position,  size_t *x, size_t *y);
 
  size_t XYToPosition(size_t x, size_t y);
 
  wxPoint PositionToPoint(size_t pos) override;
  wxPoint LineColumnToPoint(size_t line, size_t column, size_t pos);
  wxPoint PositionToPoint() override {return PositionToPoint(CursorPosition());}
 
  void SelectPointText(wxPoint point) override;
 
  wxString GetLinkAt(wxPoint point) override;
 
  void SelectRectText(wxPoint one, wxPoint two) override;
 
  wxString SelectWordUnderCaret(bool selectParens = true, bool toRight = true,
                                bool includeDoubleQuotes = false);
 
  bool IsPointInSelection(wxPoint point);
 
  bool CopyToClipboard() const override;
 
  bool CutToClipboard() override;
 
  void PasteFromClipboard(bool primary = false) override;
 
  size_t GetSelectionStart() const
    { return SelectionStart(); }
 
  long GetSelectionEnd() const
    { return SelectionEnd(); }
 
  void SelectAll() override
    {
      SetSelection(0, m_text.Length());
    }
 
  bool AllSelected() const
    {
      return (SelectionStart() == 0) && (SelectionEnd() == m_text.Length());
    }
 
  void SelectNone()
    {
      ClearSelection();
    }
 
 
  bool CanCopy() const override
    {
      return SelectionActive();
    }
 
  bool FindMatchingQuotes();
 
  void FindMatchingParens();
 
  std::pair<long, long> GetMatchingParens() const { return {m_paren1, m_paren2}; }
 
  wxCoord GetLineWidth(size_t line, size_t pos);
 
  wxCoord DigitGroupGapWidth() const;
  wxSize GetTextSize(const wxString &text) const;
 
  wxCoord NextTabStop(wxCoord startX) const;
 
  wxCoord MeasureTextWidth(wxCoord startX, const wxString &text) const;
 
  static bool IsStrongRightToLeft(wxUniChar c);
 
  static bool IsStrongLeftToRight(wxUniChar c);
 
  bool LineIsRightToLeft(size_t line);
 
  bool LineIsMixedDirection(size_t line);
 
  size_t LineLength(size_t line);
 
  wxPoint SelectionLineSpan(size_t lineStart, size_t lineEnd, wxCoord *width);
 
  bool GetLineBidiRuns(size_t line, std::vector<BidiRun> *runs);
 
  bool MixedDirectionOffset(size_t line, size_t position, wxCoord *offset);
 
  std::vector<wxCoord> RightToLeftLineOffsets();
 
  wxCoord RightToLeftLineOffset(size_t line);
 
  bool IsDirty() const override
    {
      return m_isDirty;
    }
 
  void SwitchCaretDisplay() override
    {
      m_displayCaret = !m_displayCaret;
    }
 
  void SetFocus(bool focus) override
    {
      m_hasFocus = focus;
    }
 
  bool IsActive() const override;
 
  bool CaretAtStart() const
    { return CursorPosition() == 0; }
 
  void CaretToStart();
 
  bool CaretAtEnd() const
    { return CursorPosition() == m_text.Length(); }
 
  void CaretToEnd();
 
  void CaretToPosition(size_t pos);
 
  bool CanUndo() const {return m_history.CanUndo();}
 
  void Undo();
 
  bool CanRedo() const {return m_history.CanRedo();}
 
  void Redo();
 
  class History
  {
  public:
    enum Action : uintptr_t {
      any = 0,
      removeChar  = 1,
      addChar = 2
    };
 
    class HistoryEntry // 64 bytes
    {
    public:
      HistoryEntry(){};
      HistoryEntry(const wxString &text, long long selStart, long long selEnd,
                   TextFormat::Formats formats = {}) :
        m_text(text), m_formats(std::move(formats)), m_selStart(selStart), m_selEnd(selEnd) {}
      long long SelectionStart() const {return m_selStart;}
      long long SelectionEnd() const {return m_selEnd;}
      wxString GetText() const {return m_text;}
      const TextFormat::Formats &GetFormats() const {return m_formats;}
      bool SameContent(const HistoryEntry &other) const
        {return (m_text == other.m_text) && (m_formats == other.m_formats);}
    private:
      wxString m_text;
      TextFormat::Formats m_formats;
      long long m_selStart = -1;
      long long m_selEnd = -1;
    };
    bool AddState(HistoryEntry entry, Action action = any);
    bool AddState(const wxString &text, long long selStart, long long selEnd, Action action = any,
                  TextFormat::Formats formats = {});
    bool Undo();
    bool Redo();
    bool CanUndo() const;
    bool CanRedo() const;
    void ClearUndoBuffer();
    HistoryEntry GetState() const;
  private:
    std::vector<HistoryEntry> m_history;
    size_t m_historyPosition = 0;
    Action m_lastAction = any;
  };
 
  void SaveValue(History::Action action = History::Action::any);
 
  wxString DivideAtCaret();
 
  void CommentSelection();
 
  bool ContainsChanges() const
    { return m_containsChanges; }
 
  void ContainsChanges(bool changes)
    { m_containsChanges = m_containsChangesCheck = changes; }
 
  bool CheckChanges();
 
  size_t ReplaceAll(wxString oldString, const wxString &newString, bool ignoreCase);
  size_t ReplaceAll_RegEx(const wxString &oldString, const wxString &newString);
 
  bool FindNext(wxString str, const bool &down, const bool &ignoreCase);
  bool FindNext_RegEx(wxString str, const bool &down);
 
  bool IsSelectionChanged() const { return m_selectionChanged; }
 
  void GetSelection(size_t *start, size_t *end) const
    {
      *start = SelectionStart();
      *end   = SelectionEnd();
    }
 
  bool ReplaceSelection(const wxString &oldStr, const wxString &newString,
                        bool keepSelected = false, bool ignoreCase = false,
                        bool replaceMaximaString = false);
  bool ReplaceSelection_RegEx(const wxString &oldStr, const wxString &newString);
 
  wxString GetSelectionString() const;
 
  TextStyle GetSelectionStyle() const;
 
  wxString GetWordUnderCaret();
 
  wxString GetCurrentCommand() const;
 
  void SetErrorIndex(size_t index){m_errorIndex = index; m_errorIndexSet = true;}
  void ClearErrorIndex(){m_errorIndexSet = false;}
 
  bool ErrorIndexSet() const {return m_errorIndexSet;}
 
  void GotoError(){SetCaretPosition(m_errorIndex); ActivateCursor(); ClearErrorIndex();}
 
  void ProcessNewline(bool keepCursorAtStartOfLine = true);
 
  size_t GetCaretPosition() const
    { return CursorPosition(); }
 
  void ConvertNumToUNicodeChar();
 
  void SetCaretPosition(size_t pos){CursorPosition(pos);}
 
  bool FindNextTemplate(bool left = false);
 
  void InsertText(wxString text);
 
  wxString TextInFrontOfSelection() const
    {
      return GetValue().Left(SelectionLeft());
    }
 
  void ReturnToSelectionFromTop()
    {
      SetSelection(m_lastSelectionStart, 0);
    }
 
  void SetType(CellType type) override;
  void SetStyle(TextStyle style) override;
 
  bool NeedsRecalculation(AFontSize fontSize) const override;
 
  void ReturnToSelectionFromBot()
    {
      SetSelection(m_lastSelectionStart, m_text.Length());
    }
 
//  const MaximaTokenizer::TokenList &GetDisplayedTokens() const;
  const MaximaTokenizer::TokenList &GetAllTokens() const;
 
private:
  void InsertFormatted(const wxString &text, const TextFormat::Formats &pasted);
  void PushTextLine(const wxString &line, const wxString &indentChar,
                    std::size_t startPos) const;
  wxCoord PushCodeLine(TextStyle style, const wxString &line) const;
  void PushTextRun(const wxString &run, const wxString &indentChar,
                   std::size_t startPos) const;
  void PushFormattedPiece(const wxString &piece, const wxString &indentChar,
                          std::size_t startPos, bool isLink) const;
 
  template <typename SnippetFunc>
  void WalkDrawnSnippets(wxDC *dc, SnippetFunc &&onSnippet);
 
  size_t ClampToText(long long pos) const {
    if (pos < 0)
      return 0;
    return std::min(static_cast<size_t>(pos), m_text.Length());
  }
  size_t m_selectionStart = 0;
  size_t m_selectionEnd = 0;
  size_t m_lastSelectionStart = 0;
protected:
  class StyledText
  {
  private:
    wxString m_text;
    TextStyle m_style = TS_CODE_DEFAULT;
    wxString m_indentChar;
    mutable CachedInteger<wxCoord> m_width;
    wxCoord m_indentPixels = 0;
    bool m_styleThisText = false;
    bool m_isLink = false;
    TextFormat::Format m_format = TextFormat::None;
    wxCoord m_yOffset = 0;
  public:
    StyledText(TextStyle style, const wxString &text)
      : m_text(text), m_style(style), m_styleThisText(true) {}
 
    explicit StyledText(const wxString &text, TextStyle style, wxCoord indentPixels = 0,
                        const wxString &indentChar = {})
      : m_text(text), m_style(style), m_indentChar(indentChar), m_indentPixels(indentPixels)  {}
 
    void SetWidth(wxCoord width){m_width = width;}
    void ResetSize(){m_width.Invalidate();}
    wxCoord GetWidth() const {return m_width;}
    bool SizeKnown() const {return m_width.IsValid();}
    const wxString &GetText() const { return m_text; }
    void SetText(const wxString &text) { m_text = text; }
    void SetIndentation(wxCoord indentPixels, const wxString &indentString = {})
      {
        m_indentPixels = indentPixels;
        m_indentChar = indentString;
      }
    wxCoord GetIndentPixels() const { return m_indentPixels; }
    const wxString &GetIndentChar() const { return m_indentChar; }
    TextStyle GetTextStyle() const { return m_style; }
    // Has an individual text style been set for this text portion?
    bool IsStyleSet() const { return m_styleThisText; }
    bool IsLink() const { return m_isLink; }
    void SetLink() { m_isLink = true; }
    TextFormat::Format GetFormat() const { return m_format; }
    void SetFormat(TextFormat::Format format) { m_format = format; }
    wxCoord GetYOffset() const { return m_yOffset; }
    void SetYOffset(wxCoord yOffset) { m_yOffset = yOffset; }
    const std::vector<size_t> &GetDigitGaps() const { return m_digitGaps; }
    void SetDigitGaps(std::vector<size_t> gaps) { m_digitGaps = std::move(gaps); }
  private:
    std::vector<size_t> m_digitGaps;
  };
 
private:
#if defined __WXOSX__
  bool HandleCtrlCommand(wxKeyEvent &ev);
#endif
  bool HandleSpecialKey(wxKeyEvent &event);
  bool HandleOrdinaryKey(wxKeyEvent &event);
 
  void FontsChanged() const override
    {
      m_widths.clear();
    }
 
  struct SoftBreakCandidate {
    std::size_t snippetIdx = 0;
    std::size_t textPos = 0;
    bool insert = false; 
    bool valid = false;
  };
 
  void HandleSoftLineBreaks_Code(SoftBreakCandidate &candidate, wxCoord &lineWidth,
                                 wxCoord tokenWidth, wxCoord &indentationPixels) const;
 
  wxCoord SnippetWidth(const StyledText &snippet, size_t length) const;
  wxCoord SnippetWidth(const StyledText &snippet) const {
    return SnippetWidth(snippet, snippet.GetText().Length());
  }
  void DrawSnippetText(wxDC *dc, const StyledText &snippet, wxCoord x,
                       wxCoord y) const;
  wxCoord DigitGapsWidthIn(size_t from, size_t to) const;
 
  static bool BreakAfterOperator(const wxString &token, const wxString &prevToken,
                                 const wxString &nextToken);
 
  bool IsSoftBreakBefore(std::size_t pos) const {
    return std::ranges::binary_search(m_softBreaks, pos);
  }
 
  size_t GetIndentDepth(wxString text, size_t  positionOfCaret) const;
 
  static wxString InterpretEscapeString(const wxString &txt);
 
  void MarkSelection(wxDC *dc, size_t start, size_t end, TextStyle style);
 
  wxSize GetTextSize(const wxString &text, TextFormat::Format format) const;
  wxCoord MeasureTextWidth(wxCoord startX, const wxString &text,
                           std::size_t startPos) const;
  void SyncFormats() const;
 
  struct LineSlot {
    wxCoord top = 0;
    wxCoord above = 0;
    wxCoord below = 0;
  };
  static constexpr double g_superSubscriptScale = 0.65;
  static wxCoord BaselineShift(TextFormat::Format format, wxCoord plainAscent);
  wxCoord LineTop(size_t line) const;
  void LineSlotExtent(size_t line, wxCoord *top, wxCoord *height) const;
  size_t LineAt(wxCoord y) const;
 
  History m_history;  
  void SetState(const History::HistoryEntry &state);
  std::vector<StyledText> &GetStyledText();
 
//** Large fields
//**
  using StringHash = std::unordered_map<wxString, wxSize, wxStringHash>;
  mutable StringHash m_widths;
 
  mutable std::vector<wxString> m_wordList;
 
  mutable MaximaTokenizer::TokenList m_tokens;
  mutable MaximaTokenizer::TokenList m_tokens_including_hidden;
 
  mutable wxString m_text;
protected:
  mutable std::vector<StyledText> m_styledText;
private:
 
  mutable std::vector<std::size_t> m_softBreaks;
  mutable std::vector<std::size_t> m_digitGapPositions;
 
  struct FormatState {
    TextFormat::Formats formats;
    wxString formatsText;
    TextFormat::Format pendingFormat = TextFormat::None;
    std::size_t pendingPos = 0;
    bool hasPending = false;
    std::vector<std::pair<wxString, wxString>> unknownLineAttributes;
    std::array<std::optional<wxFont>, TextFormat::FontVariants> fonts;
    std::optional<wxFont> fontsBase;
  };
  mutable std::unique_ptr<FormatState> m_formatState;
  mutable std::vector<LineSlot> m_lineSlots;
  FormatState &GetFormatState() const;
 
  std::vector<std::pair<std::size_t, std::size_t>> m_diffHighlights;
  std::size_t m_diffHighlightsTextLength = 0;
  struct ErrorMarks {
    std::vector<std::pair<std::size_t, std::size_t>> statements;
    std::vector<std::pair<std::size_t, std::size_t>> spots;
    wxString text;
  };
  std::unique_ptr<ErrorMarks> m_errorMarks;
 
//** 8/4 bytes
//**
  DocumentCellPointers *const m_documentCellPointers = GetDocumentCellPointers();
  ViewCellPointers *const m_viewCellPointers = GetViewCellPointers();
 
//** 4 bytes
//**
  size_t m_errorIndex = 1;
  mutable size_t m_numberOfLines = 1;
  mutable wxCoord m_charHeight = 12;
  long m_paren1 = -1, m_paren2 = -1;
 
//** 2 bytes
//**
  AFontStyle m_fontStyle;
  AFontWeight m_fontWeight;
 
//** Bitfield objects (2 bytes)
//**
  bool m_autoAnswer : 1 = false;
  mutable bool m_containsChanges : 1 = false;
  bool m_containsChangesCheck : 1 = false;
  bool m_displayCaret : 1 = false;
  bool m_hasFocus : 1 = false;
  bool m_errorIndexSet : 1 = false;
  bool m_selectionChanged : 1 = false;
  bool m_underlined : 1 = false;
  mutable bool m_tokens_including_hidden_valid : 1 = false;
  mutable bool m_tokens_valid : 1 = false;
  mutable bool m_containsLinks : 1 = false;
  mutable bool m_isDirty : 1 = true;
};
 
#endif // EDITORCELL_H