?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Bump version to 24.04.3.4
[LibreOffice.git] / svx / source / svdraw / svdotext.cxx
blob986e2c7a4126ae66d5364d126c7459e11da378af
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 * Licensed to the Apache Software Foundation (ASF) under one or more
12 * contributor license agreements. See the NOTICE file distributed
13 * with this work for additional information regarding copyright
14 * ownership. The ASF licenses this file to you under the Apache
15 * License, Version 2.0 (the "License"); you may not use this file
16 * except in compliance with the License. You may obtain a copy of
17 * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19
20
21 #include <comphelper/string.hxx>
22 #include <svl/stritem.hxx>
23 #include <svx/svdotext.hxx>
24 #include <svx/svdpage.hxx>
25 #include <svx/svdoutl.hxx>
26 #include <svx/svdmodel.hxx>
27 #include <svx/dialmgr.hxx>
28 #include <svx/strings.hrc>
29 #include <editeng/writingmodeitem.hxx>
30 #include <svx/sdtfchim.hxx>
31 #include <editeng/editdata.hxx>
32 #include <editeng/editstat.hxx>
33 #include <editeng/outlobj.hxx>
34 #include <editeng/editobj.hxx>
35 #include <editeng/outliner.hxx>
36 #include <textchain.hxx>
37 #include <textchainflow.hxx>
38 #include <tools/helpers.hxx>
39 #include <svx/sderitm.hxx>
40 #include <svx/sdooitm.hxx>
41 #include <svx/sdshitm.hxx>
42 #include <svx/sdtagitm.hxx>
43 #include <svx/sdtfsitm.hxx>
44 #include <svx/sdtmfitm.hxx>
45 #include <svx/xtextit0.hxx>
46 #include <svx/compatflags.hxx>
47 #include <sdr/properties/textproperties.hxx>
48 #include <sdr/contact/viewcontactoftextobj.hxx>
49 #include <basegfx/tuple/b2dtuple.hxx>
50 #include <basegfx/matrix/b2dhommatrix.hxx>
51 #include <vcl/gdimtf.hxx>
52 #include <vcl/virdev.hxx>
53 #include <basegfx/matrix/b2dhommatrixtools.hxx>
54 #include <sal/log.hxx>
55 #include <o3tl/unit_conversion.hxx>
56 #include <o3tl/temporary.hxx>
57 #include <unotools/configmgr.hxx>
58 #include <editeng/eeitem.hxx>
59 #include <editeng/fhgtitem.hxx>
60
61 using namespace com::sun::star;
62
63 // BaseProperties section
64 std::unique_ptr<sdr::properties::BaseProperties> SdrTextObj::CreateObjectSpecificProperties()
65 {
66 return std::make_unique<sdr::properties::TextProperties>(*this);
67 }
68
69 // DrawContact section
70 std::unique_ptr<sdr::contact::ViewContact> SdrTextObj::CreateObjectSpecificViewContact()
71 {
72 return std::make_unique<sdr::contact::ViewContactOfTextObj>(*this);
73 }
74
75 SdrTextObj::SdrTextObj(SdrModel& rSdrModel)
76 : SdrAttrObj(rSdrModel)
77 , mpEditingOutliner(nullptr)
78 , meTextKind(SdrObjKind::Text)
79 , maTextEditOffset(Point(0, 0))
80 , mbTextFrame(false)
81 , mbNoShear(false)
82 , mbTextSizeDirty(false)
83 , mbInEditMode(false)
84 , mbDisableAutoWidthOnDragging(false)
85 , mbTextAnimationAllowed(true)
86 , mbInDownScale(false)
87 {
88 // #i25616#
89 mbSupportTextIndentingOnLineWidthChange = true;
90 }
91
92 SdrTextObj::SdrTextObj(SdrModel& rSdrModel, SdrTextObj const & rSource)
93 : SdrAttrObj(rSdrModel, rSource)
94 , mpEditingOutliner(nullptr)
95 , meTextKind(rSource.meTextKind)
96 , maTextEditOffset(Point(0, 0))
97 , mbTextFrame(rSource.mbTextFrame)
98 , mbNoShear(rSource.mbNoShear)
99 , mbTextSizeDirty(rSource.mbTextSizeDirty)
100 , mbInEditMode(false)
101 , mbDisableAutoWidthOnDragging(rSource.mbDisableAutoWidthOnDragging)
102 , mbTextAnimationAllowed(true)
103 , mbInDownScale(false)
104 {
105 // #i25616#
106 mbSupportTextIndentingOnLineWidthChange = true;
107
108 maRectangle = rSource.maRectangle;
109 maGeo = rSource.maGeo;
110 maTextSize = rSource.maTextSize;
111
112 // Not all of the necessary parameters were copied yet.
113 SdrText* pText = getActiveText();
114
115 if( pText && rSource.HasText() )
116 {
117 // before pNewOutlinerParaObject was created the same, but
118 // set at mpText (outside this scope), but mpText might be
119 // empty (this operator== seems not prepared for MultiText
120 // objects). In the current form it makes only sense to
121 // create locally and use locally on a known existing SdrText
122 const Outliner* pEO = rSource.mpEditingOutliner;
123 std::optional<OutlinerParaObject> pNewOutlinerParaObject;
124
125 if (pEO!=nullptr)
126 {
127 pNewOutlinerParaObject = pEO->CreateParaObject();
128 }
129 else if (nullptr != rSource.getActiveText()->GetOutlinerParaObject())
130 {
131 pNewOutlinerParaObject = *rSource.getActiveText()->GetOutlinerParaObject();
132 }
133
134 pText->SetOutlinerParaObject( std::move(pNewOutlinerParaObject) );
135 }
136
137 ImpSetTextStyleSheetListeners();
138 }
139
140 SdrTextObj::SdrTextObj(SdrModel& rSdrModel, const tools::Rectangle& rNewRect)
141 : SdrAttrObj(rSdrModel)
142 , mpEditingOutliner(nullptr)
143 , meTextKind(SdrObjKind::Text)
144 , maTextEditOffset(Point(0, 0))
145 , mbTextFrame(false)
146 , mbNoShear(false)
147 , mbTextSizeDirty(false)
148 , mbInEditMode(false)
149 , mbDisableAutoWidthOnDragging(false)
150 , mbTextAnimationAllowed(true)
151 , mbInDownScale(false)
152 {
153 tools::Rectangle aRectangle(rNewRect);
154 ImpJustifyRect(aRectangle);
155 setRectangle(aRectangle);
156
157 // #i25616#
158 mbSupportTextIndentingOnLineWidthChange = true;
159 }
160
161 SdrTextObj::SdrTextObj(SdrModel& rSdrModel, SdrObjKind eNewTextKind)
162 : SdrAttrObj(rSdrModel)
163 , mpEditingOutliner(nullptr)
164 , meTextKind(eNewTextKind)
165 , maTextEditOffset(Point(0, 0))
166 , mbTextFrame(true)
167 , mbNoShear(true)
168 , mbTextSizeDirty(false)
169 , mbInEditMode(false)
170 , mbDisableAutoWidthOnDragging(false)
171 , mbTextAnimationAllowed(true)
172 , mbInDownScale(false)
173 {
174 // #i25616#
175 mbSupportTextIndentingOnLineWidthChange = true;
176 }
177
178 SdrTextObj::SdrTextObj(SdrModel& rSdrModel, SdrObjKind eNewTextKind,
179 const tools::Rectangle& rNewRect)
180 : SdrAttrObj(rSdrModel)
181 , mpEditingOutliner(nullptr)
182 , meTextKind(eNewTextKind)
183 , maTextEditOffset(Point(0, 0))
184 , mbTextFrame(true)
185 , mbNoShear(true)
186 , mbTextSizeDirty(false)
187 , mbInEditMode(false)
188 , mbDisableAutoWidthOnDragging(false)
189 , mbTextAnimationAllowed(true)
190 , mbInDownScale(false)
191 {
192 tools::Rectangle aRectangle(rNewRect);
193 ImpJustifyRect(aRectangle);
194 setRectangle(aRectangle);
195
196 // #i25616#
197 mbSupportTextIndentingOnLineWidthChange = true;
198 }
199
200 SdrTextObj::~SdrTextObj()
201 {
202 mxText.clear();
203 ImpDeregisterLink();
204 }
205
206 void SdrTextObj::FitFrameToTextSize()
207 {
208 ImpJustifyRect(maRectangle);
209
210 SdrText* pText = getActiveText();
211 if(pText==nullptr || !pText->GetOutlinerParaObject())
212 return;
213
214 SdrOutliner& rOutliner=ImpGetDrawOutliner();
215 rOutliner.SetPaperSize(Size(getRectangle().Right() - getRectangle().Left(), getRectangle().Bottom() - getRectangle().Top()));
216 rOutliner.SetUpdateLayout(true);
217 rOutliner.SetText(*pText->GetOutlinerParaObject());
218 Size aNewSize(rOutliner.CalcTextSize());
219 rOutliner.Clear();
220 aNewSize.AdjustWidth( 1 ); // because of possible rounding errors
221 aNewSize.AdjustWidth(GetTextLeftDistance()+GetTextRightDistance() );
222 aNewSize.AdjustHeight(GetTextUpperDistance()+GetTextLowerDistance() );
223 tools::Rectangle aNewRect(getRectangle());
224 aNewRect.SetSize(aNewSize);
225 ImpJustifyRect(aNewRect);
226
227 if (aNewRect != getRectangle())
228 SetLogicRect(aNewRect);
229 }
230
231 void SdrTextObj::NbcSetText(const OUString& rStr)
232 {
233 SdrOutliner& rOutliner=ImpGetDrawOutliner();
234 rOutliner.SetStyleSheet( 0, GetStyleSheet());
235 rOutliner.SetText(rStr,rOutliner.GetParagraph( 0 ));
236 std::optional<OutlinerParaObject> pNewText=rOutliner.CreateParaObject();
237 NbcSetOutlinerParaObject(std::move(pNewText));
238 mbTextSizeDirty=true;
239 }
240
241 void SdrTextObj::SetText(const OUString& rStr)
242 {
243 tools::Rectangle aBoundRect0; if (m_pUserCall!=nullptr) aBoundRect0=GetLastBoundRect();
244 NbcSetText(rStr);
245 SetChanged();
246 BroadcastObjectChange();
247 SendUserCall(SdrUserCallType::Resize,aBoundRect0);
248 }
249
250 void SdrTextObj::NbcSetText(SvStream& rInput, const OUString& rBaseURL, EETextFormat eFormat)
251 {
252 SdrOutliner& rOutliner=ImpGetDrawOutliner();
253 rOutliner.SetStyleSheet( 0, GetStyleSheet());
254 rOutliner.Read(rInput,rBaseURL,eFormat);
255 std::optional<OutlinerParaObject> pNewText=rOutliner.CreateParaObject();
256 rOutliner.SetUpdateLayout(true);
257 Size aSize(rOutliner.CalcTextSize());
258 rOutliner.Clear();
259 NbcSetOutlinerParaObject(std::move(pNewText));
260 maTextSize=aSize;
261 mbTextSizeDirty=false;
262 }
263
264 void SdrTextObj::SetText(SvStream& rInput, const OUString& rBaseURL, EETextFormat eFormat)
265 {
266 tools::Rectangle aBoundRect0; if (m_pUserCall!=nullptr) aBoundRect0=GetLastBoundRect();
267 NbcSetText(rInput,rBaseURL,eFormat);
268 SetChanged();
269 BroadcastObjectChange();
270 SendUserCall(SdrUserCallType::Resize,aBoundRect0);
271 }
272
273 const Size& SdrTextObj::GetTextSize() const
274 {
275 if (mbTextSizeDirty)
276 {
277 Size aSiz;
278 SdrText* pText = getActiveText();
279 if( pText && pText->GetOutlinerParaObject ())
280 {
281 SdrOutliner& rOutliner=ImpGetDrawOutliner();
282 rOutliner.SetText(*pText->GetOutlinerParaObject());
283 rOutliner.SetUpdateLayout(true);
284 aSiz=rOutliner.CalcTextSize();
285 rOutliner.Clear();
286 }
287 // casting to nonconst twice
288 const_cast<SdrTextObj*>(this)->maTextSize = aSiz;
289 const_cast<SdrTextObj*>(this)->mbTextSizeDirty = false;
290 }
291 return maTextSize;
292 }
293
294 bool SdrTextObj::IsAutoGrowHeight() const
295 {
296 if(!mbTextFrame)
297 return false; // AutoGrow only together with TextFrames
298
299 const SfxItemSet& rSet = GetObjectItemSet();
300 bool bRet = rSet.Get(SDRATTR_TEXT_AUTOGROWHEIGHT).GetValue();
301
302 if(bRet)
303 {
304 SdrTextAniKind eAniKind = rSet.Get(SDRATTR_TEXT_ANIKIND).GetValue();
305
306 if(eAniKind == SdrTextAniKind::Scroll || eAniKind == SdrTextAniKind::Alternate || eAniKind == SdrTextAniKind::Slide)
307 {
308 SdrTextAniDirection eDirection = rSet.Get(SDRATTR_TEXT_ANIDIRECTION).GetValue();
309
310 if(eDirection == SdrTextAniDirection::Up || eDirection == SdrTextAniDirection::Down)
311 {
312 bRet = false;
313 }
314 }
315 }
316 return bRet;
317 }
318
319 bool SdrTextObj::IsAutoGrowWidth() const
320 {
321 if (!mbTextFrame)
322 return false; // AutoGrow only together with TextFrames
323
324 const SfxItemSet& rSet = GetObjectItemSet();
325 bool bRet = rSet.Get(SDRATTR_TEXT_AUTOGROWWIDTH).GetValue();
326
327 bool bInEditMOde = IsInEditMode();
328
329 if(!bInEditMOde && bRet)
330 {
331 SdrTextAniKind eAniKind = rSet.Get(SDRATTR_TEXT_ANIKIND).GetValue();
332
333 if(eAniKind == SdrTextAniKind::Scroll || eAniKind == SdrTextAniKind::Alternate || eAniKind == SdrTextAniKind::Slide)
334 {
335 SdrTextAniDirection eDirection = rSet.Get(SDRATTR_TEXT_ANIDIRECTION).GetValue();
336
337 if(eDirection == SdrTextAniDirection::Left || eDirection == SdrTextAniDirection::Right)
338 {
339 bRet = false;
340 }
341 }
342 }
343 return bRet;
344 }
345
346 SdrTextHorzAdjust SdrTextObj::GetTextHorizontalAdjust() const
347 {
348 return GetTextHorizontalAdjust(GetObjectItemSet());
349 }
350
351 SdrTextHorzAdjust SdrTextObj::GetTextHorizontalAdjust(const SfxItemSet& rSet) const
352 {
353 if(IsContourTextFrame())
354 return SDRTEXTHORZADJUST_BLOCK;
355
356 SdrTextHorzAdjust eRet = rSet.Get(SDRATTR_TEXT_HORZADJUST).GetValue();
357
358 bool bInEditMode = IsInEditMode();
359
360 if(!bInEditMode && eRet == SDRTEXTHORZADJUST_BLOCK)
361 {
362 SdrTextAniKind eAniKind = rSet.Get(SDRATTR_TEXT_ANIKIND).GetValue();
363
364 if(eAniKind == SdrTextAniKind::Scroll || eAniKind == SdrTextAniKind::Alternate || eAniKind == SdrTextAniKind::Slide)
365 {
366 SdrTextAniDirection eDirection = rSet.Get(SDRATTR_TEXT_ANIDIRECTION).GetValue();
367
368 if(eDirection == SdrTextAniDirection::Left || eDirection == SdrTextAniDirection::Right)
369 {
370 eRet = SDRTEXTHORZADJUST_LEFT;
371 }
372 }
373 }
374
375 return eRet;
376 } // defaults: BLOCK (justify) for text frame, CENTER for captions of drawing objects
377
378 SdrTextVertAdjust SdrTextObj::GetTextVerticalAdjust() const
379 {
380 return GetTextVerticalAdjust(GetObjectItemSet());
381 }
382
383 SdrTextVertAdjust SdrTextObj::GetTextVerticalAdjust(const SfxItemSet& rSet) const
384 {
385 if(IsContourTextFrame())
386 return SDRTEXTVERTADJUST_TOP;
387
388 // Take care for vertical text animation here
389 SdrTextVertAdjust eRet = rSet.Get(SDRATTR_TEXT_VERTADJUST).GetValue();
390 bool bInEditMode = IsInEditMode();
391
392 // Take care for vertical text animation here
393 if(!bInEditMode && eRet == SDRTEXTVERTADJUST_BLOCK)
394 {
395 SdrTextAniKind eAniKind = rSet.Get(SDRATTR_TEXT_ANIKIND).GetValue();
396
397 if(eAniKind == SdrTextAniKind::Scroll || eAniKind == SdrTextAniKind::Alternate || eAniKind == SdrTextAniKind::Slide)
398 {
399 SdrTextAniDirection eDirection = rSet.Get(SDRATTR_TEXT_ANIDIRECTION).GetValue();
400
401 if(eDirection == SdrTextAniDirection::Left || eDirection == SdrTextAniDirection::Right)
402 {
403 eRet = SDRTEXTVERTADJUST_TOP;
404 }
405 }
406 }
407
408 return eRet;
409 } // defaults: TOP for text frame, CENTER for captions of drawing objects
410
411 void SdrTextObj::ImpJustifyRect(tools::Rectangle& rRect)
412 {
413 if (!rRect.IsEmpty()) {
414 rRect.Normalize();
415 if (rRect.Left()==rRect.Right()) rRect.AdjustRight( 1 );
416 if (rRect.Top()==rRect.Bottom()) rRect.AdjustBottom( 1 );
417 }
418 }
419
420 void SdrTextObj::ImpCheckShear()
421 {
422 if (mbNoShear && maGeo.m_nShearAngle)
423 {
424 maGeo.m_nShearAngle = 0_deg100;
425 maGeo.mfTanShearAngle = 0;
426 }
427 }
428
429 void SdrTextObj::TakeObjInfo(SdrObjTransformInfoRec& rInfo) const
430 {
431 bool bNoTextFrame=!IsTextFrame();
432 rInfo.bResizeFreeAllowed=bNoTextFrame || ((maGeo.m_nRotationAngle.get() % 9000) == 0);
433 rInfo.bResizePropAllowed=true;
434 rInfo.bRotateFreeAllowed=true;
435 rInfo.bRotate90Allowed =true;
436 rInfo.bMirrorFreeAllowed=bNoTextFrame;
437 rInfo.bMirror45Allowed =bNoTextFrame;
438 rInfo.bMirror90Allowed =bNoTextFrame;
439
440 // allow transparency
441 rInfo.bTransparenceAllowed = true;
442
443 rInfo.bShearAllowed =bNoTextFrame;
444 rInfo.bEdgeRadiusAllowed=true;
445 bool bCanConv=ImpCanConvTextToCurve();
446 rInfo.bCanConvToPath =bCanConv;
447 rInfo.bCanConvToPoly =bCanConv;
448 rInfo.bCanConvToPathLineToArea=bCanConv;
449 rInfo.bCanConvToPolyLineToArea=bCanConv;
450 rInfo.bCanConvToContour = (rInfo.bCanConvToPoly || LineGeometryUsageIsNecessary());
451 }
452
453 SdrObjKind SdrTextObj::GetObjIdentifier() const
454 {
455 return meTextKind;
456 }
457
458 bool SdrTextObj::HasTextImpl( SdrOutliner const * pOutliner )
459 {
460 bool bRet=false;
461 if(pOutliner)
462 {
463 Paragraph* p1stPara=pOutliner->GetParagraph( 0 );
464 sal_Int32 nParaCount=pOutliner->GetParagraphCount();
465 if(p1stPara==nullptr)
466 nParaCount=0;
467
468 if(nParaCount==1)
469 {
470 // if it is only one paragraph, check if that paragraph is empty
471 if( pOutliner->GetText(p1stPara).isEmpty() )
472 nParaCount = 0;
473 }
474
475 bRet= nParaCount!=0;
476 }
477 return bRet;
478 }
479
480 void SdrTextObj::handlePageChange(SdrPage* pOldPage, SdrPage* pNewPage)
481 {
482 const bool bRemove(pNewPage == nullptr && pOldPage != nullptr);
483 const bool bInsert(pNewPage != nullptr && pOldPage == nullptr);
484 const bool bLinked(IsLinkedText());
485
486 if (bLinked && bRemove)
487 {
488 ImpDeregisterLink();
489 }
490
491 // call parent
492 SdrAttrObj::handlePageChange(pOldPage, pNewPage);
493
494 if (bLinked && bInsert)
495 {
496 ImpRegisterLink();
497 }
498 }
499
500 void SdrTextObj::NbcSetEckenradius(tools::Long nRad)
501 {
502 SetObjectItem(makeSdrEckenradiusItem(nRad));
503 }
504
505 // #115391# This implementation is based on the object size (aRect) and the
506 // states of IsAutoGrowWidth/Height to correctly set TextMinFrameWidth/Height
507 void SdrTextObj::AdaptTextMinSize()
508 {
509 if (!mbTextFrame)
510 // Only do this for text frame.
511 return;
512
513 if (getSdrModelFromSdrObject().IsPasteResize())
514 // Don't do this during paste resize.
515 return;
516
517 const bool bW = IsAutoGrowWidth();
518 const bool bH = IsAutoGrowHeight();
519
520 if (!bW && !bH)
521 // No auto grow requested. Bail out.
522 return;
523
524 SfxItemSetFixed<SDRATTR_TEXT_MINFRAMEHEIGHT, SDRATTR_TEXT_AUTOGROWHEIGHT,
525 SDRATTR_TEXT_MINFRAMEWIDTH, SDRATTR_TEXT_AUTOGROWWIDTH> // contains SDRATTR_TEXT_MAXFRAMEWIDTH
526 aSet(*GetObjectItemSet().GetPool());
527
528 if(bW)
529 {
530 // Set minimum width.
531 const tools::Long nDist = GetTextLeftDistance() + GetTextRightDistance();
532 const tools::Long nW = std::max<tools::Long>(0, getRectangle().GetWidth() - 1 - nDist); // text width without margins
533
534 aSet.Put(makeSdrTextMinFrameWidthItem(nW));
535
536 if(!IsVerticalWriting() && mbDisableAutoWidthOnDragging)
537 {
538 mbDisableAutoWidthOnDragging = true;
539 aSet.Put(makeSdrTextAutoGrowWidthItem(false));
540 }
541 }
542
543 if(bH)
544 {
545 // Set Minimum height.
546 const tools::Long nDist = GetTextUpperDistance() + GetTextLowerDistance();
547 const tools::Long nH = std::max<tools::Long>(0, getRectangle().GetHeight() - 1 - nDist); // text height without margins
548
549 aSet.Put(makeSdrTextMinFrameHeightItem(nH));
550
551 if(IsVerticalWriting() && mbDisableAutoWidthOnDragging)
552 {
553 mbDisableAutoWidthOnDragging = false;
554 aSet.Put(makeSdrTextAutoGrowHeightItem(false));
555 }
556 }
557
558 SetObjectItemSet(aSet);
559 }
560
561 void SdrTextObj::ImpSetContourPolygon( SdrOutliner& rOutliner, tools::Rectangle const & rAnchorRect, bool bLineWidth ) const
562 {
563 basegfx::B2DPolyPolygon aXorPolyPolygon(TakeXorPoly());
564 std::optional<basegfx::B2DPolyPolygon> pContourPolyPolygon;
565 basegfx::B2DHomMatrix aMatrix(basegfx::utils::createTranslateB2DHomMatrix(
566 -rAnchorRect.Left(), -rAnchorRect.Top()));
567
568 if(maGeo.m_nRotationAngle)
569 {
570 // Unrotate!
571 aMatrix.rotate(-toRadians(maGeo.m_nRotationAngle));
572 }
573
574 aXorPolyPolygon.transform(aMatrix);
575
576 if( bLineWidth )
577 {
578 // Take line width into account.
579 // When doing the hit test, avoid this. (Performance!)
580 pContourPolyPolygon.emplace();
581
582 // test if shadow needs to be avoided for TakeContour()
583 const SfxItemSet& rSet = GetObjectItemSet();
584 bool bShadowOn = rSet.Get(SDRATTR_SHADOW).GetValue();
585
586 // #i33696#
587 // Remember TextObject currently set at the DrawOutliner, it WILL be
588 // replaced during calculating the outline since it uses an own paint
589 // and that one uses the DrawOutliner, too.
590 const SdrTextObj* pLastTextObject = rOutliner.GetTextObj();
591
592 if(bShadowOn)
593 {
594 // force shadow off
595 rtl::Reference<SdrTextObj> pCopy = SdrObject::Clone(*this, getSdrModelFromSdrObject());
596 pCopy->SetMergedItem(makeSdrShadowItem(false));
597 *pContourPolyPolygon = pCopy->TakeContour();
598 }
599 else
600 {
601 *pContourPolyPolygon = TakeContour();
602 }
603
604 // #i33696#
605 // restore remembered text object
606 if(pLastTextObject != rOutliner.GetTextObj())
607 {
608 rOutliner.SetTextObj(pLastTextObject);
609 }
610
611 pContourPolyPolygon->transform(aMatrix);
612 }
613
614 rOutliner.SetPolygon(aXorPolyPolygon, pContourPolyPolygon ? &*pContourPolyPolygon : nullptr);
615 }
616
617 void SdrTextObj::TakeUnrotatedSnapRect(tools::Rectangle& rRect) const
618 {
619 rRect = getRectangle();
620 }
621
622 // See also: <unnamed>::getTextAnchorRange in svx/source/sdr/primitive2d/sdrdecompositiontools.cxx
623 void SdrTextObj::AdjustRectToTextDistance(tools::Rectangle& rAnchorRect) const
624 {
625 const tools::Long nLeftDist = GetTextLeftDistance();
626 const tools::Long nRightDist = GetTextRightDistance();
627 const tools::Long nUpperDist = GetTextUpperDistance();
628 const tools::Long nLowerDist = GetTextLowerDistance();
629 if (!IsVerticalWriting())
630 {
631 rAnchorRect.AdjustLeft(nLeftDist);
632 rAnchorRect.AdjustTop(nUpperDist);
633 rAnchorRect.AdjustRight(-nRightDist);
634 rAnchorRect.AdjustBottom(-nLowerDist);
635 }
636 else if (IsTopToBottom())
637 {
638 rAnchorRect.AdjustLeft(nLowerDist);
639 rAnchorRect.AdjustTop(nLeftDist);
640 rAnchorRect.AdjustRight(-nUpperDist);
641 rAnchorRect.AdjustBottom(-nRightDist);
642 }
643 else
644 {
645 rAnchorRect.AdjustLeft(nUpperDist);
646 rAnchorRect.AdjustTop(nRightDist);
647 rAnchorRect.AdjustRight(-nLowerDist);
648 rAnchorRect.AdjustBottom(-nLeftDist);
649 }
650
651 // Since sizes may be bigger than the object bounds it is necessary to
652 // justify the rect now.
653 ImpJustifyRect(rAnchorRect);
654 }
655
656 void SdrTextObj::TakeTextAnchorRect(tools::Rectangle& rAnchorRect) const
657 {
658 tools::Rectangle aAnkRect(getRectangle()); // the rectangle in which we anchor
659 bool bFrame=IsTextFrame();
660 if (!bFrame) {
661 TakeUnrotatedSnapRect(aAnkRect);
662 }
663 Point aRotateRef(aAnkRect.TopLeft());
664 AdjustRectToTextDistance(aAnkRect);
665
666 if (bFrame) {
667 // TODO: Optimize this.
668 if (aAnkRect.GetWidth()<2) aAnkRect.SetRight(aAnkRect.Left()+1 ); // minimum size h and v: 2 px
669 if (aAnkRect.GetHeight()<2) aAnkRect.SetBottom(aAnkRect.Top()+1 );
670 }
671 if (maGeo.m_nRotationAngle) {
672 Point aTmpPt(aAnkRect.TopLeft());
673 RotatePoint(aTmpPt,aRotateRef,maGeo.mfSinRotationAngle,maGeo.mfCosRotationAngle);
674 aTmpPt-=aAnkRect.TopLeft();
675 aAnkRect.Move(aTmpPt.X(),aTmpPt.Y());
676 }
677 rAnchorRect=aAnkRect;
678 }
679
680 void SdrTextObj::TakeTextRect( SdrOutliner& rOutliner, tools::Rectangle& rTextRect, bool bNoEditText,
681 tools::Rectangle* pAnchorRect, bool bLineWidth ) const
682 {
683 tools::Rectangle aAnkRect; // the rectangle in which we anchor
684 TakeTextAnchorRect(aAnkRect);
685 SdrTextVertAdjust eVAdj=GetTextVerticalAdjust();
686 SdrTextHorzAdjust eHAdj=GetTextHorizontalAdjust();
687 SdrTextAniKind eAniKind=GetTextAniKind();
688 SdrTextAniDirection eAniDirection=GetTextAniDirection();
689
690 bool bFitToSize(IsFitToSize());
691 bool bContourFrame=IsContourTextFrame();
692
693 bool bFrame=IsTextFrame();
694 EEControlBits nStat0=rOutliner.GetControlWord();
695 Size aNullSize;
696 if (!bContourFrame)
697 {
698 rOutliner.SetControlWord(nStat0|EEControlBits::AUTOPAGESIZE);
699 rOutliner.SetMinAutoPaperSize(aNullSize);
700 rOutliner.SetMaxAutoPaperSize(Size(1000000,1000000));
701 }
702
703 if (!bFitToSize && !bContourFrame)
704 {
705 tools::Long nAnkWdt=aAnkRect.GetWidth();
706 tools::Long nAnkHgt=aAnkRect.GetHeight();
707 if (bFrame)
708 {
709 tools::Long nWdt=nAnkWdt;
710 tools::Long nHgt=nAnkHgt;
711
712 bool bInEditMode = IsInEditMode();
713
714 if (!bInEditMode && (eAniKind==SdrTextAniKind::Scroll || eAniKind==SdrTextAniKind::Alternate || eAniKind==SdrTextAniKind::Slide))
715 {
716 // unlimited paper size for ticker text
717 if (eAniDirection==SdrTextAniDirection::Left || eAniDirection==SdrTextAniDirection::Right) nWdt=1000000;
718 if (eAniDirection==SdrTextAniDirection::Up || eAniDirection==SdrTextAniDirection::Down) nHgt=1000000;
719 }
720
721 bool bChainedFrame = IsChainable();
722 // Might be required for overflow check working: do limit height to frame if box is chainable.
723 if (!bChainedFrame) {
724 // #i119885# Do not limit/force height to geometrical frame (vice versa for vertical writing)
725
726 if(IsVerticalWriting())
727 {
728 nWdt = 1000000;
729 }
730 else
731 {
732 nHgt = 1000000;
733 }
734 }
735
736 rOutliner.SetMaxAutoPaperSize(Size(nWdt,nHgt));
737 }
738
739 // New try with _BLOCK for hor and ver after completely
740 // supporting full width for vertical text.
741 if(SDRTEXTHORZADJUST_BLOCK == eHAdj && !IsVerticalWriting())
742 {
743 rOutliner.SetMinAutoPaperSize(Size(nAnkWdt, 0));
744 rOutliner.SetMinColumnWrapHeight(nAnkHgt);
745 }
746
747 if(SDRTEXTVERTADJUST_BLOCK == eVAdj && IsVerticalWriting())
748 {
749 rOutliner.SetMinAutoPaperSize(Size(0, nAnkHgt));
750 rOutliner.SetMinColumnWrapHeight(nAnkWdt);
751 }
752 }
753
754 rOutliner.SetPaperSize(aNullSize);
755 if (bContourFrame)
756 ImpSetContourPolygon( rOutliner, aAnkRect, bLineWidth );
757
758 // put text into the outliner, if available from the edit outliner
759 SdrText* pText = getActiveText();
760 OutlinerParaObject* pOutlinerParaObject = pText ? pText->GetOutlinerParaObject() : nullptr;
761 std::optional<OutlinerParaObject> pPara;
762 if (mpEditingOutliner && !bNoEditText)
763 pPara = mpEditingOutliner->CreateParaObject();
764 else if (pOutlinerParaObject)
765 pPara = *pOutlinerParaObject;
766
767 if (pPara)
768 {
769 const bool bHitTest(&getSdrModelFromSdrObject().GetHitTestOutliner() == &rOutliner);
770 const SdrTextObj* pTestObj = rOutliner.GetTextObj();
771
772 if( !pTestObj || !bHitTest || pTestObj != this ||
773 pTestObj->GetOutlinerParaObject() != pOutlinerParaObject )
774 {
775 if( bHitTest ) // #i33696# take back fix #i27510#
776 {
777 rOutliner.SetTextObj( this );
778 rOutliner.SetFixedCellHeight(GetMergedItem(SDRATTR_TEXT_USEFIXEDCELLHEIGHT).GetValue());
779 }
780
781 rOutliner.SetUpdateLayout(true);
782 rOutliner.SetText(*pPara);
783 }
784 }
785 else
786 {
787 rOutliner.SetTextObj( nullptr );
788 }
789
790 rOutliner.SetUpdateLayout(true);
791 rOutliner.SetControlWord(nStat0);
792
793 if( pText )
794 pText->CheckPortionInfo(rOutliner);
795
796 Point aTextPos(aAnkRect.TopLeft());
797 Size aTextSiz(rOutliner.GetPaperSize()); // GetPaperSize() adds a little tolerance, right?
798
799 // For draw objects containing text correct hor/ver alignment if text is bigger
800 // than the object itself. Without that correction, the text would always be
801 // formatted to the left edge (or top edge when vertical) of the draw object.
802 if(!IsTextFrame())
803 {
804 if(aAnkRect.GetWidth() < aTextSiz.Width() && !IsVerticalWriting())
805 {
806 // Horizontal case here. Correct only if eHAdj == SDRTEXTHORZADJUST_BLOCK,
807 // else the alignment is wanted.
808 if(SDRTEXTHORZADJUST_BLOCK == eHAdj)
809 {
810 eHAdj = SDRTEXTHORZADJUST_CENTER;
811 }
812 }
813
814 if(aAnkRect.GetHeight() < aTextSiz.Height() && IsVerticalWriting())
815 {
816 // Vertical case here. Correct only if eHAdj == SDRTEXTVERTADJUST_BLOCK,
817 // else the alignment is wanted.
818 if(SDRTEXTVERTADJUST_BLOCK == eVAdj)
819 {
820 eVAdj = SDRTEXTVERTADJUST_CENTER;
821 }
822 }
823 }
824
825 if (eHAdj==SDRTEXTHORZADJUST_CENTER || eHAdj==SDRTEXTHORZADJUST_RIGHT)
826 {
827 tools::Long nFreeWdt=aAnkRect.GetWidth()-aTextSiz.Width();
828 if (eHAdj==SDRTEXTHORZADJUST_CENTER)
829 aTextPos.AdjustX(nFreeWdt/2 );
830 if (eHAdj==SDRTEXTHORZADJUST_RIGHT)
831 aTextPos.AdjustX(nFreeWdt );
832 }
833 if (eVAdj==SDRTEXTVERTADJUST_CENTER || eVAdj==SDRTEXTVERTADJUST_BOTTOM)
834 {
835 tools::Long nFreeHgt=aAnkRect.GetHeight()-aTextSiz.Height();
836 if (eVAdj==SDRTEXTVERTADJUST_CENTER)
837 aTextPos.AdjustY(nFreeHgt/2 );
838 if (eVAdj==SDRTEXTVERTADJUST_BOTTOM)
839 aTextPos.AdjustY(nFreeHgt );
840 }
841 if (maGeo.m_nRotationAngle)
842 RotatePoint(aTextPos,aAnkRect.TopLeft(),maGeo.mfSinRotationAngle,maGeo.mfCosRotationAngle);
843
844 if (pAnchorRect)
845 *pAnchorRect=aAnkRect;
846
847 // rTextRect might not be correct in some cases at ContourFrame
848 rTextRect=tools::Rectangle(aTextPos,aTextSiz);
849 if (bContourFrame)
850 rTextRect=aAnkRect;
851 }
852
853 bool SdrTextObj::CanCreateEditOutlinerParaObject() const
854 {
855 if( HasTextImpl( mpEditingOutliner ) )
856 {
857 return mpEditingOutliner->GetParagraphCount() > 0;
858 }
859 return false;
860 }
861
862 std::optional<OutlinerParaObject> SdrTextObj::CreateEditOutlinerParaObject() const
863 {
864 std::optional<OutlinerParaObject> pPara;
865 if( HasTextImpl( mpEditingOutliner ) )
866 {
867 sal_Int32 nParaCount = mpEditingOutliner->GetParagraphCount();
868 pPara = mpEditingOutliner->CreateParaObject(0, nParaCount);
869 }
870 return pPara;
871 }
872
873 void SdrTextObj::ImpSetCharStretching(SdrOutliner& rOutliner, const Size& rTextSize, const Size& rShapeSize, Fraction& rFitXCorrection)
874 {
875 OutputDevice* pOut = rOutliner.GetRefDevice();
876 bool bNoStretching(false);
877
878 if(pOut && pOut->GetOutDevType() == OUTDEV_PRINTER)
879 {
880 // check whether CharStretching is possible at all
881 GDIMetaFile* pMtf = pOut->GetConnectMetaFile();
882 OUString aTestString(u'J');
883
884 if(pMtf && (!pMtf->IsRecord() || pMtf->IsPause()))
885 pMtf = nullptr;
886
887 if(pMtf)
888 pMtf->Pause(true);
889
890 vcl::Font aOriginalFont(pOut->GetFont());
891 vcl::Font aTmpFont( OutputDevice::GetDefaultFont( DefaultFontType::SERIF, LANGUAGE_SYSTEM, GetDefaultFontFlags::OnlyOne ) );
892
893 aTmpFont.SetFontSize(Size(0,100));
894 pOut->SetFont(aTmpFont);
895 Size aSize1(pOut->GetTextWidth(aTestString), pOut->GetTextHeight());
896 aTmpFont.SetFontSize(Size(800,100));
897 pOut->SetFont(aTmpFont);
898 Size aSize2(pOut->GetTextWidth(aTestString), pOut->GetTextHeight());
899 pOut->SetFont(aOriginalFont);
900
901 if(pMtf)
902 pMtf->Pause(false);
903
904 bNoStretching = (aSize1 == aSize2);
905
906 #ifdef _WIN32
907 // Windows zooms the font proportionally when using Size(100,500),
908 // we don't like that.
909 if(aSize2.Height() >= aSize1.Height() * 2)
910 {
911 bNoStretching = true;
912 }
913 #endif
914 }
915
916 rOutliner.setRoundFontSizeToPt(false);
917
918 unsigned nLoopCount=0;
919 bool bNoMoreLoop = false;
920 tools::Long nXDiff0=0x7FFFFFFF;
921 tools::Long nWantWdt=rShapeSize.Width();
922 tools::Long nIsWdt=rTextSize.Width();
923 if (nIsWdt==0) nIsWdt=1;
924
925 tools::Long nWantHgt=rShapeSize.Height();
926 tools::Long nIsHgt=rTextSize.Height();
927 if (nIsHgt==0) nIsHgt=1;
928
929 tools::Long nXTolPl=nWantWdt/100; // tolerance: +1%
930 tools::Long nXTolMi=nWantWdt/25; // tolerance: -4%
931 tools::Long nXCorr =nWantWdt/20; // correction scale: 5%
932
933 double nX = (nWantWdt * 100.0) / double(nIsWdt); // calculate X stretching
934 double nY = (nWantHgt * 100.0) / double(nIsHgt); // calculate Y stretching
935 bool bChkX = true;
936 if (bNoStretching)
937 { // might only be possible proportionally
938 if (nX > nY)
939 {
940 nX = nY;
941 bChkX = false;
942 }
943 else
944 {
945 nY = nX;
946 }
947 }
948
949 while (nLoopCount<5 && !bNoMoreLoop)
950 {
951 if (nX < 0.0)
952 nX = -nX;
953 if (nX < 1.0)
954 {
955 nX = 1.0;
956 bNoMoreLoop = true;
957 }
958 if (nX > 65535.0)
959 {
960 nX = 65535.0;
961 bNoMoreLoop = true;
962 }
963
964 if (nY < 0.0)
965 {
966 nY = -nY;
967 }
968 if (nY < 1.0)
969 {
970 nY = 1.0;
971 bNoMoreLoop = true;
972 }
973 if (nY > 65535.0)
974 {
975 nY = 65535.0;
976 bNoMoreLoop = true;
977 }
978
979 // exception, there is no text yet (horizontal case)
980 if (nIsWdt <= 1)
981 {
982 nX = nY;
983 bNoMoreLoop = true;
984 }
985
986 // exception, there is no text yet (vertical case)
987 if (nIsHgt <= 1)
988 {
989 nY = nX;
990 bNoMoreLoop = true;
991 }
992 rOutliner.setScalingParameters({nX, nY});
993 nLoopCount++;
994 Size aSiz(rOutliner.CalcTextSize());
995 tools::Long nXDiff = aSiz.Width() - nWantWdt;
996 rFitXCorrection=Fraction(nWantWdt,aSiz.Width());
997 if (((nXDiff>=nXTolMi || !bChkX) && nXDiff<=nXTolPl) || nXDiff==nXDiff0) {
998 bNoMoreLoop = true;
999 } else {
1000 // correct stretching factors
1001 tools::Long nMul = nWantWdt;
1002 tools::Long nDiv = aSiz.Width();
1003 if (std::abs(nXDiff) <= 2 * nXCorr)
1004 {
1005 if (nMul > nDiv)
1006 nDiv += (nMul - nDiv) / 2.0; // but only add half of what we calculated,
1007 else
1008 nMul += (nDiv - nMul) / 2.0;// because the EditEngine calculates wrongly later on
1009 }
1010 nX = nX * double(nMul) / double(nDiv);
1011 if (bNoStretching)
1012 nY = nX;
1013 }
1014 nXDiff0 = nXDiff;
1015 }
1016 }
1017
1018 OUString SdrTextObj::TakeObjNameSingul() const
1019 {
1020 OUString aStr;
1021
1022 switch(meTextKind)
1023 {
1024 case SdrObjKind::OutlineText:
1025 {
1026 aStr = SvxResId(STR_ObjNameSingulOUTLINETEXT);
1027 break;
1028 }
1029
1030 case SdrObjKind::TitleText :
1031 {
1032 aStr = SvxResId(STR_ObjNameSingulTITLETEXT);
1033 break;
1034 }
1035
1036 default:
1037 {
1038 if(IsLinkedText())
1039 aStr = SvxResId(STR_ObjNameSingulTEXTLNK);
1040 else
1041 aStr = SvxResId(STR_ObjNameSingulTEXT);
1042 break;
1043 }
1044 }
1045
1046 OutlinerParaObject* pOutlinerParaObject = GetOutlinerParaObject();
1047 if(pOutlinerParaObject && meTextKind != SdrObjKind::OutlineText)
1048 {
1049 // shouldn't currently cause any problems at OUTLINETEXT
1050 OUString aStr2(comphelper::string::stripStart(pOutlinerParaObject->GetTextObject().GetText(0), ' '));
1051
1052 // avoid non expanded text portions in object name
1053 // (second condition is new)
1054 if(!aStr2.isEmpty() && aStr2.indexOf(u'\x00FF') == -1)
1055 {
1056 // space between ResStr and content text
1057 aStr += " \'";
1058
1059 if(aStr2.getLength() > 10)
1060 {
1061 aStr2 = OUString::Concat(aStr2.subView(0, 8)) + "...";
1062 }
1063
1064 aStr += aStr2 + "\'";
1065 }
1066 }
1067
1068 OUString sName(aStr);
1069
1070 OUString aName(GetName());
1071 if (!aName.isEmpty())
1072 sName += " '" + aName + "'";
1073
1074 return sName;
1075 }
1076
1077 OUString SdrTextObj::TakeObjNamePlural() const
1078 {
1079 OUString sName;
1080 switch (meTextKind)
1081 {
1082 case SdrObjKind::OutlineText: sName=SvxResId(STR_ObjNamePluralOUTLINETEXT); break;
1083 case SdrObjKind::TitleText : sName=SvxResId(STR_ObjNamePluralTITLETEXT); break;
1084 default: {
1085 if (IsLinkedText()) {
1086 sName=SvxResId(STR_ObjNamePluralTEXTLNK);
1087 } else {
1088 sName=SvxResId(STR_ObjNamePluralTEXT);
1089 }
1090 } break;
1091 } // switch
1092 return sName;
1093 }
1094
1095 rtl::Reference<SdrObject> SdrTextObj::CloneSdrObject(SdrModel& rTargetModel) const
1096 {
1097 return new SdrTextObj(rTargetModel, *this);
1098 }
1099
1100 basegfx::B2DPolyPolygon SdrTextObj::TakeXorPoly() const
1101 {
1102 tools::Polygon aPol(getRectangle());
1103 if (maGeo.m_nShearAngle)
1104 ShearPoly(aPol, getRectangle().TopLeft(), maGeo.mfTanShearAngle);
1105 if (maGeo.m_nRotationAngle)
1106 RotatePoly(aPol, getRectangle().TopLeft(), maGeo.mfSinRotationAngle, maGeo.mfCosRotationAngle);
1107
1108 basegfx::B2DPolyPolygon aRetval;
1109 aRetval.append(aPol.getB2DPolygon());
1110 return aRetval;
1111 }
1112
1113 basegfx::B2DPolyPolygon SdrTextObj::TakeContour() const
1114 {
1115 basegfx::B2DPolyPolygon aRetval(SdrAttrObj::TakeContour());
1116
1117 // and now add the BoundRect of the text, if necessary
1118 if ( GetOutlinerParaObject() && !IsFontwork() && !IsContourTextFrame() )
1119 {
1120 // using Clone()-Paint() strategy inside TakeContour() leaves a destroyed
1121 // SdrObject as pointer in DrawOutliner. Set *this again in fetching the outliner
1122 // in every case
1123 SdrOutliner& rOutliner=ImpGetDrawOutliner();
1124
1125 tools::Rectangle aAnchor2;
1126 tools::Rectangle aR;
1127 TakeTextRect(rOutliner,aR,false,&aAnchor2);
1128 rOutliner.Clear();
1129 bool bFitToSize(IsFitToSize());
1130 if (bFitToSize) aR=aAnchor2;
1131 tools::Polygon aPol(aR);
1132 if (maGeo.m_nRotationAngle) RotatePoly(aPol,aR.TopLeft(), maGeo.mfSinRotationAngle, maGeo.mfCosRotationAngle);
1133
1134 aRetval.append(aPol.getB2DPolygon());
1135 }
1136
1137 return aRetval;
1138 }
1139
1140 void SdrTextObj::RecalcSnapRect()
1141 {
1142 if (maGeo.m_nRotationAngle || maGeo.m_nShearAngle)
1143 {
1144 maSnapRect = Rect2Poly(getRectangle(), maGeo).GetBoundRect();
1145 } else {
1146 maSnapRect = getRectangle();
1147 }
1148 }
1149
1150 sal_uInt32 SdrTextObj::GetSnapPointCount() const
1151 {
1152 return 4;
1153 }
1154
1155 Point SdrTextObj::GetSnapPoint(sal_uInt32 i) const
1156 {
1157 Point aP;
1158 auto aRectangle = getRectangle();
1159 switch (i) {
1160 case 0: aP = aRectangle.TopLeft(); break;
1161 case 1: aP = aRectangle.TopRight(); break;
1162 case 2: aP = aRectangle.BottomLeft(); break;
1163 case 3: aP = aRectangle.BottomRight(); break;
1164 default: aP = aRectangle.Center(); break;
1165 }
1166 if (maGeo.m_nShearAngle)
1167 ShearPoint(aP, aRectangle.TopLeft(), maGeo.mfTanShearAngle);
1168 if (maGeo.m_nRotationAngle)
1169 RotatePoint(aP, aRectangle.TopLeft(), maGeo.mfSinRotationAngle, maGeo.mfCosRotationAngle);
1170 return aP;
1171 }
1172
1173 // Extracted from ImpGetDrawOutliner()
1174 void SdrTextObj::ImpInitDrawOutliner( SdrOutliner& rOutl ) const
1175 {
1176 rOutl.SetUpdateLayout(false);
1177 OutlinerMode nOutlinerMode = OutlinerMode::OutlineObject;
1178 if ( !IsOutlText() )
1179 nOutlinerMode = OutlinerMode::TextObject;
1180 rOutl.Init( nOutlinerMode );
1181
1182 rOutl.resetScalingParameters();
1183
1184 EEControlBits nStat=rOutl.GetControlWord();
1185 nStat &= ~EEControlBits(EEControlBits::STRETCHING|EEControlBits::AUTOPAGESIZE);
1186 rOutl.SetControlWord(nStat);
1187 Size aMaxSize(100000,100000);
1188 rOutl.SetMinAutoPaperSize(Size());
1189 rOutl.SetMaxAutoPaperSize(aMaxSize);
1190 rOutl.SetPaperSize(aMaxSize);
1191 rOutl.ClearPolygon();
1192 }
1193
1194 SdrOutliner& SdrTextObj::ImpGetDrawOutliner() const
1195 {
1196 SdrOutliner& rOutl(getSdrModelFromSdrObject().GetDrawOutliner(this));
1197
1198 // Code extracted to ImpInitDrawOutliner()
1199 ImpInitDrawOutliner( rOutl );
1200
1201 return rOutl;
1202 }
1203
1204 // Extracted from Paint()
1205 void SdrTextObj::ImpSetupDrawOutlinerForPaint( bool bContourFrame,
1206 SdrOutliner& rOutliner,
1207 tools::Rectangle& rTextRect,
1208 tools::Rectangle& rAnchorRect,
1209 tools::Rectangle& rPaintRect,
1210 Fraction& rFitXCorrection ) const
1211 {
1212 if (!bContourFrame)
1213 {
1214 // FitToSize can't be used together with ContourFrame for now
1215 if (IsFitToSize() || IsAutoFit())
1216 {
1217 EEControlBits nStat=rOutliner.GetControlWord();
1218 nStat|=EEControlBits::STRETCHING|EEControlBits::AUTOPAGESIZE;
1219 rOutliner.SetControlWord(nStat);
1220 }
1221 }
1222 rOutliner.SetFixedCellHeight(GetMergedItem(SDRATTR_TEXT_USEFIXEDCELLHEIGHT).GetValue());
1223 TakeTextRect(rOutliner, rTextRect, false, &rAnchorRect);
1224 rPaintRect = rTextRect;
1225
1226 if (bContourFrame)
1227 return;
1228
1229 // FitToSize can't be used together with ContourFrame for now
1230 if (IsFitToSize())
1231 {
1232 ImpSetCharStretching(rOutliner,rTextRect.GetSize(),rAnchorRect.GetSize(),rFitXCorrection);
1233 rPaintRect=rAnchorRect;
1234 }
1235 else if (IsAutoFit())
1236 {
1237 setupAutoFitText(rOutliner);
1238 }
1239 }
1240
1241 double SdrTextObj::GetFontScale() const
1242 {
1243 SdrOutliner& rOutliner = ImpGetDrawOutliner();
1244 // This eventually calls setupAutoFitText
1245 UpdateOutlinerFormatting(rOutliner, o3tl::temporary(tools::Rectangle()));
1246
1247 return rOutliner.getScalingParameters().fFontY;
1248 }
1249
1250 double SdrTextObj::GetSpacingScale() const
1251 {
1252 SdrOutliner& rOutliner = ImpGetDrawOutliner();
1253 // This eventually calls setupAutoFitText
1254 UpdateOutlinerFormatting(rOutliner, o3tl::temporary(tools::Rectangle()));
1255
1256 return rOutliner.getScalingParameters().fSpacingY;
1257 }
1258
1259 void SdrTextObj::setupAutoFitText(SdrOutliner& rOutliner) const
1260 {
1261 const Size aShapeSize = GetSnapRect().GetSize();
1262 Size aSize(aShapeSize.Width() - GetTextLeftDistance() - GetTextRightDistance(),
1263 aShapeSize.Height() - GetTextUpperDistance() - GetTextLowerDistance());
1264
1265 setupAutoFitText(rOutliner, aSize);
1266 }
1267 void SdrTextObj::setupAutoFitText(SdrOutliner& rOutliner, const Size& rTextBoxSize) const
1268 {
1269 rOutliner.setRoundFontSizeToPt(true); // We need to round the font size nearest integer pt size
1270 rOutliner.SetMaxAutoPaperSize(rTextBoxSize);
1271 rOutliner.SetPaperSize(rTextBoxSize);
1272
1273 const SdrTextFitToSizeTypeItem& rItem = GetObjectItem(SDRATTR_TEXT_FITTOSIZE);
1274
1275 double fFontScale = rItem.getFontScale();
1276 double fSpacingScale = rItem.getSpacingScale();
1277
1278 if (fFontScale > 0.0 && fSpacingScale > 0.0 && !mbInEditMode)
1279 {
1280 rOutliner.setScalingParameters({ fFontScale, fFontScale, 100.0, fSpacingScale });
1281 }
1282 else
1283 {
1284 rOutliner.resetScalingParameters();
1285 }
1286
1287 rOutliner.QuickFormatDoc();
1288 }
1289
1290 void SdrTextObj::SetupOutlinerFormatting( SdrOutliner& rOutl, tools::Rectangle& rPaintRect ) const
1291 {
1292 ImpInitDrawOutliner( rOutl );
1293 UpdateOutlinerFormatting( rOutl, rPaintRect );
1294 }
1295
1296 void SdrTextObj::UpdateOutlinerFormatting( SdrOutliner& rOutl, tools::Rectangle& rPaintRect ) const
1297 {
1298 tools::Rectangle aTextRect;
1299 tools::Rectangle aAnchorRect;
1300 Fraction aFitXCorrection(1,1);
1301
1302 const bool bContourFrame(IsContourTextFrame());
1303 const MapMode aMapMode(getSdrModelFromSdrObject().GetScaleUnit());
1304
1305 rOutl.SetRefMapMode(aMapMode);
1306 ImpSetupDrawOutlinerForPaint(
1307 bContourFrame,
1308 rOutl,
1309 aTextRect,
1310 aAnchorRect,
1311 rPaintRect,
1312 aFitXCorrection);
1313 }
1314
1315
1316 OutlinerParaObject* SdrTextObj::GetOutlinerParaObject() const
1317 {
1318 SdrText* pText = getActiveText();
1319 if( pText )
1320 return pText->GetOutlinerParaObject();
1321 else
1322 return nullptr;
1323 }
1324
1325 void SdrTextObj::NbcSetOutlinerParaObject(std::optional<OutlinerParaObject> pTextObject)
1326 {
1327 NbcSetOutlinerParaObjectForText( std::move(pTextObject), getActiveText() );
1328 }
1329
1330 namespace
1331 {
1332 bool IsAutoGrow(const SdrTextObj& rObj)
1333 {
1334 bool bAutoGrow = rObj.IsAutoGrowHeight() || rObj.IsAutoGrowWidth();
1335 return bAutoGrow && !utl::ConfigManager::IsFuzzing();
1336 }
1337 }
1338
1339 void SdrTextObj::NbcSetOutlinerParaObjectForText( std::optional<OutlinerParaObject> pTextObject, SdrText* pText )
1340 {
1341 if( pText )
1342 pText->SetOutlinerParaObject( std::move(pTextObject) );
1343
1344 if (pText && pText->GetOutlinerParaObject())
1345 {
1346 SvxWritingModeItem aWritingMode(pText->GetOutlinerParaObject()->IsEffectivelyVertical() && pText->GetOutlinerParaObject()->IsTopToBottom()
1347 ? css::text::WritingMode_TB_RL
1348 : css::text::WritingMode_LR_TB,
1349 SDRATTR_TEXTDIRECTION);
1350 GetProperties().SetObjectItemDirect(aWritingMode);
1351 }
1352
1353 SetTextSizeDirty();
1354 if (IsTextFrame() && IsAutoGrow(*this))
1355 { // adapt text frame!
1356 NbcAdjustTextFrameWidthAndHeight();
1357 }
1358 if (!IsTextFrame())
1359 {
1360 // the SnapRect keeps its size
1361 SetBoundAndSnapRectsDirty(true);
1362 }
1363
1364 // always invalidate BoundRect on change
1365 SetBoundRectDirty();
1366 ActionChanged();
1367
1368 ImpSetTextStyleSheetListeners();
1369 }
1370
1371 void SdrTextObj::NbcReformatText()
1372 {
1373 SdrText* pText = getActiveText();
1374 if( !(pText && pText->GetOutlinerParaObject()) )
1375 return;
1376
1377 pText->ReformatText();
1378 if (mbTextFrame)
1379 {
1380 NbcAdjustTextFrameWidthAndHeight();
1381 }
1382 else
1383 {
1384 // the SnapRect keeps its size
1385 SetBoundRectDirty();
1386 SetBoundAndSnapRectsDirty(/*bNotMyself*/true);
1387 }
1388 SetTextSizeDirty();
1389 ActionChanged();
1390 // i22396
1391 // Necessary here since we have no compare operator at the outliner
1392 // para object which may detect changes regarding the combination
1393 // of outliner para data and configuration (e.g., change of
1394 // formatting of text numerals)
1395 GetViewContact().flushViewObjectContacts(false);
1396 }
1397
1398 std::unique_ptr<SdrObjGeoData> SdrTextObj::NewGeoData() const
1399 {
1400 return std::make_unique<SdrTextObjGeoData>();
1401 }
1402
1403 void SdrTextObj::SaveGeoData(SdrObjGeoData& rGeo) const
1404 {
1405 SdrAttrObj::SaveGeoData(rGeo);
1406 SdrTextObjGeoData& rTGeo=static_cast<SdrTextObjGeoData&>(rGeo);
1407 rTGeo.maRect = getRectangle();
1408 rTGeo.maGeo = maGeo;
1409 }
1410
1411 void SdrTextObj::RestoreGeoData(const SdrObjGeoData& rGeo)
1412 { // RectsDirty is called by SdrObject
1413 SdrAttrObj::RestoreGeoData(rGeo);
1414 const SdrTextObjGeoData& rTGeo=static_cast<const SdrTextObjGeoData&>(rGeo);
1415 NbcSetLogicRect(rTGeo.maRect);
1416 maGeo = rTGeo.maGeo;
1417 SetTextSizeDirty();
1418 }
1419
1420 drawing::TextFitToSizeType SdrTextObj::GetFitToSize() const
1421 {
1422 drawing::TextFitToSizeType eType = drawing::TextFitToSizeType_NONE;
1423
1424 if(!IsAutoGrowWidth())
1425 eType = GetObjectItem(SDRATTR_TEXT_FITTOSIZE).GetValue();
1426
1427 return eType;
1428 }
1429
1430 const tools::Rectangle& SdrTextObj::GetGeoRect() const
1431 {
1432 return getRectangle();
1433 }
1434
1435 void SdrTextObj::ForceOutlinerParaObject()
1436 {
1437 SdrText* pText = getActiveText();
1438 if( pText && (pText->GetOutlinerParaObject() == nullptr) )
1439 {
1440 OutlinerMode nOutlMode = OutlinerMode::TextObject;
1441 if( IsTextFrame() && meTextKind == SdrObjKind::OutlineText )
1442 nOutlMode = OutlinerMode::OutlineObject;
1443
1444 pText->ForceOutlinerParaObject( nOutlMode );
1445 }
1446 }
1447
1448 TextChain *SdrTextObj::GetTextChain() const
1449 {
1450 //if (!IsChainable())
1451 // return NULL;
1452
1453 return getSdrModelFromSdrObject().GetTextChain();
1454 }
1455
1456 bool SdrTextObj::IsVerticalWriting() const
1457 {
1458 if(mpEditingOutliner)
1459 {
1460 return mpEditingOutliner->IsVertical();
1461 }
1462
1463 OutlinerParaObject* pOutlinerParaObject = GetOutlinerParaObject();
1464 if(pOutlinerParaObject)
1465 {
1466 return pOutlinerParaObject->IsEffectivelyVertical();
1467 }
1468
1469 return false;
1470 }
1471
1472 void SdrTextObj::SetVerticalWriting(bool bVertical)
1473 {
1474 OutlinerParaObject* pOutlinerParaObject = GetOutlinerParaObject();
1475
1476 if( !pOutlinerParaObject && bVertical )
1477 {
1478 // we only need to force an outliner para object if the default of
1479 // horizontal text is changed
1480 ForceOutlinerParaObject();
1481 pOutlinerParaObject = GetOutlinerParaObject();
1482 }
1483
1484 if (!pOutlinerParaObject ||
1485 (pOutlinerParaObject->IsEffectivelyVertical() == bVertical))
1486 return;
1487
1488 // get item settings
1489 const SfxItemSet& rSet = GetObjectItemSet();
1490 bool bAutoGrowWidth = rSet.Get(SDRATTR_TEXT_AUTOGROWWIDTH).GetValue();
1491 bool bAutoGrowHeight = rSet.Get(SDRATTR_TEXT_AUTOGROWHEIGHT).GetValue();
1492
1493 // Also exchange hor/ver adjust items
1494 SdrTextHorzAdjust eHorz = rSet.Get(SDRATTR_TEXT_HORZADJUST).GetValue();
1495 SdrTextVertAdjust eVert = rSet.Get(SDRATTR_TEXT_VERTADJUST).GetValue();
1496
1497 // rescue object size
1498 tools::Rectangle aObjectRect = GetSnapRect();
1499
1500 // prepare ItemSet to set exchanged width and height items
1501 SfxItemSetFixed<SDRATTR_TEXT_AUTOGROWHEIGHT, SDRATTR_TEXT_AUTOGROWHEIGHT,
1502 // Expanded item ranges to also support hor and ver adjust.
1503 SDRATTR_TEXT_VERTADJUST, SDRATTR_TEXT_VERTADJUST,
1504 SDRATTR_TEXT_AUTOGROWWIDTH, SDRATTR_TEXT_HORZADJUST> aNewSet(*rSet.GetPool());
1505
1506 aNewSet.Put(rSet);
1507 aNewSet.Put(makeSdrTextAutoGrowWidthItem(bAutoGrowHeight));
1508 aNewSet.Put(makeSdrTextAutoGrowHeightItem(bAutoGrowWidth));
1509
1510 // Exchange horz and vert adjusts
1511 switch (eVert)
1512 {
1513 case SDRTEXTVERTADJUST_TOP: aNewSet.Put(SdrTextHorzAdjustItem(SDRTEXTHORZADJUST_RIGHT)); break;
1514 case SDRTEXTVERTADJUST_CENTER: aNewSet.Put(SdrTextHorzAdjustItem(SDRTEXTHORZADJUST_CENTER)); break;
1515 case SDRTEXTVERTADJUST_BOTTOM: aNewSet.Put(SdrTextHorzAdjustItem(SDRTEXTHORZADJUST_LEFT)); break;
1516 case SDRTEXTVERTADJUST_BLOCK: aNewSet.Put(SdrTextHorzAdjustItem(SDRTEXTHORZADJUST_BLOCK)); break;
1517 }
1518 switch (eHorz)
1519 {
1520 case SDRTEXTHORZADJUST_LEFT: aNewSet.Put(SdrTextVertAdjustItem(SDRTEXTVERTADJUST_BOTTOM)); break;
1521 case SDRTEXTHORZADJUST_CENTER: aNewSet.Put(SdrTextVertAdjustItem(SDRTEXTVERTADJUST_CENTER)); break;
1522 case SDRTEXTHORZADJUST_RIGHT: aNewSet.Put(SdrTextVertAdjustItem(SDRTEXTVERTADJUST_TOP)); break;
1523 case SDRTEXTHORZADJUST_BLOCK: aNewSet.Put(SdrTextVertAdjustItem(SDRTEXTVERTADJUST_BLOCK)); break;
1524 }
1525
1526 SetObjectItemSet(aNewSet);
1527
1528 pOutlinerParaObject = GetOutlinerParaObject();
1529 if (pOutlinerParaObject)
1530 {
1531 // set ParaObject orientation accordingly
1532 pOutlinerParaObject->SetVertical(bVertical);
1533 }
1534
1535 // restore object size
1536 SetSnapRect(aObjectRect);
1537 }
1538
1539 bool SdrTextObj::IsTopToBottom() const
1540 {
1541 if (mpEditingOutliner)
1542 return mpEditingOutliner->IsTopToBottom();
1543
1544 if (OutlinerParaObject* pOutlinerParaObject = GetOutlinerParaObject())
1545 return pOutlinerParaObject->IsTopToBottom();
1546
1547 return false;
1548 }
1549
1550 // transformation interface for StarOfficeAPI. This implements support for
1551 // homogeneous 3x3 matrices containing the transformation of the SdrObject. At the
1552 // moment it contains a shearX, rotation and translation, but for setting all linear
1553 // transforms like Scale, ShearX, ShearY, Rotate and Translate are supported.
1554
1555
1556 // gets base transformation and rectangle of object. If it's an SdrPathObj it fills the PolyPolygon
1557 // with the base geometry and returns TRUE. Otherwise it returns FALSE.
1558 bool SdrTextObj::TRGetBaseGeometry(basegfx::B2DHomMatrix& rMatrix, basegfx::B2DPolyPolygon& /*rPolyPolygon*/) const
1559 {
1560 // get turn and shear
1561 double fRotate = toRadians(maGeo.m_nRotationAngle);
1562 double fShearX = toRadians(maGeo.m_nShearAngle);
1563
1564 // get aRect, this is the unrotated snaprect
1565 tools::Rectangle aRectangle(getRectangle());
1566
1567 // fill other values
1568 basegfx::B2DTuple aScale(aRectangle.GetWidth(), aRectangle.GetHeight());
1569 basegfx::B2DTuple aTranslate(aRectangle.Left(), aRectangle.Top());
1570
1571 // position maybe relative to anchorpos, convert
1572 if( getSdrModelFromSdrObject().IsWriter() )
1573 {
1574 if(GetAnchorPos().X() || GetAnchorPos().Y())
1575 {
1576 aTranslate -= basegfx::B2DTuple(GetAnchorPos().X(), GetAnchorPos().Y());
1577 }
1578 }
1579
1580 // build matrix
1581 rMatrix = basegfx::utils::createScaleShearXRotateTranslateB2DHomMatrix(
1582 aScale,
1583 basegfx::fTools::equalZero(fShearX) ? 0.0 : tan(fShearX),
1584 basegfx::fTools::equalZero(fRotate) ? 0.0 : -fRotate,
1585 aTranslate);
1586
1587 return false;
1588 }
1589
1590 // sets the base geometry of the object using infos contained in the homogeneous 3x3 matrix.
1591 // If it's an SdrPathObj it will use the provided geometry information. The Polygon has
1592 // to use (0,0) as upper left and will be scaled to the given size in the matrix.
1593 void SdrTextObj::TRSetBaseGeometry(const basegfx::B2DHomMatrix& rMatrix, const basegfx::B2DPolyPolygon& /*rPolyPolygon*/)
1594 {
1595 // break up matrix
1596 basegfx::B2DTuple aScale;
1597 basegfx::B2DTuple aTranslate;
1598 double fRotate(0.0);
1599 double fShearX(0.0);
1600 rMatrix.decompose(aScale, aTranslate, fRotate, fShearX);
1601
1602 // flip?
1603 bool bFlipX = aScale.getX() < 0.0,
1604 bFlipY = aScale.getY() < 0.0;
1605 if (bFlipX)
1606 {
1607 aScale.setX(fabs(aScale.getX()));
1608 }
1609 if (bFlipY)
1610 {
1611 aScale.setY(fabs(aScale.getY()));
1612 }
1613
1614 // reset object shear and rotations
1615 maGeo.m_nRotationAngle = 0_deg100;
1616 maGeo.RecalcSinCos();
1617 maGeo.m_nShearAngle = 0_deg100;
1618 maGeo.RecalcTan();
1619
1620 // if anchor is used, make position relative to it
1621 if( getSdrModelFromSdrObject().IsWriter() )
1622 {
1623 if(GetAnchorPos().X() || GetAnchorPos().Y())
1624 {
1625 aTranslate += basegfx::B2DTuple(GetAnchorPos().X(), GetAnchorPos().Y());
1626 }
1627 }
1628
1629 // build and set BaseRect (use scale)
1630 Size aSize(FRound(aScale.getX()), FRound(aScale.getY()));
1631 tools::Rectangle aBaseRect(Point(), aSize);
1632 SetSnapRect(aBaseRect);
1633
1634 // flip?
1635 if (bFlipX)
1636 {
1637 Mirror(Point(), Point(0, 1));
1638 }
1639 if (bFlipY)
1640 {
1641 Mirror(Point(), Point(1, 0));
1642 }
1643
1644 // shear?
1645 if(!basegfx::fTools::equalZero(fShearX))
1646 {
1647 GeoStat aGeoStat;
1648 aGeoStat.m_nShearAngle = Degree100(FRound(basegfx::rad2deg<100>(atan(fShearX))));
1649 aGeoStat.RecalcTan();
1650 Shear(Point(), aGeoStat.m_nShearAngle, aGeoStat.mfTanShearAngle, false);
1651 }
1652
1653 // rotation?
1654 if(!basegfx::fTools::equalZero(fRotate))
1655 {
1656 GeoStat aGeoStat;
1657
1658 // #i78696#
1659 // fRotate is matematically correct, but aGeoStat.nRotationAngle is
1660 // mirrored -> mirror value here
1661 aGeoStat.m_nRotationAngle = NormAngle36000(Degree100(FRound(-basegfx::rad2deg<100>(fRotate))));
1662 aGeoStat.RecalcSinCos();
1663 Rotate(Point(), aGeoStat.m_nRotationAngle, aGeoStat.mfSinRotationAngle, aGeoStat.mfCosRotationAngle);
1664 }
1665
1666 // translate?
1667 if(!aTranslate.equalZero())
1668 {
1669 Move(Size(FRound(aTranslate.getX()), FRound(aTranslate.getY())));
1670 }
1671 }
1672
1673 bool SdrTextObj::IsReallyEdited() const
1674 {
1675 return mpEditingOutliner && mpEditingOutliner->IsModified();
1676 }
1677
1678 // moved inlines here form hxx
1679
1680 tools::Long SdrTextObj::GetEckenradius() const
1681 {
1682 return GetObjectItemSet().Get(SDRATTR_CORNER_RADIUS).GetValue();
1683 }
1684
1685 tools::Long SdrTextObj::GetMinTextFrameHeight() const
1686 {
1687 return GetObjectItemSet().Get(SDRATTR_TEXT_MINFRAMEHEIGHT).GetValue();
1688 }
1689
1690 tools::Long SdrTextObj::GetMaxTextFrameHeight() const
1691 {
1692 return GetObjectItemSet().Get(SDRATTR_TEXT_MAXFRAMEHEIGHT).GetValue();
1693 }
1694
1695 tools::Long SdrTextObj::GetMinTextFrameWidth() const
1696 {
1697 return GetObjectItemSet().Get(SDRATTR_TEXT_MINFRAMEWIDTH).GetValue();
1698 }
1699
1700 tools::Long SdrTextObj::GetMaxTextFrameWidth() const
1701 {
1702 return GetObjectItemSet().Get(SDRATTR_TEXT_MAXFRAMEWIDTH).GetValue();
1703 }
1704
1705 bool SdrTextObj::IsFontwork() const
1706 {
1707 return !mbTextFrame // Default is FALSE
1708 && GetObjectItemSet().Get(XATTR_FORMTXTSTYLE).GetValue() != XFormTextStyle::NONE;
1709 }
1710
1711 bool SdrTextObj::IsHideContour() const
1712 {
1713 return !mbTextFrame // Default is: no, don't HideContour; HideContour not together with TextFrames
1714 && GetObjectItemSet().Get(XATTR_FORMTXTHIDEFORM).GetValue();
1715 }
1716
1717 bool SdrTextObj::IsContourTextFrame() const
1718 {
1719 return !mbTextFrame // ContourFrame not together with normal TextFrames
1720 && GetObjectItemSet().Get(SDRATTR_TEXT_CONTOURFRAME).GetValue();
1721 }
1722
1723 tools::Long SdrTextObj::GetTextLeftDistance() const
1724 {
1725 return GetObjectItemSet().Get(SDRATTR_TEXT_LEFTDIST).GetValue();
1726 }
1727
1728 tools::Long SdrTextObj::GetTextRightDistance() const
1729 {
1730 return GetObjectItemSet().Get(SDRATTR_TEXT_RIGHTDIST).GetValue();
1731 }
1732
1733 tools::Long SdrTextObj::GetTextUpperDistance() const
1734 {
1735 return GetObjectItemSet().Get(SDRATTR_TEXT_UPPERDIST).GetValue();
1736 }
1737
1738 tools::Long SdrTextObj::GetTextLowerDistance() const
1739 {
1740 return GetObjectItemSet().Get(SDRATTR_TEXT_LOWERDIST).GetValue();
1741 }
1742
1743 SdrTextAniKind SdrTextObj::GetTextAniKind() const
1744 {
1745 return GetObjectItemSet().Get(SDRATTR_TEXT_ANIKIND).GetValue();
1746 }
1747
1748 SdrTextAniDirection SdrTextObj::GetTextAniDirection() const
1749 {
1750 return GetObjectItemSet().Get(SDRATTR_TEXT_ANIDIRECTION).GetValue();
1751 }
1752
1753 bool SdrTextObj::HasTextColumnsNumber() const
1754 {
1755 return GetObjectItemSet().HasItem(SDRATTR_TEXTCOLUMNS_NUMBER);
1756 }
1757
1758 sal_Int16 SdrTextObj::GetTextColumnsNumber() const
1759 {
1760 return GetObjectItemSet().Get(SDRATTR_TEXTCOLUMNS_NUMBER).GetValue();
1761 }
1762
1763 void SdrTextObj::SetTextColumnsNumber(sal_Int16 nColumns)
1764 {
1765 SetObjectItem(SfxInt16Item(SDRATTR_TEXTCOLUMNS_NUMBER, nColumns));
1766 }
1767
1768 bool SdrTextObj::HasTextColumnsSpacing() const
1769 {
1770 return GetObjectItemSet().HasItem(SDRATTR_TEXTCOLUMNS_SPACING);
1771 }
1772
1773 sal_Int32 SdrTextObj::GetTextColumnsSpacing() const
1774 {
1775 return GetObjectItemSet().Get(SDRATTR_TEXTCOLUMNS_SPACING).GetValue();
1776 }
1777
1778 void SdrTextObj::SetTextColumnsSpacing(sal_Int32 nSpacing)
1779 {
1780 SetObjectItem(SdrMetricItem(SDRATTR_TEXTCOLUMNS_SPACING, nSpacing));
1781 }
1782
1783 // Get necessary data for text scroll animation. ATM base it on a Text-Metafile and a
1784 // painting rectangle. Rotation is excluded from the returned values.
1785 GDIMetaFile* SdrTextObj::GetTextScrollMetaFileAndRectangle(
1786 tools::Rectangle& rScrollRectangle, tools::Rectangle& rPaintRectangle)
1787 {
1788 GDIMetaFile* pRetval = nullptr;
1789 SdrOutliner& rOutliner = ImpGetDrawOutliner();
1790 tools::Rectangle aTextRect;
1791 tools::Rectangle aAnchorRect;
1792 tools::Rectangle aPaintRect;
1793 Fraction aFitXCorrection(1,1);
1794 bool bContourFrame(IsContourTextFrame());
1795
1796 // get outliner set up. To avoid getting a somehow rotated MetaFile,
1797 // temporarily disable object rotation.
1798 Degree100 nAngle(maGeo.m_nRotationAngle);
1799 maGeo.m_nRotationAngle = 0_deg100;
1800 ImpSetupDrawOutlinerForPaint( bContourFrame, rOutliner, aTextRect, aAnchorRect, aPaintRect, aFitXCorrection );
1801 maGeo.m_nRotationAngle = nAngle;
1802
1803 tools::Rectangle aScrollFrameRect(aPaintRect);
1804 const SfxItemSet& rSet = GetObjectItemSet();
1805 SdrTextAniDirection eDirection = rSet.Get(SDRATTR_TEXT_ANIDIRECTION).GetValue();
1806
1807 if(SdrTextAniDirection::Left == eDirection || SdrTextAniDirection::Right == eDirection)
1808 {
1809 aScrollFrameRect.SetLeft( aAnchorRect.Left() );
1810 aScrollFrameRect.SetRight( aAnchorRect.Right() );
1811 }
1812
1813 if(SdrTextAniDirection::Up == eDirection || SdrTextAniDirection::Down == eDirection)
1814 {
1815 aScrollFrameRect.SetTop( aAnchorRect.Top() );
1816 aScrollFrameRect.SetBottom( aAnchorRect.Bottom() );
1817 }
1818
1819 // create the MetaFile
1820 pRetval = new GDIMetaFile;
1821 ScopedVclPtrInstance< VirtualDevice > pBlackHole;
1822 pBlackHole->EnableOutput(false);
1823 pRetval->Record(pBlackHole);
1824 Point aPaintPos = aPaintRect.TopLeft();
1825
1826 rOutliner.Draw(*pBlackHole, aPaintPos);
1827
1828 pRetval->Stop();
1829 pRetval->WindStart();
1830
1831 // return PaintRectanglePixel and pRetval;
1832 rScrollRectangle = aScrollFrameRect;
1833 rPaintRectangle = aPaintRect;
1834
1835 return pRetval;
1836 }
1837
1838 // Access to TextAnimationAllowed flag
1839 bool SdrTextObj::IsAutoFit() const
1840 {
1841 return GetFitToSize() == drawing::TextFitToSizeType_AUTOFIT;
1842 }
1843
1844 bool SdrTextObj::IsFitToSize() const
1845 {
1846 const drawing::TextFitToSizeType eFit = GetFitToSize();
1847 return (eFit == drawing::TextFitToSizeType_PROPORTIONAL
1848 || eFit == drawing::TextFitToSizeType_ALLLINES);
1849 }
1850
1851 void SdrTextObj::SetTextAnimationAllowed(bool bNew)
1852 {
1853 if(mbTextAnimationAllowed != bNew)
1854 {
1855 mbTextAnimationAllowed = bNew;
1856 ActionChanged();
1857 }
1858 }
1859
1860 /** called from the SdrObjEditView during text edit when the status of the edit outliner changes */
1861 void SdrTextObj::onEditOutlinerStatusEvent( EditStatus* pEditStatus )
1862 {
1863 const EditStatusFlags nStat = pEditStatus->GetStatusWord();
1864 const bool bGrowX = bool(nStat & EditStatusFlags::TEXTWIDTHCHANGED);
1865 const bool bGrowY = bool(nStat & EditStatusFlags::TextHeightChanged);
1866 if(!(mbTextFrame && (bGrowX || bGrowY)))
1867 return;
1868
1869 if ((bGrowX && IsAutoGrowWidth()) || (bGrowY && IsAutoGrowHeight()))
1870 {
1871 AdjustTextFrameWidthAndHeight();
1872 }
1873 else if ( (IsAutoFit() || IsFitToSize()) && !mbInDownScale)
1874 {
1875 assert(mpEditingOutliner);
1876 mbInDownScale = true;
1877
1878 // Need to reset scaling so it searches for the fitting size again
1879 mpEditingOutliner->resetScalingParameters();
1880
1881 // sucks that we cannot disable paints via
1882 // mpEditingOutliner->SetUpdateMode(FALSE) - but EditEngine skips
1883 // formatting as well, then.
1884 setupAutoFitText(*mpEditingOutliner);
1885 mbInDownScale = false;
1886 }
1887 }
1888
1889 /* Begin chaining code */
1890
1891 // XXX: Make it a method somewhere?
1892 static SdrObject *ImpGetObjByName(SdrObjList const *pObjList, std::u16string_view aObjName)
1893 {
1894 // scan the whole list
1895 for (const rtl::Reference<SdrObject>& pCurObj : *pObjList)
1896 if (pCurObj->GetName() == aObjName)
1897 return pCurObj.get();
1898 // not found
1899 return nullptr;
1900 }
1901
1902 // XXX: Make it a (private) method of SdrTextObj
1903 static void ImpUpdateChainLinks(SdrTextObj *pTextObj, std::u16string_view aNextLinkName)
1904 {
1905 // XXX: Current implementation constraints text boxes to be on the same page
1906
1907 // No next link
1908 if (aNextLinkName.empty()) {
1909 pTextObj->SetNextLinkInChain(nullptr);
1910 return;
1911 }
1912
1913 SdrPage *pPage(pTextObj->getSdrPageFromSdrObject());
1914 assert(pPage);
1915 SdrTextObj *pNextTextObj = DynCastSdrTextObj
1916 (ImpGetObjByName(pPage, aNextLinkName));
1917 if (!pNextTextObj) {
1918 SAL_INFO("svx.chaining", "[CHAINING] Can't find object as next link.");
1919 return;
1920 }
1921
1922 pTextObj->SetNextLinkInChain(pNextTextObj);
1923 }
1924
1925 bool SdrTextObj::IsChainable() const
1926 {
1927 // Read it as item
1928 const SfxItemSet& rSet = GetObjectItemSet();
1929 OUString aNextLinkName = rSet.Get(SDRATTR_TEXT_CHAINNEXTNAME).GetValue();
1930
1931 // Update links if any inconsistency is found
1932 bool bNextLinkUnsetYet = !aNextLinkName.isEmpty() && !mpNextInChain;
1933 bool bInconsistentNextLink = mpNextInChain && mpNextInChain->GetName() != aNextLinkName;
1934 // if the link is not set despite there should be one OR if it has changed
1935 if (bNextLinkUnsetYet || bInconsistentNextLink) {
1936 ImpUpdateChainLinks(const_cast<SdrTextObj *>(this), aNextLinkName);
1937 }
1938
1939 return !aNextLinkName.isEmpty(); // XXX: Should we also check for GetNilChainingEvent? (see old code below)
1940
1941 /*
1942 // Check that no overflow is going on
1943 if (!GetTextChain() || GetTextChain()->GetNilChainingEvent(this))
1944 return false;
1945 */
1946 }
1947
1948 void SdrTextObj::onChainingEvent()
1949 {
1950 if (!mpEditingOutliner)
1951 return;
1952
1953 // Outliner for text transfer
1954 SdrOutliner &aDrawOutliner = ImpGetDrawOutliner();
1955
1956 EditingTextChainFlow aTxtChainFlow(this);
1957 aTxtChainFlow.CheckForFlowEvents(mpEditingOutliner);
1958
1959 if (aTxtChainFlow.IsOverflow()) {
1960 SAL_INFO("svx.chaining", "[CHAINING] Overflow going on");
1961 // One outliner is for non-overflowing text, the other for overflowing text
1962 // We remove text directly from the editing outliner
1963 aTxtChainFlow.ExecuteOverflow(mpEditingOutliner, &aDrawOutliner);
1964 } else if (aTxtChainFlow.IsUnderflow()) {
1965 SAL_INFO("svx.chaining", "[CHAINING] Underflow going on");
1966 // underflow-induced overflow
1967 aTxtChainFlow.ExecuteUnderflow(&aDrawOutliner);
1968 bool bIsOverflowFromUnderflow = aTxtChainFlow.IsOverflow();
1969 // handle overflow
1970 if (bIsOverflowFromUnderflow) {
1971 SAL_INFO("svx.chaining", "[CHAINING] Overflow going on (underflow induced)");
1972 // prevents infinite loops when setting text for editing outliner
1973 aTxtChainFlow.ExecuteOverflow(&aDrawOutliner, &aDrawOutliner);
1974 }
1975 }
1976 }
1977
1978 SdrTextObj* SdrTextObj::GetNextLinkInChain() const
1979 {
1980 /*
1981 if (GetTextChain())
1982 return GetTextChain()->GetNextLink(this);
1983
1984 return NULL;
1985 */
1986
1987 return mpNextInChain;
1988 }
1989
1990 void SdrTextObj::SetNextLinkInChain(SdrTextObj *pNextObj)
1991 {
1992 // Basically a doubly linked list implementation
1993
1994 SdrTextObj *pOldNextObj = mpNextInChain;
1995
1996 // Replace next link
1997 mpNextInChain = pNextObj;
1998 // Deal with old next link's prev link
1999 if (pOldNextObj) {
2000 pOldNextObj->mpPrevInChain = nullptr;
2001 }
2002
2003 // Deal with new next link's prev link
2004 if (mpNextInChain) {
2005 // If there is a prev already at all and this is not already the current object
2006 if (mpNextInChain->mpPrevInChain &&
2007 mpNextInChain->mpPrevInChain != this)
2008 mpNextInChain->mpPrevInChain->mpNextInChain = nullptr;
2009 mpNextInChain->mpPrevInChain = this;
2010 }
2011
2012 // TODO: Introduce check for circular chains
2013
2014 }
2015
2016 SdrTextObj* SdrTextObj::GetPrevLinkInChain() const
2017 {
2018 /*
2019 if (GetTextChain())
2020 return GetTextChain()->GetPrevLink(this);
2021
2022 return NULL;
2023 */
2024
2025 return mpPrevInChain;
2026 }
2027
2028 bool SdrTextObj::GetPreventChainable() const
2029 {
2030 // Prevent chaining it 1) during dragging && 2) when we are editing next link
2031 return mbIsUnchainableClone || (GetNextLinkInChain() && GetNextLinkInChain()->IsInEditMode());
2032 }
2033
2034 rtl::Reference<SdrObject> SdrTextObj::getFullDragClone() const
2035 {
2036 rtl::Reference<SdrObject> pClone = SdrAttrObj::getFullDragClone();
2037 SdrTextObj *pTextObjClone = DynCastSdrTextObj(pClone.get());
2038 if (pTextObjClone != nullptr) {
2039 // Avoid transferring of text for chainable object during dragging
2040 pTextObjClone->mbIsUnchainableClone = true;
2041 }
2042
2043 return pClone;
2044 }
2045
2046 /* End chaining code */
2047
2048 /** returns the currently active text. */
2049 SdrText* SdrTextObj::getActiveText() const
2050 {
2051 if( !mxText )
2052 return getText( 0 );
2053 else
2054 return mxText.get();
2055 }
2056
2057 /** returns the nth available text. */
2058 SdrText* SdrTextObj::getText( sal_Int32 nIndex ) const
2059 {
2060 if( nIndex == 0 )
2061 {
2062 if( !mxText )
2063 const_cast< SdrTextObj* >(this)->mxText = new SdrText( *const_cast< SdrTextObj* >(this) );
2064 return mxText.get();
2065 }
2066 else
2067 {
2068 return nullptr;
2069 }
2070 }
2071
2072 /** returns the number of texts available for this object. */
2073 sal_Int32 SdrTextObj::getTextCount() const
2074 {
2075 return 1;
2076 }
2077
2078 /** changes the current active text */
2079 void SdrTextObj::setActiveText( sal_Int32 /*nIndex*/ )
2080 {
2081 }
2082
2083 /** returns the index of the text that contains the given point or -1 */
2084 sal_Int32 SdrTextObj::CheckTextHit(const Point& /*rPnt*/) const
2085 {
2086 return 0;
2087 }
2088
2089 void SdrTextObj::SetObjectItemNoBroadcast(const SfxPoolItem& rItem)
2090 {
2091 static_cast< sdr::properties::TextProperties& >(GetProperties()).SetObjectItemNoBroadcast(rItem);
2092 }
2093
2094
2095 // The concept of the text object:
2096 // ~~~~~~~~~~~~~~~~~~~~~~~~
2097 // Attributes/Variations:
2098 // - bool text frame / graphics object with caption
2099 // - bool FontWork (if it is not a text frame and not a ContourTextFrame)
2100 // - bool ContourTextFrame (if it is not a text frame and not Fontwork)
2101 // - long rotation angle (if it is not FontWork)
2102 // - long text frame margins (if it is not FontWork)
2103 // - bool FitToSize (if it is not FontWork)
2104 // - bool AutoGrowingWidth/Height (if it is not FitToSize and not FontWork)
2105 // - long Min/MaxFrameWidth/Height (if AutoGrowingWidth/Height)
2106 // - enum horizontal text anchoring left,center,right,justify/block,Stretch(ni)
2107 // - enum vertical text anchoring top, middle, bottom, block, stretch(ni)
2108 // - enum ticker text (if it is not FontWork)
2109
2110 // Every derived object is either a text frame (mbTextFrame=true)
2111 // or a drawing object with a caption (mbTextFrame=false).
2112
2113 // Default anchoring for text frames:
2114 // SDRTEXTHORZADJUST_BLOCK, SDRTEXTVERTADJUST_TOP
2115 // = static Pool defaults
2116 // Default anchoring for drawing objects with a caption:
2117 // SDRTEXTHORZADJUST_CENTER, SDRTEXTVERTADJUST_CENTER
2118 // via "hard" attribution of SdrAttrObj
2119
2120 // Every object derived from SdrTextObj must return an "UnrotatedSnapRect"
2121 // (->TakeUnrotatedSnapRect()) (the reference point for the rotation is the top
2122 // left of the rectangle (maGeo.nRotationAngle)) which is the basis for anchoring
2123 // text. We then subtract the text frame margins from this rectangle, as a re-
2124 // sult we get the anchoring area (->TakeTextAnchorRect()). Within this area, we
2125 // calculate the anchoring point and the painting area, depending on the hori-
2126 // zontal and vertical adjustment of the text (SdrTextVertAdjust,
2127 // SdrTextHorzAdjust).
2128 // In the case of drawing objects with a caption the painting area might well
2129 // be larger than the anchoring area, for text frames on the other hand, it is
2130 // always of the same or a smaller size (except when there are negative text
2131 // frame margins).
2132
2133 // FitToSize takes priority over text anchoring and AutoGrowHeight/Width. When
2134 // FitToSize is turned on, the painting area is always equal to the anchoring
2135 // area. Additionally, FitToSize doesn't allow automatic line breaks.
2136
2137 // ContourTextFrame:
2138 // - long rotation angle
2139 // - long text frame margins (maybe later)
2140 // - bool FitToSize (maybe later)
2141 // - bool AutoGrowingWidth/Height (maybe much later)
2142 // - long Min/MaxFrameWidth/Height (maybe much later)
2143 // - enum horizontal text anchoring (maybe later, for now: left, centered)
2144 // - enum vertical text anchoring (maybe later, for now: top)
2145 // - enum ticker text (maybe later, maybe even with correct clipping)
2146
2147 // When making changes, check these:
2148 // - Paint
2149 // - HitTest
2150 // - ConvertToPoly
2151 // - Edit
2152 // - Printing, Saving, Painting in neighboring View while editing
2153 // - ModelChanged (e. g. through a neighboring View or rulers) while editing
2154 // - FillColorChanged while editing
2155 // - and many more...
2156
2157
2158 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE