starmath/inc/visitors.hxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  */
   9 #ifndef SMVISITORS_H
  10 #define SMVISITORS_H
  11
  12 #include "node.hxx"
  13 #include "caret.hxx"
  14
  15 /** Base class for visitors that visits a tree of SmNodes
  16  * @remarks all methods have been left abstract to ensure that implementers
  17  * don't forget to implement one.
  18  */
  19 class SmVisitor
  20 {
  21 public:
  22     virtual void Visit( SmTableNode* pNode ) = 0;
  23     virtual void Visit( SmBraceNode* pNode ) = 0;
  24     virtual void Visit( SmBracebodyNode* pNode ) = 0;
  25     virtual void Visit( SmOperNode* pNode ) = 0;
  26     virtual void Visit( SmAlignNode* pNode ) = 0;
  27     virtual void Visit( SmAttributNode* pNode ) = 0;
  28     virtual void Visit( SmFontNode* pNode ) = 0;
  29     virtual void Visit( SmUnHorNode* pNode ) = 0;
  30     virtual void Visit( SmBinHorNode* pNode ) = 0;
  31     virtual void Visit( SmBinVerNode* pNode ) = 0;
  32     virtual void Visit( SmBinDiagonalNode* pNode ) = 0;
  33     virtual void Visit( SmSubSupNode* pNode ) = 0;
  34     virtual void Visit( SmMatrixNode* pNode ) = 0;
  35     virtual void Visit( SmPlaceNode* pNode ) = 0;
  36     virtual void Visit( SmTextNode* pNode ) = 0;
  37     virtual void Visit( SmSpecialNode* pNode ) = 0;
  38     virtual void Visit( SmGlyphSpecialNode* pNode ) = 0;
  39     virtual void Visit( SmMathSymbolNode* pNode ) = 0;
  40     virtual void Visit( SmBlankNode* pNode ) = 0;
  41     virtual void Visit( SmErrorNode* pNode ) = 0;
  42     virtual void Visit( SmLineNode* pNode ) = 0;
  43     virtual void Visit( SmExpressionNode* pNode ) = 0;
  44     virtual void Visit( SmPolyLineNode* pNode ) = 0;
  45     virtual void Visit( SmRootNode* pNode ) = 0;
  46     virtual void Visit( SmRootSymbolNode* pNode ) = 0;
  47     virtual void Visit( SmRectangleNode* pNode ) = 0;
  48     virtual void Visit( SmVerticalBraceNode* pNode ) = 0;
  49
  50 protected:
  51     ~SmVisitor() {}
  52 };
  53
  54 /** Simple visitor for testing SmVisitor */
  55 class SmVisitorTest : public SmVisitor
  56 {
  57 public:
  58     virtual ~SmVisitorTest() {}
  59     void Visit( SmTableNode* pNode );
  60     void Visit( SmBraceNode* pNode );
  61     void Visit( SmBracebodyNode* pNode );
  62     void Visit( SmOperNode* pNode );
  63     void Visit( SmAlignNode* pNode );
  64     void Visit( SmAttributNode* pNode );
  65     void Visit( SmFontNode* pNode );
  66     void Visit( SmUnHorNode* pNode );
  67     void Visit( SmBinHorNode* pNode );
  68     void Visit( SmBinVerNode* pNode );
  69     void Visit( SmBinDiagonalNode* pNode );
  70     void Visit( SmSubSupNode* pNode );
  71     void Visit( SmMatrixNode* pNode );
  72     void Visit( SmPlaceNode* pNode );
  73     void Visit( SmTextNode* pNode );
  74     void Visit( SmSpecialNode* pNode );
  75     void Visit( SmGlyphSpecialNode* pNode );
  76     void Visit( SmMathSymbolNode* pNode );
  77     void Visit( SmBlankNode* pNode );
  78     void Visit( SmErrorNode* pNode );
  79     void Visit( SmLineNode* pNode );
  80     void Visit( SmExpressionNode* pNode );
  81     void Visit( SmPolyLineNode* pNode );
  82     void Visit( SmRootNode* pNode );
  83     void Visit( SmRootSymbolNode* pNode );
  84     void Visit( SmRectangleNode* pNode );
  85     void Visit( SmVerticalBraceNode* pNode );
  86 private:
  87     /** Auxiliary method for visiting the children of a pNode */
  88     void VisitChildren( SmNode* pNode );
  89 };
  90
  91 /////////////////////////////// SmDefaultingVisitor ////////////////////////////////
  92
  93
  94 /** Visitor that uses DefaultVisit for handling visits by default
  95  *
  96  * This abstract baseclass is useful for visitors where many methods share the same
  97  * implementation.
  98  */
  99 class SmDefaultingVisitor : public SmVisitor
 100 {
 101 public:
 102     void Visit( SmTableNode* pNode );
 103     void Visit( SmBraceNode* pNode );
 104     void Visit( SmBracebodyNode* pNode );
 105     void Visit( SmOperNode* pNode );
 106     void Visit( SmAlignNode* pNode );
 107     void Visit( SmAttributNode* pNode );
 108     void Visit( SmFontNode* pNode );
 109     void Visit( SmUnHorNode* pNode );
 110     void Visit( SmBinHorNode* pNode );
 111     void Visit( SmBinVerNode* pNode );
 112     void Visit( SmBinDiagonalNode* pNode );
 113     void Visit( SmSubSupNode* pNode );
 114     void Visit( SmMatrixNode* pNode );
 115     void Visit( SmPlaceNode* pNode );
 116     void Visit( SmTextNode* pNode );
 117     void Visit( SmSpecialNode* pNode );
 118     void Visit( SmGlyphSpecialNode* pNode );
 119     void Visit( SmMathSymbolNode* pNode );
 120     void Visit( SmBlankNode* pNode );
 121     void Visit( SmErrorNode* pNode );
 122     void Visit( SmLineNode* pNode );
 123     void Visit( SmExpressionNode* pNode );
 124     void Visit( SmPolyLineNode* pNode );
 125     void Visit( SmRootNode* pNode );
 126     void Visit( SmRootSymbolNode* pNode );
 127     void Visit( SmRectangleNode* pNode );
 128     void Visit( SmVerticalBraceNode* pNode );
 129 protected:
 130     ~SmDefaultingVisitor() {}
 131
 132     /** Method invoked by Visit methods by default */
 133     virtual void DefaultVisit( SmNode* pNode ) = 0;
 134 };
 135
 136 /////////////////////////////// SmCaretDrawingVisitor ////////////////////////////////
 137
 138 /** Visitor for drawing a caret position */
 139 class SmCaretDrawingVisitor : public SmDefaultingVisitor
 140 {
 141 public:
 142     /** Given position and device this constructor will draw the caret */
 143     SmCaretDrawingVisitor( OutputDevice& rDevice, SmCaretPos position, Point offset, bool caretVisible );
 144     virtual ~SmCaretDrawingVisitor() {}
 145     void Visit( SmTextNode* pNode );
 146     using SmDefaultingVisitor::Visit;
 147 private:
 148     OutputDevice &rDev;
 149     SmCaretPos pos;
 150     /** Offset to draw from */
 151     Point Offset;
 152     bool isCaretVisible;
 153 protected:
 154     /** Default method for drawing pNodes */
 155     void DefaultVisit( SmNode* pNode );
 156 };
 157
 158 /////////////////////////////// SmCaretPos2LineVisitor ////////////////////////////////
 159
 160 /** Visitor getting a line from a caret position */
 161 class SmCaretPos2LineVisitor : public SmDefaultingVisitor
 162 {
 163 public:
 164     /** Given position and device this constructor will compute a line for the caret */
 165     SmCaretPos2LineVisitor( OutputDevice *pDevice, SmCaretPos position ) {
 166         pDev = pDevice;
 167         pos = position;
 168         OSL_ENSURE( position.IsValid( ), "Cannot draw invalid position!" );
 169
 170         pos.pSelectedNode->Accept( this );
 171     }
 172     virtual ~SmCaretPos2LineVisitor() {}
 173     void Visit( SmTextNode* pNode );
 174     using SmDefaultingVisitor::Visit;
 175     SmCaretLine GetResult( ){
 176         return line;
 177     }
 178 private:
 179     SmCaretLine line;
 180     OutputDevice *pDev;
 181     SmCaretPos pos;
 182 protected:
 183     /** Default method for computing lines for pNodes */
 184     void DefaultVisit( SmNode* pNode );
 185 };
 186
 187 /////////////////////////////// SmDrawingVisitor ////////////////////////////////
 188
 189 /** Visitor for drawing SmNodes to OutputDevice */
 190 class SmDrawingVisitor : public SmVisitor
 191 {
 192 public:
 193     /** Create an instance of SmDrawingVisitor, and use it to draw a formula
 194      * @param rDevice   Device to draw on
 195      * @param position  Offset on device to draw the formula
 196      * @param pTree     Formula tree to draw
 197      * @remarks This constructor will do the drawing, no need to anything more.
 198      */
 199     SmDrawingVisitor( OutputDevice &rDevice, Point position, SmNode* pTree )
 200         : rDev( rDevice ) {
 201         this->Position = position;
 202         pTree->Accept( this );
 203     }
 204     virtual ~SmDrawingVisitor() {}
 205     void Visit( SmTableNode* pNode );
 206     void Visit( SmBraceNode* pNode );
 207     void Visit( SmBracebodyNode* pNode );
 208     void Visit( SmOperNode* pNode );
 209     void Visit( SmAlignNode* pNode );
 210     void Visit( SmAttributNode* pNode );
 211     void Visit( SmFontNode* pNode );
 212     void Visit( SmUnHorNode* pNode );
 213     void Visit( SmBinHorNode* pNode );
 214     void Visit( SmBinVerNode* pNode );
 215     void Visit( SmBinDiagonalNode* pNode );
 216     void Visit( SmSubSupNode* pNode );
 217     void Visit( SmMatrixNode* pNode );
 218     void Visit( SmPlaceNode* pNode );
 219     void Visit( SmTextNode* pNode );
 220     void Visit( SmSpecialNode* pNode );
 221     void Visit( SmGlyphSpecialNode* pNode );
 222     void Visit( SmMathSymbolNode* pNode );
 223     void Visit( SmBlankNode* pNode );
 224     void Visit( SmErrorNode* pNode );
 225     void Visit( SmLineNode* pNode );
 226     void Visit( SmExpressionNode* pNode );
 227     void Visit( SmPolyLineNode* pNode );
 228     void Visit( SmRootNode* pNode );
 229     void Visit( SmRootSymbolNode* pNode );
 230     void Visit( SmRectangleNode* pNode );
 231     void Visit( SmVerticalBraceNode* pNode );
 232 private:
 233     /** Draw the children of a pNode
 234      * This the default method, use by most pNodes
 235      */
 236     void DrawChildren( SmNode* pNode );
 237
 238     /** Draw an SmTextNode or a subclass of this */
 239     void DrawTextNode( SmTextNode* pNode );
 240     /** Draw an SmSpecialNode or a subclass of this  */
 241     void DrawSpecialNode( SmSpecialNode* pNode );
 242     /** OutputDevice to draw on */
 243     OutputDevice& rDev;
 244     /** Position to draw on the rDev
 245      * @remarks This variable is used to pass parameters in DrawChildren( ), this means
 246                 that after a call to DrawChildren( ) the contents of this method is undefined
 247                 so if needed cache it locally on the stack.
 248      */
 249     Point Position;
 250 };
 251
 252 /////////////////////////////// SmSetSelectionVisitor ////////////////////////////////
 253
 254 /** Set Selection Visitor
 255  * Sets the IsSelected( ) property on all SmNodes of the tree
 256  */
 257 class SmSetSelectionVisitor : public SmDefaultingVisitor
 258 {
 259 public:
 260     SmSetSelectionVisitor( SmCaretPos startPos, SmCaretPos endPos, SmNode* pNode);
 261     virtual ~SmSetSelectionVisitor() {}
 262     void Visit( SmBinHorNode* pNode );
 263     void Visit( SmUnHorNode* pNode );
 264     void Visit( SmFontNode* pNode );
 265     void Visit( SmTextNode* pNode );
 266     void Visit( SmExpressionNode* pNode );
 267     void Visit( SmLineNode* pNode );
 268     void Visit( SmAlignNode* pNode );
 269     using SmDefaultingVisitor::Visit;
 270     /** Set IsSelected on all pNodes of pSubTree */
 271     static void SetSelectedOnAll( SmNode* pSubTree, bool IsSelected = true );
 272 private:
 273     /** Visit a selectable pNode
 274      * Can be used to handle pNodes that can be selected, that doesn't have more SmCaretPos'
 275      * than 0 and 1 inside them. SmTextNode should be handle separately!
 276      * Also note that pNodes such as SmBinVerNode cannot be selected, don't this method for
 277      * it.
 278      */
 279     void DefaultVisit( SmNode* pNode );
 280     void VisitCompositionNode( SmNode* pNode );
 281     /** Caret position where the selection starts */
 282     SmCaretPos  StartPos;
 283     /** Caret position where the selection ends */
 284     SmCaretPos  EndPos;
 285     /** The current state of this visitor
 286      * This property changes when the visitor meets either StartPos
 287      * or EndPos. This means that anything visited in between will be
 288      * selected.
 289      */
 290     bool IsSelecting;
 291 };
 292
 293
 294 /////////////////////////////// SmCaretPosGraphBuildingVisitor ////////////////////////////////
 295
 296
 297 /** A visitor for building a SmCaretPosGraph
 298  *
 299  * Visit invariant:
 300  * Each pNode, except SmExpressionNode, SmBinHorNode and a few others, constitues an entry
 301  * in a line. Consider the line entry "H", this entry creates one carat position, here
 302  * denoted by | in "H|".
 303  *
 304  * Parameter variables:
 305  *  The following variables are used to transfer parameters in to calls and results out
 306  *  of calls.
 307  *      pRightMost : SmCaretPosGraphEntry*
 308  *
 309  * Prior to a Visit call:
 310  *  pRightMost: A pointer to right most position in front of the current line entry.
 311  *
 312  * After a Visit call:
 313  *  pRightMost: A pointer to the right most position in the called line entry, if no there's
 314  *              no caret positions in called line entry don't change this variable.
 315  */
 316 class SmCaretPosGraphBuildingVisitor : public SmVisitor
 317 {
 318 public:
 319     /** Builds a caret position graph for pRootNode */
 320     SmCaretPosGraphBuildingVisitor( SmNode* pRootNode );
 321     virtual ~SmCaretPosGraphBuildingVisitor() {}
 322     void Visit( SmTableNode* pNode );
 323     void Visit( SmBraceNode* pNode );
 324     void Visit( SmBracebodyNode* pNode );
 325     void Visit( SmOperNode* pNode );
 326     void Visit( SmAlignNode* pNode );
 327     void Visit( SmAttributNode* pNode );
 328     void Visit( SmFontNode* pNode );
 329     void Visit( SmUnHorNode* pNode );
 330     void Visit( SmBinHorNode* pNode );
 331     void Visit( SmBinVerNode* pNode );
 332     void Visit( SmBinDiagonalNode* pNode );
 333     void Visit( SmSubSupNode* pNode );
 334     void Visit( SmMatrixNode* pNode );
 335     void Visit( SmPlaceNode* pNode );
 336     void Visit( SmTextNode* pNode );
 337     void Visit( SmSpecialNode* pNode );
 338     void Visit( SmGlyphSpecialNode* pNode );
 339     void Visit( SmMathSymbolNode* pNode );
 340     void Visit( SmBlankNode* pNode );
 341     void Visit( SmErrorNode* pNode );
 342     void Visit( SmLineNode* pNode );
 343     void Visit( SmExpressionNode* pNode );
 344     void Visit( SmPolyLineNode* pNode );
 345     void Visit( SmRootNode* pNode );
 346     void Visit( SmRootSymbolNode* pNode );
 347     void Visit( SmRectangleNode* pNode );
 348     void Visit( SmVerticalBraceNode* pNode );
 349     SmCaretPosGraph* Graph( ){
 350         return pGraph;
 351     }
 352 private:
 353     SmCaretPosGraphEntry* pRightMost;
 354     SmCaretPosGraph*      pGraph;
 355 };
 356
 357 /////////////////////////////// SmCloningVisitor ///////////////////////////////
 358
 359 /** Visitor for cloning a pNode
 360  *
 361  * This visitor creates deep clones.
 362  */
 363 class SmCloningVisitor : public SmVisitor
 364 {
 365 public:
 366     SmCloningVisitor( ){ pResult = NULL; }
 367     virtual ~SmCloningVisitor() {}
 368     void Visit( SmTableNode* pNode );
 369     void Visit( SmBraceNode* pNode );
 370     void Visit( SmBracebodyNode* pNode );
 371     void Visit( SmOperNode* pNode );
 372     void Visit( SmAlignNode* pNode );
 373     void Visit( SmAttributNode* pNode );
 374     void Visit( SmFontNode* pNode );
 375     void Visit( SmUnHorNode* pNode );
 376     void Visit( SmBinHorNode* pNode );
 377     void Visit( SmBinVerNode* pNode );
 378     void Visit( SmBinDiagonalNode* pNode );
 379     void Visit( SmSubSupNode* pNode );
 380     void Visit( SmMatrixNode* pNode );
 381     void Visit( SmPlaceNode* pNode );
 382     void Visit( SmTextNode* pNode );
 383     void Visit( SmSpecialNode* pNode );
 384     void Visit( SmGlyphSpecialNode* pNode );
 385     void Visit( SmMathSymbolNode* pNode );
 386     void Visit( SmBlankNode* pNode );
 387     void Visit( SmErrorNode* pNode );
 388     void Visit( SmLineNode* pNode );
 389     void Visit( SmExpressionNode* pNode );
 390     void Visit( SmPolyLineNode* pNode );
 391     void Visit( SmRootNode* pNode );
 392     void Visit( SmRootSymbolNode* pNode );
 393     void Visit( SmRectangleNode* pNode );
 394     void Visit( SmVerticalBraceNode* pNode );
 395     /** Clone a pNode */
 396     SmNode* Clone( SmNode* pNode );
 397 private:
 398     SmNode* pResult;
 399     /** Clone children of pSource and give them to pTarget */
 400     void CloneKids( SmStructureNode* pSource, SmStructureNode* pTarget );
 401     /** Clone attributes on a pNode */
 402     void CloneNodeAttr( SmNode* pSource, SmNode* pTarget );
 403 };
 404
 405
 406 /////////////////////////////// SmSelectionDrawingVisitor ///////////////////////////////
 407
 408 class SmSelectionDrawingVisitor : public SmDefaultingVisitor
 409 {
 410 public:
 411     /** Draws a selection on rDevice for the selection on pTree */
 412     SmSelectionDrawingVisitor( OutputDevice& rDevice, SmNode* pTree, Point Offset );
 413     virtual ~SmSelectionDrawingVisitor() {}
 414     void Visit( SmTextNode* pNode );
 415     using SmDefaultingVisitor::Visit;
 416 private:
 417     /** Reference to drawing device */
 418     OutputDevice& rDev;
 419     /** True if  aSelectionArea have been initialized */
 420     bool bHasSelectionArea;
 421     /** The current area that is selected */
 422     Rectangle aSelectionArea;
 423     /** Extend the area that must be selected  */
 424     void ExtendSelectionArea( Rectangle aArea );
 425     /** Default visiting method */
 426     void DefaultVisit( SmNode* pNode );
 427     /** Visit the children of a given pNode */
 428     void VisitChildren( SmNode* pNode );
 429 };
 430
 431 /////////////////////////////// SmNodeToTextVisitor ///////////////////////////////
 432
 433 /** Extract command text from pNodes */
 434 class SmNodeToTextVisitor : public SmVisitor
 435 {
 436 public:
 437     SmNodeToTextVisitor( SmNode* pNode, OUString &rText );
 438     virtual ~SmNodeToTextVisitor() {}
 439
 440     void Visit( SmTableNode* pNode );
 441     void Visit( SmBraceNode* pNode );
 442     void Visit( SmBracebodyNode* pNode );
 443     void Visit( SmOperNode* pNode );
 444     void Visit( SmAlignNode* pNode );
 445     void Visit( SmAttributNode* pNode );
 446     void Visit( SmFontNode* pNode );
 447     void Visit( SmUnHorNode* pNode );
 448     void Visit( SmBinHorNode* pNode );
 449     void Visit( SmBinVerNode* pNode );
 450     void Visit( SmBinDiagonalNode* pNode );
 451     void Visit( SmSubSupNode* pNode );
 452     void Visit( SmMatrixNode* pNode );
 453     void Visit( SmPlaceNode* pNode );
 454     void Visit( SmTextNode* pNode );
 455     void Visit( SmSpecialNode* pNode );
 456     void Visit( SmGlyphSpecialNode* pNode );
 457     void Visit( SmMathSymbolNode* pNode );
 458     void Visit( SmBlankNode* pNode );
 459     void Visit( SmErrorNode* pNode );
 460     void Visit( SmLineNode* pNode );
 461     void Visit( SmExpressionNode* pNode );
 462     void Visit( SmPolyLineNode* pNode );
 463     void Visit( SmRootNode* pNode );
 464     void Visit( SmRootSymbolNode* pNode );
 465     void Visit( SmRectangleNode* pNode );
 466     void Visit( SmVerticalBraceNode* pNode );
 467 private:
 468     /** Extract text from a pNode that constitues a line */
 469     void LineToText( SmNode* pNode ) {
 470         Separate( );
 471         if( pNode )
 472             pNode->Accept( this );
 473         Separate( );
 474     }
 475     void Append( const OUString &rText ) {
 476         aCmdText.append( rText );
 477     }
 478     /** Append a blank for separation, if needed */
 479     inline void Separate( ){
 480         if( !aCmdText.getLength() || aCmdText[ aCmdText.getLength() - 1 ] != ' ' )
 481             aCmdText.append(' ');
 482     }
 483     /** Output text generated from the pNodes */
 484     OUStringBuffer aCmdText;
 485 };
 486
 487 #endif /* SMVISITORS_H */
 488
 489 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */