starmath/source/visitors.cxx

   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 #include "visitors.hxx"
  10 #include "cursor.hxx"
  11
  12 ///////////////////////////////////// SmVisitorTest /////////////////////////////////////
  13
  14 void SmVisitorTest::Visit( SmTableNode* pNode )
  15 {
  16     OSL_ENSURE( pNode->GetType( ) == NTABLE, "the visitor-patterns isn't implemented correctly" );
  17     VisitChildren( pNode );
  18 }
  19
  20 void SmVisitorTest::Visit( SmBraceNode* pNode )
  21 {
  22     OSL_ENSURE( pNode->GetType( ) == NBRACE, "the visitor-patterns isn't implemented correctly" );
  23     VisitChildren( pNode );
  24 }
  25
  26 void SmVisitorTest::Visit( SmBracebodyNode* pNode )
  27 {
  28     OSL_ENSURE( pNode->GetType( ) == NBRACEBODY, "the visitor-patterns isn't implemented correctly" );
  29     VisitChildren( pNode );
  30 }
  31
  32 void SmVisitorTest::Visit( SmOperNode* pNode )
  33 {
  34     OSL_ENSURE( pNode->GetType( ) == NOPER, "the visitor-patterns isn't implemented correctly" );
  35     VisitChildren( pNode );
  36 }
  37
  38 void SmVisitorTest::Visit( SmAlignNode* pNode )
  39 {
  40     OSL_ENSURE( pNode->GetType( ) == NALIGN, "the visitor-patterns isn't implemented correctly" );
  41     VisitChildren( pNode );
  42 }
  43
  44 void SmVisitorTest::Visit( SmAttributNode* pNode )
  45 {
  46     OSL_ENSURE( pNode->GetType( ) == NATTRIBUT, "the visitor-patterns isn't implemented correctly" );
  47     VisitChildren( pNode );
  48 }
  49
  50 void SmVisitorTest::Visit( SmFontNode* pNode )
  51 {
  52     OSL_ENSURE( pNode->GetType( ) == NFONT, "the visitor-patterns isn't implemented correctly" );
  53     VisitChildren( pNode );
  54 }
  55
  56 void SmVisitorTest::Visit( SmUnHorNode* pNode )
  57 {
  58     OSL_ENSURE( pNode->GetType( ) == NUNHOR, "the visitor-patterns isn't implemented correctly" );
  59     VisitChildren( pNode );
  60 }
  61
  62 void SmVisitorTest::Visit( SmBinHorNode* pNode )
  63 {
  64     OSL_ENSURE( pNode->GetType( ) == NBINHOR, "the visitor-patterns isn't implemented correctly" );
  65     VisitChildren( pNode );
  66 }
  67
  68 void SmVisitorTest::Visit( SmBinVerNode* pNode )
  69 {
  70     OSL_ENSURE( pNode->GetType( ) == NBINVER, "the visitor-patterns isn't implemented correctly" );
  71     VisitChildren( pNode );
  72 }
  73
  74 void SmVisitorTest::Visit( SmBinDiagonalNode* pNode )
  75 {
  76     OSL_ENSURE( pNode->GetType( ) == NBINDIAGONAL, "the visitor-patterns isn't implemented correctly" );
  77     VisitChildren( pNode );
  78 }
  79
  80 void SmVisitorTest::Visit( SmSubSupNode* pNode )
  81 {
  82     OSL_ENSURE( pNode->GetType( ) == NSUBSUP, "the visitor-patterns isn't implemented correctly" );
  83     VisitChildren( pNode );
  84 }
  85
  86 void SmVisitorTest::Visit( SmMatrixNode* pNode )
  87 {
  88     OSL_ENSURE( pNode->GetType( ) == NMATRIX, "the visitor-patterns isn't implemented correctly" );
  89     VisitChildren( pNode );
  90 }
  91
  92 void SmVisitorTest::Visit( SmPlaceNode* pNode )
  93 {
  94     OSL_ENSURE( pNode->GetType( ) == NPLACE, "the visitor-patterns isn't implemented correctly" );
  95     VisitChildren( pNode );
  96 }
  97
  98 void SmVisitorTest::Visit( SmTextNode* pNode )
  99 {
 100     OSL_ENSURE( pNode->GetType( ) == NTEXT, "the visitor-patterns isn't implemented correctly" );
 101     VisitChildren( pNode );
 102 }
 103
 104 void SmVisitorTest::Visit( SmSpecialNode* pNode )
 105 {
 106     OSL_ENSURE( pNode->GetType( ) == NSPECIAL, "the visitor-patterns isn't implemented correctly" );
 107     VisitChildren( pNode );
 108 }
 109
 110 void SmVisitorTest::Visit( SmGlyphSpecialNode* pNode )
 111 {
 112     OSL_ENSURE( pNode->GetType( ) == NGLYPH_SPECIAL, "the visitor-patterns isn't implemented correctly" );
 113     VisitChildren( pNode );
 114 }
 115
 116 void SmVisitorTest::Visit( SmMathSymbolNode* pNode )
 117 {
 118     OSL_ENSURE( pNode->GetType( ) == NMATH, "the visitor-patterns isn't implemented correctly" );
 119     VisitChildren( pNode );
 120 }
 121
 122 void SmVisitorTest::Visit( SmBlankNode* pNode )
 123 {
 124     OSL_ENSURE( pNode->GetType( ) == NBLANK, "the visitor-patterns isn't implemented correctly" );
 125     VisitChildren( pNode );
 126 }
 127
 128 void SmVisitorTest::Visit( SmErrorNode* pNode )
 129 {
 130     OSL_ENSURE( pNode->GetType( ) == NERROR, "the visitor-patterns isn't implemented correctly" );
 131     VisitChildren( pNode );
 132 }
 133
 134 void SmVisitorTest::Visit( SmLineNode* pNode )
 135 {
 136     OSL_ENSURE( pNode->GetType( ) == NLINE, "the visitor-patterns isn't implemented correctly" );
 137     VisitChildren( pNode );
 138 }
 139
 140 void SmVisitorTest::Visit( SmExpressionNode* pNode )
 141 {
 142     OSL_ENSURE( pNode->GetType( ) == NEXPRESSION, "the visitor-patterns isn't implemented correctly" );
 143     VisitChildren( pNode );
 144 }
 145
 146 void SmVisitorTest::Visit( SmPolyLineNode* pNode )
 147 {
 148     OSL_ENSURE( pNode->GetType( ) == NPOLYLINE, "the visitor-patterns isn't implemented correctly" );
 149     VisitChildren( pNode );
 150 }
 151
 152 void SmVisitorTest::Visit( SmRootNode* pNode )
 153 {
 154     OSL_ENSURE( pNode->GetType( ) == NROOT, "the visitor-patterns isn't implemented correctly" );
 155     VisitChildren( pNode );
 156 }
 157
 158 void SmVisitorTest::Visit( SmRootSymbolNode* pNode )
 159 {
 160     OSL_ENSURE( pNode->GetType( ) == NROOTSYMBOL, "the visitor-patterns isn't implemented correctly" );
 161     VisitChildren( pNode );
 162 }
 163
 164 void SmVisitorTest::Visit( SmRectangleNode* pNode )
 165 {
 166     OSL_ENSURE( pNode->GetType( ) == NRECTANGLE, "the visitor-patterns isn't implemented correctly" );
 167     VisitChildren( pNode );
 168 }
 169
 170 void SmVisitorTest::Visit( SmVerticalBraceNode* pNode )
 171 {
 172     OSL_ENSURE( pNode->GetType( ) == NVERTICAL_BRACE, "the visitor-patterns isn't implemented correctly" );
 173     VisitChildren( pNode );
 174 }
 175
 176 void SmVisitorTest::VisitChildren( SmNode* pNode )
 177 {
 178     SmNodeIterator it( pNode );
 179     while( it.Next( ) )
 180         it->Accept( this );
 181 }
 182
 183 /////////////////////////////// SmDefaultingVisitor ////////////////////////////////
 184
 185 void SmDefaultingVisitor::Visit( SmTableNode* pNode )
 186 {
 187     DefaultVisit( pNode );
 188 }
 189
 190 void SmDefaultingVisitor::Visit( SmBraceNode* pNode )
 191 {
 192     DefaultVisit( pNode );
 193 }
 194
 195 void SmDefaultingVisitor::Visit( SmBracebodyNode* pNode )
 196 {
 197     DefaultVisit( pNode );
 198 }
 199
 200 void SmDefaultingVisitor::Visit( SmOperNode* pNode )
 201 {
 202     DefaultVisit( pNode );
 203 }
 204
 205 void SmDefaultingVisitor::Visit( SmAlignNode* pNode )
 206 {
 207     DefaultVisit( pNode );
 208 }
 209
 210 void SmDefaultingVisitor::Visit( SmAttributNode* pNode )
 211 {
 212     DefaultVisit( pNode );
 213 }
 214
 215 void SmDefaultingVisitor::Visit( SmFontNode* pNode )
 216 {
 217     DefaultVisit( pNode );
 218 }
 219
 220 void SmDefaultingVisitor::Visit( SmUnHorNode* pNode )
 221 {
 222     DefaultVisit( pNode );
 223 }
 224
 225 void SmDefaultingVisitor::Visit( SmBinHorNode* pNode )
 226 {
 227     DefaultVisit( pNode );
 228 }
 229
 230 void SmDefaultingVisitor::Visit( SmBinVerNode* pNode )
 231 {
 232     DefaultVisit( pNode );
 233 }
 234
 235 void SmDefaultingVisitor::Visit( SmBinDiagonalNode* pNode )
 236 {
 237     DefaultVisit( pNode );
 238 }
 239
 240 void SmDefaultingVisitor::Visit( SmSubSupNode* pNode )
 241 {
 242     DefaultVisit( pNode );
 243 }
 244
 245 void SmDefaultingVisitor::Visit( SmMatrixNode* pNode )
 246 {
 247     DefaultVisit( pNode );
 248 }
 249
 250 void SmDefaultingVisitor::Visit( SmPlaceNode* pNode )
 251 {
 252     DefaultVisit( pNode );
 253 }
 254
 255 void SmDefaultingVisitor::Visit( SmTextNode* pNode )
 256 {
 257     DefaultVisit( pNode );
 258 }
 259
 260 void SmDefaultingVisitor::Visit( SmSpecialNode* pNode )
 261 {
 262     DefaultVisit( pNode );
 263 }
 264
 265 void SmDefaultingVisitor::Visit( SmGlyphSpecialNode* pNode )
 266 {
 267     DefaultVisit( pNode );
 268 }
 269
 270 void SmDefaultingVisitor::Visit( SmMathSymbolNode* pNode )
 271 {
 272     DefaultVisit( pNode );
 273 }
 274
 275 void SmDefaultingVisitor::Visit( SmBlankNode* pNode )
 276 {
 277     DefaultVisit( pNode );
 278 }
 279
 280 void SmDefaultingVisitor::Visit( SmErrorNode* pNode )
 281 {
 282     DefaultVisit( pNode );
 283 }
 284
 285 void SmDefaultingVisitor::Visit( SmLineNode* pNode )
 286 {
 287     DefaultVisit( pNode );
 288 }
 289
 290 void SmDefaultingVisitor::Visit( SmExpressionNode* pNode )
 291 {
 292     DefaultVisit( pNode );
 293 }
 294
 295 void SmDefaultingVisitor::Visit( SmPolyLineNode* pNode )
 296 {
 297     DefaultVisit( pNode );
 298 }
 299
 300 void SmDefaultingVisitor::Visit( SmRootNode* pNode )
 301 {
 302     DefaultVisit( pNode );
 303 }
 304
 305 void SmDefaultingVisitor::Visit( SmRootSymbolNode* pNode )
 306 {
 307     DefaultVisit( pNode );
 308 }
 309
 310 void SmDefaultingVisitor::Visit( SmRectangleNode* pNode )
 311 {
 312     DefaultVisit( pNode );
 313 }
 314
 315 void SmDefaultingVisitor::Visit( SmVerticalBraceNode* pNode )
 316 {
 317     DefaultVisit( pNode );
 318 }
 319
 320 /////////////////////////////// SmCaretDrawingVisitor ////////////////////////////////
 321
 322 SmCaretDrawingVisitor::SmCaretDrawingVisitor( OutputDevice& rDevice,
 323                                              SmCaretPos position,
 324                                              Point offset,
 325                                              bool caretVisible )
 326  : rDev( rDevice )
 327 {
 328     pos = position;
 329     Offset = offset;
 330     isCaretVisible = caretVisible;
 331     OSL_ENSURE( position.IsValid( ), "Cannot draw invalid position!" );
 332     if( !position.IsValid( ) )
 333         return;
 334
 335     //Save device state
 336     rDev.Push( PUSH_FONT | PUSH_MAPMODE | PUSH_LINECOLOR | PUSH_FILLCOLOR | PUSH_TEXTCOLOR );
 337
 338     pos.pSelectedNode->Accept( this );
 339     //Restore device state
 340     rDev.Pop( );
 341 }
 342
 343 void SmCaretDrawingVisitor::Visit( SmTextNode* pNode )
 344 {
 345     long i = pos.Index;
 346
 347     rDev.SetFont( pNode->GetFont( ) );
 348
 349     //Find the line
 350     SmNode* pLine = SmCursor::FindTopMostNodeInLine( pNode );
 351
 352     //Find coordinates
 353     long left = pNode->GetLeft( ) + rDev.GetTextWidth( pNode->GetText( ), 0, i ) + Offset.X( );
 354     long top = pLine->GetTop( ) + Offset.Y( );
 355     long height = pLine->GetHeight( );
 356     long left_line = pLine->GetLeft( ) + Offset.X( );
 357     long right_line = pLine->GetRight( ) + Offset.X( );
 358
 359     //Set color
 360     rDev.SetLineColor( Color( COL_BLACK ) );
 361
 362     if ( isCaretVisible ) {
 363         //Draw vertical line
 364         Point p1( left, top );
 365         Point p2( left, top + height );
 366         rDev.DrawLine( p1, p2 );
 367     }
 368
 369     //Underline the line
 370     Point pLeft( left_line, top + height );
 371     Point pRight( right_line, top + height );
 372     rDev.DrawLine( pLeft, pRight );
 373 }
 374
 375 void SmCaretDrawingVisitor::DefaultVisit( SmNode* pNode )
 376 {
 377     rDev.SetLineColor( Color( COL_BLACK ) );
 378
 379     //Find the line
 380     SmNode* pLine = SmCursor::FindTopMostNodeInLine( pNode );
 381
 382     //Find coordinates
 383     long left = pNode->GetLeft( ) + Offset.X( ) + ( pos.Index == 1 ? pNode->GetWidth( ) : 0 );
 384     long top = pLine->GetTop( ) + Offset.Y( );
 385     long height = pLine->GetHeight( );
 386     long left_line = pLine->GetLeft( ) + Offset.X( );
 387     long right_line = pLine->GetRight( ) + Offset.X( );
 388
 389     //Set color
 390     rDev.SetLineColor( Color( COL_BLACK ) );
 391
 392     if ( isCaretVisible ) {
 393         //Draw vertical line
 394         Point p1( left, top );
 395         Point p2( left, top + height );
 396         rDev.DrawLine( p1, p2 );
 397     }
 398
 399     //Underline the line
 400     Point pLeft( left_line, top + height );
 401     Point pRight( right_line, top + height );
 402     rDev.DrawLine( pLeft, pRight );
 403 }
 404
 405 /////////////////////////////// SmCaretPos2LineVisitor ////////////////////////////////
 406
 407 void SmCaretPos2LineVisitor::Visit( SmTextNode* pNode )
 408 {
 409     //Save device state
 410     pDev->Push( PUSH_FONT | PUSH_TEXTCOLOR );
 411
 412     long i = pos.Index;
 413
 414     pDev->SetFont( pNode->GetFont( ) );
 415
 416     //Find coordinates
 417     long left = pNode->GetLeft( ) + pDev->GetTextWidth( pNode->GetText( ), 0, i );
 418     long top = pNode->GetTop( );
 419     long height = pNode->GetHeight( );
 420
 421     line = SmCaretLine( left, top, height );
 422
 423     //Restore device state
 424     pDev->Pop( );
 425 }
 426
 427 void SmCaretPos2LineVisitor::DefaultVisit( SmNode* pNode )
 428 {
 429     //Vertical line ( code from SmCaretDrawingVisitor )
 430     Point p1 = pNode->GetTopLeft( );
 431     if( pos.Index == 1 )
 432         p1.Move( pNode->GetWidth( ), 0 );
 433
 434     line = SmCaretLine( p1.X( ), p1.Y( ), pNode->GetHeight( ) );
 435 }
 436
 437 /////////////////////////////// Nasty temporary device!!! ////////////////////////////////
 438
 439 #include <tools/gen.hxx>
 440 #include <tools/fract.hxx>
 441 #include <rtl/math.hxx>
 442 #include <tools/color.hxx>
 443 #include <vcl/metric.hxx>
 444 #include <vcl/lineinfo.hxx>
 445 #include <vcl/outdev.hxx>
 446 #include <sfx2/module.hxx>
 447 #include "symbol.hxx"
 448 #include "smmod.hxx"
 449
 450 class SmTmpDevice2
 451 {
 452     OutputDevice  &rOutDev;
 453
 454     // disallow use of copy-constructor and assignment-operator
 455     SmTmpDevice2( const SmTmpDevice2 &rTmpDev );
 456     SmTmpDevice2 & operator = ( const SmTmpDevice2 &rTmpDev );
 457
 458     Color   Impl_GetColor( const Color& rColor );
 459
 460 public:
 461     SmTmpDevice2( OutputDevice &rTheDev, bool bUseMap100th_mm );
 462     ~SmTmpDevice2( )  { rOutDev.Pop( ); }
 463
 464     void SetFont( const Font &rNewFont );
 465
 466     void SetLineColor( const Color& rColor )    { rOutDev.SetLineColor( Impl_GetColor( rColor ) ); }
 467     void SetFillColor( const Color& rColor )    { rOutDev.SetFillColor( Impl_GetColor( rColor ) ); }
 468     void SetTextColor( const Color& rColor )    { rOutDev.SetTextColor( Impl_GetColor( rColor ) ); }
 469
 470     operator OutputDevice & ( ) const { return rOutDev; }
 471 };
 472
 473 SmTmpDevice2::SmTmpDevice2( OutputDevice &rTheDev, bool bUseMap100th_mm ) :
 474     rOutDev( rTheDev )
 475 {
 476     rOutDev.Push( PUSH_FONT | PUSH_MAPMODE |
 477                   PUSH_LINECOLOR | PUSH_FILLCOLOR | PUSH_TEXTCOLOR );
 478     if ( bUseMap100th_mm  &&  MAP_100TH_MM != rOutDev.GetMapMode( ).GetMapUnit( ) )
 479     {
 480         OSL_FAIL( "incorrect MapMode?" );
 481         rOutDev.SetMapMode( MAP_100TH_MM );     //format for 100% always
 482     }
 483 }
 484
 485 Color SmTmpDevice2::Impl_GetColor( const Color& rColor )
 486 {
 487     ColorData nNewCol = rColor.GetColor( );
 488     if ( COL_AUTO == nNewCol )
 489     {
 490         if ( OUTDEV_PRINTER == rOutDev.GetOutDevType( ) )
 491             nNewCol = COL_BLACK;
 492         else
 493         {
 494             Color aBgCol( rOutDev.GetBackground( ).GetColor( ) );
 495             if ( OUTDEV_WINDOW == rOutDev.GetOutDevType( ) )
 496                 aBgCol = ( ( Window & ) rOutDev ).GetDisplayBackground( ).GetColor( );
 497
 498             nNewCol = SM_MOD( )->GetColorConfig( ).GetColorValue( svtools::FONTCOLOR ).nColor;
 499
 500             Color aTmpColor( nNewCol );
 501             if ( aBgCol.IsDark( ) && aTmpColor.IsDark( ) )
 502                 nNewCol = COL_WHITE;
 503             else if ( aBgCol.IsBright( ) && aTmpColor.IsBright( ) )
 504                 nNewCol = COL_BLACK;
 505         }
 506     }
 507     return Color( nNewCol );
 508 }
 509
 510 void SmTmpDevice2::SetFont( const Font &rNewFont )
 511 {
 512     rOutDev.SetFont( rNewFont );
 513     rOutDev.SetTextColor( Impl_GetColor( rNewFont.GetColor( ) ) );
 514 }
 515
 516 /////////////////////////////// SmDrawingVisitor ////////////////////////////////
 517
 518 void SmDrawingVisitor::Visit( SmTableNode* pNode )
 519 {
 520     DrawChildren( pNode );
 521 }
 522
 523 void SmDrawingVisitor::Visit( SmBraceNode* pNode )
 524 {
 525     DrawChildren( pNode );
 526 }
 527
 528 void SmDrawingVisitor::Visit( SmBracebodyNode* pNode )
 529 {
 530     DrawChildren( pNode );
 531 }
 532
 533 void SmDrawingVisitor::Visit( SmOperNode* pNode )
 534 {
 535     DrawChildren( pNode );
 536 }
 537
 538 void SmDrawingVisitor::Visit( SmAlignNode* pNode )
 539 {
 540     DrawChildren( pNode );
 541 }
 542
 543 void SmDrawingVisitor::Visit( SmAttributNode* pNode )
 544 {
 545     DrawChildren( pNode );
 546 }
 547
 548 void SmDrawingVisitor::Visit( SmFontNode* pNode )
 549 {
 550     DrawChildren( pNode );
 551 }
 552
 553 void SmDrawingVisitor::Visit( SmUnHorNode* pNode )
 554 {
 555     DrawChildren( pNode );
 556 }
 557
 558 void SmDrawingVisitor::Visit( SmBinHorNode* pNode )
 559 {
 560     DrawChildren( pNode );
 561 }
 562
 563 void SmDrawingVisitor::Visit( SmBinVerNode* pNode )
 564 {
 565     DrawChildren( pNode );
 566 }
 567
 568 void SmDrawingVisitor::Visit( SmBinDiagonalNode* pNode )
 569 {
 570     DrawChildren( pNode );
 571 }
 572
 573 void SmDrawingVisitor::Visit( SmSubSupNode* pNode )
 574 {
 575     DrawChildren( pNode );
 576 }
 577
 578 void SmDrawingVisitor::Visit( SmMatrixNode* pNode )
 579 {
 580     DrawChildren( pNode );
 581 }
 582
 583 void SmDrawingVisitor::Visit( SmPlaceNode* pNode )
 584 {
 585     DrawSpecialNode( pNode );
 586 }
 587
 588 void SmDrawingVisitor::Visit( SmTextNode* pNode )
 589 {
 590     DrawTextNode( pNode );
 591 }
 592
 593 void SmDrawingVisitor::Visit( SmSpecialNode* pNode )
 594 {
 595     DrawSpecialNode( pNode );
 596 }
 597
 598 void SmDrawingVisitor::Visit( SmGlyphSpecialNode* pNode )
 599 {
 600     DrawSpecialNode( pNode );
 601 }
 602
 603 void SmDrawingVisitor::Visit( SmMathSymbolNode* pNode )
 604 {
 605     DrawSpecialNode( pNode );
 606 }
 607
 608 void SmDrawingVisitor::Visit( SmBlankNode* pNode )
 609 {
 610     DrawChildren( pNode );
 611 }
 612
 613 void SmDrawingVisitor::Visit( SmErrorNode* pNode )
 614 {
 615     DrawSpecialNode( pNode );
 616 }
 617
 618 void SmDrawingVisitor::Visit( SmLineNode* pNode )
 619 {
 620     DrawChildren( pNode );
 621 }
 622
 623 void SmDrawingVisitor::Visit( SmExpressionNode* pNode )
 624 {
 625     DrawChildren( pNode );
 626 }
 627
 628 void SmDrawingVisitor::Visit( SmRootNode* pNode )
 629 {
 630     DrawChildren( pNode );
 631 }
 632
 633 void SmDrawingVisitor::Visit( SmVerticalBraceNode* pNode )
 634 {
 635     DrawChildren( pNode );
 636 }
 637
 638 void SmDrawingVisitor::Visit( SmRootSymbolNode* pNode )
 639 {
 640     if ( pNode->IsPhantom( ) )
 641         return;
 642
 643     // draw root-sign itself
 644     DrawSpecialNode( pNode );
 645
 646     SmTmpDevice2  aTmpDev( ( OutputDevice & ) rDev, true );
 647     aTmpDev.SetFillColor( pNode->GetFont( ).GetColor( ) );
 648     rDev.SetLineColor( );
 649     aTmpDev.SetFont( pNode->GetFont( ) );
 650
 651     // since the width is always unscaled it corresponds ot the _original_
 652     // _unscaled_ font height to be used, we use that to calculate the
 653     // bar height. Thus it is independent of the arguments height.
 654     // ( see display of sqrt QQQ versus sqrt stack{Q#Q#Q#Q} )
 655     long nBarHeight = pNode->GetWidth( ) * 7L / 100L;
 656     long nBarWidth = pNode->GetBodyWidth( ) + pNode->GetBorderWidth( );
 657     Point aBarOffset( pNode->GetWidth( ), +pNode->GetBorderWidth( ) );
 658     Point aBarPos( Position + aBarOffset );
 659
 660     Rectangle  aBar( aBarPos, Size( nBarWidth, nBarHeight ) );
 661     //! avoid GROWING AND SHRINKING of drawn rectangle when constantly
 662     //! increasing zoomfactor.
 663     //  This is done by shifting its output-position to a point that
 664     //  corresponds exactly to a pixel on the output device.
 665     Point  aDrawPos( rDev.PixelToLogic( rDev.LogicToPixel( aBar.TopLeft( ) ) ) );
 666     aBar.SetPos( aDrawPos );
 667
 668     rDev.DrawRect( aBar );
 669 }
 670
 671 void SmDrawingVisitor::Visit( SmPolyLineNode* pNode )
 672 {
 673     if ( pNode->IsPhantom( ) )
 674         return;
 675
 676     long nBorderwidth = pNode->GetFont( ).GetBorderWidth( );
 677
 678     LineInfo  aInfo;
 679     aInfo.SetWidth( pNode->GetWidth( ) - 2 * nBorderwidth );
 680
 681     Point aOffset ( Point( ) - pNode->GetPolygon( ).GetBoundRect( ).TopLeft( )
 682                    + Point( nBorderwidth, nBorderwidth ) ),
 683           aPos ( Position + aOffset );
 684     pNode->GetPolygon( ).Move( aPos.X( ), aPos.Y( ) );    //Works because Polygon wraps a pointer
 685
 686     SmTmpDevice2  aTmpDev ( ( OutputDevice & ) rDev, false );
 687     aTmpDev.SetLineColor( pNode->GetFont( ).GetColor( ) );
 688
 689     rDev.DrawPolyLine( pNode->GetPolygon( ), aInfo );
 690 }
 691
 692 void SmDrawingVisitor::Visit( SmRectangleNode* pNode )
 693 {
 694     if ( pNode->IsPhantom( ) )
 695         return;
 696
 697     SmTmpDevice2  aTmpDev ( ( OutputDevice & ) rDev, false );
 698     aTmpDev.SetFillColor( pNode->GetFont( ).GetColor( ) );
 699     rDev.SetLineColor( );
 700     aTmpDev.SetFont( pNode->GetFont( ) );
 701
 702     sal_uLong  nTmpBorderWidth = pNode->GetFont( ).GetBorderWidth( );
 703
 704     // get rectangle and remove borderspace
 705     Rectangle  aTmp ( pNode->AsRectangle( ) + Position - pNode->GetTopLeft( ) );
 706     aTmp.Left( )   += nTmpBorderWidth;
 707     aTmp.Right( )  -= nTmpBorderWidth;
 708     aTmp.Top( )    += nTmpBorderWidth;
 709     aTmp.Bottom( ) -= nTmpBorderWidth;
 710
 711     OSL_ENSURE( aTmp.GetHeight( ) > 0  &&  aTmp.GetWidth( ) > 0,
 712                "Sm: leeres Rechteck" );
 713
 714     //! avoid GROWING AND SHRINKING of drawn rectangle when constantly
 715     //! increasing zoomfactor.
 716     //  This is done by shifting its output-position to a point that
 717     //  corresponds exactly to a pixel on the output device.
 718     Point  aPos ( rDev.PixelToLogic( rDev.LogicToPixel( aTmp.TopLeft( ) ) ) );
 719     aTmp.SetPos( aPos );
 720
 721     rDev.DrawRect( aTmp );
 722 }
 723
 724 void SmDrawingVisitor::DrawTextNode( SmTextNode* pNode )
 725 {
 726     if ( pNode->IsPhantom() || pNode->GetText().isEmpty() || pNode->GetText()[0] == '\0' )
 727         return;
 728
 729     SmTmpDevice2  aTmpDev ( ( OutputDevice & ) rDev, false );
 730     aTmpDev.SetFont( pNode->GetFont( ) );
 731
 732     Point  aPos ( Position );
 733     aPos.Y( ) += pNode->GetBaselineOffset( );
 734     // auf Pixelkoordinaten runden
 735     aPos = rDev.PixelToLogic( rDev.LogicToPixel( aPos ) );
 736
 737     rDev.DrawStretchText( aPos, pNode->GetWidth( ), pNode->GetText( ) );
 738 }
 739
 740 void SmDrawingVisitor::DrawSpecialNode( SmSpecialNode* pNode )
 741 {
 742     //! since this chars might come from any font, that we may not have
 743     //! set to ALIGN_BASELINE yet, we do it now.
 744     pNode->GetFont( ).SetAlign( ALIGN_BASELINE );
 745
 746     DrawTextNode( pNode );
 747 }
 748
 749 void SmDrawingVisitor::DrawChildren( SmNode* pNode )
 750 {
 751     if ( pNode->IsPhantom( ) )
 752         return;
 753
 754     Point rPosition = Position;
 755
 756     SmNodeIterator it( pNode );
 757     while( it.Next( ) )
 758     {
 759         Point  aOffset ( it->GetTopLeft( ) - pNode->GetTopLeft( ) );
 760         Position = rPosition + aOffset;
 761         it->Accept( this );
 762     }
 763 }
 764
 765 /////////////////////////////// SmSetSelectionVisitor ////////////////////////////////
 766
 767 SmSetSelectionVisitor::SmSetSelectionVisitor( SmCaretPos startPos, SmCaretPos endPos, SmNode* pTree) {
 768     StartPos    = startPos;
 769     EndPos      = endPos;
 770     IsSelecting = false;
 771
 772     //Assume that pTree is a SmTableNode
 773     OSL_ENSURE(pTree->GetType() == NTABLE, "pTree should be a SmTableNode!");
 774     //Visit root node, this is special as this node cannot be selected, but its children can!
 775     if(pTree->GetType() == NTABLE){
 776         //Change state if StartPos is in front of this node
 777         if( StartPos.pSelectedNode == pTree && StartPos.Index == 0 )
 778             IsSelecting = !IsSelecting;
 779         //Change state if EndPos is in front of this node
 780         if( EndPos.pSelectedNode == pTree && EndPos.Index == 0 )
 781             IsSelecting = !IsSelecting;
 782         OSL_ENSURE(!IsSelecting, "Caret positions needed to set IsSelecting about, shouldn't be possible!");
 783
 784         //Visit lines
 785         SmNodeIterator it( pTree );
 786         while( it.Next( ) ) {
 787             it->Accept( this );
 788             //If we started a selection in this line and it haven't ended, we do that now!
 789             if(IsSelecting) {
 790                 IsSelecting = false;
 791                 SetSelectedOnAll(it.Current(), true);
 792                 //Set StartPos and EndPos to invalid positions, this ensures that an unused
 793                 //start or end (because we forced end above), doesn't start a new selection.
 794                 StartPos = EndPos = SmCaretPos();
 795             }
 796         }
 797         //Check if pTree isn't selected
 798         OSL_ENSURE(!pTree->IsSelected(), "pTree should never be selected!");
 799         //Discard the selection if there's a bug (it's better than crashing)
 800         if(pTree->IsSelected())
 801             SetSelectedOnAll(pTree, false);
 802     }else //This shouldn't happen, but I don't see any reason to die if it does
 803         pTree->Accept(this);
 804 }
 805
 806 void SmSetSelectionVisitor::SetSelectedOnAll( SmNode* pSubTree, bool IsSelected ) {
 807     pSubTree->SetSelected( IsSelected );
 808
 809     //Quick BFS to set all selections
 810     SmNodeIterator it( pSubTree );
 811     while( it.Next( ) )
 812         SetSelectedOnAll( it.Current( ), IsSelected );
 813 }
 814
 815 void SmSetSelectionVisitor::DefaultVisit( SmNode* pNode ) {
 816     //Change state if StartPos is in front of this node
 817     if( StartPos.pSelectedNode == pNode && StartPos.Index == 0 )
 818         IsSelecting = !IsSelecting;
 819     //Change state if EndPos is in front of this node
 820     if( EndPos.pSelectedNode == pNode && EndPos.Index == 0 )
 821         IsSelecting = !IsSelecting;
 822
 823     //Cache current state
 824     bool WasSelecting = IsSelecting;
 825     bool ChangedState = false;
 826
 827     //Set selected
 828     pNode->SetSelected( IsSelecting );
 829
 830     //Visit children
 831     SmNodeIterator it( pNode );
 832     while( it.Next( ) )
 833     {
 834         it->Accept( this );
 835         ChangedState = ( WasSelecting != IsSelecting ) || ChangedState;
 836     }
 837
 838     //If state changed
 839     if( ChangedState )
 840     {
 841         //Select this node and all of its children
 842         //(Make exception for SmBracebodyNode)
 843         if( pNode->GetType() != NBRACEBODY ||
 844             !pNode->GetParent() ||
 845             pNode->GetParent()->GetType() != NBRACE )
 846             SetSelectedOnAll( pNode, true );
 847         else
 848             SetSelectedOnAll( pNode->GetParent(), true );
 849         /* If the equation is:      sqrt{2 + 4} + 5
 850          * And the selection is:    sqrt{2 + [4} +] 5
 851          *      Where [ denotes StartPos and ] denotes EndPos
 852          * Then the sqrt node should be selected, so that the
 853          * effective selection is:  [sqrt{2 + 4} +] 5
 854          * The same is the case if we swap StartPos and EndPos.
 855          */
 856     }
 857
 858     //Change state if StartPos is after this node
 859     if( StartPos.pSelectedNode == pNode && StartPos.Index == 1 )
 860     {
 861         IsSelecting = !IsSelecting;
 862     }
 863     //Change state if EndPos is after of this node
 864     if( EndPos.pSelectedNode == pNode && EndPos.Index == 1 )
 865     {
 866         IsSelecting = !IsSelecting;
 867     }
 868 }
 869
 870 void SmSetSelectionVisitor::VisitCompositionNode( SmNode* pNode ) {
 871     //Change state if StartPos is in front of this node
 872     if( StartPos.pSelectedNode == pNode && StartPos.Index == 0 )
 873         IsSelecting = !IsSelecting;
 874     //Change state if EndPos is in front of this node
 875     if( EndPos.pSelectedNode == pNode && EndPos.Index == 0 )
 876         IsSelecting = !IsSelecting;
 877
 878     //Cache current state
 879     bool WasSelecting = IsSelecting;
 880
 881     //Visit children
 882     SmNodeIterator it( pNode );
 883     while( it.Next( ) )
 884         it->Accept( this );
 885
 886     //Set selected, if everything was selected
 887     pNode->SetSelected( WasSelecting && IsSelecting );
 888
 889     //Change state if StartPos is after this node
 890     if( StartPos.pSelectedNode == pNode && StartPos.Index == 1 )
 891         IsSelecting = !IsSelecting;
 892     //Change state if EndPos is after of this node
 893     if( EndPos.pSelectedNode == pNode && EndPos.Index == 1 )
 894         IsSelecting = !IsSelecting;
 895 }
 896
 897 void SmSetSelectionVisitor::Visit( SmTextNode* pNode ) {
 898     long    i1 = -1,
 899             i2 = -1;
 900     if( StartPos.pSelectedNode == pNode )
 901         i1 = StartPos.Index;
 902     if( EndPos.pSelectedNode == pNode )
 903         i2 = EndPos.Index;
 904
 905     long start, end;
 906     pNode->SetSelected( true );
 907     if( i1 != -1 && i2 != -1 ) {
 908         start = i1 < i2 ? i1 : i2; //MIN
 909         end   = i1 > i2 ? i1 : i2; //MAX
 910     } else if( IsSelecting && i1 != -1 ) {
 911         start = 0;
 912         end = i1;
 913         IsSelecting = false;
 914     } else if( IsSelecting && i2 != -1 ) {
 915         start = 0;
 916         end = i2;
 917         IsSelecting = false;
 918     } else if( !IsSelecting && i1 != -1 ) {
 919         start = i1;
 920         end = pNode->GetText().getLength();
 921         IsSelecting = true;
 922     } else if( !IsSelecting && i2 != -1 ) {
 923         start = i2;
 924         end = pNode->GetText().getLength();
 925         IsSelecting = true;
 926     } else if( IsSelecting ) {
 927         start = 0;
 928         end = pNode->GetText().getLength();
 929     } else {
 930         pNode->SetSelected( false );
 931         start = 0;
 932         end = 0;
 933     }
 934     pNode->SetSelected( start != end );
 935     pNode->SetSelectionStart( start );
 936     pNode->SetSelectionEnd( end );
 937 }
 938
 939 void SmSetSelectionVisitor::Visit( SmExpressionNode* pNode ) {
 940     VisitCompositionNode( pNode );
 941 }
 942
 943 void SmSetSelectionVisitor::Visit( SmLineNode* pNode ) {
 944     VisitCompositionNode( pNode );
 945 }
 946
 947 void SmSetSelectionVisitor::Visit( SmAlignNode* pNode ) {
 948     VisitCompositionNode( pNode );
 949 }
 950
 951 void SmSetSelectionVisitor::Visit( SmBinHorNode* pNode ) {
 952     VisitCompositionNode( pNode );
 953 }
 954
 955 void SmSetSelectionVisitor::Visit( SmUnHorNode* pNode ) {
 956     VisitCompositionNode( pNode );
 957 }
 958
 959 void SmSetSelectionVisitor::Visit( SmFontNode* pNode ) {
 960     VisitCompositionNode( pNode );
 961 }
 962
 963 /////////////////////////////// SmCaretPosGraphBuildingVisitor ////////////////////////////////
 964
 965 SmCaretPosGraphBuildingVisitor::SmCaretPosGraphBuildingVisitor( SmNode* pRootNode ) {
 966     pRightMost  = NULL;
 967     pGraph = new SmCaretPosGraph( );
 968     //pRootNode should always be a table
 969     OSL_ENSURE( pRootNode->GetType( ) == NTABLE, "pRootNode must be a table node");
 970     //Handle the special case where NTABLE is used a rootnode
 971     if( pRootNode->GetType( ) == NTABLE ){
 972         //Children are SmLineNodes
 973         //Or so I thought... Aparently, the children can be instances of SmExpression
 974         //especially if there's a error in the formula... So he we go, a simple work around.
 975         SmNodeIterator it( pRootNode );
 976         while( it.Next( ) ){
 977             //There's a special invariant between this method and the Visit( SmLineNode* )
 978             //Usually pRightMost may not be NULL, to avoid this pRightMost should here be
 979             //set to a new SmCaretPos in front of it.Current( ), however, if it.Current( ) is
 980             //an instance of SmLineNode we let SmLineNode create this position in front of
 981             //the visual line.
 982             //The argument for doing this is that we now don't have to worry about SmLineNode
 983             //being a visual line composition node. Thus, no need for yet another special case
 984             //in SmCursor::IsLineCompositionNode and everywhere this method is used.
 985             //if( it->GetType( ) != NLINE )
 986                 pRightMost = pGraph->Add( SmCaretPos( it.Current( ), 0 ) );
 987             it->Accept( this );
 988         }
 989     }else
 990         pRootNode->Accept(this);
 991 }
 992
 993 void SmCaretPosGraphBuildingVisitor::Visit( SmLineNode* pNode ){
 994     SmNodeIterator it( pNode );
 995     while( it.Next( ) ){
 996         it->Accept( this );
 997     }
 998 }
 999
