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