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 <vector>
#include <algorithm>
#include <list>
#include <unordered_map>
 
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 TabExpand(const wxString &input_, size_t posInLine);
 
  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);
  }
  void SetFont(wxDC *dc) const;
 
  void SetForeground(wxDC *dc);
 
  void SetValue(const wxString &text) override;
 
  const wxString &GetValue() const override { return m_text; }
 
  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 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 PositionToPoint() override {return PositionToPoint(CursorPosition());}
 
  void SelectPointText(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();
 
  wxCoord GetLineWidth(size_t line, size_t pos);
 
  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) :
        m_text(text), 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;}
    private:
      wxString m_text;
      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);
    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:
  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;
  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; }
  };
 
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,
                                 const wxString &token, wxCoord &indentationPixels) const;
 
  static bool BreakAfterOperator(const wxString &token, const wxString &prevToken,
                                 const wxString &nextToken);
 
  bool IsSoftBreakBefore(std::size_t pos) const {
    return std::binary_search(m_softBreaks.begin(), m_softBreaks.end(), 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) const;
 
  History m_history;  
  void SetState(const History::HistoryEntry &state);
  std::vector<StyledText> &GetStyledText();
 
//** Large fields
//**
  typedef std::unordered_map <wxString, wxSize, wxStringHash> StringHash;
  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;
 
  std::vector<std::pair<std::size_t, std::size_t>> m_diffHighlights;
  std::size_t m_diffHighlightsTextLength = 0;
 
//** 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;
 
 
  mutable bool m_tokens_including_hidden_valid = false;
  mutable bool m_tokens_valid = false;
 
 
//** Bitfield objects (2 bytes)
//**
  void InitBitFields_EditorCell()
    { // Keep the initialization order below same as the order
      // of bit fields in this class!
      m_autoAnswer = false;
      m_containsChanges = false;
      m_containsChangesCheck = false;
      m_displayCaret = false;
      m_hasFocus = false;
      m_selectionChanged = false;
      m_underlined = false;
      m_errorIndexSet = false;
    }
 
  bool m_autoAnswer : 1 /* InitBitFields_EditorCell */;
  mutable bool m_containsChanges : 1 /* InitBitFields_EditorCell */;
  bool m_containsChangesCheck : 1 /* InitBitFields_EditorCell */;
  bool m_displayCaret : 1 /* InitBitFields_EditorCell */;
  bool m_hasFocus : 1 /* InitBitFields_EditorCell */;
  bool m_errorIndexSet : 1 /* InitBitFields_EditorCell */;
  bool m_selectionChanged : 1 /* InitBitFields_EditorCell */;
  bool m_underlined : 1 /* InitBitFields_EditorCell */;
  mutable bool m_isDirty = true /* InitBitFields_EditorCell */;
};
 
#endif // EDITORCELL_H