1000 /** Build SmCaretPosGraph for SmTableNode
1001  * This method covers cases where SmTableNode is used in a binom or stack,
1002  * the special case where it is used as root node for the entire formula is
1003  * handled in the constructor.
1004  */
1005 void SmCaretPosGraphBuildingVisitor::Visit( SmTableNode* pNode ){
1006     SmCaretPosGraphEntry *left  = pRightMost,
1007                          *right = pGraph->Add( SmCaretPos( pNode, 1) );
1008     bool bIsFirst = true;
1009     SmNodeIterator it( pNode );
1010     while( it.Next() ){
1011         pRightMost = pGraph->Add( SmCaretPos( it.Current(), 0 ), left);
1012         if(bIsFirst)
1013             left->SetRight(pRightMost);
1014         it->Accept( this );
1015         pRightMost->SetRight(right);
1016         if(bIsFirst)
1017             right->SetLeft(pRightMost);
1018         bIsFirst = false;
1019     }
1020     pRightMost = right;
1021 }
1022
1023 /** Build SmCaretPosGraph for SmSubSupNode
1024  *
1025  * The child positions in a SubSupNode, where H is the body:
1026  * \code
1027  *      CSUP
1028  *
1029  * LSUP H  H RSUP
1030  *      H  H
1031  *      HHHH
1032  *      H  H
1033  * LSUB H  H RSUB
1034  *
1035  *      CSUB
1036  * \endcode
1037  *
1038  * Graph over these, where "left" is before the SmSubSupNode and "right" is after:
1039  * \dot
1040  *  digraph Graph{
1041  *      left -> H;
1042  *      H -> right;
1043  *      LSUP -> H;
1044  *      LSUB -> H;
1045  *      CSUP -> right;
1046  *      CSUB -> right;
1047  *      RSUP -> right;
1048  *      RSUB -> right;
1049  *  };
1050  * \enddot
1051  *
1052  */
1053 void SmCaretPosGraphBuildingVisitor::Visit( SmSubSupNode* pNode )
1054 {
1055     SmCaretPosGraphEntry *left,
1056                          *right,
1057                          *bodyLeft,
1058                          *bodyRight;
1059
1060     left = pRightMost;
1061     OSL_ENSURE( pRightMost, "pRightMost shouldn't be NULL here!" );
1062
1063     //Create bodyLeft
1064     OSL_ENSURE( pNode->GetBody( ), "SmSubSupNode Doesn't have a body!" );
1065     bodyLeft = pGraph->Add( SmCaretPos( pNode->GetBody( ), 0 ), left );
1066     left->SetRight( bodyLeft ); //TODO: Don't make this if LSUP or LSUB are NULL ( not sure??? )
1067
1068     //Create right
1069     right = pGraph->Add( SmCaretPos( pNode, 1 ) );
1070
1071     //Visit the body, to get bodyRight
1072     pRightMost = bodyLeft;
1073     pNode->GetBody( )->Accept( this );
1074     bodyRight = pRightMost;
1075     bodyRight->SetRight( right );
1076     right->SetLeft( bodyRight );
1077
1078     SmNode* pChild;
1079     //If there's an LSUP
1080     if( ( pChild = pNode->GetSubSup( LSUP ) ) ){
1081         SmCaretPosGraphEntry *cLeft; //Child left
1082         cLeft = pGraph->Add( SmCaretPos( pChild, 0 ), left );
1083
1084         pRightMost = cLeft;
1085         pChild->Accept( this );
1086
1087         pRightMost->SetRight( bodyLeft );
1088     }
1089     //If there's an LSUB
1090     if( ( pChild = pNode->GetSubSup( LSUB ) ) ){
1091         SmCaretPosGraphEntry *cLeft; //Child left
1092         cLeft = pGraph->Add( SmCaretPos( pChild, 0 ), left );
1093
1094         pRightMost = cLeft;
1095         pChild->Accept( this );
1096
1097         pRightMost->SetRight( bodyLeft );
1098     }
1099     //If there's an CSUP
1100     if( ( pChild = pNode->GetSubSup( CSUP ) ) ){
1101         SmCaretPosGraphEntry *cLeft; //Child left
1102         cLeft = pGraph->Add( SmCaretPos( pChild, 0 ), left );
1103
1104         pRightMost = cLeft;
1105         pChild->Accept( this );
1106
1107         pRightMost->SetRight( right );
1108     }
1109     //If there's an CSUB
1110     if( ( pChild = pNode->GetSubSup( CSUB ) ) ){
1111         SmCaretPosGraphEntry *cLeft; //Child left
1112         cLeft = pGraph->Add( SmCaretPos( pChild, 0 ), left );
1113
1114         pRightMost = cLeft;
1115         pChild->Accept( this );
1116
1117         pRightMost->SetRight( right );
1118     }
1119     //If there's an RSUP
1120     if( ( pChild = pNode->GetSubSup( RSUP ) ) ){
1121         SmCaretPosGraphEntry *cLeft; //Child left
1122         cLeft = pGraph->Add( SmCaretPos( pChild, 0 ), bodyRight );
1123
1124         pRightMost = cLeft;
1125         pChild->Accept( this );
1126
1127         pRightMost->SetRight( right );
1128     }
1129     //If there's an RSUB
1130     if( ( pChild = pNode->GetSubSup( RSUB ) ) ){
1131         SmCaretPosGraphEntry *cLeft; //Child left
1132         cLeft = pGraph->Add( SmCaretPos( pChild, 0 ), bodyRight );
1133
1134         pRightMost = cLeft;
1135         pChild->Accept( this );
1136
1137         pRightMost->SetRight( right );
1138     }
1139
1140     //Set return parameters
1141     pRightMost = right;
1142 }
1143
1144 /** Build caret position for SmOperNode
1145  *
1146  * If first child is an SmSubSupNode we will ignore its
1147  * body, as this body is a SmMathSymbol, for SUM, INT or similar
1148  * that shouldn't be subject to modification.
1149  * If first child is not a SmSubSupNode, ignore it completely
1150  * as it is a SmMathSymbol.
1151  *
1152  * The child positions in a SmOperNode, where H is symbol, e.g. int, sum or similar:
1153  * \code
1154  *       TO
1155  *
1156  * LSUP H  H RSUP    BBB    BB  BBB  B   B
1157  *      H  H         B  B  B  B B  B  B B
1158  *      HHHH         BBB   B  B B  B   B
1159  *      H  H         B  B  B  B B  B   B
1160  * LSUB H  H RSUB    BBB    BB  BBB    B
1161  *
1162  *      FROM
1163  * \endcode
1164  * Notice, CSUP, etc. are actually granchildren, but inorder to ignore H, these are visited
1165  * from here. If they are present, that is if pOper is an instance of SmSubSupNode.
1166  *
1167  * Graph over these, where "left" is before the SmOperNode and "right" is after:
1168  * \dot
1169  *  digraph Graph{
1170  *      left -> BODY;
1171  *      BODY -> right;
1172  *      LSUP -> BODY;
1173  *      LSUB -> BODY;
1174  *      TO   -> BODY;
1175  *      FROM -> BODY;
1176  *      RSUP -> BODY;
1177  *      RSUB -> BODY;
1178  *  };
1179  * \enddot
1180  */
1181 void SmCaretPosGraphBuildingVisitor::Visit( SmOperNode* pNode )
1182 {
1183     SmNode *pOper = pNode->GetSubNode( 0 ),
1184            *pBody = pNode->GetSubNode( 1 );
1185
1186     SmCaretPosGraphEntry *left = pRightMost,
1187                          *bodyLeft,
1188                          *bodyRight,
1189                          *right;
1190     //Create body left
1191     bodyLeft = pGraph->Add( SmCaretPos( pBody, 0 ), left );
1192     left->SetRight( bodyLeft );
1193
1194     //Visit body, get bodyRight
1195     pRightMost = bodyLeft;
1196     pBody->Accept( this );
1197     bodyRight = pRightMost;
1198
1199     //Create right
1200     right = pGraph->Add( SmCaretPos( pNode, 1 ), bodyRight );
1201     bodyRight->SetRight( right );
1202
1203     //Get subsup pNode if any
1204     SmSubSupNode* pSubSup = pOper->GetType( ) == NSUBSUP ? ( SmSubSupNode* )pOper : NULL;
1205
1206     SmNode* pChild;
1207     SmCaretPosGraphEntry *childLeft;
1208     if( pSubSup && ( pChild = pSubSup->GetSubSup( LSUP ) ) ) {
1209         //Create position in front of pChild
1210         childLeft = pGraph->Add( SmCaretPos( pChild, 0 ), left );
1211         //Visit pChild
1212         pRightMost = childLeft;
1213         pChild->Accept( this );
1214         //Set right on pRightMost from pChild
1215         pRightMost->SetRight( bodyLeft );
1216     }
1217     if( pSubSup && ( pChild = pSubSup->GetSubSup( LSUB ) ) ) {
1218         //Create position in front of pChild
1219         childLeft = pGraph->Add( SmCaretPos( pChild, 0 ), left );
1220         //Visit pChild
1221         pRightMost = childLeft;
1222         pChild->Accept( this );
1223         //Set right on pRightMost from pChild
1224         pRightMost->SetRight( bodyLeft );
1225     }
1226     if( pSubSup && ( pChild = pSubSup->GetSubSup( CSUP ) ) ) {//TO
1227         //Create position in front of pChild
1228         childLeft = pGraph->Add( SmCaretPos( pChild, 0 ), left );
1229         //Visit pChild
1230         pRightMost = childLeft;
1231         pChild->Accept( this );
1232         //Set right on pRightMost from pChild
1233         pRightMost->SetRight( bodyLeft );
1234     }
1235     if( pSubSup && ( pChild = pSubSup->GetSubSup( CSUB ) ) ) { //FROM
1236         //Create position in front of pChild
1237         childLeft = pGraph->Add( SmCaretPos( pChild, 0 ), left );
1238         //Visit pChild
1239         pRightMost = childLeft;
1240         pChild->Accept( this );
1241         //Set right on pRightMost from pChild
1242         pRightMost->SetRight( bodyLeft );
1243     }
1244     if( pSubSup && ( pChild = pSubSup->GetSubSup( RSUP ) ) ) {
1245         //Create position in front of pChild
1246         childLeft = pGraph->Add( SmCaretPos( pChild, 0 ), left );
1247         //Visit pChild
1248         pRightMost = childLeft;
1249         pChild->Accept( this );
1250         //Set right on pRightMost from pChild
1251         pRightMost->SetRight( bodyLeft );
1252     }
1253     if( pSubSup && ( pChild = pSubSup->GetSubSup( RSUB ) ) ) {
1254         //Create position in front of pChild
1255         childLeft = pGraph->Add( SmCaretPos( pChild, 0 ), left );
1256         //Visit pChild
1257         pRightMost = childLeft;
1258         pChild->Accept( this );
1259         //Set right on pRightMost from pChild
1260         pRightMost->SetRight( bodyLeft );
1261     }
1262
1263     //Return right
1264     pRightMost = right;
1265 }
1266
1267 void SmCaretPosGraphBuildingVisitor::Visit( SmMatrixNode* pNode )
1268 {
1269     SmCaretPosGraphEntry *left  = pRightMost,
1270                          *right = pGraph->Add( SmCaretPos( pNode, 1 ) );
1271
1272     for ( sal_uInt16 i = 0;  i < pNode->GetNumRows( ); i++ ) {
1273         SmCaretPosGraphEntry* r = left;
1274         for ( sal_uInt16 j = 0;  j < pNode->GetNumCols( ); j++ ){
1275             SmNode* pSubNode = pNode->GetSubNode( i * pNode->GetNumCols( ) + j );
1276
1277             pRightMost = pGraph->Add( SmCaretPos( pSubNode, 0 ), r );
1278             if( j != 0 || ( pNode->GetNumRows( ) - 1 ) / 2 == i )
1279                 r->SetRight( pRightMost );
1280
1281             pSubNode->Accept( this );
1282
1283             r = pRightMost;
1284         }
1285         pRightMost->SetRight( right );
1286         if( ( pNode->GetNumRows( ) - 1 ) / 2 == i )
1287             right->SetLeft( pRightMost );
1288     }
1289
1290     pRightMost = right;
1291 }
1292
1293 /** Build SmCaretPosGraph for SmTextNode
1294  *
1295  * Lines in an SmTextNode:
1296  * \code
1297  * A B C
1298  * \endcode
1299  * Where A B and C are characters in the text.
1300  *
1301  * Graph over these, where "left" is before the SmTextNode and "right" is after:
1302  * \dot
1303  *  digraph Graph{
1304  *      left -> A;
1305  *      A -> B
1306  *      B -> right;
1307  *  };
1308  * \enddot
1309  * Notice that C and right is the same position here.
1310  */
1311 void SmCaretPosGraphBuildingVisitor::Visit( SmTextNode* pNode )
1312 {
1313     OSL_ENSURE( !pNode->GetText().isEmpty(), "Empty SmTextNode is bad" );
1314
1315     int size = pNode->GetText().getLength();
1316     for( int i = 1; i <= size; i++ ){
1317         SmCaretPosGraphEntry* pRight = pRightMost;
1318         pRightMost = pGraph->Add( SmCaretPos( pNode, i ), pRight );
1319         pRight->SetRight( pRightMost );
1320     }
1321 }
1322
1323 /** Build SmCaretPosGraph for SmBinVerNode
1324  *
1325  * Lines in an SmBinVerNode:
1326  * \code
1327  *    A
1328  *  -----
1329  *    B
1330  * \endcode
1331  *
1332  * Graph over these, where "left" is before the SmBinVerNode and "right" is after:
1333  * \dot
1334  *  digraph Graph{
1335  *      left -> A;
1336  *      A -> right;
1337  *      B -> right;
1338  *  };
1339  * \enddot
1340  */
1341 void SmCaretPosGraphBuildingVisitor::Visit( SmBinVerNode* pNode )
1342 {
1343     //None if these children can be NULL, see SmBinVerNode::Arrange
1344     SmNode  *pNum   = pNode->GetSubNode( 0 ),
1345             *pDenom = pNode->GetSubNode( 2 );
1346
1347     SmCaretPosGraphEntry *left,
1348                          *right,
1349                          *numLeft,
1350                          *denomLeft;
1351
1352     //Set left
1353     left = pRightMost;
1354     OSL_ENSURE( pRightMost, "There must be a position in front of this" );
1355
1356     //Create right
1357     right = pGraph->Add( SmCaretPos( pNode, 1 ) );
1358
1359     //Create numLeft
1360     numLeft = pGraph->Add( SmCaretPos( pNum, 0 ), left );
1361     left->SetRight( numLeft );
1362
1363     //Visit pNum
1364     pRightMost = numLeft;
1365     pNum->Accept( this );
1366     pRightMost->SetRight( right );
1367     right->SetLeft( pRightMost );
1368
1369     //Create denomLeft
1370     denomLeft = pGraph->Add( SmCaretPos( pDenom, 0 ), left );
1371
1372     //Visit pDenom
1373     pRightMost = denomLeft;
1374     pDenom->Accept( this );
1375     pRightMost->SetRight( right );
1376
1377     //Set return parameter
1378     pRightMost = right;
1379 }
1380
1381 /** Build SmCaretPosGraph for SmVerticalBraceNode
1382  *
1383  * Lines in an SmVerticalBraceNode:
1384  * \code
1385  *   pScript
1386  *  ________
1387  * /        \
1388  *   pBody
1389  * \endcode
1390  *
1391  */
1392 void SmCaretPosGraphBuildingVisitor::Visit( SmVerticalBraceNode* pNode )
1393 {
1394     SmNode  *pBody   = pNode->GetSubNode( 0 ),
1395             *pScript = pNode->GetSubNode( 2 );
1396     //None of these children can be NULL
1397
1398     SmCaretPosGraphEntry  *left,
1399                         *bodyLeft,
1400                         *scriptLeft,
1401                         *right;
1402
1403     left = pRightMost;
1404
1405     //Create right
1406     right = pGraph->Add( SmCaretPos( pNode, 1 ) );
1407
1408     //Create bodyLeft
1409     bodyLeft = pGraph->Add( SmCaretPos( pBody, 0 ), left );
1410     left->SetRight( bodyLeft );
1411     pRightMost = bodyLeft;
1412     pBody->Accept( this );
1413     pRightMost->SetRight( right );
1414     right->SetLeft( pRightMost );
1415
1416     //Create script
1417     scriptLeft = pGraph->Add( SmCaretPos( pScript, 0 ), left );
1418     pRightMost = scriptLeft;
1419     pScript->Accept( this );
1420     pRightMost->SetRight( right );
1421
1422     //Set return value
1423     pRightMost = right;
1424 }
1425
1426 /** Build SmCaretPosGraph for SmBinDiagonalNode
1427  *
1428  * Lines in an SmBinDiagonalNode:
1429  * \code
1430  *  A /
1431  *   /
1432  *  / B
1433  * \endcode
1434  * Where A and B are lines.
1435  *
1436  * Used in formulas such as "A wideslash B"
1437  */
1438 void SmCaretPosGraphBuildingVisitor::Visit( SmBinDiagonalNode* pNode )
1439 {
1440     SmNode  *A = pNode->GetSubNode( 0 ),
1441             *B = pNode->GetSubNode( 1 );
1442
1443     SmCaretPosGraphEntry  *left,
1444                         *leftA,
1445                         *rightA,
1446                         *leftB,
1447                         *right;
1448     left = pRightMost;
1449
1450     //Create right
1451     right = pGraph->Add( SmCaretPos( pNode, 1 ) );
1452
1453     //Create left A
1454     leftA = pGraph->Add( SmCaretPos( A, 0 ), left );
1455     left->SetRight( leftA );
1456
1457     //Visit A
1458     pRightMost = leftA;
1459     A->Accept( this );
1460     rightA = pRightMost;
1461
1462     //Create left B
1463     leftB = pGraph->Add( SmCaretPos( B, 0 ), rightA );
1464     rightA->SetRight( leftB );
1465
1466     //Visit B
1467     pRightMost = leftB;
1468     B->Accept( this );
1469     pRightMost->SetRight( right );
1470     right->SetLeft( pRightMost );
1471
1472     //Set return value
1473     pRightMost = right;
1474 }
1475
1476 //Straigt forward ( I think )
1477 void SmCaretPosGraphBuildingVisitor::Visit( SmBinHorNode* pNode )
1478 {
1479     SmNodeIterator it( pNode );
1480     while( it.Next( ) )
1481         it->Accept( this );
1482 }
1483 void SmCaretPosGraphBuildingVisitor::Visit( SmUnHorNode* pNode )
1484 {
1485     // Unary operator node
1486     SmNodeIterator it( pNode );
1487     while( it.Next( ) )
1488         it->Accept( this );
1489
1490 }
1491
1492 void SmCaretPosGraphBuildingVisitor::Visit( SmExpressionNode* pNode )
1493 {
1494     SmNodeIterator it( pNode );
1495     while( it.Next( ) )
1496         it->Accept( this );
1497 }
1498
1499 void SmCaretPosGraphBuildingVisitor::Visit( SmFontNode* pNode )
1500 {
1501     //Has only got one child, should act as an expression if possible
1502     SmNodeIterator it( pNode );
1503     while( it.Next( ) )
1504         it->Accept( this );
1505 }
1506
1507 /** Build SmCaretPosGraph for SmBracebodyNode
1508  * Acts as an SmExpressionNode
1509  *
1510  * Below is an example of a formula tree that has multiple children for SmBracebodyNode
1511  * \dot
1512  * digraph {
1513  * labelloc = "t";
1514  * label= "Equation: \"lbrace i mline i in setZ rbrace\"";
1515  * n0 [label="SmTableNode"];
1516  * n0 -> n1 [label="0"];
1517  * n1 [label="SmLineNode"];
1518  * n1 -> n2 [label="0"];
1519  * n2 [label="SmExpressionNode"];
1520  * n2 -> n3 [label="0"];
1521  * n3 [label="SmBraceNode"];
1522  * n3 -> n4 [label="0"];
1523  * n4 [label="SmMathSymbolNode: {"];
1524  * n3 -> n5 [label="1"];
1525  * n5 [label="SmBracebodyNode"];
1526  * n5 -> n6 [label="0"];
1527  * n6 [label="SmExpressionNode"];
1528  * n6 -> n7 [label="0"];
1529  * n7 [label="SmTextNode: i"];
1530  * n5 -> n8 [label="1"];
1531  * n8 [label="SmMathSymbolNode: ∣"];
1532  * n5 -> n9 [label="2"];
1533  * n9 [label="SmExpressionNode"];
1534  * n9 -> n10 [label="0"];
1535  * n10 [label="SmBinHorNode"];
1536  * n10 -> n11 [label="0"];
1537  * n11 [label="SmTextNode: i"];
1538  * n10 -> n12 [label="1"];
1539  * n12 [label="SmMathSymbolNode: ∈"];
1540  * n10 -> n13 [label="2"];
1541  * n13 [label="SmMathSymbolNode: ℤ"];
1542  * n3 -> n14 [label="2"];
1543  * n14 [label="SmMathSymbolNode: }"];
1544  * }
1545  * \enddot
1546  */
1547 void SmCaretPosGraphBuildingVisitor::Visit( SmBracebodyNode* pNode )
1548 {
1549     SmNodeIterator it( pNode );
1550     while( it.Next( ) ) {
1551         SmCaretPosGraphEntry* pStart = pGraph->Add( SmCaretPos( it.Current(), 0), pRightMost );
1552         pRightMost->SetRight( pStart );
1553         pRightMost = pStart;
1554         it->Accept( this );
1555     }
1556 }
1557
1558 /** Build SmCaretPosGraph for SmAlignNode
1559  * Acts as an SmExpressionNode, as it only has one child this okay
1560  */
1561 void SmCaretPosGraphBuildingVisitor::Visit( SmAlignNode* pNode )
1562 {
1563     SmNodeIterator it( pNode );
1564     while( it.Next( ) )
1565         it->Accept( this );
1566 }
1567
1568 /** Build SmCaretPosGraph for SmRootNode
1569  *
1570  * Lines in an SmRootNode:
1571  * \code
1572  *    _________
1573  *  A/
1574  * \/    B
1575  *
1576  * \endcode
1577  * A: pExtra ( optional, can be NULL ),
1578  * B: pBody
1579  *
1580  * Graph over these, where "left" is before the SmRootNode and "right" is after:
1581  * \dot
1582  *  digraph Graph{
1583  *      left -> B;
1584  *      B -> right;
1585  *      A -> B;
1586  *  }
1587  * \enddot
1588  */
1589 void SmCaretPosGraphBuildingVisitor::Visit( SmRootNode* pNode )
1590 {
1591     SmNode  *pExtra = pNode->GetSubNode( 0 ), //Argument, NULL for sqrt, and SmTextNode if cubicroot
1592             *pBody  = pNode->GetSubNode( 2 ); //Body of the root
1593     OSL_ENSURE( pBody, "pBody cannot be NULL" );
1594
1595     SmCaretPosGraphEntry  *left,
1596                         *right,
1597                         *bodyLeft,
1598                         *bodyRight;
1599
1600     //Get left and save it
1601     OSL_ENSURE( pRightMost, "There must be a position in front of this" );
1602     left = pRightMost;
1603
1604     //Create body left
1605     bodyLeft = pGraph->Add( SmCaretPos( pBody, 0 ), left );
1606     left->SetRight( bodyLeft );
1607
1608     //Create right
1609     right = pGraph->Add( SmCaretPos( pNode, 1 ) );
1610
1611     //Visit body
1612     pRightMost = bodyLeft;
1613     pBody->Accept( this );
1614     bodyRight = pRightMost;
1615     bodyRight->SetRight( right );
1616     right->SetLeft( bodyRight );
1617
1618     //Visit pExtra
1619     if( pExtra ){
1620         pRightMost = pGraph->Add( SmCaretPos( pExtra, 0 ), left );
1621         pExtra->Accept( this );
1622         pRightMost->SetRight( bodyLeft );
1623     }
1624
1625     pRightMost = right;
1626 }
1627
1628 /** Build SmCaretPosGraph for SmPlaceNode
1629  * Consider this a single character.
1630  */
1631 void SmCaretPosGraphBuildingVisitor::Visit( SmPlaceNode* pNode )
1632 {
1633     SmCaretPosGraphEntry* right = pGraph->Add( SmCaretPos( pNode, 1 ), pRightMost );
1634     pRightMost->SetRight( right );
1635     pRightMost = right;
1636 }
1637
1638 /** SmErrorNode is context dependent metadata, it can't be selected
1639  *
1640  * @remarks There's no point in deleting, copying and/or moving an instance
1641  * of SmErrorNode as it may not exist in an other context! Thus there are no
1642  * positions to select an SmErrorNode.
1643  */
1644 void SmCaretPosGraphBuildingVisitor::Visit( SmErrorNode* )
1645 {
1646 }
1647
1648 /** Build SmCaretPosGraph for SmBlankNode
1649  * Consider this a single character, as it is only a blank space
1650  */
1651 void SmCaretPosGraphBuildingVisitor::Visit( SmBlankNode* pNode )
1652 {
1653     SmCaretPosGraphEntry* right = pGraph->Add( SmCaretPos( pNode, 1 ), pRightMost );
1654     pRightMost->SetRight( right );
1655     pRightMost = right;
1656 }
1657
1658 /** Build SmCaretPosGraph for SmBraceNode
1659  *
1660  * Lines in an SmBraceNode:
1661  * \code
1662  * |     |
1663  * |  B  |
1664  * |     |
1665  * \endcode
1666  * B: Body
1667  *
1668  * Graph over these, where "left" is before the SmBraceNode and "right" is after:
1669  * \dot
1670  *  digraph Graph{
1671  *      left -> B;
1672  *      B -> right;
1673  *  }
1674  * \enddot
1675  */
1676 void SmCaretPosGraphBuildingVisitor::Visit( SmBraceNode* pNode )
1677 {
1678     SmNode* pBody = pNode->GetSubNode( 1 );
1679
1680     SmCaretPosGraphEntry  *left = pRightMost,
1681                         *right = pGraph->Add( SmCaretPos( pNode, 1 ) );
1682
1683     if( pBody->GetType() != NBRACEBODY ) {
1684         pRightMost = pGraph->Add( SmCaretPos( pBody, 0 ), left );
1685         left->SetRight( pRightMost );
1686     }else
1687         pRightMost = left;
1688
1689     pBody->Accept( this );
1690     pRightMost->SetRight( right );
1691     right->SetLeft( pRightMost );
1692
1693     pRightMost = right;
1694 }
1695
1696 /** Build SmCaretPosGraph for SmAttributNode
1697  *
1698  * Lines in an SmAttributNode:
1699  * \code
1700  *   Attr
1701  *   Body
1702  * \endcode
1703  *
1704  * There's a body and an attribute, the construction is used for "widehat A", where "A" is the body
1705  * and "^" is the attribute ( note GetScaleMode( ) on SmAttributNode tells how the attribute should be
1706  * scaled ).
1707  */
1708 void SmCaretPosGraphBuildingVisitor::Visit( SmAttributNode* pNode )
1709 {
1710     SmNode  *pAttr = pNode->GetSubNode( 0 ),
1711             *pBody = pNode->GetSubNode( 1 );
1712     //None of the children can be NULL
1713
1714     SmCaretPosGraphEntry  *left = pRightMost,
1715                         *attrLeft,
1716                         *bodyLeft,
1717                         *bodyRight,
1718                         *right;
1719
1720     //Creating bodyleft
1721     bodyLeft = pGraph->Add( SmCaretPos( pBody, 0 ), left );
1722     left->SetRight( bodyLeft );
1723
1724     //Creating right
1725     right = pGraph->Add( SmCaretPos( pNode, 1 ) );
1726
1727     //Visit the body
1728     pRightMost = bodyLeft;
1729     pBody->Accept( this );
1730     bodyRight = pRightMost;
1731     bodyRight->SetRight( right );
1732     right->SetLeft( bodyRight );
1733
1734     //Create attrLeft
1735     attrLeft = pGraph->Add( SmCaretPos( pAttr, 0 ), left );
1736
1737     //Visit attribute
1738     pRightMost = attrLeft;
1739     pAttr->Accept( this );
1740     pRightMost->SetRight( right );
1741
1742     //Set return value
1743     pRightMost = right;
1744 }
1745
1746 //Consider these single symboles
1747 void SmCaretPosGraphBuildingVisitor::Visit( SmSpecialNode* pNode )
1748 {
1749     SmCaretPosGraphEntry* right = pGraph->Add( SmCaretPos( pNode, 1 ), pRightMost );
1750     pRightMost->SetRight( right );
1751     pRightMost = right;
1752 }
1753 void SmCaretPosGraphBuildingVisitor::Visit( SmGlyphSpecialNode* pNode )
1754 {
1755     SmCaretPosGraphEntry* right = pGraph->Add( SmCaretPos( pNode, 1 ), pRightMost );
1756     pRightMost->SetRight( right );
1757     pRightMost = right;
1758 }
1759 void SmCaretPosGraphBuildingVisitor::Visit( SmMathSymbolNode* pNode )
1760 {
1761     SmCaretPosGraphEntry* right = pGraph->Add( SmCaretPos( pNode, 1 ), pRightMost );
1762     pRightMost->SetRight( right );
1763     pRightMost = right;
1764 }
1765
1766 void SmCaretPosGraphBuildingVisitor::Visit( SmRootSymbolNode* )
1767 {
1768     //Do nothing
1769 }
1770 void SmCaretPosGraphBuildingVisitor::Visit( SmRectangleNode* )
1771 {
1772     //Do nothing
1773 }
1774 void SmCaretPosGraphBuildingVisitor::Visit( SmPolyLineNode* )
1775 {
1776     //Do nothing
1777 }
1778
1779 /////////////////////////////// SmCloningVisitor ///////////////////////////////
1780
1781 SmNode* SmCloningVisitor::Clone( SmNode* pNode )
1782 {
1783     SmNode* pCurrResult = pResult;
1784     pNode->Accept( this );
1785     SmNode* pClone = pResult;
1786     pResult = pCurrResult;
1787     return pClone;
1788 }
1789
1790 void SmCloningVisitor::CloneNodeAttr( SmNode* pSource, SmNode* pTarget )
1791 {
1792     pTarget->SetScaleMode( pSource->GetScaleMode( ) );
1793     //Other attributes are set when prepare or arrange is executed
1794     //and may depend on stuff not being cloned here.
1795 }
1796
1797 void SmCloningVisitor::CloneKids( SmStructureNode* pSource, SmStructureNode* pTarget )
1798 {
1799     //Cache current result
1800     SmNode* pCurrResult = pResult;
1801
1802     //Create array for holding clones
1803     sal_uInt16 nSize = pSource->GetNumSubNodes( );
1804     SmNodeArray aNodes( nSize );
1805
1806     //Clone children
1807     SmNode* pKid;
1808     for( sal_uInt16 i = 0; i < nSize; i++ ){
1809         if( NULL != ( pKid = pSource->GetSubNode( i ) ) )
1810             pKid->Accept( this );
1811         else
1812             pResult = NULL;
1813         aNodes[i] = pResult;
1814     }
1815
1816     //Set subnodes of pTarget
1817     pTarget->SetSubNodes( aNodes );
1818
1819     //Restore result as where prior to call
1820     pResult = pCurrResult;
1821 }
1822
1823 void SmCloningVisitor::Visit( SmTableNode* pNode )
1824 {
1825     SmTableNode* pClone = new SmTableNode( pNode->GetToken( ) );
1826     CloneNodeAttr( pNode, pClone );
1827     CloneKids( pNode, pClone );
1828     pResult = pClone;
1829 }
1830
1831 void SmCloningVisitor::Visit( SmBraceNode* pNode )
1832 {
1833     SmBraceNode* pClone = new SmBraceNode( pNode->GetToken( ) );
1834     CloneNodeAttr( pNode, pClone );
1835     CloneKids( pNode, pClone );
1836     pResult = pClone;
1837 }
1838
1839 void SmCloningVisitor::Visit( SmBracebodyNode* pNode )
1840 {
1841     SmBracebodyNode* pClone = new SmBracebodyNode( pNode->GetToken( ) );
1842     CloneNodeAttr( pNode, pClone );
1843     CloneKids( pNode, pClone );
1844     pResult = pClone;
1845 }
1846
1847 void SmCloningVisitor::Visit( SmOperNode* pNode )
1848 {
1849     SmOperNode* pClone = new SmOperNode( pNode->GetToken( ) );
1850     CloneNodeAttr( pNode, pClone );
1851     CloneKids( pNode, pClone );
1852     pResult = pClone;
1853 }
1854
1855 void SmCloningVisitor::Visit( SmAlignNode* pNode )
1856 {
1857     SmAlignNode* pClone = new SmAlignNode( pNode->GetToken( ) );
1858     CloneNodeAttr( pNode, pClone );
1859     CloneKids( pNode, pClone );
1860     pResult = pClone;
1861 }
1862
1863 void SmCloningVisitor::Visit( SmAttributNode* pNode )
1864 {
1865     SmAttributNode* pClone = new SmAttributNode( pNode->GetToken( ) );
1866     CloneNodeAttr( pNode, pClone );
1867     CloneKids( pNode, pClone );
1868     pResult = pClone;
1869 }
1870
1871 void SmCloningVisitor::Visit( SmFontNode* pNode )
1872 {
1873     SmFontNode* pClone = new SmFontNode( pNode->GetToken( ) );
1874     pClone->SetSizeParameter( pNode->GetSizeParameter( ), pNode->GetSizeType( ) );
1875     CloneNodeAttr( pNode, pClone );
1876     CloneKids( pNode, pClone );
1877     pResult = pClone;
1878 }
1879
1880 void SmCloningVisitor::Visit( SmUnHorNode* pNode )
1881 {
1882     SmUnHorNode* pClone = new SmUnHorNode( pNode->GetToken( ) );
1883     CloneNodeAttr( pNode, pClone );
1884     CloneKids( pNode, pClone );
1885     pResult = pClone;
1886 }
1887
1888 void SmCloningVisitor::Visit( SmBinHorNode* pNode )
1889 {
1890     SmBinHorNode* pClone = new SmBinHorNode( pNode->GetToken( ) );
1891     CloneNodeAttr( pNode, pClone );
1892     CloneKids( pNode, pClone );
1893     pResult = pClone;
1894 }
1895
1896 void SmCloningVisitor::Visit( SmBinVerNode* pNode )
1897 {
1898     SmBinVerNode* pClone = new SmBinVerNode( pNode->GetToken( ) );
1899     CloneNodeAttr( pNode, pClone );
1900     CloneKids( pNode, pClone );
1901     pResult = pClone;
1902 }
1903
1904 void SmCloningVisitor::Visit( SmBinDiagonalNode* pNode )
1905 {
1906     SmBinDiagonalNode *pClone = new SmBinDiagonalNode( pNode->GetToken( ) );
1907     pClone->SetAscending( pNode->IsAscending( ) );
1908     CloneNodeAttr( pNode, pClone );
1909     CloneKids( pNode, pClone );
1910     pResult = pClone;
1911 }
1912
1913 void SmCloningVisitor::Visit( SmSubSupNode* pNode )
1914 {
1915     SmSubSupNode *pClone = new SmSubSupNode( pNode->GetToken( ) );
1916     pClone->SetUseLimits( pNode->IsUseLimits( ) );
1917     CloneNodeAttr( pNode, pClone );
1918     CloneKids( pNode, pClone );
1919     pResult = pClone;
1920 }
1921
1922 void SmCloningVisitor::Visit( SmMatrixNode* pNode )
1923 {
1924     SmMatrixNode *pClone = new SmMatrixNode( pNode->GetToken( ) );
1925     pClone->SetRowCol( pNode->GetNumRows( ), pNode->GetNumCols( ) );
1926     CloneNodeAttr( pNode, pClone );
1927     CloneKids( pNode, pClone );
1928     pResult = pClone;
1929 }
1930
1931 void SmCloningVisitor::Visit( SmPlaceNode* pNode )
1932 {
1933     pResult = new SmPlaceNode( pNode->GetToken( ) );
1934     CloneNodeAttr( pNode, pResult );
1935 }
1936
1937 void SmCloningVisitor::Visit( SmTextNode* pNode )
1938 {
1939     SmTextNode* pClone = new SmTextNode( pNode->GetToken( ), pNode->GetFontDesc( ) );
1940     pClone->ChangeText( pNode->GetText( ) );
1941     CloneNodeAttr( pNode, pClone );
1942     pResult = pClone;
1943 }
1944
1945 void SmCloningVisitor::Visit( SmSpecialNode* pNode )
1946 {
1947     pResult = new SmSpecialNode( pNode->GetToken( ) );
1948     CloneNodeAttr( pNode, pResult );
1949 }
1950
1951 void SmCloningVisitor::Visit( SmGlyphSpecialNode* pNode )
1952 {
1953     pResult = new SmGlyphSpecialNode( pNode->GetToken( ) );
1954     CloneNodeAttr( pNode, pResult );
1955 }
1956
1957 void SmCloningVisitor::Visit( SmMathSymbolNode* pNode )
1958 {
1959     pResult = new SmMathSymbolNode( pNode->GetToken( ) );
1960     CloneNodeAttr( pNode, pResult );
1961 }
1962
1963 void SmCloningVisitor::Visit( SmBlankNode* pNode )
1964 {
1965     SmBlankNode* pClone = new SmBlankNode( pNode->GetToken( ) );
1966     pClone->SetBlankNum( pNode->GetBlankNum( ) );
1967     pResult = pClone;
1968     CloneNodeAttr( pNode, pResult );
1969 }
1970
1971 void SmCloningVisitor::Visit( SmErrorNode* pNode )
1972 {
1973     //PE_NONE is used the information have been discarded and isn't used
1974     pResult = new SmErrorNode( PE_NONE, pNode->GetToken( ) );
1975     CloneNodeAttr( pNode, pResult );
1976 }
1977
1978 void SmCloningVisitor::Visit( SmLineNode* pNode )
1979 {
1980     SmLineNode* pClone = new SmLineNode( pNode->GetToken( ) );
1981     CloneNodeAttr( pNode, pClone );
1982     CloneKids( pNode, pClone );
1983     pResult = pClone;
1984 }
1985
1986 void SmCloningVisitor::Visit( SmExpressionNode* pNode )
1987 {
1988     SmExpressionNode* pClone = new SmExpressionNode( pNode->GetToken( ) );
1989     CloneNodeAttr( pNode, pClone );
1990     CloneKids( pNode, pClone );
1991     pResult = pClone;
1992 }
1993
1994 void SmCloningVisitor::Visit( SmPolyLineNode* pNode )
1995 {
1996     pResult = new SmPolyLineNode( pNode->GetToken( ) );
1997     CloneNodeAttr( pNode, pResult );
1998 }
1999
2000 void SmCloningVisitor::Visit( SmRootNode* pNode )
2001 {
2002     SmRootNode* pClone = new SmRootNode( pNode->GetToken( ) );
2003     CloneNodeAttr( pNode, pClone );
2004     CloneKids( pNode, pClone );
2005     pResult = pClone;
2006 }
2007
2008 void SmCloningVisitor::Visit( SmRootSymbolNode* pNode )
2009 {
2010     pResult = new SmRootSymbolNode( pNode->GetToken( ) );
2011     CloneNodeAttr( pNode, pResult );
2012 }
2013
2014 void SmCloningVisitor::Visit( SmRectangleNode* pNode )
2015 {
2016     pResult = new SmRectangleNode( pNode->GetToken( ) );
2017     CloneNodeAttr( pNode, pResult );
2018 }
2019
2020 void SmCloningVisitor::Visit( SmVerticalBraceNode* pNode )
2021 {
2022     SmVerticalBraceNode* pClone = new SmVerticalBraceNode( pNode->GetToken( ) );
2023     CloneNodeAttr( pNode, pClone );
2024     CloneKids( pNode, pClone );
2025     pResult = pClone;
2026 }
2027
2028 /////////////////////////////// SmSelectionDrawingVisitor ///////////////////////////////
2029
2030 SmSelectionDrawingVisitor::SmSelectionDrawingVisitor( OutputDevice& rDevice, SmNode* pTree, Point Offset )
2031     : rDev( rDevice ) {
2032     bHasSelectionArea = false;
2033
2034     //Visit everything
2035     OSL_ENSURE( pTree, "pTree can't be null!" );
2036     if( pTree )
2037         pTree->Accept( this );
2038
2039     //Draw selection if there's any
2040     if( bHasSelectionArea ){
2041         aSelectionArea.Move( Offset.X( ), Offset.Y( ) );
2042
2043         //Save device state
2044         rDev.Push( PUSH_LINECOLOR | PUSH_FILLCOLOR );
2045         //Change colors
2046         rDev.SetLineColor( );
2047         rDev.SetFillColor( Color( COL_LIGHTGRAY ) );
2048
2049         //Draw rectangle
2050         rDev.DrawRect( aSelectionArea );
2051
2052         //Restore device state
2053         rDev.Pop( );
2054     }
2055 }
2056
2057 void SmSelectionDrawingVisitor::ExtendSelectionArea( Rectangle aArea )
2058 {
2059     if ( ! bHasSelectionArea ) {
2060         aSelectionArea = aArea;
2061         bHasSelectionArea = true;
2062     } else
2063         aSelectionArea.Union( aArea );
2064 }
2065
2066 void SmSelectionDrawingVisitor::DefaultVisit( SmNode* pNode )
2067 {
2068     if( pNode->IsSelected( ) )
2069         ExtendSelectionArea( pNode->AsRectangle( ) );
2070     VisitChildren( pNode );
2071 }
2072
2073 void SmSelectionDrawingVisitor::VisitChildren( SmNode* pNode )
2074 {
2075     SmNodeIterator it( pNode );
2076     while( it.Next( ) )
2077         it->Accept( this );
2078 }
2079
2080 void SmSelectionDrawingVisitor::Visit( SmTextNode* pNode )
2081 {
2082     if( pNode->IsSelected( ) ){
2083         rDev.Push( PUSH_TEXTCOLOR | PUSH_FONT );
2084
2085         rDev.SetFont( pNode->GetFont( ) );
2086         Point Position = pNode->GetTopLeft( );
2087         long left   = Position.getX( ) + rDev.GetTextWidth( pNode->GetText( ), 0, pNode->GetSelectionStart( ) );
2088         long right  = Position.getX( ) + rDev.GetTextWidth( pNode->GetText( ), 0, pNode->GetSelectionEnd( ) );
2089         long top    = Position.getY( );
2090         long bottom = top + pNode->GetHeight( );
2091         Rectangle rect( left, top, right, bottom );
2092
2093         ExtendSelectionArea( rect );
2094
2095         rDev.Pop( );
2096     }
2097 }
2098
2099 /////////////////////////////// SmNodeToTextVisitor ///////////////////////////////
2100
2101 SmNodeToTextVisitor::SmNodeToTextVisitor( SmNode* pNode, OUString &rText )
2102 {
2103     pNode->Accept( this );
2104     rText = aCmdText.makeStringAndClear();
2105 }
2106
2107 void SmNodeToTextVisitor::Visit( SmTableNode* pNode )
2108 {
2109     if( pNode->GetToken( ).eType == TBINOM ) {
2110         Append( "{ binom" );
2111         LineToText( pNode->GetSubNode( 0 ) );
2112         LineToText( pNode->GetSubNode( 1 ) );
2113         Append("} ");
2114     } else if( pNode->GetToken( ).eType == TSTACK ) {
2115         Append( "stack{ " );
2116         SmNodeIterator it( pNode );
2117         it.Next( );
2118         while( true ) {
2119             LineToText( it.Current( ) );
2120             if( it.Next( ) ) {
2121                 Separate( );
2122                 Append( "# " );
2123             }else
2124                 break;
2125         }
2126         Separate( );
2127         Append( "}" );
2128     } else { //Assume it's a toplevel table, containing lines
2129         SmNodeIterator it( pNode );
2130         it.Next( );
2131         while( true ) {
2132             Separate( );
2133             it->Accept( this );
2134             if( it.Next( ) ) {
2135                 Separate( );
2136                 Append( "newline" );
2137             }else
2138                 break;
2139         }
2140     }
2141 }
2142
2143 void SmNodeToTextVisitor::Visit( SmBraceNode* pNode )
2144 {
2145     SmNode *pLeftBrace  = pNode->GetSubNode( 0 ),
2146            *pBody       = pNode->GetSubNode( 1 ),
2147            *pRightBrace = pNode->GetSubNode( 2 );
2148     //Handle special case where it's absolute function
2149     if( pNode->GetToken( ).eType == TABS ) {
2150         Append( "abs" );
2151         LineToText( pBody );
2152     } else {
2153         if( pNode->GetScaleMode( ) == SCALE_HEIGHT )
2154             Append( "left " );
2155         pLeftBrace->Accept( this );
2156         Separate( );
2157         pBody->Accept( this );
2158         Separate( );
2159         if( pNode->GetScaleMode( ) == SCALE_HEIGHT )
2160             Append( "right " );
2161         pRightBrace->Accept( this );
2162     }
2163 }
2164
2165 void SmNodeToTextVisitor::Visit( SmBracebodyNode* pNode )
2166 {
2167     SmNodeIterator it( pNode );
2168     while( it.Next( ) ){
2169         Separate( );
2170         it->Accept( this );
2171     }
2172 }
2173
2174 void SmNodeToTextVisitor::Visit( SmOperNode* pNode )
2175 {
2176     Append( pNode->GetToken( ).aText );
2177     Separate( );
2178     if( pNode->GetToken( ).eType == TOPER ){
2179         //There's an SmGlyphSpecialNode if eType == TOPER
2180         if( pNode->GetSubNode( 0 )->GetType( ) == NSUBSUP )
2181             Append( pNode->GetSubNode( 0 )->GetSubNode( 0 )->GetToken( ).aText );
2182         else
2183             Append( pNode->GetSubNode( 0 )->GetToken( ).aText );
2184     }
2185     if( pNode->GetSubNode( 0 )->GetType( ) == NSUBSUP ) {
2186         SmSubSupNode *pSubSup = ( SmSubSupNode* )pNode->GetSubNode( 0 );
2187         SmNode* pChild;
2188         if( ( pChild = pSubSup->GetSubSup( LSUP ) ) ) {
2189             Separate( );
2190             Append( "lsup { " );
2191             LineToText( pChild );
2192             Append( "} " );
2193         }
2194         if( ( pChild = pSubSup->GetSubSup( LSUB ) ) ) {
2195             Separate( );
2196             Append( "lsub { " );
2197             LineToText( pChild );
2198             Append( "} " );
2199         }
2200         if( ( pChild = pSubSup->GetSubSup( RSUP ) ) ) {
2201             Separate( );
2202             Append( "^ { " );
2203             LineToText( pChild );
2204             Append( "} " );
2205         }
2206         if( ( pChild = pSubSup->GetSubSup( RSUB ) ) ) {
2207             Separate( );
2208             Append( "_ { " );
2209             LineToText( pChild );
2210             Append( "} " );
2211         }
2212         if( ( pChild = pSubSup->GetSubSup( CSUB ) ) ) {
2213             Separate( );
2214             if (pSubSup->IsUseLimits())
2215                 Append( "from { " );
2216             else
2217                 Append( "csub { " );
2218             LineToText( pChild );
2219             Append( "} " );
2220         }
2221         if( ( pChild = pSubSup->GetSubSup( CSUP ) ) ) {
2222             Separate( );
2223             if (pSubSup->IsUseLimits())
2224                 Append( "to { " );
2225             else
2226                 Append( "csup { " );
2227             LineToText( pChild );
2228             Append( "} " );
2229         }
2230     }
2231     LineToText( pNode->GetSubNode( 1 ) );
2232 }
2233
2234 void SmNodeToTextVisitor::Visit( SmAlignNode* pNode )
2235 {
2236     Append( pNode->GetToken( ).aText );
2237     LineToText( pNode->GetSubNode( 0 ) );
2238 }
2239
2240 void SmNodeToTextVisitor::Visit( SmAttributNode* pNode )
2241 {
2242     Append( pNode->GetToken( ).aText );
2243     LineToText( pNode->GetSubNode( 1 ) );
2244 }
2245
2246 void SmNodeToTextVisitor::Visit( SmFontNode* pNode )
2247 {
2248     switch ( pNode->GetToken( ).eType )
2249     {
2250         case TBOLD:
2251             Append( "bold " );
2252             break;
2253         case TNBOLD:
2254             Append( "nbold " );
2255             break;
2256         case TITALIC:
2257             Append( "italic " );
2258             break;
2259         case TNITALIC:
2260             Append( "nitalic " );
2261             break;
2262         case TPHANTOM:
2263             Append( "phantom " );
2264             break;
2265         case TSIZE:
2266             {
2267                 Append( "size " );
2268                 switch ( pNode->GetSizeType( ) )
2269                 {
2270                     case FNTSIZ_PLUS:
2271                         Append( "+" );
2272                         break;
2273                     case FNTSIZ_MINUS:
2274                         Append( "-" );
2275                         break;
2276                     case FNTSIZ_MULTIPLY:
2277                         Append( "*" );
2278                         break;
2279                     case FNTSIZ_DIVIDE:
2280                         Append( "/" );
2281                         break;
2282                     case FNTSIZ_ABSOLUT:
2283                     default:
2284                         break;
2285                 }
2286                 Append( ::rtl::math::doubleToUString(
2287                             static_cast<double>( pNode->GetSizeParameter( ) ),
2288                             rtl_math_StringFormat_Automatic,
2289                             rtl_math_DecimalPlaces_Max, '.', sal_True ) );
2290                 Append( " " );
2291             }
2292             break;
2293         case TBLACK:
2294             Append( "color black " );
2295             break;
2296         case TWHITE:
2297             Append( "color white " );
2298             break;
2299         case TRED:
2300             Append( "color red " );
2301             break;
2302         case TGREEN:
2303             Append( "color green " );
2304             break;
2305         case TBLUE:
2306             Append( "color blue " );
2307             break;
2308         case TCYAN:
2309             Append( "color cyan " );
2310             break;
2311         case TMAGENTA:
2312             Append( "color magenta " );
2313             break;
2314         case TYELLOW:
2315             Append( "color yellow " );
2316             break;
2317         case TSANS:
2318             Append( "font sans " );
2319             break;
2320         case TSERIF:
2321             Append( "font serif " );
2322             break;
2323         case TFIXED:
2324             Append( "font fixed " );
2325             break;
2326         default:
2327             break;
2328     }
2329     LineToText( pNode->GetSubNode( 1 ) );
2330 }
2331
2332 void SmNodeToTextVisitor::Visit( SmUnHorNode* pNode )
2333 {
2334     SmNodeIterator it( pNode, pNode->GetSubNode( 1 )->GetToken( ).eType == TFACT );
2335     while( it.Next( ) ) {
2336         Separate( );
2337         it->Accept( this );
2338     }
2339 }
2340
2341 void SmNodeToTextVisitor::Visit( SmBinHorNode* pNode )
2342 {
2343     SmNode *pLeft  = pNode->GetSubNode( 0 ),
2344            *pOper  = pNode->GetSubNode( 1 ),
2345            *pRight = pNode->GetSubNode( 2 );
2346     Separate( );
2347     pLeft->Accept( this );
2348     Separate( );
2349     pOper->Accept( this );
2350     Separate( );
2351     pRight->Accept( this );
2352     Separate( );
2353 }
2354
2355 void SmNodeToTextVisitor::Visit( SmBinVerNode* pNode )
2356 {
2357     SmNode *pNum    = pNode->GetSubNode( 0 ),
2358            *pDenom  = pNode->GetSubNode( 2 );
2359     Append( "{ " );
2360     LineToText( pNum );
2361     Append( "over" );
2362     LineToText( pDenom );
2363     Append( "} " );
2364 }
2365
2366 void SmNodeToTextVisitor::Visit( SmBinDiagonalNode* pNode )
2367 {
2368     SmNode *pLeftOperand  = pNode->GetSubNode( 0 ),
2369            *pRightOperand = pNode->GetSubNode( 1 );
2370     Append( "{ " );
2371     LineToText( pLeftOperand );
2372     Separate( );
2373     Append( "wideslash " );
2374     LineToText( pRightOperand );
2375     Append( "} " );
2376 }
2377
2378 void SmNodeToTextVisitor::Visit( SmSubSupNode* pNode )
2379 {
2380     LineToText( pNode->GetBody( ) );
2381     SmNode *pChild;
2382     if( ( pChild = pNode->GetSubSup( LSUP ) ) ) {
2383         Separate( );
2384         Append( "lsup " );
2385         LineToText( pChild );
2386     }
2387     if( ( pChild = pNode->GetSubSup( LSUB ) ) ) {
2388         Separate( );
2389         Append( "lsub " );
2390         LineToText( pChild );
2391     }
2392     if( ( pChild = pNode->GetSubSup( RSUP ) ) ) {
2393         Separate( );
2394         Append( "^ " );
2395         LineToText( pChild );
2396     }
2397     if( ( pChild = pNode->GetSubSup( RSUB ) ) ) {
2398         Separate( );
2399         Append( "_ " );
2400         LineToText( pChild );
2401     }
2402     if( ( pChild = pNode->GetSubSup( CSUB ) ) ) {
2403         Separate( );
2404         if (pNode->IsUseLimits())
2405             Append( "from " );
2406         else
2407             Append( "csub " );
2408         LineToText( pChild );
2409     }
2410     if( ( pChild = pNode->GetSubSup( CSUP ) ) ) {
2411         Separate( );
2412         if (pNode->IsUseLimits())
2413             Append( "to " );
2414         else
2415             Append( "csup " );
2416         LineToText( pChild );
2417     }
2418 }
2419
2420 void SmNodeToTextVisitor::Visit( SmMatrixNode* pNode )
2421 {
2422     Append( "matrix{" );
2423     for ( sal_uInt16 i = 0; i < pNode->GetNumRows( ); i++ ) {
2424         for ( sal_uInt16 j = 0; j < pNode->GetNumCols( ); j++ ) {
2425             SmNode* pSubNode = pNode->GetSubNode( i * pNode->GetNumCols( ) + j );
2426             Separate( );
2427             pSubNode->Accept( this );
2428             Separate( );
2429             if( j != pNode->GetNumCols( ) - 1 )
2430                 Append( "#" );
2431         }
2432         Separate( );
2433         if( i != pNode->GetNumRows( ) - 1 )
2434             Append( "##" );
2435     }
2436     Append( "} " );
2437 }
2438
2439 void SmNodeToTextVisitor::Visit( SmPlaceNode* )
2440 {
2441     Append( "<?>" );
2442 }
2443
2444 void SmNodeToTextVisitor::Visit( SmTextNode* pNode )
2445 {
2446     //TODO: This method might need improvements, see SmTextNode::CreateTextFromNode
2447     if( pNode->GetToken( ).eType == TTEXT )
2448         Append( "\"" );
2449     Append( pNode->GetText( ) );
2450     if( pNode->GetToken( ).eType == TTEXT )
2451         Append( "\"" );
2452 }
2453
2454 void SmNodeToTextVisitor::Visit( SmSpecialNode* pNode )
2455 {
2456     Append( pNode->GetToken( ).aText );
2457 }
2458
2459 void SmNodeToTextVisitor::Visit( SmGlyphSpecialNode* pNode )
2460 {
2461     if( pNode->GetToken( ).eType == TBOPER )
2462         Append( "boper " );
2463     else
2464         Append( "uoper " );
2465     Append( pNode->GetToken( ).aText );
2466 }
2467
2468 void SmNodeToTextVisitor::Visit( SmMathSymbolNode* pNode )
2469 {
2470     Append( pNode->GetToken( ).aText );
2471 }
2472
2473 void SmNodeToTextVisitor::Visit( SmBlankNode* pNode )
2474 {
2475     Append( pNode->GetToken( ).aText );
2476 }
2477
2478 void SmNodeToTextVisitor::Visit( SmErrorNode* )
2479 {
2480 }
2481
2482 void SmNodeToTextVisitor::Visit( SmLineNode* pNode )
2483 {
2484     SmNodeIterator it( pNode );
2485     while( it.Next( ) ){
2486         Separate( );
2487         it->Accept( this );
2488     }
2489 }
2490
2491 void SmNodeToTextVisitor::Visit( SmExpressionNode* pNode )
2492 {
2493     bool bracketsNeeded = pNode->GetNumSubNodes() != 1 || pNode->GetSubNode(0)->GetType() == NBINHOR;
2494     if (!bracketsNeeded)
2495     {
2496         const SmNode *pParent = pNode->GetParent();
2497         // nested subsups
2498         bracketsNeeded =
2499             pParent && pParent->GetType() == NSUBSUP &&
2500             pNode->GetNumSubNodes() == 1 &&
2501             pNode->GetSubNode(0)->GetType() == NSUBSUP;
2502     }
2503
2504     if (bracketsNeeded) {
2505         Append( "{ " );
2506     }
2507     SmNodeIterator it( pNode );
2508     while( it.Next( ) ) {
2509         it->Accept( this );
2510         Separate( );
2511     }
2512     if (bracketsNeeded) {
2513         Append( "} " );
2514     }
2515 }
2516
2517 void SmNodeToTextVisitor::Visit( SmPolyLineNode* )
2518 {
2519 }
2520
2521 void SmNodeToTextVisitor::Visit( SmRootNode* pNode )
2522 {
2523     SmNode *pExtra   = pNode->GetSubNode( 0 ),
2524            *pBody    = pNode->GetSubNode( 2 );
2525     if( pExtra ) {
2526         Append( "nroot" );
2527         LineToText( pExtra );
2528     } else
2529         Append( "sqrt" );
2530     LineToText( pBody );
2531 }
2532
2533 void SmNodeToTextVisitor::Visit( SmRootSymbolNode* )
2534 {
2535 }
2536
2537 void SmNodeToTextVisitor::Visit( SmRectangleNode* )
2538 {
2539 }
2540
2541 void SmNodeToTextVisitor::Visit( SmVerticalBraceNode* pNode )
2542 {
2543     SmNode *pBody   = pNode->GetSubNode( 0 ),
2544            *pScript = pNode->GetSubNode( 2 );
2545     LineToText( pBody );
2546     Append( pNode->GetToken( ).aText );
2547     LineToText( pScript );
2548 }
2549
2550 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */