/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/
#pragma once
#include "caret.hxx"
#include <list>
/** Factor to multiple the squared horizontal distance with
* Used for Up and Down movement.
*/
#define HORIZONTICAL_DISTANCE_FACTOR 10
/** Enum of direction for movement */
enum SmMovementDirection
{
MoveUp,
MoveDown,
MoveLeft,
MoveRight
};
/** Enum of elements that can inserted into a formula */
enum SmFormulaElement
{
BlankElement,
FactorialElement,
PlusElement,
MinusElement,
CDotElement,
EqualElement,
LessThanElement,
GreaterThanElement,
PercentElement
};
/** Bracket types that can be inserted */
enum class SmBracketType
{
/** Round brackets, left command "(" */
Round,
/**Square brackets, left command "[" */
Square,
/** Curly brackets, left command "lbrace" */
Curly,
};
/** A list of nodes */
typedef std::list<SmNode*> SmNodeList;
typedef std::list<std::unique_ptr<SmNode>> SmClipboard;
class SmDocShell;
/** Formula cursor
*
* This class is used to represent a cursor in a formula, which can be used to manipulate
* a formula programmatically.
* @remarks This class is a very intimate friend of SmDocShell.
*/
class SmCursor
{
public:
SmCursor(SmNode* tree, SmDocShell* pShell)
: mpAnchor(nullptr)
, mpPosition(nullptr)
, mpTree(tree)
, mpDocShell(pShell)
, mnEditSections(0)
, mbIsEnabledSetModifiedSmDocShell(
false)
{
//Build graph
BuildGraph();
}
/** Get position */
const SmCaretPos& GetPosition()
const {
return mpPosition->CaretPos; }
/** True, if the cursor has a selection */
bool HasSelection()
const {
return mpAnchor != mpPosition; }
/** Move the position of this cursor */
void Move(OutputDevice* pDev, SmMovementDirection direction,
bool bMoveAnchor =
true);
/** Move to the caret position closest to a given point */
void MoveTo(OutputDevice* pDev,
const Point& pos,
bool bMoveAnchor);
/** Delete the current selection or do nothing */
void Delete();
/** Delete selection, previous element or merge lines
*
* This method implements the behaviour of backspace.
*/
void DeletePrev(OutputDevice* pDev);
/** Insert text at the current position */
void InsertText(
const OUString& aString);
/** Insert an element into the formula */
void InsertElement(SmFormulaElement element);
/** Insert command text translated into line entries at position
*
* Note: This method uses the parser to translate a command text into a
* tree, then it copies line entries from this tree into the current tree.
* Will not work for commands such as newline or ##, if position is in a matrix.
* This will work for stuff like "A intersection B". But stuff spanning multiple lines
* or dependent on the context which position is placed in will not work!
*/
void InsertCommandText(
const OUString& aCommandText);
/** Insert a special node created from aString
*
* Used for handling insert request from the "catalog" dialog.
* The provided string should be formatted as the desired command: %phi
* Note: this method ONLY supports commands defined in Math.xcu
*
* For more complex expressions use InsertCommandText, this method doesn't
* use SmParser, this means that it's faster, but not as strong.
*/
void InsertSpecial(std::u16string_view aString);
/** Create sub-/super script
*
* If there's a selection, it will be move into the appropriate sub-/super scription
* of the node in front of it. If there's no node in front of position (or the selection),
* a sub-/super scription of a new SmPlaceNode will be made.
*
* If there's is an existing subscription of the node, the caret will be moved into it,
* and any selection will replace it.
*/
void InsertSubSup(SmSubSup eSubSup);
/** Insert a new row or newline
*
* Inserts a new row if position is in a matrix or stack command.
* Otherwise a newline is inserted if we're in a toplevel line.
*
* @returns True, if a new row/line could be inserted.
*
* @remarks If the caret is placed in a subline of a command that doesn't support
* this operator the method returns FALSE, and doesn't do anything.
*/
bool InsertRow();
/** Insert a fraction, use selection as numerator */
void InsertFraction();
/** Create brackets around current selection, or new SmPlaceNode */
void InsertBrackets(SmBracketType eBracketType);
/** Copy the current selection */
void Copy(vcl::Window* pWindow = nullptr);
/** Cut the current selection */
void Cut(vcl::Window* pWindow = nullptr)
{
Copy(pWindow);
Delete();
}
/** Paste the clipboard */
void Paste(vcl::Window* pWindow = nullptr);
/** Returns true if more than one node is selected
*
* This method is used for implementing backspace and delete.
* If one of these causes a complex selection, e.g. a node with
* subnodes or similar, this should not be deleted immediately.
*/
bool HasComplexSelection();
/** Finds the topmost node in a visual line
*
* If MoveUpIfSelected is true, this will move up to the parent line
* if the parent of the current line is selected.
*/
static SmNode* FindTopMostNodeInLine(SmNode* pSNode,
bool MoveUpIfSelected =
false);
/** Draw the caret */
void Draw(OutputDevice& pDev, Point Offset,
bool isCaretVisible);
tools::Rectangle GetCaretRectangle(OutputDevice& rOutDev)
const;
tools::Rectangle GetSelectionRectangle(OutputDevice& rOutDev)
const;
bool IsAtTailOfBracket(SmBracketType eBracketType)
const;
private:
friend class SmDocShell;
SmCaretPosGraphEntry *mpAnchor, *mpPosition;
/** Formula tree */
SmNode* mpTree;
/** Owner of the formula tree */
SmDocShell* mpDocShell;
/** Graph over caret position in the current tree */
std::unique_ptr<SmCaretPosGraph> mpGraph;
/** Returns a node that is selected, if any could be found */
SmNode* FindSelectedNode(SmNode* pNode);
/** Is this one of the nodes used to compose a line
*
* These are SmExpression, SmBinHorNode, SmUnHorNode etc.
*/
static bool IsLineCompositionNode(SmNode
const* pNode);
/** Count number of selected nodes, excluding line composition nodes
*
* Note this function doesn't count line composition nodes and it
* does count all subnodes as well as the owner nodes.
*
* Used by SmCursor::HasComplexSelection()
*/
int CountSelectedNodes(SmNode* pNode);
/** Convert a visual line to a list
*
* Note this method will delete all the nodes that will no longer be needed.
* that includes pLine!
* This method also deletes SmErrorNode's as they're just meta info in the line.
*/
static void LineToList(SmStructureNode* pLine, SmNodeList& rList);
/** Auxiliary function for calling LineToList on a node
*
* This method sets pNode = NULL and remove it from its parent.
* (Assuming it has a parent, and is a child of it).
*/
static void NodeToList(SmNode*& rpNode, SmNodeList& rList)
{
//Remove from parent and NULL rpNode
SmNode* pNode = rpNode;
if (rpNode && rpNode->GetParent())
{
//Don't remove this, correctness relies on it
int index = rpNode->GetParent()->IndexOfSubNode(rpNode);
assert(index >= 0);
rpNode->GetParent()->SetSubNode(index, nullptr);
}
rpNode = nullptr;
//Create line from node
if (pNode && IsLineCompositionNode(pNode))
{
LineToList(
static_cast<SmStructureNode*>(pNode), rList);
return;
}
if (pNode)
rList.push_front(pNode);
}
/** Clone a visual line to a clipboard
*
* ... but the selected part only.
* Doesn't clone SmErrorNodes, which are ignored as they are context dependent metadata.
*/
static void CloneLineToClipboard(SmStructureNode* pLine, SmClipboard* pClipboard);
/** Build pGraph over caret positions */
void BuildGraph();
/** Insert new nodes in the tree after position */
void InsertNodes(std::unique_ptr<SmNodeList> pNewNodes);
/** tries to set position to a specific SmCaretPos
*
* @returns false on failure to find the position in pGraph.
*/
bool SetCaretPosition(SmCaretPos pos);
/** Set selected on nodes of the tree */
void AnnotateSelection()
const;
/** Clone list of nodes in a clipboard (creates a deep clone) */
static std::unique_ptr<SmNodeList> CloneList(SmClipboard& rClipboard);
/** Find an iterator pointing to the node in pLineList following rCaretPos
*
* If rCaretPos.pSelectedNode cannot be found it is assumed that it's in front of pLineList,
* thus not an element in pLineList. In this case this method returns an iterator to the
* first element in pLineList.
*
* If the current position is inside an SmTextNode, this node will be split in two, for this
* reason you should beaware that iterators to elements in pLineList may be invalidated, and
* that you should call PatchLineList() with this iterator if no action is taken.
*/
static SmNodeList::iterator FindPositionInLineList(SmNodeList* pLineList,
const SmCaretPos& rCaretPos);
/** Patch a line list after modification, merge SmTextNode, remove SmPlaceNode etc.
*
* @param pLineList The line list to patch
* @param aIter Iterator pointing to the element that needs to be patched with its previous.
*
* When the list is patched text nodes before and after aIter will be merged.
* If there's an, in the context, inappropriate SmPlaceNode before or after aIter it will also be
* removed.
*
* @returns A caret position equivalent to one selecting the node before aIter, the method returns
* an invalid SmCaretPos to indicate placement in front of the line.
*/
static SmCaretPos PatchLineList(SmNodeList* pLineList, SmNodeList::iterator aIter);
/** Take selected nodes from a list
*
* Puts the selected nodes into pSelectedNodes, or if pSelectedNodes is NULL deletes
* the selected nodes.
* Note: If there's a selection inside an SmTextNode this node will be split, and it
* will not be merged when the selection have been taken. Use PatchLineList on the
* iterator returns to fix this.
*
* @returns An iterator pointing to the element following the selection taken.
*/
static SmNodeList::iterator TakeSelectedNodesFromList(SmNodeList* pLineList,
SmNodeList* pSelectedNodes = nullptr);
/** Create an instance of SmMathSymbolNode usable for brackets */
static SmNode* CreateBracket(SmBracketType eBracketType,
bool bIsLeft);
/** The number of times BeginEdit have been called
* Used to allow nesting of BeginEdit() and EndEdit() sections
*/
int mnEditSections;
/** Holds data for BeginEdit() and EndEdit() */
bool mbIsEnabledSetModifiedSmDocShell;
/** Begin edit section where the tree will be modified */
void BeginEdit();
/** End edit section where the tree will be modified */
void EndEdit();
/** Finish editing
*
* Finishes editing by parsing pLineList and inserting back into pParent at nParentIndex.
* This method also rebuilds the graph, annotates the selection, sets caret position and
* Calls EndEdit.
*
* @remarks Please note that this method will delete pLineList, as the elements are taken.
*
* @param pLineList List the constitutes the edited line.
* @param pParent Parent to which the line should be inserted.
* @param nParentIndex Index in parent where the line should be inserted.
* @param PosAfterEdit Caret position to look for after rebuilding graph.
* @param pStartLine Line to take first position in, if PosAfterEdit cannot be found,
* leave it NULL for pLineList.
*/
void FinishEdit(std::unique_ptr<SmNodeList> pLineList, SmStructureNode* pParent,
int nParentIndex, SmCaretPos PosAfterEdit, SmNode* pStartLine = nullptr);
/** Request the formula is repainted */
void RequestRepaint();
};
/** Minimalistic recursive decent SmNodeList parser
*
* This parser is used to take a list of nodes that constitutes a line
* and parse them to a tree of SmBinHorNode, SmUnHorNode and SmExpression.
*
* Please note, this will not handle all kinds of nodes, only nodes that
* constitutes and entry in a line.
*
* Below is an EBNF representation of the grammar used for this parser:
* \code
* Expression -> Relation*
* Relation -> Sum [(=|<|>|...) Sum]*
* Sum -> Product [(+|-) Product]*
* Product -> Factor [(*|/) Factor]*
* Factor -> [+|-|-+|...]* Factor | Postfix
* Postfix -> node [!]*
* \endcode
*/
class SmNodeListParser
{
public:
/** Create an instance of SmNodeListParser */
SmNodeListParser() { pList = nullptr; }
/** Parse a list of nodes to an expression.
*
* Old error nodes will be deleted.
*/
SmNode* Parse(SmNodeList* list);
/** True, if the token is an operator */
static bool IsOperator(
const SmToken& token);
/** True, if the token is a relation operator */
static bool IsRelationOperator(
const SmToken& token);
/** True, if the token is a sum operator */
static bool IsSumOperator(
const SmToken& token);
/** True, if the token is a product operator */
static bool IsProductOperator(
const SmToken& token);
/** True, if the token is a unary operator */
static bool IsUnaryOperator(
const SmToken& token);
/** True, if the token is a postfix operator */
static bool IsPostfixOperator(
const SmToken& token);
private:
SmNodeList* pList;
/** Get the current terminal */
SmNode* Terminal()
{
if (!pList->empty())
return pList->front();
return nullptr;
}
/** Move to next terminal */
SmNode* Next()
{
pList->pop_front();
return Terminal();
}
/** Take the current terminal */
SmNode* Take()
{
SmNode* pRetVal = Terminal();
Next();
return pRetVal;
}
SmNode* Expression();
SmNode* Relation();
SmNode* Sum();
SmNode* Product();
SmNode* Factor();
SmNode* Postfix();
static SmNode* Error();
};
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
