1 /**************************************************************
2 *
3 * Licensed to the Apache Software Foundation (ASF) under one
4 * or more contributor license agreements. See the NOTICE file
5 * distributed with this work for additional information
6 * regarding copyright ownership. The ASF licenses this file
7 * to you under the Apache License, Version 2.0 (the
8 * "License"); you may not use this file except in compliance
9 * with the License. You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing,
14 * software distributed under the License is distributed on an
15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16 * KIND, either express or implied. See the License for the
17 * specific language governing permissions and limitations
18 * under the License.
19 *
20 *************************************************************/
21
22
23
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_starmath.hxx"
26
27 #include "node.hxx"
28 #include "rect.hxx"
29 #include "symbol.hxx"
30 #include "smmod.hxx"
31 #include "document.hxx"
32 #include "view.hxx"
33 #include "mathtype.hxx"
34
35 #include <tools/gen.hxx>
36 #include <tools/fract.hxx>
37 #include <rtl/math.hxx>
38 #include <tools/color.hxx>
39 #include <vcl/metric.hxx>
40 #include <vcl/lineinfo.hxx>
41 #include <vcl/outdev.hxx>
42 #include <sfx2/module.hxx>
43
44 #include <math.h>
45 #include <float.h>
46
47
48 #define APPEND(str,ascii) str.AppendAscii(RTL_CONSTASCII_STRINGPARAM(ascii))
49
50 // define this to draw rectangles for debugging
51 //#define SM_RECT_DEBUG
52
53
54 using ::rtl::OUString;
55
56
57 ////////////////////////////////////////
58 // SmTmpDevice
59 // Allows for font and color changes. The original settings will be restored
60 // in the destructor.
61 // It's main purpose is to allow for the "const" in the 'OutputDevice'
62 // argument in the 'Arrange' functions and restore changes made in the 'Draw'
63 // functions.
64 // Usually a MapMode of 1/100th mm will be used.
65 //
66
67 class SmTmpDevice
68 {
69 OutputDevice &rOutDev;
70
71 // disallow use of copy-constructor and assignment-operator
72 SmTmpDevice(const SmTmpDevice &rTmpDev);
73 SmTmpDevice & operator = (const SmTmpDevice &rTmpDev);
74
75 Color Impl_GetColor( const Color& rColor );
76
77 public:
78 SmTmpDevice(OutputDevice &rTheDev, sal_Bool bUseMap100th_mm);
~SmTmpDevice()79 ~SmTmpDevice() { rOutDev.Pop(); }
80
81 void SetFont(const Font &rNewFont);
82
SetLineColor(const Color & rColor)83 void SetLineColor( const Color& rColor ) { rOutDev.SetLineColor( Impl_GetColor(rColor) ); }
SetFillColor(const Color & rColor)84 void SetFillColor( const Color& rColor ) { rOutDev.SetFillColor( Impl_GetColor(rColor) ); }
SetTextColor(const Color & rColor)85 void SetTextColor( const Color& rColor ) { rOutDev.SetTextColor( Impl_GetColor(rColor) ); }
86
operator OutputDevice&()87 operator OutputDevice & () { return rOutDev; }
88 };
89
90
SmTmpDevice(OutputDevice & rTheDev,sal_Bool bUseMap100th_mm)91 SmTmpDevice::SmTmpDevice(OutputDevice &rTheDev, sal_Bool bUseMap100th_mm) :
92 rOutDev(rTheDev)
93 {
94 rOutDev.Push( PUSH_FONT | PUSH_MAPMODE |
95 PUSH_LINECOLOR | PUSH_FILLCOLOR | PUSH_TEXTCOLOR );
96 if (bUseMap100th_mm && MAP_100TH_MM != rOutDev.GetMapMode().GetMapUnit())
97 {
98 DBG_ERROR( "incorrect MapMode?" );
99 rOutDev.SetMapMode( MAP_100TH_MM ); //Immer fuer 100% fomatieren
100 }
101 }
102
103
Impl_GetColor(const Color & rColor)104 Color SmTmpDevice::Impl_GetColor( const Color& rColor )
105 {
106 ColorData nNewCol = rColor.GetColor();
107 if (COL_AUTO == nNewCol)
108 {
109 if (OUTDEV_PRINTER == rOutDev.GetOutDevType())
110 nNewCol = COL_BLACK;
111 else
112 {
113 Color aBgCol( rOutDev.GetBackground().GetColor() );
114 if (OUTDEV_WINDOW == rOutDev.GetOutDevType())
115 aBgCol = ((Window &) rOutDev).GetDisplayBackground().GetColor();
116
117 nNewCol = SM_MOD()->GetColorConfig().GetColorValue(svtools::FONTCOLOR).nColor;
118
119 Color aTmpColor( nNewCol );
120 if (aBgCol.IsDark() && aTmpColor.IsDark())
121 nNewCol = COL_WHITE;
122 else if (aBgCol.IsBright() && aTmpColor.IsBright())
123 nNewCol = COL_BLACK;
124 }
125 }
126 return Color( nNewCol );
127 }
128
129
SetFont(const Font & rNewFont)130 void SmTmpDevice::SetFont(const Font &rNewFont)
131 {
132 rOutDev.SetFont( rNewFont );
133 rOutDev.SetTextColor( Impl_GetColor( rNewFont.GetColor() ) );
134 }
135
136
137 ///////////////////////////////////////////////////////////////////////////
138
139
SmNode(SmNodeType eNodeType,const SmToken & rNodeToken)140 SmNode::SmNode(SmNodeType eNodeType, const SmToken &rNodeToken)
141 {
142 eType = eNodeType;
143 eScaleMode = SCALE_NONE;
144 aNodeToken = rNodeToken;
145 nAccIndex = -1;
146 }
147
148
~SmNode()149 SmNode::~SmNode()
150 {
151 }
152
153
IsVisible() const154 sal_Bool SmNode::IsVisible() const
155 {
156 return sal_False;
157 }
158
159
GetNumSubNodes() const160 sal_uInt16 SmNode::GetNumSubNodes() const
161 {
162 return 0;
163 }
164
165
GetSubNode(sal_uInt16)166 SmNode * SmNode::GetSubNode(sal_uInt16 /*nIndex*/)
167 {
168 return NULL;
169 }
170
171
GetLeftMost()172 SmNode * SmNode::GetLeftMost()
173 // returns leftmost node of current subtree.
174 //! (this assumes the one with index 0 is always the leftmost subnode
175 //! for the current node).
176 {
177 SmNode *pNode = GetNumSubNodes() > 0 ?
178 GetSubNode(0) : NULL;
179
180 return pNode ? pNode->GetLeftMost() : this;
181 }
182
183
SetPhantom(sal_Bool bIsPhantomP)184 void SmNode::SetPhantom(sal_Bool bIsPhantomP)
185 {
186 if (! (Flags() & FLG_VISIBLE))
187 bIsPhantom = bIsPhantomP;
188
189 SmNode *pNode;
190 sal_uInt16 nSize = GetNumSubNodes();
191 for (sal_uInt16 i = 0; i < nSize; i++)
192 if (NULL != (pNode = GetSubNode(i)))
193 pNode->SetPhantom(bIsPhantom);
194 }
195
196
SetColor(const Color & rColor)197 void SmNode::SetColor(const Color& rColor)
198 {
199 if (! (Flags() & FLG_COLOR))
200 GetFont().SetColor(rColor);
201
202 SmNode *pNode;
203 sal_uInt16 nSize = GetNumSubNodes();
204 for (sal_uInt16 i = 0; i < nSize; i++)
205 if (NULL != (pNode = GetSubNode(i)))
206 pNode->SetColor(rColor);
207 }
208
209
SetAttribut(sal_uInt16 nAttrib)210 void SmNode::SetAttribut(sal_uInt16 nAttrib)
211 {
212 if (
213 (nAttrib == ATTR_BOLD && !(Flags() & FLG_BOLD)) ||
214 (nAttrib == ATTR_ITALIC && !(Flags() & FLG_ITALIC))
215 )
216 {
217 nAttributes |= nAttrib;
218 }
219
220 SmNode *pNode;
221 sal_uInt16 nSize = GetNumSubNodes();
222 for (sal_uInt16 i = 0; i < nSize; i++)
223 if (NULL != (pNode = GetSubNode(i)))
224 pNode->SetAttribut(nAttrib);
225 }
226
227
ClearAttribut(sal_uInt16 nAttrib)228 void SmNode::ClearAttribut(sal_uInt16 nAttrib)
229 {
230 if (
231 (nAttrib == ATTR_BOLD && !(Flags() & FLG_BOLD)) ||
232 (nAttrib == ATTR_ITALIC && !(Flags() & FLG_ITALIC))
233 )
234 {
235 nAttributes &= ~nAttrib;
236 }
237
238 SmNode *pNode;
239 sal_uInt16 nSize = GetNumSubNodes();
240 for (sal_uInt16 i = 0; i < nSize; i++)
241 if (NULL != (pNode = GetSubNode(i)))
242 pNode->ClearAttribut(nAttrib);
243 }
244
245
SetFont(const SmFace & rFace)246 void SmNode::SetFont(const SmFace &rFace)
247 {
248 if (!(Flags() & FLG_FONT))
249 GetFont() = rFace;
250
251 SmNode *pNode;
252 sal_uInt16 nSize = GetNumSubNodes();
253 for (sal_uInt16 i = 0; i < nSize; i++)
254 if (NULL != (pNode = GetSubNode(i)))
255 pNode->SetFont(rFace);
256 }
257
258
SetFontSize(const Fraction & rSize,sal_uInt16 nType)259 void SmNode::SetFontSize(const Fraction &rSize, sal_uInt16 nType)
260 //! 'rSize' is in units of pts
261 {
262 Size aFntSize;
263
264 if (!(Flags() & FLG_SIZE))
265 {
266 Fraction aVal (SmPtsTo100th_mm(rSize.GetNumerator()),
267 rSize.GetDenominator());
268 //long nHeight = ::rtl::math::round(aVal);
269 long nHeight = (long)aVal;
270
271 aFntSize = GetFont().GetSize();
272 aFntSize.Width() = 0;
273 switch(nType)
274 {
275 case FNTSIZ_ABSOLUT:
276 aFntSize.Height() = nHeight;
277 break;
278
279 case FNTSIZ_PLUS:
280 aFntSize.Height() += nHeight;
281 break;
282
283 case FNTSIZ_MINUS:
284 aFntSize.Height() -= nHeight;
285 break;
286
287 case FNTSIZ_MULTIPLY:
288 aFntSize.Height() = (long) (Fraction(aFntSize.Height()) * rSize);
289 break;
290
291 case FNTSIZ_DIVIDE:
292 if (rSize != Fraction(0L))
293 aFntSize.Height() = (long) (Fraction(aFntSize.Height()) / rSize);
294 break;
295 default:
296 break;
297 }
298
299 // check the requested size against maximum value
300 static int __READONLY_DATA nMaxVal = SmPtsTo100th_mm(128);
301 if (aFntSize.Height() > nMaxVal)
302 aFntSize.Height() = nMaxVal;
303
304 GetFont().SetSize(aFntSize);
305 }
306
307 SmNode *pNode;
308 sal_uInt16 nSize = GetNumSubNodes();
309 for (sal_uInt16 i = 0; i < nSize; i++)
310 if (NULL != (pNode = GetSubNode(i)))
311 pNode->SetFontSize(rSize, nType);
312 }
313
314
SetSize(const Fraction & rSize)315 void SmNode::SetSize(const Fraction &rSize)
316 {
317 GetFont() *= rSize;
318
319 SmNode *pNode;
320 sal_uInt16 nSize = GetNumSubNodes();
321 for (sal_uInt16 i = 0; i < nSize; i++)
322 if (NULL != (pNode = GetSubNode(i)))
323 pNode->SetSize(rSize);
324 }
325
326
SetRectHorAlign(RectHorAlign eHorAlign,sal_Bool bApplyToSubTree)327 void SmNode::SetRectHorAlign(RectHorAlign eHorAlign, sal_Bool bApplyToSubTree )
328 {
329 if (!(Flags() & FLG_HORALIGN))
330 eRectHorAlign = eHorAlign;
331
332 if (bApplyToSubTree)
333 {
334 SmNode *pNode;
335 sal_uInt16 nSize = GetNumSubNodes();
336 for (sal_uInt16 i = 0; i < nSize; i++)
337 if (NULL != (pNode = GetSubNode(i)))
338 pNode->SetRectHorAlign(eHorAlign);
339 }
340 }
341
342
PrepareAttributes()343 void SmNode::PrepareAttributes()
344 {
345 GetFont().SetWeight((Attributes() & ATTR_BOLD) ? WEIGHT_BOLD : WEIGHT_NORMAL);
346 GetFont().SetItalic((Attributes() & ATTR_ITALIC) ? ITALIC_NORMAL : ITALIC_NONE);
347 }
348
349
Prepare(const SmFormat & rFormat,const SmDocShell & rDocShell)350 void SmNode::Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell)
351 {
352 #if OSL_DEBUG_LEVEL > 1
353 bIsDebug = sal_True;
354 #else
355 bIsDebug = sal_False;
356 #endif
357 bIsPhantom = sal_False;
358 nFlags = 0;
359 nAttributes = 0;
360
361 switch (rFormat.GetHorAlign())
362 { case AlignLeft: eRectHorAlign = RHA_LEFT; break;
363 case AlignCenter: eRectHorAlign = RHA_CENTER; break;
364 case AlignRight: eRectHorAlign = RHA_RIGHT; break;
365 }
366
367 GetFont() = rFormat.GetFont(FNT_MATH);
368 //GetFont().SetCharSet(RTL_TEXTENCODING_SYMBOL);
369 DBG_ASSERT( GetFont().GetCharSet() == RTL_TEXTENCODING_UNICODE,
370 "unexpected CharSet" );
371 GetFont().SetWeight(WEIGHT_NORMAL);
372 GetFont().SetItalic(ITALIC_NONE);
373
374 SmNode *pNode;
375 sal_uInt16 nSize = GetNumSubNodes();
376 for (sal_uInt16 i = 0; i < nSize; i++)
377 if (NULL != (pNode = GetSubNode(i)))
378 pNode->Prepare(rFormat, rDocShell);
379 }
380
381
382 #if OSL_DEBUG_LEVEL > 1
ToggleDebug() const383 void SmNode::ToggleDebug() const
384 // toggle 'bIsDebug' in current subtree
385 {
386 SmNode *pThis = (SmNode *) this;
387
388 pThis->bIsDebug = bIsDebug ? sal_False : sal_True;
389
390 SmNode *pNode;
391 sal_uInt16 nSize = GetNumSubNodes();
392 for (sal_uInt16 i = 0; i < nSize; i++)
393 if (NULL != (pNode = pThis->GetSubNode(i)))
394 pNode->ToggleDebug();
395 }
396 #endif
397
398
Move(const Point & rPosition)399 void SmNode::Move(const Point& rPosition)
400 {
401 if (rPosition.X() == 0 && rPosition.Y() == 0)
402 return;
403
404 SmRect::Move(rPosition);
405
406 SmNode *pNode;
407 sal_uInt16 nSize = GetNumSubNodes();
408 for (sal_uInt16 i = 0; i < nSize; i++)
409 if (NULL != (pNode = GetSubNode(i)))
410 pNode->Move(rPosition);
411 }
412
413
Arrange(const OutputDevice & rDev,const SmFormat & rFormat)414 void SmNode::Arrange(const OutputDevice &rDev, const SmFormat &rFormat)
415 {
416 SmNode *pNode;
417 sal_uInt16 nSize = GetNumSubNodes();
418 for (sal_uInt16 i = 0; i < nSize; i++)
419 if (NULL != (pNode = GetSubNode(i)))
420 pNode->Arrange(rDev, rFormat);
421 }
422
CreateTextFromNode(String & rText)423 void SmNode::CreateTextFromNode(String &rText)
424 {
425 SmNode *pNode;
426 sal_uInt16 nSize = GetNumSubNodes();
427 if (nSize > 1)
428 rText.Append('{');
429 for (sal_uInt16 i = 0; i < nSize; i++)
430 if (NULL != (pNode = GetSubNode(i)))
431 pNode->CreateTextFromNode(rText);
432 if (nSize > 1)
433 {
434 rText.EraseTrailingChars();
435 APPEND(rText,"} ");
436 }
437 }
438
439
AdaptToX(const OutputDevice &,sal_uLong)440 void SmNode::AdaptToX(const OutputDevice &/*rDev*/, sal_uLong /*nWidth*/)
441 {
442 }
443
444
AdaptToY(const OutputDevice &,sal_uLong)445 void SmNode::AdaptToY(const OutputDevice &/*rDev*/, sal_uLong /*nHeight*/)
446 {
447 }
448
449
Draw(OutputDevice & rDev,const Point & rPosition) const450 void SmNode::Draw(OutputDevice &rDev, const Point &rPosition) const
451 {
452 if (IsPhantom())
453 return;
454
455 const SmNode *pNode;
456 sal_uInt16 nSize = GetNumSubNodes();
457 for (sal_uInt16 i = 0; i < nSize; i++)
458 if (NULL != (pNode = GetSubNode(i)))
459 { Point aOffset (pNode->GetTopLeft() - GetTopLeft());
460 pNode->Draw(rDev, rPosition + aOffset);
461 }
462
463 #ifdef SM_RECT_DEBUG
464 if (!IsDebug())
465 return;
466
467 int nRFlags = SM_RECT_CORE | SM_RECT_ITALIC | SM_RECT_LINES | SM_RECT_MID;
468 SmRect::Draw(rDev, rPosition, nRFlags);
469 #endif
470 }
471
FindTokenAt(sal_uInt16 nRow,sal_uInt16 nCol) const472 const SmNode * SmNode::FindTokenAt(sal_uInt16 nRow, sal_uInt16 nCol) const
473 // returns (first) ** visible ** (sub)node with the tokens text at
474 // position 'nRow', 'nCol'.
475 //! (there should be exactly one such node if any)
476 {
477 if ( IsVisible()
478 && nRow == GetToken().nRow
479 && nCol >= GetToken().nCol && nCol < GetToken().nCol + GetToken().aText.Len())
480 return this;
481 else
482 {
483 sal_uInt16 nNumSubNodes = GetNumSubNodes();
484 for (sal_uInt16 i = 0; i < nNumSubNodes; i++)
485 { const SmNode *pNode = GetSubNode(i);
486
487 if (!pNode)
488 continue;
489
490 const SmNode *pResult = pNode->FindTokenAt(nRow, nCol);
491 if (pResult)
492 return pResult;
493 }
494 }
495
496 return 0;
497 }
498
499
FindRectClosestTo(const Point & rPoint) const500 const SmNode * SmNode::FindRectClosestTo(const Point &rPoint) const
501 {
502 long nDist = LONG_MAX;
503 const SmNode *pResult = 0;
504
505 if (IsVisible())
506 pResult = this;
507 else
508 {
509 sal_uInt16 nNumSubNodes = GetNumSubNodes();
510 for (sal_uInt16 i = 0; i < nNumSubNodes; i++)
511 { const SmNode *pNode = GetSubNode(i);
512
513 if (!pNode)
514 continue;
515
516 long nTmp;
517 const SmNode *pFound = pNode->FindRectClosestTo(rPoint);
518 if (pFound && (nTmp = pFound->OrientedDist(rPoint)) < nDist)
519 { nDist = nTmp;
520 pResult = pFound;
521
522 // quit immediately if 'rPoint' is inside the *should not
523 // overlap with other rectangles* part.
524 // This (partly) serves for getting the attributes in eg
525 // "bar overstrike a".
526 // ('nDist < 0' is used as *quick shot* to avoid evaluation of
527 // the following expression, where the result is already determined)
528 if (nDist < 0 && pFound->IsInsideRect(rPoint))
529 break;
530 }
531 }
532 }
533
534 return pResult;
535 }
536
GetAccessibleText(String &) const537 void SmNode::GetAccessibleText( String &/*rText*/ ) const
538 {
539 DBG_ERROR( "SmNode: GetAccessibleText not overloaded" );
540 }
541
FindNodeWithAccessibleIndex(xub_StrLen nAccIdx) const542 const SmNode * SmNode::FindNodeWithAccessibleIndex(xub_StrLen nAccIdx) const
543 {
544 const SmNode *pResult = 0;
545
546 sal_Int32 nIdx = GetAccessibleIndex();
547 String aTxt;
548 if (nIdx >= 0)
549 GetAccessibleText( aTxt ); // get text if used in following 'if' statement
550
551 if (nIdx >= 0
552 && nIdx <= nAccIdx && nAccIdx < nIdx + aTxt.Len())
553 pResult = this;
554 else
555 {
556 sal_uInt16 nNumSubNodes = GetNumSubNodes();
557 for (sal_uInt16 i = 0; i < nNumSubNodes; i++)
558 {
559 const SmNode *pNode = GetSubNode(i);
560 if (!pNode)
561 continue;
562
563 pResult = pNode->FindNodeWithAccessibleIndex(nAccIdx);
564 if (pResult)
565 return pResult;
566 }
567 }
568
569 return pResult;
570 }
571
572
GetFormulaBaseline() const573 long SmNode::GetFormulaBaseline() const
574 {
575 DBG_ASSERT( 0, "This dummy implementation should not have been called." );
576 return 0;
577 }
578
579 ///////////////////////////////////////////////////////////////////////////
580
SmStructureNode(const SmStructureNode & rNode)581 SmStructureNode::SmStructureNode( const SmStructureNode &rNode ) :
582 SmNode( rNode.GetType(), rNode.GetToken() )
583 {
584 sal_uLong i;
585 for (i = 0; i < aSubNodes.size(); i++)
586 delete aSubNodes[i];
587 aSubNodes.resize(0);
588
589 sal_uLong nSize = rNode.aSubNodes.size();
590 aSubNodes.resize( nSize );
591 for (i = 0; i < nSize; ++i)
592 {
593 SmNode *pNode = rNode.aSubNodes[i];
594 aSubNodes[i] = pNode ? new SmNode( *pNode ) : 0;
595 }
596 }
597
598
~SmStructureNode()599 SmStructureNode::~SmStructureNode()
600 {
601 SmNode *pNode;
602
603 for (sal_uInt16 i = 0; i < GetNumSubNodes(); i++)
604 if (NULL != (pNode = GetSubNode(i)))
605 delete pNode;
606 }
607
608
operator =(const SmStructureNode & rNode)609 SmStructureNode & SmStructureNode::operator = ( const SmStructureNode &rNode )
610 {
611 SmNode::operator = ( rNode );
612
613 sal_uLong i;
614 for (i = 0; i < aSubNodes.size(); i++)
615 delete aSubNodes[i];
616 aSubNodes.resize(0);
617
618 sal_uLong nSize = rNode.aSubNodes.size();
619 aSubNodes.resize( nSize );
620 for (i = 0; i < nSize; ++i)
621 {
622 SmNode *pNode = rNode.aSubNodes[i];
623 aSubNodes[i] = pNode ? new SmNode( *pNode ) : 0;
624 }
625
626 return *this;
627 }
628
629
SetSubNodes(SmNode * pFirst,SmNode * pSecond,SmNode * pThird)630 void SmStructureNode::SetSubNodes(SmNode *pFirst, SmNode *pSecond, SmNode *pThird)
631 {
632 size_t nSize = pThird ? 3 : (pSecond ? 2 : (pFirst ? 1 : 0));
633 aSubNodes.resize( nSize );
634 if (pFirst)
635 aSubNodes[0] = pFirst;
636 if (pSecond)
637 aSubNodes[1] = pSecond;
638 if (pThird)
639 aSubNodes[2] = pThird;
640 }
641
642
SetSubNodes(const SmNodeArray & rNodeArray)643 void SmStructureNode::SetSubNodes(const SmNodeArray &rNodeArray)
644 {
645 aSubNodes = rNodeArray;
646 }
647
648
IsVisible() const649 sal_Bool SmStructureNode::IsVisible() const
650 {
651 return sal_False;
652 }
653
654
GetNumSubNodes() const655 sal_uInt16 SmStructureNode::GetNumSubNodes() const
656 {
657 return (sal_uInt16) aSubNodes.size();
658 }
659
660
GetSubNode(sal_uInt16 nIndex)661 SmNode * SmStructureNode::GetSubNode(sal_uInt16 nIndex)
662 {
663 return aSubNodes[nIndex];
664 }
665
666
GetAccessibleText(String & rText) const667 void SmStructureNode::GetAccessibleText( String &rText ) const
668 {
669 sal_uInt16 nNodes = GetNumSubNodes();
670 for (sal_uInt16 i = 0; i < nNodes; ++i)
671 {
672 const SmNode *pNode = ((SmStructureNode *) this)->GetSubNode(i);
673 if (pNode)
674 {
675 if (pNode->IsVisible())
676 ((SmStructureNode *) pNode)->nAccIndex = rText.Len();
677 pNode->GetAccessibleText( rText );
678 // if (rText.Len() && ' ' != rText.GetChar( rText.Len() - 1 ))
679 // rText += String::CreateFromAscii( " " );
680 }
681 }
682 }
683
684 ///////////////////////////////////////////////////////////////////////////
685
686
IsVisible() const687 sal_Bool SmVisibleNode::IsVisible() const
688 {
689 return sal_True;
690 }
691
692
GetNumSubNodes() const693 sal_uInt16 SmVisibleNode::GetNumSubNodes() const
694 {
695 return 0;
696 }
697
698
GetSubNode(sal_uInt16)699 SmNode * SmVisibleNode::GetSubNode(sal_uInt16 /*nIndex*/)
700 {
701 return NULL;
702 }
703
704
705 ///////////////////////////////////////////////////////////////////////////
706
GetAccessibleText(String & rText) const707 void SmGraphicNode::GetAccessibleText( String &rText ) const
708 {
709 rText += GetToken().aText;
710 }
711
712 ///////////////////////////////////////////////////////////////////////////
713
714
CreateTextFromNode(String & rText)715 void SmExpressionNode::CreateTextFromNode(String &rText)
716 {
717 SmNode *pNode;
718 sal_uInt16 nSize = GetNumSubNodes();
719 if (nSize > 1)
720 rText.Append('{');
721 for (sal_uInt16 i = 0; i < nSize; i++)
722 if (NULL != (pNode = GetSubNode(i)))
723 {
724 pNode->CreateTextFromNode(rText);
725 //Just a bit of foo to make unary +asd -asd +-asd -+asd look nice
726 if (pNode->GetType() == NMATH)
727 if ((nSize != 2) || ((rText.GetChar(rText.Len()-1) != '+') &&
728 (rText.GetChar(rText.Len()-1) != '-')))
729 rText.Append(' ');
730 }
731
732 if (nSize > 1)
733 {
734 rText.EraseTrailingChars();
735 APPEND(rText,"} ");
736 }
737 }
738
739
740 ///////////////////////////////////////////////////////////////////////////
741
Arrange(const OutputDevice & rDev,const SmFormat & rFormat)742 void SmTableNode::Arrange(const OutputDevice &rDev, const SmFormat &rFormat)
743 // arranges all subnodes in one column
744 {
745 Point rPosition;
746
747 SmNode *pNode;
748 sal_uInt16 nSize = GetNumSubNodes();
749
750 // make distance depend on font size
751 long nDist = +(rFormat.GetDistance(DIS_VERTICAL)
752 * GetFont().GetSize().Height()) / 100L;
753
754 if (nSize < 1)
755 return;
756
757 // arrange subnodes and get maximum width of them
758 long nMaxWidth = 0,
759 nTmp;
760 sal_uInt16 i;
761 for (i = 0; i < nSize; i++)
762 if (NULL != (pNode = GetSubNode(i)))
763 { pNode->Arrange(rDev, rFormat);
764 if ((nTmp = pNode->GetItalicWidth()) > nMaxWidth)
765 nMaxWidth = nTmp;
766 }
767
768 Point aPos;
769 SmRect::operator = (SmRect(nMaxWidth, 1));
770 for (i = 0; i < nSize; i++)
771 { if (NULL != (pNode = GetSubNode(i)))
772 { const SmRect &rNodeRect = pNode->GetRect();
773 const SmNode *pCoNode = pNode->GetLeftMost();
774 //SmTokenType eType = pCoNode->GetToken().eType;
775 RectHorAlign eHorAlign = pCoNode->GetRectHorAlign();
776
777 aPos = rNodeRect.AlignTo(*this, RP_BOTTOM,
778 eHorAlign, RVA_BASELINE);
779 if (i)
780 aPos.Y() += nDist;
781 pNode->MoveTo(aPos);
782 ExtendBy(rNodeRect, nSize > 1 ? RCP_NONE : RCP_ARG);
783 }
784 }
785 // --> 4.7.2010 #i972#
786 if (HasBaseline())
787 nFormulaBaseline = GetBaseline();
788 else
789 {
790 SmTmpDevice aTmpDev ((OutputDevice &) rDev, sal_True);
791 aTmpDev.SetFont(GetFont());
792
793 SmRect aRect = (SmRect(aTmpDev, &rFormat, C2S("a"),
794 GetFont().GetBorderWidth()));
795 nFormulaBaseline = GetAlignM();
796 // move from middle position by constant - distance
797 // between middle and baseline for single letter
798 nFormulaBaseline += aRect.GetBaseline() - aRect.GetAlignM();
799 }
800 // <--
801 }
802
803
GetLeftMost()804 SmNode * SmTableNode::GetLeftMost()
805 {
806 return this;
807 }
808
809
GetFormulaBaseline() const810 long SmTableNode::GetFormulaBaseline() const
811 {
812 return nFormulaBaseline;
813 }
814
815
816 /**************************************************************************/
817
818
Prepare(const SmFormat & rFormat,const SmDocShell & rDocShell)819 void SmLineNode::Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell)
820 {
821 SmNode::Prepare(rFormat, rDocShell);
822
823 //! wir verwenden hier den 'FNT_VARIABLE' Font, da er vom Ascent und Descent
824 //! ia besser zum Rest der Formel passt als der 'FNT_MATH' Font.
825 GetFont() = rFormat.GetFont(FNT_VARIABLE);
826 Flags() |= FLG_FONT;
827 }
828
829
830 /**************************************************************************/
831
832
Arrange(const OutputDevice & rDev,const SmFormat & rFormat)833 void SmLineNode::Arrange(const OutputDevice &rDev, const SmFormat &rFormat)
834 // arranges all subnodes in one row with some extra space between
835 {
836 SmNode *pNode;
837 sal_uInt16 nSize = GetNumSubNodes();
838 sal_uInt16 i;
839 for (i = 0; i < nSize; i++)
840 if (NULL != (pNode = GetSubNode(i)))
841 pNode->Arrange(rDev, rFormat);
842
843 SmTmpDevice aTmpDev ((OutputDevice &) rDev, sal_True);
844 aTmpDev.SetFont(GetFont());
845
846 if (nSize < 1)
847 {
848 // provide an empty rectangle with alignment parameters for the "current"
849 // font (in order to make "a^1 {}_2^3 a_4" work correct, that is, have the
850 // same sub-/supscript positions.)
851 //! be sure to use a character that has explicitly defined HiAttribut
852 //! line in rect.cxx such as 'a' in order to make 'vec a' look same to
853 //! 'vec {a}'.
854 SmRect::operator = (SmRect(aTmpDev, &rFormat, C2S("a"),
855 GetFont().GetBorderWidth()));
856 // make sure that the rectangle occupies (almost) no space
857 SetWidth(1);
858 SetItalicSpaces(0, 0);
859 return;
860 }
861
862 // make distance depend on font size
863 long nDist = (rFormat.GetDistance(DIS_HORIZONTAL) * GetFont().GetSize().Height()) / 100L;
864 if (!IsUseExtraSpaces())
865 nDist = 0;
866
867 Point aPos;
868 // copy the first node into LineNode and extend by the others
869 if (NULL != (pNode = GetSubNode(0)))
870 SmRect::operator = (pNode->GetRect());
871
872 for (i = 1; i < nSize; i++)
873 if (NULL != (pNode = GetSubNode(i)))
874 {
875 aPos = pNode->AlignTo(*this, RP_RIGHT, RHA_CENTER, RVA_BASELINE);
876
877 // add horizontal space to the left for each but the first sub node
878 aPos.X() += nDist;
879
880 pNode->MoveTo(aPos);
881 ExtendBy( *pNode, RCP_XOR );
882 }
883 }
884
885
886 /**************************************************************************/
887
888
Arrange(const OutputDevice & rDev,const SmFormat & rFormat)889 void SmExpressionNode::Arrange(const OutputDevice &rDev, const SmFormat &rFormat)
890 // as 'SmLineNode::Arrange' but keeps alignment of leftmost subnode
891 {
892 SmLineNode::Arrange(rDev, rFormat);
893
894 // copy alignment of leftmost subnode if any
895 SmNode *pNode = GetLeftMost();
896 if (pNode)
897 SetRectHorAlign(pNode->GetRectHorAlign(), sal_False);
898 }
899
900
901 /**************************************************************************/
902
903
Arrange(const OutputDevice & rDev,const SmFormat & rFormat)904 void SmUnHorNode::Arrange(const OutputDevice &rDev, const SmFormat &rFormat)
905 {
906 sal_Bool bIsPostfix = GetToken().eType == TFACT;
907
908 SmNode *pOper = GetSubNode(bIsPostfix ? 1 : 0),
909 *pBody = GetSubNode(bIsPostfix ? 0 : 1);
910 DBG_ASSERT(pOper, "Sm: NULL pointer");
911 DBG_ASSERT(pBody, "Sm: NULL pointer");
912
913 pOper->SetSize(Fraction (rFormat.GetRelSize(SIZ_OPERATOR), 100));
914 pOper->Arrange(rDev, rFormat);
915 pBody->Arrange(rDev, rFormat);
916
917 Point aPos = pOper->AlignTo(*pBody, bIsPostfix ? RP_RIGHT : RP_LEFT,
918 RHA_CENTER, RVA_BASELINE);
919 // add a bit space between operator and argument
920 // (worst case -{1 over 2} where - and over have almost no space inbetween)
921 long nDelta = pOper->GetFont().GetSize().Height() / 20;
922 if (bIsPostfix)
923 aPos.X() += nDelta;
924 else
925 aPos.X() -= nDelta;
926 pOper->MoveTo(aPos);
927
928 SmRect::operator = (*pBody);
929 long nOldBot = GetBottom();
930
931 ExtendBy(*pOper, RCP_XOR);
932
933 // workaround for Bug 50865: "a^2 a^+2" have different baselines
934 // for exponents (if size of exponent is large enough)
935 SetBottom(nOldBot);
936 }
937
938
939 /**************************************************************************/
940
941
GetHeightVerOffset(const SmRect & rRect,long & rHeight,long & rVerOffset) const942 void SmRootNode::GetHeightVerOffset(const SmRect &rRect,
943 long &rHeight, long &rVerOffset) const
944 // calculate height and vertical offset of root sign suitable for 'rRect'
945 {
946 rVerOffset = (rRect.GetBottom() - rRect.GetAlignB()) / 2;
947 rHeight = rRect.GetHeight() - rVerOffset;
948
949 DBG_ASSERT(rHeight >= 0, "Sm : Ooops...");
950 DBG_ASSERT(rVerOffset >= 0, "Sm : Ooops...");
951 }
952
953
GetExtraPos(const SmRect & rRootSymbol,const SmRect & rExtra) const954 Point SmRootNode::GetExtraPos(const SmRect &rRootSymbol,
955 const SmRect &rExtra) const
956 {
957 const Size &rSymSize = rRootSymbol.GetSize();
958
959 Point aPos = rRootSymbol.GetTopLeft()
960 + Point((rSymSize.Width() * 70) / 100,
961 (rSymSize.Height() * 52) / 100);
962
963 // from this calculate topleft edge of 'rExtra'
964 aPos.X() -= rExtra.GetWidth() + rExtra.GetItalicRightSpace();
965 aPos.Y() -= rExtra.GetHeight();
966 // if there's enough space move a bit less to the right
967 // examples: "nroot i a", "nroot j a"
968 // (it looks better if we don't use italic-spaces here)
969 long nX = rRootSymbol.GetLeft() + (rSymSize.Width() * 30) / 100;
970 if (aPos.X() > nX)
971 aPos.X() = nX;
972
973 return aPos;
974 }
975
976
Arrange(const OutputDevice & rDev,const SmFormat & rFormat)977 void SmRootNode::Arrange(const OutputDevice &rDev, const SmFormat &rFormat)
978 {
979 //! pExtra needs to have the smaller index than pRootSym in order to
980 //! not to get the root symbol but the pExtra when clicking on it in the
981 //! GraphicWindow. (That is because of the simplicity of the algorithm
982 //! that finds the node corresponding to a mouseclick in the window.)
983 SmNode *pExtra = GetSubNode(0),
984 *pRootSym = GetSubNode(1),
985 *pBody = GetSubNode(2);
986 DBG_ASSERT(pRootSym, "Sm: NULL pointer");
987 DBG_ASSERT(pBody, "Sm: NULL pointer");
988
989 pBody->Arrange(rDev, rFormat);
990
991 long nHeight,
992 nVerOffset;
993 GetHeightVerOffset(*pBody, nHeight, nVerOffset);
994 nHeight += rFormat.GetDistance(DIS_ROOT)
995 * GetFont().GetSize().Height() / 100L;
996
997 // font specialist advised to change the width first
998 pRootSym->AdaptToY(rDev, nHeight);
999 pRootSym->AdaptToX(rDev, pBody->GetItalicWidth());
1000
1001 pRootSym->Arrange(rDev, rFormat);
1002
1003 Point aPos = pRootSym->AlignTo(*pBody, RP_LEFT, RHA_CENTER, RVA_BASELINE);
1004 //! overrride calculated vertical position
1005 aPos.Y() = pRootSym->GetTop() + pBody->GetBottom() - pRootSym->GetBottom();
1006 aPos.Y() -= nVerOffset;
1007 pRootSym->MoveTo(aPos);
1008
1009 if (pExtra)
1010 { pExtra->SetSize(Fraction(rFormat.GetRelSize(SIZ_INDEX), 100));
1011 pExtra->Arrange(rDev, rFormat);
1012
1013 aPos = GetExtraPos(*pRootSym, *pExtra);
1014 pExtra->MoveTo(aPos);
1015 }
1016
1017 SmRect::operator = (*pBody);
1018 ExtendBy(*pRootSym, RCP_THIS);
1019 if (pExtra)
1020 ExtendBy(*pExtra, RCP_THIS, (sal_Bool) sal_True);
1021 }
1022
1023
CreateTextFromNode(String & rText)1024 void SmRootNode::CreateTextFromNode(String &rText)
1025 {
1026 SmNode *pExtra = GetSubNode(0);
1027 if (pExtra)
1028 {
1029 APPEND(rText,"nroot ");
1030 pExtra->CreateTextFromNode(rText);
1031 }
1032 else
1033 APPEND(rText,"sqrt ");
1034 GetSubNode(2)->CreateTextFromNode(rText);
1035 }
1036
1037
1038 /**************************************************************************/
1039
1040
Arrange(const OutputDevice & rDev,const SmFormat & rFormat)1041 void SmBinHorNode::Arrange(const OutputDevice &rDev, const SmFormat &rFormat)
1042 {
1043 SmNode *pLeft = GetSubNode(0),
1044 *pOper = GetSubNode(1),
1045 *pRight = GetSubNode(2);
1046 DBG_ASSERT(pLeft != NULL, "Sm: NULL pointer");
1047 DBG_ASSERT(pOper != NULL, "Sm: NULL pointer");
1048 DBG_ASSERT(pRight != NULL, "Sm: NULL pointer");
1049
1050 pOper->SetSize(Fraction (rFormat.GetRelSize(SIZ_OPERATOR), 100));
1051
1052 pLeft ->Arrange(rDev, rFormat);
1053 pOper ->Arrange(rDev, rFormat);
1054 pRight->Arrange(rDev, rFormat);
1055
1056 const SmRect &rOpRect = pOper->GetRect();
1057
1058 long nDist = (rOpRect.GetWidth() *
1059 rFormat.GetDistance(DIS_HORIZONTAL)) / 100L;
1060
1061 SmRect::operator = (*pLeft);
1062
1063 Point aPos;
1064 aPos = pOper->AlignTo(*this, RP_RIGHT, RHA_CENTER, RVA_BASELINE);
1065 aPos.X() += nDist;
1066 pOper->MoveTo(aPos);
1067 ExtendBy(*pOper, RCP_XOR);
1068
1069 aPos = pRight->AlignTo(*this, RP_RIGHT, RHA_CENTER, RVA_BASELINE);
1070 aPos.X() += nDist;
1071
1072 pRight->MoveTo(aPos);
1073 ExtendBy(*pRight, RCP_XOR);
1074 }
1075
1076
1077 /**************************************************************************/
1078
1079
Arrange(const OutputDevice & rDev,const SmFormat & rFormat)1080 void SmBinVerNode::Arrange(const OutputDevice &rDev, const SmFormat &rFormat)
1081 {
1082 SmNode *pNum = GetSubNode(0),
1083 *pLine = GetSubNode(1),
1084 *pDenom = GetSubNode(2);
1085 DBG_ASSERT(pNum, "Sm : NULL pointer");
1086 DBG_ASSERT(pLine, "Sm : NULL pointer");
1087 DBG_ASSERT(pDenom, "Sm : NULL pointer");
1088
1089 sal_Bool bIsTextmode = rFormat.IsTextmode();
1090 if (bIsTextmode)
1091 {
1092 Fraction aFraction(rFormat.GetRelSize(SIZ_INDEX), 100);
1093 pNum ->SetSize(aFraction);
1094 pLine ->SetSize(aFraction);
1095 pDenom->SetSize(aFraction);
1096 }
1097
1098 pNum ->Arrange(rDev, rFormat);
1099 pDenom->Arrange(rDev, rFormat);
1100
1101 long nFontHeight = GetFont().GetSize().Height(),
1102 nExtLen = nFontHeight * rFormat.GetDistance(DIS_FRACTION) / 100L,
1103 nThick = nFontHeight * rFormat.GetDistance(DIS_STROKEWIDTH) / 100L,
1104 nWidth = Max(pNum->GetItalicWidth(), pDenom->GetItalicWidth()),
1105 nNumDist = bIsTextmode ? 0 :
1106 nFontHeight * rFormat.GetDistance(DIS_NUMERATOR) / 100L,
1107 nDenomDist = bIsTextmode ? 0 :
1108 nFontHeight * rFormat.GetDistance(DIS_DENOMINATOR) / 100L;
1109
1110 // font specialist advised to change the width first
1111 pLine->AdaptToY(rDev, nThick);
1112 pLine->AdaptToX(rDev, nWidth + 2 * nExtLen);
1113 pLine->Arrange(rDev, rFormat);
1114
1115 // get horizontal alignment for numerator
1116 const SmNode *pLM = pNum->GetLeftMost();
1117 RectHorAlign eHorAlign = pLM->GetRectHorAlign();
1118
1119 // move numerator to its position
1120 Point aPos = pNum->AlignTo(*pLine, RP_TOP, eHorAlign, RVA_BASELINE);
1121 aPos.Y() -= nNumDist;
1122 pNum->MoveTo(aPos);
1123
1124 // get horizontal alignment for denominator
1125 pLM = pDenom->GetLeftMost();
1126 eHorAlign = pLM->GetRectHorAlign();
1127
1128 // move denominator to its position
1129 aPos = pDenom->AlignTo(*pLine, RP_BOTTOM, eHorAlign, RVA_BASELINE);
1130 aPos.Y() += nDenomDist;
1131 pDenom->MoveTo(aPos);
1132
1133 SmRect::operator = (*pNum);
1134 ExtendBy(*pDenom, RCP_NONE).ExtendBy(*pLine, RCP_NONE, pLine->GetCenterY());
1135 }
1136
CreateTextFromNode(String & rText)1137 void SmBinVerNode::CreateTextFromNode(String &rText)
1138 {
1139 SmNode *pNum = GetSubNode(0),
1140 // *pLine = GetSubNode(1),
1141 *pDenom = GetSubNode(2);
1142 pNum->CreateTextFromNode(rText);
1143 APPEND(rText,"over ");
1144 pDenom->CreateTextFromNode(rText);
1145 }
1146
1147
GetLeftMost()1148 SmNode * SmBinVerNode::GetLeftMost()
1149 {
1150 return this;
1151 }
1152
1153
1154 /**************************************************************************/
1155
1156
Det(const Point & rHeading1,const Point & rHeading2)1157 double Det(const Point &rHeading1, const Point &rHeading2)
1158 // gibt den Wert der durch die beiden Punkte gebildeten Determinante
1159 // zurueck
1160 {
1161 return rHeading1.X() * rHeading2.Y() - rHeading1.Y() * rHeading2.X();
1162 }
1163
1164
IsPointInLine(const Point & rPoint1,const Point & rPoint2,const Point & rHeading2)1165 sal_Bool IsPointInLine(const Point &rPoint1,
1166 const Point &rPoint2, const Point &rHeading2)
1167 // ergibt sal_True genau dann, wenn der Punkt 'rPoint1' zu der Gerade gehoert die
1168 // durch den Punkt 'rPoint2' geht und den Richtungsvektor 'rHeading2' hat
1169 {
1170 DBG_ASSERT(rHeading2 != Point(), "Sm : 0 vector");
1171
1172 sal_Bool bRes = sal_False;
1173 const double eps = 5.0 * DBL_EPSILON;
1174
1175 double fLambda;
1176 if (labs(rHeading2.X()) > labs(rHeading2.Y()))
1177 {
1178 fLambda = (rPoint1.X() - rPoint2.X()) / (double) rHeading2.X();
1179 bRes = fabs(rPoint1.Y() - (rPoint2.Y() + fLambda * rHeading2.Y())) < eps;
1180 }
1181 else
1182 {
1183 fLambda = (rPoint1.Y() - rPoint2.Y()) / (double) rHeading2.Y();
1184 bRes = fabs(rPoint1.X() - (rPoint2.X() + fLambda * rHeading2.X())) < eps;
1185 }
1186
1187 return bRes;
1188 }
1189
1190
GetLineIntersectionPoint(Point & rResult,const Point & rPoint1,const Point & rHeading1,const Point & rPoint2,const Point & rHeading2)1191 sal_uInt16 GetLineIntersectionPoint(Point &rResult,
1192 const Point& rPoint1, const Point &rHeading1,
1193 const Point& rPoint2, const Point &rHeading2)
1194 {
1195 DBG_ASSERT(rHeading1 != Point(), "Sm : 0 vector");
1196 DBG_ASSERT(rHeading2 != Point(), "Sm : 0 vector");
1197
1198 sal_uInt16 nRes = 1;
1199 const double eps = 5.0 * DBL_EPSILON;
1200
1201 // sind die Richtumgsvektoren linear abhaengig ?
1202 double fDet = Det(rHeading1, rHeading2);
1203 if (fabs(fDet) < eps)
1204 {
1205 nRes = IsPointInLine(rPoint1, rPoint2, rHeading2) ? USHRT_MAX : 0;
1206 rResult = nRes ? rPoint1 : Point();
1207 }
1208 else
1209 {
1210 // hier achten wir nicht auf Rechengenauigkeit
1211 // (das wuerde aufwendiger und lohnt sich hier kaum)
1212 double fLambda = ( (rPoint1.Y() - rPoint2.Y()) * rHeading2.X()
1213 - (rPoint1.X() - rPoint2.X()) * rHeading2.Y())
1214 / fDet;
1215 rResult = Point(rPoint1.X() + (long) (fLambda * rHeading1.X()),
1216 rPoint1.Y() + (long) (fLambda * rHeading1.Y()));
1217 }
1218
1219 return nRes;
1220 }
1221
1222
1223
SmBinDiagonalNode(const SmToken & rNodeToken)1224 SmBinDiagonalNode::SmBinDiagonalNode(const SmToken &rNodeToken)
1225 : SmStructureNode(NBINDIAGONAL, rNodeToken)
1226 {
1227 bAscending = sal_False;
1228 SetNumSubNodes(3);
1229 }
1230
1231
GetOperPosSize(Point & rPos,Size & rSize,const Point & rDiagPoint,double fAngleDeg) const1232 void SmBinDiagonalNode::GetOperPosSize(Point &rPos, Size &rSize,
1233 const Point &rDiagPoint, double fAngleDeg) const
1234 // gibt die Position und Groesse fuer den Diagonalstrich zurueck.
1235 // Vor.: das SmRect des Nodes gibt die Begrenzung vor(!), muss also selbst
1236 // bereits bekannt sein.
1237
1238 {
1239 const double fPi = 3.1415926535897932384626433;
1240 double fAngleRad = fAngleDeg / 180.0 * fPi;
1241 long nRectLeft = GetItalicLeft(),
1242 nRectRight = GetItalicRight(),
1243 nRectTop = GetTop(),
1244 nRectBottom = GetBottom();
1245 Point aRightHdg (100, 0),
1246 aDownHdg (0, 100),
1247 aDiagHdg ( (long)(100.0 * cos(fAngleRad)),
1248 (long)(-100.0 * sin(fAngleRad)) );
1249
1250 long nLeft, nRight, nTop, nBottom; // Raender des Rechtecks fuer die
1251 // Diagonale
1252 Point aPoint;
1253 if (IsAscending())
1254 {
1255 //
1256 // obere rechte Ecke bestimmen
1257 //
1258 GetLineIntersectionPoint(aPoint,
1259 Point(nRectLeft, nRectTop), aRightHdg,
1260 rDiagPoint, aDiagHdg);
1261 //
1262 // gibt es einen Schnittpunkt mit dem oberen Rand ?
1263 if (aPoint.X() <= nRectRight)
1264 {
1265 nRight = aPoint.X();
1266 nTop = nRectTop;
1267 }
1268 else
1269 {
1270 // es muss einen Schnittpunkt mit dem rechten Rand geben!
1271 GetLineIntersectionPoint(aPoint,
1272 Point(nRectRight, nRectTop), aDownHdg,
1273 rDiagPoint, aDiagHdg);
1274
1275 nRight = nRectRight;
1276 nTop = aPoint.Y();
1277 }
1278
1279 //
1280 // untere linke Ecke bestimmen
1281 //
1282 GetLineIntersectionPoint(aPoint,
1283 Point(nRectLeft, nRectBottom), aRightHdg,
1284 rDiagPoint, aDiagHdg);
1285 //
1286 // gibt es einen Schnittpunkt mit dem unteren Rand ?
1287 if (aPoint.X() >= nRectLeft)
1288 {
1289 nLeft = aPoint.X();
1290 nBottom = nRectBottom;
1291 }
1292 else
1293 {
1294 // es muss einen Schnittpunkt mit dem linken Rand geben!
1295 GetLineIntersectionPoint(aPoint,
1296 Point(nRectLeft, nRectTop), aDownHdg,
1297 rDiagPoint, aDiagHdg);
1298
1299 nLeft = nRectLeft;
1300 nBottom = aPoint.Y();
1301 }
1302 }
1303 else
1304 {
1305 //
1306 // obere linke Ecke bestimmen
1307 //
1308 GetLineIntersectionPoint(aPoint,
1309 Point(nRectLeft, nRectTop), aRightHdg,
1310 rDiagPoint, aDiagHdg);
1311 //
1312 // gibt es einen Schnittpunkt mit dem oberen Rand ?
1313 if (aPoint.X() >= nRectLeft)
1314 {
1315 nLeft = aPoint.X();
1316 nTop = nRectTop;
1317 }
1318 else
1319 {
1320 // es muss einen Schnittpunkt mit dem linken Rand geben!
1321 GetLineIntersectionPoint(aPoint,
1322 Point(nRectLeft, nRectTop), aDownHdg,
1323 rDiagPoint, aDiagHdg);
1324
1325 nLeft = nRectLeft;
1326 nTop = aPoint.Y();
1327 }
1328
1329 //
1330 // untere rechte Ecke bestimmen
1331 //
1332 GetLineIntersectionPoint(aPoint,
1333 Point(nRectLeft, nRectBottom), aRightHdg,
1334 rDiagPoint, aDiagHdg);
1335 //
1336 // gibt es einen Schnittpunkt mit dem unteren Rand ?
1337 if (aPoint.X() <= nRectRight)
1338 {
1339 nRight = aPoint.X();
1340 nBottom = nRectBottom;
1341 }
1342 else
1343 {
1344 // es muss einen Schnittpunkt mit dem rechten Rand geben!
1345 GetLineIntersectionPoint(aPoint,
1346 Point(nRectRight, nRectTop), aDownHdg,
1347 rDiagPoint, aDiagHdg);
1348
1349 nRight = nRectRight;
1350 nBottom = aPoint.Y();
1351 }
1352 }
1353
1354 rSize = Size(nRight - nLeft + 1, nBottom - nTop + 1);
1355 rPos.X() = nLeft;
1356 rPos.Y() = nTop;
1357 }
1358
1359
Arrange(const OutputDevice & rDev,const SmFormat & rFormat)1360 void SmBinDiagonalNode::Arrange(const OutputDevice &rDev, const SmFormat &rFormat)
1361 {
1362 //! die beiden Argumente muessen in den Subnodes vor dem Operator kommen,
1363 //! damit das anklicken im GraphicWindow den FormulaCursor richtig setzt
1364 //! (vgl SmRootNode)
1365 SmNode *pLeft = GetSubNode(0),
1366 *pRight = GetSubNode(1);
1367 DBG_ASSERT(pLeft, "Sm : NULL pointer");
1368 DBG_ASSERT(pRight, "Sm : NULL pointer");
1369
1370 DBG_ASSERT(GetSubNode(2)->GetType() == NPOLYLINE, "Sm : falscher Nodetyp");
1371 SmPolyLineNode *pOper = (SmPolyLineNode *) GetSubNode(2);
1372 DBG_ASSERT(pOper, "Sm : NULL pointer");
1373
1374 //! some routines being called extract some info from the OutputDevice's
1375 //! font (eg the space to be used for borders OR the font name(!!)).
1376 //! Thus the font should reflect the needs and has to be set!
1377 SmTmpDevice aTmpDev ((OutputDevice &) rDev, sal_True);
1378 aTmpDev.SetFont(GetFont());
1379
1380 pLeft->Arrange(aTmpDev, rFormat);
1381 pRight->Arrange(aTmpDev, rFormat);
1382
1383 // implizit die Weite (incl Rand) des Diagonalstrichs ermitteln
1384 pOper->Arrange(aTmpDev, rFormat);
1385
1386 long nDelta = pOper->GetWidth() * 8 / 10;
1387
1388 // TopLeft Position vom rechten Argument ermitteln
1389 Point aPos;
1390 aPos.X() = pLeft->GetItalicRight() + nDelta + pRight->GetItalicLeftSpace();
1391 if (IsAscending())
1392 aPos.Y() = pLeft->GetBottom() + nDelta;
1393 else
1394 aPos.Y() = pLeft->GetTop() - nDelta - pRight->GetHeight();
1395
1396 pRight->MoveTo(aPos);
1397
1398 // neue Baseline bestimmen
1399 long nTmpBaseline = IsAscending() ? (pLeft->GetBottom() + pRight->GetTop()) / 2
1400 : (pLeft->GetTop() + pRight->GetBottom()) / 2;
1401 Point aLogCenter ((pLeft->GetItalicRight() + pRight->GetItalicLeft()) / 2,
1402 nTmpBaseline);
1403
1404 SmRect::operator = (*pLeft);
1405 ExtendBy(*pRight, RCP_NONE);
1406
1407
1408 // Position und Groesse des Diagonalstrich ermitteln
1409 Size aTmpSize;
1410 GetOperPosSize(aPos, aTmpSize, aLogCenter, IsAscending() ? 60.0 : -60.0);
1411
1412 // font specialist advised to change the width first
1413 pOper->AdaptToY(aTmpDev, aTmpSize.Height());
1414 pOper->AdaptToX(aTmpDev, aTmpSize.Width());
1415 // und diese wirksam machen
1416 pOper->Arrange(aTmpDev, rFormat);
1417
1418 pOper->MoveTo(aPos);
1419
1420 ExtendBy(*pOper, RCP_NONE, nTmpBaseline);
1421 }
1422
1423
1424 /**************************************************************************/
1425
1426
Arrange(const OutputDevice & rDev,const SmFormat & rFormat)1427 void SmSubSupNode::Arrange(const OutputDevice &rDev, const SmFormat &rFormat)
1428 {
1429 DBG_ASSERT(GetNumSubNodes() == 1 + SUBSUP_NUM_ENTRIES,
1430 "Sm: falsche Anzahl von subnodes");
1431
1432 SmNode *pBody = GetBody();
1433 DBG_ASSERT(pBody, "Sm: NULL pointer");
1434
1435 long nOrigHeight = pBody->GetFont().GetSize().Height();
1436
1437 pBody->Arrange(rDev, rFormat);
1438
1439 const SmRect &rBodyRect = pBody->GetRect();
1440 SmRect::operator = (rBodyRect);
1441
1442 // line that separates sub- and supscript rectangles
1443 long nDelimLine = SmFromTo(GetAlignB(), GetAlignT(), 0.4);
1444
1445 Point aPos;
1446 long nDelta, nDist;
1447
1448 // iterate over all possible sub-/supscripts
1449 SmRect aTmpRect (rBodyRect);
1450 for (int i = 0; i < SUBSUP_NUM_ENTRIES; i++)
1451 { SmSubSup eSubSup = (SmSubSup) i; // cast
1452 SmNode *pSubSup = GetSubSup(eSubSup);
1453
1454 if (!pSubSup)
1455 continue;
1456
1457 // switch position of limits if we are in textmode
1458 if (rFormat.IsTextmode() && (GetToken().nGroup & TGLIMIT))
1459 switch (eSubSup)
1460 { case CSUB: eSubSup = RSUB; break;
1461 case CSUP: eSubSup = RSUP; break;
1462 default:
1463 break;
1464 }
1465
1466 // prevent sub-/supscripts from diminishing in size
1467 // (as would be in "a_{1_{2_{3_4}}}")
1468 if (GetFont().GetSize().Height() > rFormat.GetBaseSize().Height() / 3)
1469 {
1470 sal_uInt16 nIndex = (eSubSup == CSUB || eSubSup == CSUP) ?
1471 SIZ_LIMITS : SIZ_INDEX;
1472 Fraction aFraction ( rFormat.GetRelSize(nIndex), 100 );
1473 pSubSup->SetSize(aFraction);
1474 }
1475
1476 pSubSup->Arrange(rDev, rFormat);
1477
1478 sal_Bool bIsTextmode = rFormat.IsTextmode();
1479 nDist = 0;
1480
1481 //! be sure that CSUB, CSUP are handled before the other cases!
1482 switch (eSubSup)
1483 { case RSUB :
1484 case LSUB :
1485 if (!bIsTextmode)
1486 nDist = nOrigHeight
1487 * rFormat.GetDistance(DIS_SUBSCRIPT) / 100L;
1488 aPos = pSubSup->GetRect().AlignTo(aTmpRect,
1489 eSubSup == LSUB ? RP_LEFT : RP_RIGHT,
1490 RHA_CENTER, RVA_BOTTOM);
1491 aPos.Y() += nDist;
1492 nDelta = nDelimLine - aPos.Y();
1493 if (nDelta > 0)
1494 aPos.Y() += nDelta;
1495 break;
1496 case RSUP :
1497 case LSUP :
1498 if (!bIsTextmode)
1499 nDist = nOrigHeight
1500 * rFormat.GetDistance(DIS_SUPERSCRIPT) / 100L;
1501 aPos = pSubSup->GetRect().AlignTo(aTmpRect,
1502 eSubSup == LSUP ? RP_LEFT : RP_RIGHT,
1503 RHA_CENTER, RVA_TOP);
1504 aPos.Y() -= nDist;
1505 nDelta = aPos.Y() + pSubSup->GetHeight() - nDelimLine;
1506 if (nDelta > 0)
1507 aPos.Y() -= nDelta;
1508 break;
1509 case CSUB :
1510 if (!bIsTextmode)
1511 nDist = nOrigHeight
1512 * rFormat.GetDistance(DIS_LOWERLIMIT) / 100L;
1513 aPos = pSubSup->GetRect().AlignTo(rBodyRect, RP_BOTTOM,
1514 RHA_CENTER, RVA_BASELINE);
1515 aPos.Y() += nDist;
1516 break;
1517 case CSUP :
1518 if (!bIsTextmode)
1519 nDist = nOrigHeight
1520 * rFormat.GetDistance(DIS_UPPERLIMIT) / 100L;
1521 aPos = pSubSup->GetRect().AlignTo(rBodyRect, RP_TOP,
1522 RHA_CENTER, RVA_BASELINE);
1523 aPos.Y() -= nDist;
1524 break;
1525 default :
1526 DBG_ASSERT(sal_False, "Sm: unbekannter Fall");
1527 break;
1528 }
1529
1530 pSubSup->MoveTo(aPos);
1531 ExtendBy(*pSubSup, RCP_THIS, (sal_Bool) sal_True);
1532
1533 // update rectangle to which RSUB, RSUP, LSUB, LSUP
1534 // will be aligned to
1535 if (eSubSup == CSUB || eSubSup == CSUP)
1536 aTmpRect = *this;
1537 }
1538 }
1539
CreateTextFromNode(String & rText)1540 void SmSubSupNode::CreateTextFromNode(String &rText)
1541 {
1542 SmNode *pNode;
1543 GetSubNode(0)->CreateTextFromNode(rText);
1544
1545 if (NULL != (pNode = GetSubNode(LSUB+1)))
1546 {
1547 APPEND(rText,"lsub ");
1548 pNode->CreateTextFromNode(rText);
1549 }
1550 if (NULL != (pNode = GetSubNode(LSUP+1)))
1551 {
1552 APPEND(rText,"lsup ");
1553 pNode->CreateTextFromNode(rText);
1554 }
1555 if (NULL != (pNode = GetSubNode(CSUB+1)))
1556 {
1557 APPEND(rText,"csub ");
1558 pNode->CreateTextFromNode(rText);
1559 }
1560 if (NULL != (pNode = GetSubNode(CSUP+1)))
1561 {
1562 APPEND(rText,"csup ");
1563 pNode->CreateTextFromNode(rText);
1564 }
1565 if (NULL != (pNode = GetSubNode(RSUB+1)))
1566 {
1567 rText.EraseTrailingChars();
1568 rText.Append('_');
1569 pNode->CreateTextFromNode(rText);
1570 }
1571 if (NULL != (pNode = GetSubNode(RSUP+1)))
1572 {
1573 rText.EraseTrailingChars();
1574 rText.Append('^');
1575 pNode->CreateTextFromNode(rText);
1576 }
1577 }
1578
1579
1580 /**************************************************************************/
1581
CreateTextFromNode(String & rText)1582 void SmBraceNode::CreateTextFromNode(String &rText)
1583 {
1584 if (GetScaleMode() == SCALE_HEIGHT)
1585 APPEND(rText,"left ");
1586 {
1587 String aStr;
1588 GetSubNode(0)->CreateTextFromNode(aStr);
1589 aStr.EraseLeadingAndTrailingChars();
1590 aStr.EraseLeadingChars('\\');
1591 if (aStr.Len())
1592 {
1593 if (aStr.EqualsAscii("divides"))
1594 APPEND(rText,"lline");
1595 else if (aStr.EqualsAscii("parallel"))
1596 APPEND(rText,"ldline");
1597 else if (aStr.EqualsAscii("<"))
1598 APPEND(rText,"langle");
1599 else
1600 rText.Append(aStr);
1601 rText.Append(' ');
1602 }
1603 else
1604 APPEND(rText,"none ");
1605 }
1606 GetSubNode(1)->CreateTextFromNode(rText);
1607 if (GetScaleMode() == SCALE_HEIGHT)
1608 APPEND(rText,"right ");
1609 {
1610 String aStr;
1611 GetSubNode(2)->CreateTextFromNode(aStr);
1612 aStr.EraseLeadingAndTrailingChars();
1613 aStr.EraseLeadingChars('\\');
1614 if (aStr.Len())
1615 {
1616 if (aStr.EqualsAscii("divides"))
1617 APPEND(rText,"rline");
1618 else if (aStr.EqualsAscii("parallel"))
1619 APPEND(rText,"rdline");
1620 else if (aStr.EqualsAscii(">"))
1621 APPEND(rText,"rangle");
1622 else
1623 rText.Append(aStr);
1624 rText.Append(' ');
1625 }
1626 else
1627 APPEND(rText,"none ");
1628 }
1629 rText.Append(' ');
1630
1631 }
1632
Arrange(const OutputDevice & rDev,const SmFormat & rFormat)1633 void SmBraceNode::Arrange(const OutputDevice &rDev, const SmFormat &rFormat)
1634 {
1635 SmNode *pLeft = GetSubNode(0),
1636 *pBody = GetSubNode(1),
1637 *pRight = GetSubNode(2);
1638 DBG_ASSERT(pLeft, "Sm: NULL pointer");
1639 DBG_ASSERT(pBody, "Sm: NULL pointer");
1640 DBG_ASSERT(pRight, "Sm: NULL pointer");
1641
1642 pBody->Arrange(rDev, rFormat);
1643
1644 sal_Bool bIsScaleNormal = rFormat.IsScaleNormalBrackets(),
1645 bScale = pBody->GetHeight() > 0 &&
1646 (GetScaleMode() == SCALE_HEIGHT || bIsScaleNormal),
1647 bIsABS = GetToken().eType == TABS;
1648
1649 long nFaceHeight = GetFont().GetSize().Height();
1650
1651 // Uebergroesse in % ermitteln
1652 sal_uInt16 nPerc = 0;
1653 if (!bIsABS && bScale)
1654 { // im Fall von Klammern mit Uebergroesse...
1655 sal_uInt16 nIndex = GetScaleMode() == SCALE_HEIGHT ?
1656 DIS_BRACKETSIZE : DIS_NORMALBRACKETSIZE;
1657 nPerc = rFormat.GetDistance(nIndex);
1658 }
1659
1660 // ermitteln der Hoehe fuer die Klammern
1661 long nBraceHeight;
1662 if (bScale)
1663 {
1664 nBraceHeight = pBody->GetType() == NBRACEBODY ?
1665 ((SmBracebodyNode *) pBody)->GetBodyHeight()
1666 : pBody->GetHeight();
1667 nBraceHeight += 2 * (nBraceHeight * nPerc / 100L);
1668 }
1669 else
1670 nBraceHeight = nFaceHeight;
1671
1672 // Abstand zum Argument
1673 nPerc = bIsABS ? 0 : rFormat.GetDistance(DIS_BRACKETSPACE);
1674 long nDist = nFaceHeight * nPerc / 100L;
1675
1676 // sofern erwuenscht skalieren der Klammern auf die gewuenschte Groesse
1677 if (bScale)
1678 {
1679 Size aTmpSize (pLeft->GetFont().GetSize());
1680 DBG_ASSERT(pRight->GetFont().GetSize() == aTmpSize,
1681 "Sm : unterschiedliche Fontgroessen");
1682 aTmpSize.Width() = Min((long) nBraceHeight * 60L / 100L,
1683 rFormat.GetBaseSize().Height() * 3L / 2L);
1684 // correction factor since change from StarMath to OpenSymbol font
1685 // because of the different font width in the FontMetric
1686 aTmpSize.Width() *= 182;
1687 aTmpSize.Width() /= 267;
1688
1689 xub_Unicode cChar = pLeft->GetToken().cMathChar;
1690 if (cChar != MS_LINE && cChar != MS_DLINE)
1691 pLeft ->GetFont().SetSize(aTmpSize);
1692
1693 cChar = pRight->GetToken().cMathChar;
1694 if (cChar != MS_LINE && cChar != MS_DLINE)
1695 pRight->GetFont().SetSize(aTmpSize);
1696
1697 pLeft ->AdaptToY(rDev, nBraceHeight);
1698 pRight->AdaptToY(rDev, nBraceHeight);
1699 }
1700
1701 pLeft ->Arrange(rDev, rFormat);
1702 pRight->Arrange(rDev, rFormat);
1703
1704 // damit auch "\(a\) - (a) - left ( a right )" vernuenftig aussieht
1705 RectVerAlign eVerAlign = bScale ? RVA_CENTERY : RVA_BASELINE;
1706
1707 Point aPos;
1708 aPos = pLeft->AlignTo(*pBody, RP_LEFT, RHA_CENTER, eVerAlign);
1709 aPos.X() -= nDist;
1710 pLeft->MoveTo(aPos);
1711
1712 aPos = pRight->AlignTo(*pBody, RP_RIGHT, RHA_CENTER, eVerAlign);
1713 aPos.X() += nDist;
1714 pRight->MoveTo(aPos);
1715
1716 SmRect::operator = (*pBody);
1717 ExtendBy(*pLeft, RCP_THIS).ExtendBy(*pRight, RCP_THIS);
1718 }
1719
1720
1721 /**************************************************************************/
1722
1723
Arrange(const OutputDevice & rDev,const SmFormat & rFormat)1724 void SmBracebodyNode::Arrange(const OutputDevice &rDev, const SmFormat &rFormat)
1725 {
1726 sal_uInt16 nNumSubNodes = GetNumSubNodes();
1727 if (nNumSubNodes == 0)
1728 return;
1729
1730 // arrange arguments
1731 sal_uInt16 i;
1732 for (i = 0; i < nNumSubNodes; i += 2)
1733 GetSubNode(i)->Arrange(rDev, rFormat);
1734
1735 // build reference rectangle with necessary info for vertical alignment
1736 SmRect aRefRect (*GetSubNode(0));
1737 for (i = 0; i < nNumSubNodes; i += 2)
1738 {
1739 SmRect aTmpRect (*GetSubNode(i));
1740 Point aPos = aTmpRect.AlignTo(aRefRect, RP_RIGHT, RHA_CENTER, RVA_BASELINE);
1741 aTmpRect.MoveTo(aPos);
1742 aRefRect.ExtendBy(aTmpRect, RCP_XOR);
1743 }
1744
1745 nBodyHeight = aRefRect.GetHeight();
1746
1747 // scale separators to required height and arrange them
1748 sal_Bool bScale = GetScaleMode() == SCALE_HEIGHT || rFormat.IsScaleNormalBrackets();
1749 long nHeight = bScale ? aRefRect.GetHeight() : GetFont().GetSize().Height();
1750 sal_uInt16 nIndex = GetScaleMode() == SCALE_HEIGHT ?
1751 DIS_BRACKETSIZE : DIS_NORMALBRACKETSIZE;
1752 sal_uInt16 nPerc = rFormat.GetDistance(nIndex);
1753 if (bScale)
1754 nHeight += 2 * (nHeight * nPerc / 100L);
1755 for (i = 1; i < nNumSubNodes; i += 2)
1756 {
1757 SmNode *pNode = GetSubNode(i);
1758 pNode->AdaptToY(rDev, nHeight);
1759 pNode->Arrange(rDev, rFormat);
1760 }
1761
1762 // horizontal distance between argument and brackets or separators
1763 long nDist = GetFont().GetSize().Height()
1764 * rFormat.GetDistance(DIS_BRACKETSPACE) / 100L;
1765
1766 SmNode *pLeft = GetSubNode(0);
1767 SmRect::operator = (*pLeft);
1768 for (i = 1; i < nNumSubNodes; i++)
1769 {
1770 sal_Bool bIsSeparator = i % 2 != 0;
1771 RectVerAlign eVerAlign = bIsSeparator ? RVA_CENTERY : RVA_BASELINE;
1772
1773 SmNode *pRight = GetSubNode(i);
1774 Point aPosX = pRight->AlignTo(*pLeft, RP_RIGHT, RHA_CENTER, eVerAlign),
1775 aPosY = pRight->AlignTo(aRefRect, RP_RIGHT, RHA_CENTER, eVerAlign);
1776 aPosX.X() += nDist;
1777
1778 pRight->MoveTo(Point(aPosX.X(), aPosY.Y()));
1779 ExtendBy(*pRight, bIsSeparator ? RCP_THIS : RCP_XOR);
1780
1781 pLeft = pRight;
1782 }
1783 }
1784
1785
1786 /**************************************************************************/
1787
1788
Arrange(const OutputDevice & rDev,const SmFormat & rFormat)1789 void SmVerticalBraceNode::Arrange(const OutputDevice &rDev, const SmFormat &rFormat)
1790 {
1791 SmNode *pBody = GetSubNode(0),
1792 *pBrace = GetSubNode(1),
1793 *pScript = GetSubNode(2);
1794 DBG_ASSERT(pBody, "Sm: NULL pointer!");
1795 DBG_ASSERT(pBrace, "Sm: NULL pointer!");
1796 DBG_ASSERT(pScript, "Sm: NULL pointer!");
1797
1798 SmTmpDevice aTmpDev ((OutputDevice &) rDev, sal_True);
1799 aTmpDev.SetFont(GetFont());
1800
1801 pBody->Arrange(aTmpDev, rFormat);
1802
1803 // Groesse wie bei Grenzen fuer diesen Teil
1804 pScript->SetSize( Fraction( rFormat.GetRelSize(SIZ_LIMITS), 100 ) );
1805 // etwas hoehere Klammern als normal
1806 pBrace ->SetSize( Fraction(3, 2) );
1807
1808 long nItalicWidth = pBody->GetItalicWidth();
1809 if (nItalicWidth > 0)
1810 pBrace->AdaptToX(aTmpDev, nItalicWidth);
1811
1812 pBrace ->Arrange(aTmpDev, rFormat);
1813 pScript->Arrange(aTmpDev, rFormat);
1814
1815 // die relativen Position und die Abstaende zueinander bestimmen
1816 RectPos eRectPos;
1817 long nFontHeight = pBody->GetFont().GetSize().Height();
1818 long nDistBody = nFontHeight * rFormat.GetDistance(DIS_ORNAMENTSIZE),
1819 nDistScript = nFontHeight;
1820 if (GetToken().eType == TOVERBRACE)
1821 {
1822 eRectPos = RP_TOP;
1823 nDistBody = - nDistBody;
1824 nDistScript *= - rFormat.GetDistance(DIS_UPPERLIMIT);
1825 }
1826 else // TUNDERBRACE
1827 {
1828 eRectPos = RP_BOTTOM;
1829 nDistScript *= + rFormat.GetDistance(DIS_LOWERLIMIT);
1830 }
1831 nDistBody /= 100L;
1832 nDistScript /= 100L;
1833
1834 Point aPos = pBrace->AlignTo(*pBody, eRectPos, RHA_CENTER, RVA_BASELINE);
1835 aPos.Y() += nDistBody;
1836 pBrace->MoveTo(aPos);
1837
1838 aPos = pScript->AlignTo(*pBrace, eRectPos, RHA_CENTER, RVA_BASELINE);
1839 aPos.Y() += nDistScript;
1840 pScript->MoveTo(aPos);
1841
1842 SmRect::operator = (*pBody);
1843 ExtendBy(*pBrace, RCP_THIS).ExtendBy(*pScript, RCP_THIS);
1844 }
1845
1846
1847 /**************************************************************************/
1848
1849
GetSymbol()1850 SmNode * SmOperNode::GetSymbol()
1851 {
1852 SmNode *pNode = GetSubNode(0);
1853 DBG_ASSERT(pNode, "Sm: NULL pointer!");
1854
1855 if (pNode->GetType() == NSUBSUP)
1856 pNode = ((SmSubSupNode *) pNode)->GetBody();
1857
1858 DBG_ASSERT(pNode, "Sm: NULL pointer!");
1859 return pNode;
1860 }
1861
1862
CalcSymbolHeight(const SmNode & rSymbol,const SmFormat & rFormat) const1863 long SmOperNode::CalcSymbolHeight(const SmNode &rSymbol,
1864 const SmFormat &rFormat) const
1865 // returns the font height to be used for operator-symbol
1866 {
1867 long nHeight = GetFont().GetSize().Height();
1868
1869 SmTokenType eTmpType = GetToken().eType;
1870 if (eTmpType == TLIM || eTmpType == TLIMINF || eTmpType == TLIMSUP)
1871 return nHeight;
1872
1873 if (!rFormat.IsTextmode())
1874 {
1875 // set minimum size ()
1876 nHeight += (nHeight * 20L) / 100L;
1877
1878 nHeight += nHeight
1879 * rFormat.GetDistance(DIS_OPERATORSIZE) / 100L;
1880 nHeight = nHeight * 686L / 845L;
1881 }
1882
1883 // correct user-defined symbols to match height of sum from used font
1884 if (rSymbol.GetToken().eType == TSPECIAL)
1885 nHeight = nHeight * 845L / 686L;
1886
1887 return nHeight;
1888 }
1889
1890
Arrange(const OutputDevice & rDev,const SmFormat & rFormat)1891 void SmOperNode::Arrange(const OutputDevice &rDev, const SmFormat &rFormat)
1892 {
1893 SmNode *pOper = GetSubNode(0);
1894 SmNode *pBody = GetSubNode(1);
1895
1896 DBG_ASSERT(pOper, "Sm: Subnode fehlt");
1897 DBG_ASSERT(pBody, "Sm: Subnode fehlt");
1898
1899 SmNode *pSymbol = GetSymbol();
1900 pSymbol->SetSize(Fraction(CalcSymbolHeight(*pSymbol, rFormat),
1901 pSymbol->GetFont().GetSize().Height()));
1902
1903 pBody->Arrange(rDev, rFormat);
1904 pOper->Arrange(rDev, rFormat);
1905
1906 long nOrigHeight = GetFont().GetSize().Height(),
1907 nDist = nOrigHeight
1908 * rFormat.GetDistance(DIS_OPERATORSPACE) / 100L;
1909
1910 Point aPos = pOper->AlignTo(*pBody, RP_LEFT, RHA_CENTER, /*RVA_CENTERY*/RVA_MID);
1911 aPos.X() -= nDist;
1912 pOper->MoveTo(aPos);
1913
1914 SmRect::operator = (*pBody);
1915 ExtendBy(*pOper, RCP_THIS);
1916 }
1917
1918
1919 /**************************************************************************/
1920
1921
Arrange(const OutputDevice & rDev,const SmFormat & rFormat)1922 void SmAlignNode::Arrange(const OutputDevice &rDev, const SmFormat &rFormat)
1923 // setzt im ganzen subtree (incl aktuellem node) das alignment
1924 {
1925 DBG_ASSERT(GetNumSubNodes() > 0, "Sm: SubNode fehlt");
1926
1927 SmNode *pNode = GetSubNode(0);
1928
1929 RectHorAlign eHorAlign = RHA_CENTER;
1930 switch (GetToken().eType)
1931 {
1932 case TALIGNL: eHorAlign = RHA_LEFT; break;
1933 case TALIGNC: eHorAlign = RHA_CENTER; break;
1934 case TALIGNR: eHorAlign = RHA_RIGHT; break;
1935 default:
1936 break;
1937 }
1938 SetRectHorAlign(eHorAlign);
1939
1940 pNode->Arrange(rDev, rFormat);
1941
1942 SmRect::operator = (pNode->GetRect());
1943 }
1944
1945
1946 /**************************************************************************/
1947
1948
Arrange(const OutputDevice & rDev,const SmFormat & rFormat)1949 void SmAttributNode::Arrange(const OutputDevice &rDev, const SmFormat &rFormat)
1950 {
1951 SmNode *pAttr = GetSubNode(0),
1952 *pBody = GetSubNode(1);
1953 DBG_ASSERT(pBody, "Sm: Body fehlt");
1954 DBG_ASSERT(pAttr, "Sm: Attribut fehlt");
1955
1956 pBody->Arrange(rDev, rFormat);
1957
1958 if (GetScaleMode() == SCALE_WIDTH)
1959 pAttr->AdaptToX(rDev, pBody->GetItalicWidth());
1960 pAttr->Arrange(rDev, rFormat);
1961
1962 // get relative position of attribut
1963 RectVerAlign eVerAlign;
1964 long nDist = 0;
1965 switch (GetToken().eType)
1966 { case TUNDERLINE :
1967 eVerAlign = RVA_ATTRIBUT_LO;
1968 break;
1969 case TOVERSTRIKE :
1970 eVerAlign = RVA_ATTRIBUT_MID;
1971 break;
1972 default :
1973 eVerAlign = RVA_ATTRIBUT_HI;
1974 if (pBody->GetType() == NATTRIBUT)
1975 nDist = GetFont().GetSize().Height()
1976 * rFormat.GetDistance(DIS_ORNAMENTSPACE) / 100L;
1977 }
1978 Point aPos = pAttr->AlignTo(*pBody, RP_ATTRIBUT, RHA_CENTER, eVerAlign);
1979 aPos.Y() -= nDist;
1980 pAttr->MoveTo(aPos);
1981
1982 SmRect::operator = (*pBody);
1983 ExtendBy(*pAttr, RCP_THIS, (sal_Bool) sal_True);
1984 }
1985
1986
1987 /**************************************************************************/
1988
1989
1990
1991
CreateTextFromNode(String & rText)1992 void SmFontNode::CreateTextFromNode(String &rText)
1993 {
1994 switch (GetToken().eType)
1995 {
1996 case TBOLD:
1997 APPEND(rText,"bold ");
1998 break;
1999 case TNBOLD:
2000 APPEND(rText,"nbold ");
2001 break;
2002 case TITALIC:
2003 APPEND(rText,"italic ");
2004 break;
2005 case TNITALIC:
2006 APPEND(rText,"nitalic ");
2007 break;
2008 case TPHANTOM:
2009 APPEND(rText,"phantom ");
2010 break;
2011 case TSIZE:
2012 {
2013 APPEND(rText,"size ");
2014 switch (nSizeType)
2015 {
2016 case FNTSIZ_PLUS:
2017 rText.Append('+');
2018 break;
2019 case FNTSIZ_MINUS:
2020 rText.Append('-');
2021 break;
2022 case FNTSIZ_MULTIPLY:
2023 rText.Append('*');
2024 break;
2025 case FNTSIZ_DIVIDE:
2026 rText.Append('/');
2027 break;
2028 case FNTSIZ_ABSOLUT:
2029 default:
2030 break;
2031 }
2032 rText += String( ::rtl::math::doubleToUString(
2033 static_cast<double>(aFontSize),
2034 rtl_math_StringFormat_Automatic,
2035 rtl_math_DecimalPlaces_Max, '.', sal_True));
2036 rText.Append(' ');
2037 }
2038 break;
2039 case TBLACK:
2040 APPEND(rText,"color black ");
2041 break;
2042 case TWHITE:
2043 APPEND(rText,"color white ");
2044 break;
2045 case TRED:
2046 APPEND(rText,"color red ");
2047 break;
2048 case TGREEN:
2049 APPEND(rText,"color green ");
2050 break;
2051 case TBLUE:
2052 APPEND(rText,"color blue ");
2053 break;
2054 case TCYAN:
2055 APPEND(rText,"color cyan ");
2056 break;
2057 case TMAGENTA:
2058 APPEND(rText,"color magenta ");
2059 break;
2060 case TYELLOW:
2061 APPEND(rText,"color yellow ");
2062 break;
2063 case TTEAL:
2064 APPEND(rText,"color teal");
2065 break;
2066 case TSILVER:
2067 APPEND(rText,"color silver");
2068 break;
2069 case TGRAY:
2070 APPEND(rText,"color gray");
2071 break;
2072 case TMAROON:
2073 APPEND(rText,"color maroon");
2074 break;
2075 case TPURPLE:
2076 APPEND(rText,"color purple");
2077 break;
2078 case TLIME:
2079 APPEND(rText,"color lime");
2080 break;
2081 case TOLIVE:
2082 APPEND(rText,"color olive");
2083 break;
2084 case TNAVY:
2085 APPEND(rText,"color navy");
2086 break;
2087 case TAQUA:
2088 APPEND(rText,"color aqua");
2089 break;
2090 case TFUCHSIA:
2091 APPEND(rText,"color fuchsia");
2092 break;
2093 case TSANS:
2094 APPEND(rText,"font sans ");
2095 break;
2096 case TSERIF:
2097 APPEND(rText,"font serif ");
2098 break;
2099 case TFIXED:
2100 APPEND(rText,"font fixed ");
2101 break;
2102 default:
2103 break;
2104 }
2105 GetSubNode(1)->CreateTextFromNode(rText);
2106 }
2107
2108
Prepare(const SmFormat & rFormat,const SmDocShell & rDocShell)2109 void SmFontNode::Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell)
2110 {
2111 //! prepare subnodes first
2112 SmNode::Prepare(rFormat, rDocShell);
2113
2114 int nFnt = -1;
2115 switch (GetToken().eType)
2116 {
2117 case TFIXED: nFnt = FNT_FIXED; break;
2118 case TSANS: nFnt = FNT_SANS; break;
2119 case TSERIF: nFnt = FNT_SERIF; break;
2120 default:
2121 break;
2122 }
2123 if (nFnt != -1)
2124 { GetFont() = rFormat.GetFont( sal::static_int_cast< sal_uInt16 >(nFnt) );
2125 SetFont(GetFont());
2126 }
2127
2128 //! prevent overwrites of this font by 'Arrange' or 'SetFont' calls of
2129 //! other font nodes (those with lower depth in the tree)
2130 Flags() |= FLG_FONT;
2131 }
2132
2133
Arrange(const OutputDevice & rDev,const SmFormat & rFormat)2134 void SmFontNode::Arrange(const OutputDevice &rDev, const SmFormat &rFormat)
2135 {
2136 SmNode *pNode = GetSubNode(1);
2137 DBG_ASSERT(pNode, "Sm: SubNode fehlt");
2138
2139 switch (GetToken().eType)
2140 { case TSIZE :
2141 pNode->SetFontSize(aFontSize, nSizeType);
2142 break;
2143 case TSANS :
2144 case TSERIF :
2145 case TFIXED :
2146 pNode->SetFont(GetFont());
2147 break;
2148 case TUNKNOWN : break; // no assertion on "font <?> <?>"
2149
2150 case TPHANTOM : SetPhantom(sal_True); break;
2151 case TBOLD : SetAttribut(ATTR_BOLD); break;
2152 case TITALIC : SetAttribut(ATTR_ITALIC); break;
2153 case TNBOLD : ClearAttribut(ATTR_BOLD); break;
2154 case TNITALIC : ClearAttribut(ATTR_ITALIC); break;
2155
2156 case TBLACK : SetColor(Color(COL_BLACK)); break;
2157 case TWHITE : SetColor(Color(COL_WHITE)); break;
2158 case TRED : SetColor(Color(COL_LIGHTRED)); break;
2159 case TGREEN : SetColor(Color(COL_GREEN)); break;
2160 case TBLUE : SetColor(Color(COL_LIGHTBLUE)); break;
2161 case TCYAN : SetColor(Color(COL_LIGHTCYAN)); break; // as in Calc
2162 case TMAGENTA : SetColor(Color(COL_LIGHTMAGENTA)); break; // as in Calc
2163 case TYELLOW : SetColor(Color(COL_YELLOW)); break;
2164 case TTEAL : SetColor(Color(COL_CYAN)); break;
2165 case TSILVER : SetColor(Color(COL_LIGHTGRAY)); break;
2166 case TGRAY : SetColor(Color(COL_GRAY)); break;
2167 case TMAROON : SetColor(Color(COL_RED)); break;
2168 case TPURPLE : SetColor(Color(COL_MAGENTA)); break;
2169 case TLIME : SetColor(Color(COL_LIGHTGREEN)); break;
2170 case TOLIVE : SetColor(Color(COL_BROWN)); break;
2171 case TNAVY : SetColor(Color(COL_BLUE)); break;
2172 case TAQUA : SetColor(Color(COL_LIGHTCYAN)); break;
2173 case TFUCHSIA : SetColor(Color(COL_LIGHTMAGENTA)); break;
2174
2175 default:
2176 DBG_ASSERT(sal_False, "Sm: unbekannter Fall");
2177 }
2178
2179 pNode->Arrange(rDev, rFormat);
2180
2181 SmRect::operator = (pNode->GetRect());
2182 }
2183
2184
SetSizeParameter(const Fraction & rValue,sal_uInt16 Type)2185 void SmFontNode::SetSizeParameter(const Fraction& rValue, sal_uInt16 Type)
2186 {
2187 nSizeType = Type;
2188 aFontSize = rValue;
2189 }
2190
2191
2192 /**************************************************************************/
2193
2194
SmPolyLineNode(const SmToken & rNodeToken)2195 SmPolyLineNode::SmPolyLineNode(const SmToken &rNodeToken)
2196 : SmGraphicNode(NPOLYLINE, rNodeToken)
2197 {
2198 aPoly.SetSize(2);
2199 nWidth = 0;
2200 }
2201
2202
AdaptToX(const OutputDevice &,sal_uLong nNewWidth)2203 void SmPolyLineNode::AdaptToX(const OutputDevice &/*rDev*/, sal_uLong nNewWidth)
2204 {
2205 aToSize.Width() = nNewWidth;
2206 }
2207
2208
AdaptToY(const OutputDevice &,sal_uLong nNewHeight)2209 void SmPolyLineNode::AdaptToY(const OutputDevice &/*rDev*/, sal_uLong nNewHeight)
2210 {
2211 GetFont().FreezeBorderWidth();
2212 aToSize.Height() = nNewHeight;
2213 }
2214
2215
Arrange(const OutputDevice & rDev,const SmFormat & rFormat)2216 void SmPolyLineNode::Arrange(const OutputDevice &rDev, const SmFormat &rFormat)
2217 {
2218 //! some routines being called extract some info from the OutputDevice's
2219 //! font (eg the space to be used for borders OR the font name(!!)).
2220 //! Thus the font should reflect the needs and has to be set!
2221 SmTmpDevice aTmpDev ((OutputDevice &) rDev, sal_True);
2222 aTmpDev.SetFont(GetFont());
2223
2224 long nBorderwidth = GetFont().GetBorderWidth();
2225
2226 //
2227 // Das Polygon mit den beiden Endpunkten bilden
2228 //
2229 DBG_ASSERT(aPoly.GetSize() == 2, "Sm : falsche Anzahl von Punkten");
2230 Point aPointA, aPointB;
2231 if (GetToken().eType == TWIDESLASH)
2232 {
2233 aPointA.X() = nBorderwidth;
2234 aPointA.Y() = aToSize.Height() - nBorderwidth;
2235 aPointB.X() = aToSize.Width() - nBorderwidth;
2236 aPointB.Y() = nBorderwidth;
2237 }
2238 else
2239 {
2240 DBG_ASSERT(GetToken().eType == TWIDEBACKSLASH, "Sm : unerwartetes Token");
2241 aPointA.X() =
2242 aPointA.Y() = nBorderwidth;
2243 aPointB.X() = aToSize.Width() - nBorderwidth;
2244 aPointB.Y() = aToSize.Height() - nBorderwidth;
2245 }
2246 aPoly.SetPoint(aPointA, 0);
2247 aPoly.SetPoint(aPointB, 1);
2248
2249 long nThick = GetFont().GetSize().Height()
2250 * rFormat.GetDistance(DIS_STROKEWIDTH) / 100L;
2251 nWidth = nThick + 2 * nBorderwidth;
2252
2253 SmRect::operator = (SmRect(aToSize.Width(), aToSize.Height()));
2254 }
2255
2256
Draw(OutputDevice & rDev,const Point & rPosition) const2257 void SmPolyLineNode::Draw(OutputDevice &rDev, const Point &rPosition) const
2258 {
2259 if (IsPhantom())
2260 return;
2261
2262 long nBorderwidth = GetFont().GetBorderWidth();
2263
2264 LineInfo aInfo;
2265 aInfo.SetWidth(nWidth - 2 * nBorderwidth);
2266
2267 Point aOffset (Point() - aPoly.GetBoundRect().TopLeft()
2268 + Point(nBorderwidth, nBorderwidth)),
2269 aPos (rPosition + aOffset);
2270 ((Polygon &) aPoly).Move(aPos.X(), aPos.Y());
2271
2272 SmTmpDevice aTmpDev ((OutputDevice &) rDev, sal_False);
2273 aTmpDev.SetLineColor( GetFont().GetColor() );
2274
2275 rDev.DrawPolyLine(aPoly, aInfo);
2276
2277 #ifdef SM_RECT_DEBUG
2278 if (!IsDebug())
2279 return;
2280
2281 int nRFlags = SM_RECT_CORE | SM_RECT_ITALIC | SM_RECT_LINES | SM_RECT_MID;
2282 SmRect::Draw(rDev, rPosition, nRFlags);
2283 #endif
2284 }
2285
2286
2287 /**************************************************************************/
2288
AdaptToX(const OutputDevice &,sal_uLong nWidth)2289 void SmRootSymbolNode::AdaptToX(const OutputDevice &/*rDev*/, sal_uLong nWidth)
2290 {
2291 nBodyWidth = nWidth;
2292 }
2293
2294
AdaptToY(const OutputDevice & rDev,sal_uLong nHeight)2295 void SmRootSymbolNode::AdaptToY(const OutputDevice &rDev, sal_uLong nHeight)
2296 {
2297 // etwas extra Laenge damit der horizontale Balken spaeter ueber dem
2298 // Argument positioniert ist
2299 SmMathSymbolNode::AdaptToY(rDev, nHeight + nHeight / 10L);
2300 }
2301
2302
Draw(OutputDevice & rDev,const Point & rPosition) const2303 void SmRootSymbolNode::Draw(OutputDevice &rDev, const Point &rPosition) const
2304 {
2305 if (IsPhantom())
2306 return;
2307
2308 // draw root-sign itself
2309 SmMathSymbolNode::Draw(rDev, rPosition);
2310
2311 SmTmpDevice aTmpDev( (OutputDevice &) rDev, sal_True );
2312 aTmpDev.SetFillColor(GetFont().GetColor());
2313 rDev.SetLineColor();
2314 aTmpDev.SetFont( GetFont() );
2315
2316 // since the width is always unscaled it corresponds ot the _original_
2317 // _unscaled_ font height to be used, we use that to calculate the
2318 // bar height. Thus it is independent of the arguments height.
2319 // ( see display of sqrt QQQ versus sqrt stack{Q#Q#Q#Q} )
2320 long nBarHeight = GetWidth() * 7L / 100L;
2321 long nBarWidth = nBodyWidth + GetBorderWidth();
2322 Point aBarOffset( GetWidth(), +GetBorderWidth() );
2323 Point aBarPos( rPosition + aBarOffset );
2324
2325 Rectangle aBar(aBarPos, Size( nBarWidth, nBarHeight) );
2326 //! avoid GROWING AND SHRINKING of drawn rectangle when constantly
2327 //! increasing zoomfactor.
2328 // This is done by shifting it's output-position to a point that
2329 // corresponds exactly to a pixel on the output device.
2330 Point aDrawPos( rDev.PixelToLogic(rDev.LogicToPixel(aBar.TopLeft())) );
2331 //aDrawPos.X() = aBar.Left(); //! don't change X position
2332 aBar.SetPos( aDrawPos );
2333
2334 rDev.DrawRect( aBar );
2335
2336 #ifdef SM_RECT_DEBUG
2337 if (!IsDebug())
2338 return;
2339
2340 int nRFlags = SM_RECT_CORE | SM_RECT_ITALIC | SM_RECT_LINES | SM_RECT_MID;
2341 SmRect::Draw(rDev, rPosition, nRFlags);
2342 #endif
2343 }
2344
2345
2346 /**************************************************************************/
2347
2348
AdaptToX(const OutputDevice &,sal_uLong nWidth)2349 void SmRectangleNode::AdaptToX(const OutputDevice &/*rDev*/, sal_uLong nWidth)
2350 {
2351 aToSize.Width() = nWidth;
2352 }
2353
2354
AdaptToY(const OutputDevice &,sal_uLong nHeight)2355 void SmRectangleNode::AdaptToY(const OutputDevice &/*rDev*/, sal_uLong nHeight)
2356 {
2357 GetFont().FreezeBorderWidth();
2358 aToSize.Height() = nHeight;
2359 }
2360
2361
Arrange(const OutputDevice & rDev,const SmFormat &)2362 void SmRectangleNode::Arrange(const OutputDevice &rDev, const SmFormat &/*rFormat*/)
2363 {
2364 long nFontHeight = GetFont().GetSize().Height();
2365 long nWidth = aToSize.Width(),
2366 nHeight = aToSize.Height();
2367 if (nHeight == 0)
2368 nHeight = nFontHeight / 30;
2369 if (nWidth == 0)
2370 nWidth = nFontHeight / 3;
2371
2372 SmTmpDevice aTmpDev ((OutputDevice &) rDev, sal_True);
2373 aTmpDev.SetFont(GetFont());
2374
2375 // add some borderspace
2376 sal_uLong nTmpBorderWidth = GetFont().GetBorderWidth();
2377 //nWidth += nTmpBorderWidth;
2378 nHeight += 2 * nTmpBorderWidth;
2379
2380 //! use this method in order to have 'SmRect::HasAlignInfo() == sal_True'
2381 //! and thus having the attribut-fences updated in 'SmRect::ExtendBy'
2382 SmRect::operator = (SmRect(nWidth, nHeight));
2383 }
2384
2385
Draw(OutputDevice & rDev,const Point & rPosition) const2386 void SmRectangleNode::Draw(OutputDevice &rDev, const Point &rPosition) const
2387 {
2388 if (IsPhantom())
2389 return;
2390
2391 SmTmpDevice aTmpDev ((OutputDevice &) rDev, sal_False);
2392 aTmpDev.SetFillColor(GetFont().GetColor());
2393 rDev.SetLineColor();
2394 aTmpDev.SetFont(GetFont());
2395
2396 sal_uLong nTmpBorderWidth = GetFont().GetBorderWidth();
2397
2398 // get rectangle and remove borderspace
2399 Rectangle aTmp (AsRectangle() + rPosition - GetTopLeft());
2400 aTmp.Left() += nTmpBorderWidth;
2401 aTmp.Right() -= nTmpBorderWidth;
2402 aTmp.Top() += nTmpBorderWidth;
2403 aTmp.Bottom() -= nTmpBorderWidth;
2404
2405 DBG_ASSERT(aTmp.GetHeight() > 0 && aTmp.GetWidth() > 0,
2406 "Sm: leeres Rechteck");
2407
2408 //! avoid GROWING AND SHRINKING of drawn rectangle when constantly
2409 //! increasing zoomfactor.
2410 // This is done by shifting it's output-position to a point that
2411 // corresponds exactly to a pixel on the output device.
2412 Point aPos (rDev.PixelToLogic(rDev.LogicToPixel(aTmp.TopLeft())));
2413 aTmp.SetPos(aPos);
2414
2415 rDev.DrawRect(aTmp);
2416
2417 #ifdef SM_RECT_DEBUG
2418 if (!IsDebug())
2419 return;
2420
2421 int nRFlags = SM_RECT_CORE | SM_RECT_ITALIC | SM_RECT_LINES | SM_RECT_MID;
2422 SmRect::Draw(rDev, rPosition, nRFlags);
2423 #endif
2424 }
2425
2426
2427 /**************************************************************************/
2428
2429
SmTextNode(SmNodeType eNodeType,const SmToken & rNodeToken,sal_uInt16 nFontDescP)2430 SmTextNode::SmTextNode( SmNodeType eNodeType, const SmToken &rNodeToken, sal_uInt16 nFontDescP ) :
2431 SmVisibleNode(eNodeType, rNodeToken)
2432 {
2433 nFontDesc = nFontDescP;
2434 }
2435
2436
SmTextNode(const SmToken & rNodeToken,sal_uInt16 nFontDescP)2437 SmTextNode::SmTextNode( const SmToken &rNodeToken, sal_uInt16 nFontDescP ) :
2438 SmVisibleNode(NTEXT, rNodeToken)
2439 {
2440 nFontDesc = nFontDescP;
2441 }
2442
2443
Prepare(const SmFormat & rFormat,const SmDocShell & rDocShell)2444 void SmTextNode::Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell)
2445 {
2446 SmNode::Prepare(rFormat, rDocShell);
2447
2448 // default setting for horizontal alignment of nodes with TTEXT
2449 // content is as alignl (cannot be done in Arrange since it would
2450 // override the settings made by an SmAlignNode before)
2451 if (TTEXT == GetToken().eType)
2452 SetRectHorAlign( RHA_LEFT );
2453
2454 aText = GetToken().aText;
2455 GetFont() = rFormat.GetFont(GetFontDesc());
2456
2457 if (IsItalic( GetFont() ))
2458 Attributes() |= ATTR_ITALIC;
2459 if (IsBold( GetFont() ))
2460 Attributes() |= ATTR_BOLD;
2461
2462 // special handling for ':' where it is a token on it's own and is likely
2463 // to be used for mathematical notations. (E.g. a:b = 2:3)
2464 // In that case it should not be displayed in italic.
2465 if (GetToken().aText.Len() == 1 && GetToken().aText.GetChar(0) == ':')
2466 Attributes() &= ~ATTR_ITALIC;
2467 };
2468
2469
Arrange(const OutputDevice & rDev,const SmFormat & rFormat)2470 void SmTextNode::Arrange(const OutputDevice &rDev, const SmFormat &rFormat)
2471 {
2472 PrepareAttributes();
2473
2474 sal_uInt16 nSizeDesc = GetFontDesc() == FNT_FUNCTION ?
2475 SIZ_FUNCTION : SIZ_TEXT;
2476 GetFont() *= Fraction (rFormat.GetRelSize(nSizeDesc), 100);
2477
2478 SmTmpDevice aTmpDev ((OutputDevice &) rDev, sal_True);
2479 aTmpDev.SetFont(GetFont());
2480
2481 SmRect::operator = (SmRect(aTmpDev, &rFormat, aText, GetFont().GetBorderWidth()));
2482 }
2483
CreateTextFromNode(String & rText)2484 void SmTextNode::CreateTextFromNode(String &rText)
2485 {
2486 sal_Bool bQuoted=sal_False;
2487 if (GetToken().eType == TTEXT)
2488 {
2489 rText.Append('\"');
2490 bQuoted=sal_True;
2491 }
2492 else
2493 {
2494 SmParser aParseTest;
2495 SmNode *pTable = aParseTest.Parse(GetToken().aText);
2496 bQuoted=sal_True;
2497 if ( (pTable->GetType() == NTABLE) && (pTable->GetNumSubNodes() == 1) )
2498 {
2499 SmNode *pResult = pTable->GetSubNode(0);
2500 if ( (pResult->GetType() == NLINE) &&
2501 (pResult->GetNumSubNodes() == 1) )
2502 {
2503 pResult = pResult->GetSubNode(0);
2504 if ( (pResult->GetType() == NEXPRESSION) &&
2505 (pResult->GetNumSubNodes() == 1) )
2506 {
2507 pResult = pResult->GetSubNode(0);
2508 if (pResult->GetType() == NTEXT)
2509 bQuoted=sal_False;
2510 }
2511 }
2512 }
2513 delete pTable;
2514
2515 if ((GetToken().eType == TIDENT) && (GetFontDesc() == FNT_FUNCTION))
2516 {
2517 //Search for existing functions and remove extraenous keyword
2518 APPEND(rText,"func ");
2519 }
2520 else if (bQuoted)
2521 APPEND(rText,"italic ");
2522
2523 if (bQuoted)
2524 rText.Append('\"');
2525
2526 }
2527
2528 rText.Append(GetToken().aText);
2529
2530 if (bQuoted)
2531 rText.Append('\"');
2532 rText.Append(' ');
2533 }
2534
Draw(OutputDevice & rDev,const Point & rPosition) const2535 void SmTextNode::Draw(OutputDevice &rDev, const Point& rPosition) const
2536 {
2537 if (IsPhantom() || aText.Len() == 0 || aText.GetChar(0) == xub_Unicode('\0'))
2538 return;
2539
2540 SmTmpDevice aTmpDev ((OutputDevice &) rDev, sal_False);
2541 aTmpDev.SetFont(GetFont());
2542
2543 Point aPos (rPosition);
2544 aPos.Y() += GetBaselineOffset();
2545 // auf Pixelkoordinaten runden
2546 aPos = rDev.PixelToLogic( rDev.LogicToPixel(aPos) );
2547
2548 #if OSL_DEBUG_LEVEL > 1
2549 sal_Int32 nPos = 0;
2550 sal_UCS4 cChar = OUString( aText ).iterateCodePoints( &nPos );
2551 (void) cChar;
2552 #endif
2553
2554 rDev.DrawStretchText(aPos, GetWidth(), aText);
2555
2556 #ifdef SM_RECT_DEBUG
2557 if (!IsDebug())
2558 return;
2559
2560 int nRFlags = SM_RECT_CORE | SM_RECT_ITALIC | SM_RECT_LINES | SM_RECT_MID;
2561 SmRect::Draw(rDev, rPosition, nRFlags);
2562 #endif
2563 }
2564
GetAccessibleText(String & rText) const2565 void SmTextNode::GetAccessibleText( String &rText ) const
2566 {
2567 rText += aText;
2568 }
2569
2570 /**************************************************************************/
2571
CreateTextFromNode(String & rText)2572 void SmMatrixNode::CreateTextFromNode(String &rText)
2573 {
2574 APPEND(rText,"matrix {");
2575 for (sal_uInt16 i = 0; i < nNumRows; i++)
2576 {
2577 for (sal_uInt16 j = 0; j < nNumCols; j++)
2578 {
2579 SmNode *pNode = GetSubNode(i * nNumCols + j);
2580 pNode->CreateTextFromNode(rText);
2581 if (j != nNumCols-1)
2582 APPEND(rText,"# ");
2583 }
2584 if (i != nNumRows-1)
2585 APPEND(rText,"## ");
2586 }
2587 rText.EraseTrailingChars();
2588 APPEND(rText,"} ");
2589 }
2590
2591
Arrange(const OutputDevice & rDev,const SmFormat & rFormat)2592 void SmMatrixNode::Arrange(const OutputDevice &rDev, const SmFormat &rFormat)
2593 {
2594 Point aPosition,
2595 aOffset;
2596 SmNode *pNode;
2597 sal_uInt16 i, j;
2598
2599 // initialize array that is to hold the maximum widhts of all
2600 // elements (subnodes) in that column.
2601 long *pColWidth = new long[nNumCols];
2602 for (j = 0; j < nNumCols; j++)
2603 pColWidth[j] = 0;
2604
2605 // arrange subnodes and calculate the aboves arrays contents
2606 sal_uInt16 nNodes = GetNumSubNodes();
2607 for (i = 0; i < nNodes; i++)
2608 {
2609 sal_uInt16 nIdx = nNodes - 1 - i;
2610 if (NULL != (pNode = GetSubNode(nIdx)))
2611 {
2612 pNode->Arrange(rDev, rFormat);
2613 int nCol = nIdx % nNumCols;
2614 pColWidth[nCol] = Max(pColWidth[nCol], pNode->GetItalicWidth());
2615 }
2616 }
2617
2618 // norm distance from which the following two are calcutated
2619 const int nNormDist = 3 * GetFont().GetSize().Height();
2620
2621 // define horizontal and vertical minimal distances that separate
2622 // the elements
2623 long nHorDist = nNormDist * rFormat.GetDistance(DIS_MATRIXCOL) / 100L,
2624 nVerDist = nNormDist * rFormat.GetDistance(DIS_MATRIXROW) / 100L;
2625
2626 // build array that holds the leftmost position for each column
2627 long *pColLeft = new long[nNumCols];
2628 long nX = 0;
2629 for (j = 0; j < nNumCols; j++)
2630 { pColLeft[j] = nX;
2631 nX += pColWidth[j] + nHorDist;
2632 }
2633
2634 Point aPos, aDelta;
2635 SmRect aLineRect;
2636 SmRect::operator = (SmRect());
2637 for (i = 0; i < nNumRows; i++)
2638 { aLineRect = SmRect();
2639 for (j = 0; j < nNumCols; j++)
2640 { SmNode *pTmpNode = GetSubNode(i * nNumCols + j);
2641 DBG_ASSERT(pTmpNode, "Sm: NULL pointer");
2642
2643 const SmRect &rNodeRect = pTmpNode->GetRect();
2644
2645 // align all baselines in that row if possible
2646 aPos = rNodeRect.AlignTo(aLineRect, RP_RIGHT, RHA_CENTER, RVA_BASELINE);
2647 aPos.X() += nHorDist;
2648
2649 // get horizontal alignment
2650 const SmNode *pCoNode = pTmpNode->GetLeftMost();
2651 RectHorAlign eHorAlign = pCoNode->GetRectHorAlign();
2652
2653 // caculate horizontal position of element depending on column
2654 // and horizontal alignment
2655 switch (eHorAlign)
2656 { case RHA_LEFT:
2657 aPos.X() = rNodeRect.GetLeft() + pColLeft[j];
2658 break;
2659 case RHA_CENTER:
2660 aPos.X() = rNodeRect.GetLeft() + pColLeft[j]
2661 + pColWidth[j] / 2
2662 - rNodeRect.GetItalicCenterX();
2663 break;
2664 case RHA_RIGHT:
2665 aPos.X() = rNodeRect.GetLeft() + pColLeft[j]
2666 + pColWidth[j] - rNodeRect.GetItalicWidth();
2667 break;
2668 }
2669
2670 pTmpNode->MoveTo(aPos);
2671 aLineRect.ExtendBy(rNodeRect, RCP_XOR);
2672 }
2673
2674 aPos = aLineRect.AlignTo(*this, RP_BOTTOM, RHA_CENTER, RVA_BASELINE);
2675 aPos.Y() += nVerDist;
2676
2677 // move 'aLineRect' and rectangles in that line to final position
2678 aDelta.X() = 0; // since horizontal alignment is already done
2679 aDelta.Y() = aPos.Y() - aLineRect.GetTop();
2680 aLineRect.Move(aDelta);
2681 for (j = 0; j < nNumCols; j++)
2682 if (NULL != (pNode = GetSubNode(i * nNumCols + j)))
2683 pNode->Move(aDelta);
2684
2685 ExtendBy(aLineRect, RCP_NONE);
2686 }
2687
2688 delete [] pColLeft;
2689 delete [] pColWidth;
2690 }
2691
2692
SetRowCol(sal_uInt16 nMatrixRows,sal_uInt16 nMatrixCols)2693 void SmMatrixNode::SetRowCol(sal_uInt16 nMatrixRows, sal_uInt16 nMatrixCols)
2694 {
2695 nNumRows = nMatrixRows;
2696 nNumCols = nMatrixCols;
2697 }
2698
2699
GetLeftMost()2700 SmNode * SmMatrixNode::GetLeftMost()
2701 {
2702 return this;
2703 }
2704
2705
2706 /**************************************************************************/
2707
2708
SmMathSymbolNode(const SmToken & rNodeToken)2709 SmMathSymbolNode::SmMathSymbolNode(const SmToken &rNodeToken)
2710 : SmSpecialNode(NMATH, rNodeToken, FNT_MATH)
2711 {
2712 xub_Unicode cChar = GetToken().cMathChar;
2713 if ((xub_Unicode) '\0' != cChar)
2714 SetText( cChar );
2715 }
2716
AdaptToX(const OutputDevice & rDev,sal_uLong nWidth)2717 void SmMathSymbolNode::AdaptToX(const OutputDevice &rDev, sal_uLong nWidth)
2718 {
2719 // Since there is no function to do this, we try to approximate it:
2720 Size aFntSize (GetFont().GetSize());
2721
2722 //! however the result is a bit better with 'nWidth' as initial font width
2723 aFntSize.Width() = nWidth;
2724 GetFont().SetSize(aFntSize);
2725
2726 SmTmpDevice aTmpDev ((OutputDevice &) rDev, sal_True);
2727 aTmpDev.SetFont(GetFont());
2728
2729 // get denominator of error factor for width
2730 long nTmpBorderWidth = GetFont().GetBorderWidth();
2731 long nDenom = SmRect(aTmpDev, NULL, GetText(), nTmpBorderWidth).GetItalicWidth();
2732
2733 // scale fontwidth with this error factor
2734 aFntSize.Width() *= nWidth;
2735 aFntSize.Width() /= nDenom ? nDenom : 1;
2736
2737 GetFont().SetSize(aFntSize);
2738 }
2739
AdaptToY(const OutputDevice & rDev,sal_uLong nHeight)2740 void SmMathSymbolNode::AdaptToY(const OutputDevice &rDev, sal_uLong nHeight)
2741 {
2742 GetFont().FreezeBorderWidth();
2743 Size aFntSize (GetFont().GetSize());
2744
2745 // da wir nur die Hoehe skalieren wollen muesen wir hier ggf die Fontweite
2746 // ermitteln um diese beizubehalten.
2747 if (aFntSize.Width() == 0)
2748 {
2749 OutputDevice &rDevNC = (OutputDevice &) rDev;
2750 rDevNC.Push(PUSH_FONT | PUSH_MAPMODE);
2751 rDevNC.SetFont(GetFont());
2752 aFntSize.Width() = rDev.GetFontMetric().GetSize().Width();
2753 rDevNC.Pop();
2754 }
2755 DBG_ASSERT(aFntSize.Width() != 0, "Sm: ");
2756
2757 //! however the result is a bit better with 'nHeight' as initial
2758 //! font height
2759 aFntSize.Height() = nHeight;
2760 GetFont().SetSize(aFntSize);
2761
2762 SmTmpDevice aTmpDev ((OutputDevice &) rDev, sal_True);
2763 aTmpDev.SetFont(GetFont());
2764
2765 // get denominator of error factor for height
2766 long nTmpBorderWidth = GetFont().GetBorderWidth();
2767 long nDenom = SmRect(aTmpDev, NULL, GetText(), nTmpBorderWidth).GetHeight();
2768
2769 // scale fontwidth with this error factor
2770 aFntSize.Height() *= nHeight;
2771 aFntSize.Height() /= nDenom ? nDenom : 1;
2772
2773 GetFont().SetSize(aFntSize);
2774 }
2775
2776
Prepare(const SmFormat & rFormat,const SmDocShell & rDocShell)2777 void SmMathSymbolNode::Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell)
2778 {
2779 SmNode::Prepare(rFormat, rDocShell);
2780
2781 GetFont() = rFormat.GetFont(GetFontDesc());
2782 // use same font size as is used for variables
2783 GetFont().SetSize( rFormat.GetFont( FNT_VARIABLE ).GetSize() );
2784
2785 DBG_ASSERT(GetFont().GetCharSet() == RTL_TEXTENCODING_SYMBOL ||
2786 GetFont().GetCharSet() == RTL_TEXTENCODING_UNICODE,
2787 "incorrect charset for character from StarMath/OpenSymbol font");
2788
2789 Flags() |= FLG_FONT | FLG_ITALIC;
2790 };
2791
2792
Arrange(const OutputDevice & rDev,const SmFormat & rFormat)2793 void SmMathSymbolNode::Arrange(const OutputDevice &rDev, const SmFormat &rFormat)
2794 {
2795 const XubString &rText = GetText();
2796
2797 if (rText.Len() == 0 || rText.GetChar(0) == xub_Unicode('\0'))
2798 { SmRect::operator = (SmRect());
2799 return;
2800 }
2801
2802 PrepareAttributes();
2803
2804 GetFont() *= Fraction (rFormat.GetRelSize(SIZ_TEXT), 100);
2805
2806 SmTmpDevice aTmpDev ((OutputDevice &) rDev, sal_True);
2807 aTmpDev.SetFont(GetFont());
2808
2809 SmRect::operator = (SmRect(aTmpDev, &rFormat, rText, GetFont().GetBorderWidth()));
2810 }
2811
CreateTextFromNode(String & rText)2812 void SmMathSymbolNode::CreateTextFromNode(String &rText)
2813 {
2814 String sStr;
2815 MathType::LookupChar(GetToken().cMathChar, sStr);
2816 rText.Append(sStr);
2817 }
2818
CreateTextFromNode(String & rText)2819 void SmRectangleNode::CreateTextFromNode(String &rText)
2820 {
2821 switch (GetToken().eType)
2822 {
2823 case TUNDERLINE:
2824 APPEND(rText,"underline ");
2825 break;
2826 case TOVERLINE:
2827 APPEND(rText,"overline ");
2828 break;
2829 case TOVERSTRIKE:
2830 APPEND(rText,"overstrike ");
2831 break;
2832 default:
2833 break;
2834 }
2835 }
2836
CreateTextFromNode(String & rText)2837 void SmAttributNode::CreateTextFromNode(String &rText)
2838 {
2839 SmNode *pNode;
2840 sal_uInt16 nSize = GetNumSubNodes();
2841 DBG_ASSERT(nSize == 2, "Node missing members");
2842 rText.Append('{');
2843 sal_Unicode nLast=0;
2844 if (NULL != (pNode = GetSubNode(0)))
2845 {
2846 String aStr;
2847 pNode->CreateTextFromNode(aStr);
2848 if (aStr.Len() > 1)
2849 rText.Append(aStr);
2850 else
2851 {
2852 nLast = aStr.GetChar(0);
2853 switch (nLast)
2854 {
2855 case 0xAF: // MACRON
2856 APPEND(rText,"overline ");
2857 break;
2858 case 0x2d9: // DOT ABOVE
2859 APPEND(rText,"dot ");
2860 break;
2861 case 0x2dc: // SMALL TILDE
2862 APPEND(rText,"widetilde ");
2863 break;
2864 case 0xA8: // DIAERESIS
2865 APPEND(rText,"ddot ");
2866 break;
2867 case 0xE082:
2868 break;
2869 case 0xE09B:
2870 case 0x20DB: // COMBINING THREE DOTS ABOVE
2871 APPEND(rText,"dddot ");
2872 break;
2873 case 0x301: // COMBINING ACUTE ACCENT
2874 APPEND(rText,"acute ");
2875 break;
2876 case 0x300: // COMBINING GRAVE ACCENT
2877 APPEND(rText,"grave ");
2878 break;
2879 case 0x30C: // COMBINING CARON
2880 APPEND(rText,"check ");
2881 break;
2882 case 0x306: // COMBINING BREVE
2883 APPEND(rText,"breve ");
2884 break;
2885 case 0x30A: // COMBINING RING ABOVE
2886 APPEND(rText,"circle ");
2887 break;
2888 case 0x20D7: // COMBINING RIGHT ARROW ABOVE
2889 APPEND(rText,"vec ");
2890 break;
2891 case 0x303: // COMBINING TILDE
2892 APPEND(rText,"tilde ");
2893 break;
2894 case 0x302: // COMBINING CIRCUMFLEX ACCENT
2895 APPEND(rText,"hat ");
2896 break;
2897 case 0x304: // COMBINING MACRON
2898 APPEND(rText,"bar ");
2899 break;
2900 default:
2901 rText.Append(nLast);
2902 break;
2903 }
2904 }
2905 }
2906
2907 if (nSize == 2)
2908 if (NULL != (pNode = GetSubNode(1)))
2909 pNode->CreateTextFromNode(rText);
2910
2911 rText.EraseTrailingChars();
2912
2913 if (nLast == 0xE082)
2914 APPEND(rText," overbrace {}");
2915
2916 APPEND(rText,"} ");
2917 }
2918
2919 /**************************************************************************/
2920
lcl_IsFromGreekSymbolSet(const String & rTokenText)2921 bool lcl_IsFromGreekSymbolSet( const String &rTokenText )
2922 {
2923 bool bRes = false;
2924
2925 // valid symbol name needs to have a '%' at pos 0 and at least an additional char
2926 if (rTokenText.Len() > 2 && rTokenText.GetBuffer()[0] == (sal_Unicode)'%')
2927 {
2928 String aName( rTokenText.Copy(1) );
2929 SmSym *pSymbol = SM_MOD()->GetSymbolManager().GetSymbolByName( aName );
2930 if (pSymbol && GetExportSymbolSetName( pSymbol->GetSymbolSetName() ).EqualsAscii( "Greek" ) )
2931 bRes = true;
2932 }
2933
2934 return bRes;
2935 }
2936
2937
SmSpecialNode(SmNodeType eNodeType,const SmToken & rNodeToken,sal_uInt16 _nFontDesc)2938 SmSpecialNode::SmSpecialNode(SmNodeType eNodeType, const SmToken &rNodeToken, sal_uInt16 _nFontDesc) :
2939 SmTextNode(eNodeType, rNodeToken, _nFontDesc)
2940 {
2941 bIsFromGreekSymbolSet = lcl_IsFromGreekSymbolSet( rNodeToken.aText );
2942 }
2943
2944
SmSpecialNode(const SmToken & rNodeToken)2945 SmSpecialNode::SmSpecialNode(const SmToken &rNodeToken) :
2946 SmTextNode(NSPECIAL, rNodeToken, FNT_MATH) //! default Font nicht immer richtig
2947 {
2948 bIsFromGreekSymbolSet = lcl_IsFromGreekSymbolSet( rNodeToken.aText );
2949 }
2950
2951
Prepare(const SmFormat & rFormat,const SmDocShell & rDocShell)2952 void SmSpecialNode::Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell)
2953 {
2954 SmNode::Prepare(rFormat, rDocShell);
2955
2956 const SmSym *pSym;
2957 SmModule *pp = SM_MOD();
2958
2959 String aName( GetToken().aText.Copy(1) );
2960 if (NULL != (pSym = pp->GetSymbolManager().GetSymbolByName( aName )))
2961 {
2962 sal_UCS4 cChar = pSym->GetCharacter();
2963 String aTmp( OUString( &cChar, 1 ) );
2964 SetText( aTmp );
2965 GetFont() = pSym->GetFace();
2966 }
2967 else
2968 {
2969 SetText( GetToken().aText );
2970 GetFont() = rFormat.GetFont(FNT_VARIABLE);
2971 }
2972 // use same font size as is used for variables
2973 GetFont().SetSize( rFormat.GetFont( FNT_VARIABLE ).GetSize() );
2974
2975 //! eigentlich sollten nur WEIGHT_NORMAL und WEIGHT_BOLD vorkommen...
2976 //! In der sms-Datei gibt es jedoch zB auch 'WEIGHT_ULTRALIGHT'
2977 //! daher vergleichen wir hier mit > statt mit != .
2978 //! (Langfristig sollte die Notwendigkeit fuer 'PrepareAttribut', und damit
2979 //! fuer dieses hier, mal entfallen.)
2980 //
2981 //! see also SmFontStyles::GetStyleName
2982 if (IsItalic( GetFont() ))
2983 SetAttribut(ATTR_ITALIC);
2984 if (IsBold( GetFont() ))
2985 SetAttribut(ATTR_BOLD);
2986
2987 Flags() |= FLG_FONT;
2988
2989 if (bIsFromGreekSymbolSet)
2990 {
2991 DBG_ASSERT( GetText().Len() == 1, "a symbol should only consist of 1 char!" );
2992 bool bItalic = false;
2993 sal_Int16 nStyle = rFormat.GetGreekCharStyle();
2994 DBG_ASSERT( nStyle >= 0 && nStyle <= 2, "unexpected value for GreekCharStyle" );
2995 if (nStyle == 1)
2996 bItalic = true;
2997 else if (nStyle == 2)
2998 {
2999 String aTmp( GetText() );
3000 if (aTmp.Len() > 0)
3001 {
3002 const sal_Unicode cUppercaseAlpha = 0x0391;
3003 const sal_Unicode cUppercaseOmega = 0x03A9;
3004 sal_Unicode cChar = aTmp.GetBuffer()[0];
3005 // uppercase letters should be straight and lowercase letters italic
3006 bItalic = !(cUppercaseAlpha <= cChar && cChar <= cUppercaseOmega);
3007 }
3008 }
3009
3010 if (bItalic)
3011 Attributes() |= ATTR_ITALIC;
3012 else
3013 Attributes() &= ~ATTR_ITALIC;;
3014 }
3015 };
3016
3017
Arrange(const OutputDevice & rDev,const SmFormat & rFormat)3018 void SmSpecialNode::Arrange(const OutputDevice &rDev, const SmFormat &rFormat)
3019 {
3020 PrepareAttributes();
3021
3022 SmTmpDevice aTmpDev ((OutputDevice &) rDev, sal_True);
3023 aTmpDev.SetFont(GetFont());
3024
3025 SmRect::operator = (SmRect(aTmpDev, &rFormat, GetText(), GetFont().GetBorderWidth()));
3026 }
3027
3028
Draw(OutputDevice & rDev,const Point & rPosition) const3029 void SmSpecialNode::Draw(OutputDevice &rDev, const Point& rPosition) const
3030 {
3031 //! since this chars might come from any font, that we may not have
3032 //! set to ALIGN_BASELINE yet, we do it now.
3033 ((SmSpecialNode *)this)->GetFont().SetAlign(ALIGN_BASELINE);
3034
3035 SmTextNode::Draw(rDev, rPosition);
3036 }
3037
3038
3039 /**************************************************************************/
3040
3041
Arrange(const OutputDevice & rDev,const SmFormat & rFormat)3042 void SmGlyphSpecialNode::Arrange(const OutputDevice &rDev, const SmFormat &rFormat)
3043 {
3044 PrepareAttributes();
3045
3046 SmTmpDevice aTmpDev ((OutputDevice &) rDev, sal_True);
3047 aTmpDev.SetFont(GetFont());
3048
3049 SmRect::operator = (SmRect(aTmpDev, &rFormat, GetText(),
3050 GetFont().GetBorderWidth()).AsGlyphRect());
3051 }
3052
3053
3054 /**************************************************************************/
3055
3056
Prepare(const SmFormat & rFormat,const SmDocShell & rDocShell)3057 void SmPlaceNode::Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell)
3058 {
3059 SmNode::Prepare(rFormat, rDocShell);
3060
3061 GetFont().SetColor(COL_GRAY);
3062 Flags() |= FLG_COLOR | FLG_FONT | FLG_ITALIC;
3063 };
3064
3065
Arrange(const OutputDevice & rDev,const SmFormat & rFormat)3066 void SmPlaceNode::Arrange(const OutputDevice &rDev, const SmFormat &rFormat)
3067 {
3068 PrepareAttributes();
3069
3070 SmTmpDevice aTmpDev ((OutputDevice &) rDev, sal_True);
3071 aTmpDev.SetFont(GetFont());
3072
3073 SmRect::operator = (SmRect(aTmpDev, &rFormat, GetText(), GetFont().GetBorderWidth()));
3074 }
3075
3076
3077 /**************************************************************************/
3078
3079
Prepare(const SmFormat & rFormat,const SmDocShell & rDocShell)3080 void SmErrorNode::Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell)
3081 {
3082 SmNode::Prepare(rFormat, rDocShell);
3083
3084 GetFont().SetColor(COL_RED);
3085 Flags() |= FLG_VISIBLE | FLG_BOLD | FLG_ITALIC
3086 | FLG_COLOR | FLG_FONT | FLG_SIZE;
3087 }
3088
3089
Arrange(const OutputDevice & rDev,const SmFormat & rFormat)3090 void SmErrorNode::Arrange(const OutputDevice &rDev, const SmFormat &rFormat)
3091 {
3092 PrepareAttributes();
3093
3094 SmTmpDevice aTmpDev ((OutputDevice &) rDev, sal_True);
3095 aTmpDev.SetFont(GetFont());
3096
3097 const XubString &rText = GetText();
3098 SmRect::operator = (SmRect(aTmpDev, &rFormat, rText, GetFont().GetBorderWidth()));
3099 }
3100
3101
3102 /**************************************************************************/
3103
3104
IncreaseBy(const SmToken & rToken)3105 void SmBlankNode::IncreaseBy(const SmToken &rToken)
3106 {
3107 switch(rToken.eType)
3108 {
3109 case TBLANK: nNum += 4; break;
3110 case TSBLANK: nNum += 1; break;
3111 default:
3112 break;
3113 }
3114 }
3115
3116
Prepare(const SmFormat & rFormat,const SmDocShell & rDocShell)3117 void SmBlankNode::Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell)
3118 {
3119 SmNode::Prepare(rFormat, rDocShell);
3120
3121 //! hier muss/sollte es lediglich nicht der StarMath Font sein,
3122 //! damit fuer das in Arrange verwendete Zeichen ein "normales"
3123 //! (ungecliptes) Rechteck erzeugt wird.
3124 GetFont() = rFormat.GetFont(FNT_VARIABLE);
3125
3126 Flags() |= FLG_FONT | FLG_BOLD | FLG_ITALIC;
3127 }
3128
3129
Arrange(const OutputDevice & rDev,const SmFormat & rFormat)3130 void SmBlankNode::Arrange(const OutputDevice &rDev, const SmFormat &rFormat)
3131 {
3132 SmTmpDevice aTmpDev ((OutputDevice &) rDev, sal_True);
3133 aTmpDev.SetFont(GetFont());
3134
3135 // Abstand von der Fonthoehe abhaengig machen
3136 // (damit er beim skalieren (zB size *2 {a ~ b}) mitwaechst)
3137 long nDist = GetFont().GetSize().Height() / 10L,
3138 nSpace = nNum * nDist;
3139
3140 // ein SmRect mit Baseline und allem drum und dran besorgen
3141 SmRect::operator = (SmRect(aTmpDev, &rFormat, XubString(xub_Unicode(' ')),
3142 GetFont().GetBorderWidth()));
3143
3144 // und dieses auf die gewuenschte Breite bringen
3145 SetItalicSpaces(0, 0);
3146 SetWidth(nSpace);
3147 }
3148
3149
3150
3151