cursor.hxx

Go to the documentation of this file.

/* -*- 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>
 
#define HORIZONTICAL_DISTANCE_FACTOR 10
 
enum SmMovementDirection
{
    MoveUp,
    MoveDown,
    MoveLeft,
    MoveRight
};
 
enum SmFormulaElement
{
    BlankElement,
    FactorialElement,
    PlusElement,
    MinusElement,
    CDotElement,
    EqualElement,
    LessThanElement,
    GreaterThanElement,
    PercentElement
};
 
enum class SmBracketType
{
    Round,
    Square,
    Curly,
};
 
typedef std::list<SmNode*> SmNodeList;
 
typedef std::list<std::unique_ptr<SmNode>> SmClipboard;
 
class SmDocShell;
 
class SmCursor
{
public:
    SmCursor(SmNode* tree, SmDocShell* pShell)
        : mpAnchor(nullptr)
        , mpPosition(nullptr)
        , mpTree(tree)
        , mpDocShell(pShell)
        , mnEditSections(0)
        , mbIsEnabledSetModifiedSmDocShell(false)
    {
        //Build graph
        BuildGraph();
    }
 
    const SmCaretPos& GetPosition() const { return mpPosition->CaretPos; }
 
    bool HasSelection() const { return mpAnchor != mpPosition; }
 
    void Move(OutputDevice* pDev, SmMovementDirection direction, bool bMoveAnchor = true);
 
    void MoveTo(OutputDevice* pDev, const Point& pos, bool bMoveAnchor);
 
    void Delete();
 
    void DeletePrev(OutputDevice* pDev);
 
    void InsertText(const OUString& aString);
 
    void InsertElement(SmFormulaElement element);
 
    void InsertCommandText(const OUString& aCommandText);
 
    void InsertSpecial(std::u16string_view aString);
 
    void InsertSubSup(SmSubSup eSubSup);
 
    bool InsertRow();
 
    void InsertFraction();
 
    void InsertBrackets(SmBracketType eBracketType);
 
    void Copy();
    void Cut()
    {
        Copy();
        Delete();
    }
    void Paste();
 
    bool HasComplexSelection();
 
    static SmNode* FindTopMostNodeInLine(SmNode* pSNode, bool MoveUpIfSelected = false);
 
    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;
    SmNode* mpTree;
    SmDocShell* mpDocShell;
    std::unique_ptr<SmCaretPosGraph> mpGraph;
    SmClipboard maClipboard;
 
    SmNode* FindSelectedNode(SmNode* pNode);
 
    static bool IsLineCompositionNode(SmNode const* pNode);
 
    int CountSelectedNodes(SmNode* pNode);
 
    static void LineToList(SmStructureNode* pLine, SmNodeList& rList);
 
    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);
    }
 
    static void CloneLineToClipboard(SmStructureNode* pLine, SmClipboard* pClipboard);
 
    void BuildGraph();
 
    void InsertNodes(std::unique_ptr<SmNodeList> pNewNodes);
 
    bool SetCaretPosition(SmCaretPos pos);
 
    void AnnotateSelection() const;
 
    static std::unique_ptr<SmNodeList> CloneList(SmClipboard& rClipboard);
 
    static SmNodeList::iterator FindPositionInLineList(SmNodeList* pLineList,
                                                       const SmCaretPos& rCaretPos);
 
    static SmCaretPos PatchLineList(SmNodeList* pLineList, SmNodeList::iterator aIter);
 
    static SmNodeList::iterator TakeSelectedNodesFromList(SmNodeList* pLineList,
                                                          SmNodeList* pSelectedNodes = nullptr);
 
    static SmNode* CreateBracket(SmBracketType eBracketType, bool bIsLeft);
 
    int mnEditSections;
    bool mbIsEnabledSetModifiedSmDocShell;
    void BeginEdit();
    void EndEdit();
    void FinishEdit(std::unique_ptr<SmNodeList> pLineList, SmStructureNode* pParent,
                    int nParentIndex, SmCaretPos PosAfterEdit, SmNode* pStartLine = nullptr);
    void RequestRepaint();
};
 
class SmNodeListParser
{
public:
    SmNodeListParser() { pList = nullptr; }
    SmNode* Parse(SmNodeList* list);
    static bool IsOperator(const SmToken& token);
    static bool IsRelationOperator(const SmToken& token);
    static bool IsSumOperator(const SmToken& token);
    static bool IsProductOperator(const SmToken& token);
    static bool IsUnaryOperator(const SmToken& token);
    static bool IsPostfixOperator(const SmToken& token);
 
private:
    SmNodeList* pList;
    SmNode* Terminal()
    {
        if (!pList->empty())
            return pList->front();
        return nullptr;
    }
    SmNode* Next()
    {
        pList->pop_front();
        return 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: */