LibreOffice Module sw (master)  1
notxtfrm.cxx
Go to the documentation of this file.
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 #include <hintids.hxx>
21 #include <tools/urlobj.hxx>
22 #include <vcl/print.hxx>
23 #include <vcl/virdev.hxx>
24 #include <vcl/svapp.hxx>
25 #include <vcl/imapobj.hxx>
26 #include <vcl/imap.hxx>
27 #include <svl/urihelper.hxx>
28 #include <svtools/soerr.hxx>
29 #include <sfx2/progress.hxx>
30 #include <sfx2/docfile.hxx>
31 #include <sfx2/printer.hxx>
32 #include <editeng/udlnitem.hxx>
33 #include <editeng/colritem.hxx>
34 #include <editeng/boxitem.hxx>
35 #include <svx/xoutbmp.hxx>
36 #include <fmturl.hxx>
37 #include <fmtsrnd.hxx>
38 #include <frmfmt.hxx>
39 #include <swrect.hxx>
40 #include <fesh.hxx>
41 #include <doc.hxx>
46 #include <flyfrm.hxx>
47 #include <flyfrms.hxx>
48 #include <frmtool.hxx>
49 #include <viewopt.hxx>
50 #include <viewimp.hxx>
51 #include <pam.hxx>
52 #include <hints.hxx>
53 #include <rootfrm.hxx>
54 #include <dflyobj.hxx>
55 #include <pagefrm.hxx>
56 #include <notxtfrm.hxx>
57 #include <grfatr.hxx>
58 #include <charatr.hxx>
59 #include <fmtornt.hxx>
60 #include <ndnotxt.hxx>
61 #include <ndgrf.hxx>
62 #include <ndole.hxx>
63 #include <swregion.hxx>
64 #include <poolfmt.hxx>
65 #include <mdiexp.hxx>
66 #include <swwait.hxx>
67 #include <strings.hrc>
68 #include <accessibilityoptions.hxx>
69 #include <com/sun/star/embed/EmbedMisc.hpp>
70 #include <com/sun/star/embed/EmbedStates.hpp>
71 #include <com/sun/star/embed/XEmbeddedObject.hpp>
72 #include <svtools/embedhlp.hxx>
73 #include <dview.hxx>
80 #include <txtfly.hxx>
81 #include <vcl/graphicfilter.hxx>
82 #include <vcl/pdfextoutdevdata.hxx>
86 
87 using namespace com::sun::star;
88 
89 static bool GetRealURL( const SwGrfNode& rNd, OUString& rText )
90 {
91  bool bRet = rNd.GetFileFilterNms( &rText, nullptr );
92  if( bRet )
95  if (rText.startsWith("data:image")) rText = "inline image";
96 
97  return bRet;
98 }
99 
100 static void lcl_PaintReplacement( const SwRect &rRect, const OUString &rText,
101  const SwViewShell &rSh, const SwNoTextFrame *pFrame,
102  bool bDefect )
103 {
104  static vcl::Font aFont = [&]()
105  {
106  vcl::Font tmp;
107  tmp.SetWeight( WEIGHT_BOLD );
108  tmp.SetStyleName( OUString() );
109  tmp.SetFamilyName("Arial Unicode");
110  tmp.SetFamily( FAMILY_SWISS );
111  tmp.SetTransparent( true );
112  return tmp;
113  }();
114 
115  Color aCol( COL_RED );
116  FontLineStyle eUnderline = LINESTYLE_NONE;
117  const SwFormatURL &rURL = pFrame->FindFlyFrame()->GetFormat()->GetURL();
118  if( !rURL.GetURL().isEmpty() || rURL.GetMap() )
119  {
120  bool bVisited = false;
121  if ( rURL.GetMap() )
122  {
123  ImageMap *pMap = const_cast<ImageMap*>(rURL.GetMap());
124  for( size_t i = 0; i < pMap->GetIMapObjectCount(); ++i )
125  {
126  IMapObject *pObj = pMap->GetIMapObject( i );
127  if( rSh.GetDoc()->IsVisitedURL( pObj->GetURL() ) )
128  {
129  bVisited = true;
130  break;
131  }
132  }
133  }
134  else if ( !rURL.GetURL().isEmpty() )
135  bVisited = rSh.GetDoc()->IsVisitedURL( rURL.GetURL() );
136 
137  SwFormat *pFormat = rSh.GetDoc()->getIDocumentStylePoolAccess().GetFormatFromPool( static_cast<sal_uInt16>
139  aCol = pFormat->GetColor().GetValue();
140  eUnderline = pFormat->GetUnderline().GetLineStyle();
141  }
142 
143  aFont.SetUnderline( eUnderline );
144  aFont.SetColor( aCol );
145 
146  const BitmapEx& rBmp = const_cast<SwViewShell&>(rSh).GetReplacementBitmap(bDefect);
147  Graphic::DrawEx( rSh.GetOut(), rText, aFont, rBmp, rRect.Pos(), rRect.SSize() );
148 }
149 
151 : SwContentFrame( pNode, pSib ),
152  // RotateFlyFrame3
153  mpTransformableSwFrame()
154 {
156 }
157 
159 {
160  return new SwNoTextFrame(this, pSib);
161 }
162 
164 {
165  StopAnimation();
166 
168 }
169 
171 {
172 }
173 
174 void SetOutDev( SwViewShell *pSh, OutputDevice *pOut )
175 {
176  pSh->mpOut = pOut;
177 }
178 
179 static void lcl_ClearArea( const SwFrame &rFrame,
180  vcl::RenderContext &rOut, const SwRect& rPtArea,
181  const SwRect &rGrfArea )
182 {
183  SwRegionRects aRegion( rPtArea, 4 );
184  aRegion -= rGrfArea;
185 
186  if ( !aRegion.empty() )
187  {
188  const SvxBrushItem *pItem;
189  const Color *pCol;
190  SwRect aOrigRect;
192 
193  if ( rFrame.GetBackgroundBrush( aFillAttributes, pItem, pCol, aOrigRect, false, /*bConsiderTextBox=*/false ) )
194  {
195  SwRegionRects const region(rPtArea);
196  basegfx::utils::B2DClipState aClipState;
197  const bool bDone(::DrawFillAttributes(aFillAttributes, aOrigRect, region, aClipState, rOut));
198 
199  if(!bDone)
200  {
201  for( const auto &rRegion : aRegion )
202  {
203  ::DrawGraphic( pItem, &rOut, aOrigRect, rRegion );
204  }
205  }
206  }
207  else
208  {
209  rOut.Push( PushFlags::FILLCOLOR|PushFlags::LINECOLOR );
210  rOut.SetFillColor( rFrame.getRootFrame()->GetCurrShell()->Imp()->GetRetoucheColor());
211  rOut.SetLineColor();
212  for( const auto &rRegion : aRegion )
213  rOut.DrawRect( rRegion.SVRect() );
214  rOut.Pop();
215  }
216  }
217 }
218 
219 void SwNoTextFrame::PaintSwFrame(vcl::RenderContext& rRenderContext, SwRect const& rRect, SwPrintData const*const) const
220 {
221  if ( getFrameArea().IsEmpty() )
222  return;
223 
224  const SwViewShell* pSh = getRootFrame()->GetCurrShell();
225  if( !pSh->GetViewOptions()->IsGraphic() )
226  {
227  StopAnimation();
228  // #i6467# - no paint of placeholder for page preview
229  if ( pSh->GetWin() && !pSh->IsPreview() )
230  {
231  const SwNoTextNode* pNd = GetNode()->GetNoTextNode();
232  OUString aText( pNd->GetTitle() );
233  if ( aText.isEmpty() && pNd->IsGrfNode() )
234  GetRealURL( *static_cast<const SwGrfNode*>(pNd), aText );
235  if( aText.isEmpty() )
236  aText = FindFlyFrame()->GetFormat()->GetName();
237  lcl_PaintReplacement( getFrameArea(), aText, *pSh, this, false );
238  }
239  return;
240  }
241 
243  // #i9684# Stop animation during printing/pdf export
244  !pSh->GetWin() )
245  StopAnimation();
246 
247  SfxProgress::EnterLock(); // No progress reschedules in paint (SwapIn)
248 
249  rRenderContext.Push();
250  bool bClip = true;
251  tools::PolyPolygon aPoly;
252 
253  SwNoTextNode& rNoTNd = const_cast<SwNoTextNode&>(*static_cast<const SwNoTextNode*>(GetNode()));
254  SwGrfNode* pGrfNd = rNoTNd.GetGrfNode();
255  if( pGrfNd )
256  pGrfNd->SetFrameInPaint( true );
257 
258  // #i13147# - add 2nd parameter with value <true> to
259  // method call <FindFlyFrame().GetContour(..)> to indicate that it is called
260  // for paint in order to avoid load of the intrinsic graphic.
261  if ( ( !rRenderContext.GetConnectMetaFile() ||
262  !pSh->GetWin() ) &&
263  FindFlyFrame()->GetContour( aPoly, true )
264  )
265  {
266  rRenderContext.SetClipRegion(vcl::Region(aPoly));
267  bClip = false;
268  }
269 
270  SwRect aOrigPaint( rRect );
271  if ( HasAnimation() && pSh->GetWin() )
272  {
273  aOrigPaint = getFrameArea(); aOrigPaint += getFramePrintArea().Pos();
274  }
275 
276  SwRect aGrfArea( getFrameArea() );
277  SwRect aPaintArea( aGrfArea );
278 
279  // In case the picture fly frm was clipped, render it with the origin
280  // size instead of scaling it
282  {
283  const SwFlyFreeFrame *pFly = dynamic_cast< const SwFlyFreeFrame* >( FindFlyFrame() );
284  if( pFly )
285  {
286  bool bGetUnclippedFrame=true;
287  const SfxPoolItem* pItem;
288  if( pFly->GetFormat() && SfxItemState::SET == pFly->GetFormat()->GetItemState(RES_BOX, false, &pItem) )
289  {
290  const SvxBoxItem& rBox = *static_cast<const SvxBoxItem*>(pItem);
291  if( rBox.HasBorder( /*bTreatPaddingAsBorder*/true) )
292  bGetUnclippedFrame = false;
293  }
294 
295  if( bGetUnclippedFrame )
296  aGrfArea = SwRect( getFrameArea().Pos( ), pFly->GetUnclippedFrame( ).SSize( ) );
297  }
298  }
299 
300  aPaintArea.Intersection_( aOrigPaint );
301 
303  aNormal.Justify(); // Normalized rectangle for the comparisons
304 
305  if( aPaintArea.IsOver( aNormal ) )
306  {
307  // Calculate the four to-be-deleted rectangles
308  if( pSh->GetWin() )
309  ::lcl_ClearArea( *this, rRenderContext, aPaintArea, aNormal );
310 
311  // The intersection of the PaintArea and the Bitmap contains the absolutely visible area of the Frame
312  aPaintArea.Intersection_( aNormal );
313 
314  if ( bClip )
315  rRenderContext.IntersectClipRegion( aPaintArea.SVRect() );
317  PaintPicture( &rRenderContext, aGrfArea );
318  }
319  else
320  // If it's not visible, simply delete the given Area
321  lcl_ClearArea( *this, rRenderContext, aPaintArea, SwRect() );
322  if( pGrfNd )
323  pGrfNd->SetFrameInPaint( false );
324 
325  rRenderContext.Pop();
327 }
328 
336 static void lcl_CalcRect( Point& rPt, Size& rDim, MirrorGraph nMirror )
337 {
338  if( nMirror == MirrorGraph::Vertical || nMirror == MirrorGraph::Both )
339  {
340  rPt.setX(rPt.getX() + rDim.Width() -1);
341  rDim.setWidth( -rDim.Width() );
342  }
343 
344  if( nMirror == MirrorGraph::Horizontal || nMirror == MirrorGraph::Both )
345  {
346  rPt.setY(rPt.getY() + rDim.Height() -1);
347  rDim.setHeight( -rDim.Height() );
348  }
349 }
350 
352 void SwNoTextFrame::GetGrfArea( SwRect &rRect, SwRect* pOrigRect ) const
353 {
354  // Currently only used for scaling, cropping and mirroring the contour of graphics!
355  // Everything else is handled by GraphicObject
356  // We put the graphic's visible rectangle into rRect.
357  // pOrigRect contains position and size of the whole graphic.
358 
359  // RotateFlyFrame3: SwFrame may be transformed. Get untransformed
360  // SwRect(s) as base of calculation
361  const TransformableSwFrame* pTransformableSwFrame(getTransformableSwFrame());
362  const SwRect aFrameArea(pTransformableSwFrame ? pTransformableSwFrame->getUntransformedFrameArea() : getFrameArea());
363  const SwRect aFramePrintArea(pTransformableSwFrame ? pTransformableSwFrame->getUntransformedFramePrintArea() : getFramePrintArea());
364 
365  const SwAttrSet& rAttrSet = GetNode()->GetSwAttrSet();
366  const SwCropGrf& rCrop = rAttrSet.GetCropGrf();
367  MirrorGraph nMirror = rAttrSet.GetMirrorGrf().GetValue();
368 
369  if( rAttrSet.GetMirrorGrf().IsGrfToggle() )
370  {
371  if( !(FindPageFrame()->GetVirtPageNum() % 2) )
372  {
373  switch ( nMirror )
374  {
375  case MirrorGraph::Dont: nMirror = MirrorGraph::Vertical; break;
376  case MirrorGraph::Vertical: nMirror = MirrorGraph::Dont; break;
377  case MirrorGraph::Horizontal: nMirror = MirrorGraph::Both; break;
378  default: nMirror = MirrorGraph::Horizontal; break;
379  }
380  }
381  }
382 
383  // We read graphic from the Node, if needed.
384  // It may fail, however.
385  long nLeftCrop, nRightCrop, nTopCrop, nBottomCrop;
386  Size aOrigSz( static_cast<const SwNoTextNode*>(GetNode())->GetTwipSize() );
387  if ( !aOrigSz.Width() )
388  {
389  aOrigSz.setWidth( aFramePrintArea.Width() );
390  nLeftCrop = -rCrop.GetLeft();
391  nRightCrop = -rCrop.GetRight();
392  }
393  else
394  {
395  nLeftCrop = std::max( aOrigSz.Width() -
396  (rCrop.GetRight() + rCrop.GetLeft()), long(1) );
397  const double nScale = double(aFramePrintArea.Width()) / double(nLeftCrop);
398  nLeftCrop = long(nScale * -rCrop.GetLeft() );
399  nRightCrop = long(nScale * -rCrop.GetRight() );
400  }
401 
402  // crop values have to be mirrored too
403  if( nMirror == MirrorGraph::Vertical || nMirror == MirrorGraph::Both )
404  {
405  long nTmpCrop = nLeftCrop;
406  nLeftCrop = nRightCrop;
407  nRightCrop= nTmpCrop;
408  }
409 
410  if( !aOrigSz.Height() )
411  {
412  aOrigSz.setHeight( aFramePrintArea.Height() );
413  nTopCrop = -rCrop.GetTop();
414  nBottomCrop= -rCrop.GetBottom();
415  }
416  else
417  {
418  nTopCrop = std::max( aOrigSz.Height() - (rCrop.GetTop() + rCrop.GetBottom()), long(1) );
419  const double nScale = double(aFramePrintArea.Height()) / double(nTopCrop);
420  nTopCrop = long(nScale * -rCrop.GetTop() );
421  nBottomCrop= long(nScale * -rCrop.GetBottom() );
422  }
423 
424  // crop values have to be mirrored too
425  if( nMirror == MirrorGraph::Horizontal || nMirror == MirrorGraph::Both )
426  {
427  long nTmpCrop = nTopCrop;
428  nTopCrop = nBottomCrop;
429  nBottomCrop= nTmpCrop;
430  }
431 
432  Size aVisSz( aFramePrintArea.SSize() );
433  Size aGrfSz( aVisSz );
434  Point aVisPt( aFrameArea.Pos() + aFramePrintArea.Pos() );
435  Point aGrfPt( aVisPt );
436 
437  // Set the "visible" rectangle first
438  if ( nLeftCrop > 0 )
439  {
440  aVisPt.setX(aVisPt.getX() + nLeftCrop);
441  aVisSz.AdjustWidth( -nLeftCrop );
442  }
443  if ( nTopCrop > 0 )
444  {
445  aVisPt.setY(aVisPt.getY() + nTopCrop);
446  aVisSz.AdjustHeight( -nTopCrop );
447  }
448  if ( nRightCrop > 0 )
449  aVisSz.AdjustWidth( -nRightCrop );
450  if ( nBottomCrop > 0 )
451  aVisSz.AdjustHeight( -nBottomCrop );
452 
453  rRect.Pos ( aVisPt );
454  rRect.SSize( aVisSz );
455 
456  // Calculate the whole graphic if needed
457  if ( pOrigRect )
458  {
459  Size aTmpSz( aGrfSz );
460  aGrfPt.setX(aGrfPt.getX() + nLeftCrop);
461  aTmpSz.AdjustWidth( -(nLeftCrop + nRightCrop) );
462  aGrfPt.setY(aGrfPt.getY() + nTopCrop);
463  aTmpSz.AdjustHeight( -(nTopCrop + nBottomCrop) );
464 
465  if( MirrorGraph::Dont != nMirror )
466  lcl_CalcRect( aGrfPt, aTmpSz, nMirror );
467 
468  pOrigRect->Pos ( aGrfPt );
469  pOrigRect->SSize( aTmpSz );
470  }
471 }
472 
475 {
476  // Return the Frame's size
477  const SwFrame *pFly = FindFlyFrame();
478  if( !pFly )
479  pFly = this;
480  return pFly->getFramePrintArea().SSize();
481 }
482 
484 {
485  // RotateFlyFrame3 - inner frame. Get rotation and check if used
486  const double fRotation(getLocalFrameRotation());
487  const bool bRotated(!basegfx::fTools::equalZero(fRotation));
488 
489  if(bRotated)
490  {
491  SwFlyFreeFrame* pUpperFly(dynamic_cast< SwFlyFreeFrame* >(GetUpper()));
492 
493  if(pUpperFly)
494  {
495  if(!pUpperFly->isFrameAreaDefinitionValid())
496  {
497  // RotateFlyFrame3: outer frame *needs* to be layouted first, force this by calling
498  // it's ::Calc directly
499  pUpperFly->Calc(pRenderContext);
500  }
501 
502  // Reset outer frame to unrotated state. This is necessary to make the
503  // layouting below work as currently implemented in Writer. As expected
504  // using Transformations allows to do this on the fly due to all information
505  // being included there.
506  // The full solution would be to adapt the whole layouting
507  // process of Writer to take care of Transformations, but that
508  // is currently beyond scope
509  if(pUpperFly->isTransformableSwFrame())
510  {
512  }
513  }
514 
515  // Re-layout may be partially (see all isFrameAreaDefinitionValid() flags),
516  // so resetting the local SwFrame(s) in the local SwFrameAreaDefinition is also
517  // needed (e.g. for PrintPreview).
518  // Reset to BoundAreas will be done below automatically
520  {
522  }
523  }
524 
525  SwContentNotify aNotify( this );
526  SwBorderAttrAccess aAccess( SwFrame::GetCache(), this );
527  const SwBorderAttrs &rAttrs = *aAccess.Get();
528 
530  {
531  MakePos();
532 
533  if ( !isFrameAreaSizeValid() )
534  {
536  aFrm.Width( GetUpper()->getFramePrintArea().Width() );
537  }
538 
539  MakePrtArea( rAttrs );
540 
541  if ( !isFrameAreaSizeValid() )
542  {
543  setFrameAreaSizeValid(true);
544  Format(getRootFrame()->GetCurrShell()->GetOut());
545  }
546  }
547 
548  // RotateFlyFrame3 - inner frame
549  if(bRotated)
550  {
551  SwFlyFreeFrame* pUpperFly(dynamic_cast< SwFlyFreeFrame* >(GetUpper()));
552 
553  if(pUpperFly)
554  {
555  // restore outer frame back to Transformed state, that means
556  // set the SwFrameAreaDefinition(s) back to BoundAreas of
557  // the transformed SwFrame. All needed information is part
558  // of the already correctly created Transformations of the
559  // upper frame, so it can bre re-created on the fly
560  if(pUpperFly->isTransformableSwFrame())
561  {
563  }
564  }
565 
566  // After the unrotated layout is finished, apply possible set rotation to it
567  // get center from outer frame (layout frame) to be on the safe side
568  const Point aCenter(GetUpper() ? GetUpper()->getFrameArea().Center() : getFrameArea().Center());
569  const basegfx::B2DPoint aB2DCenter(aCenter.X(), aCenter.Y());
570 
572  {
574  }
575 
577  fRotation,
578  aB2DCenter);
580  }
581  else
582  {
583  // reset transformations to show that they are not used
584  mpTransformableSwFrame.reset();
585  }
586 }
587 
588 // RotateFlyFrame3 - Support for Transformations - outer frame
590 {
592  {
593  // use pre-created transformation
595  }
596 
597  // call parent
599 }
600 
602 {
604  {
605  // use pre-created transformation
607  }
608 
609  // call parent
611 }
612 
613 // RotateFlyFrame3 - Support for Transformations
615 {
616  // call parent - this will do the basic transform for SwRect(s)
617  // in the SwFrameAreaDefinition
619 
620  // check if the Transformations need to be adapted
622  {
623  const basegfx::B2DHomMatrix aTransform(
625  rOffset.X(), rOffset.Y()));
626 
627  // transform using TransformableSwFrame
628  getTransformableSwFrame()->transform(aTransform);
629  }
630 }
631 
632 // RotateFlyFrame3 - inner frame
633 // Check if we contain a SwGrfNode and get possible rotation from it
635 {
636  const SwNoTextNode* pSwNoTextNode(nullptr != GetNode() ? GetNode()->GetNoTextNode() : nullptr);
637 
638  if(nullptr != pSwNoTextNode)
639  {
640  const SwGrfNode* pSwGrfNode(pSwNoTextNode->GetGrfNode());
641 
642  if(nullptr != pSwGrfNode)
643  {
644  const SwAttrSet& rSwAttrSet(pSwGrfNode->GetSwAttrSet());
645  const SwRotationGrf& rSwRotationGrf(rSwAttrSet.GetRotationGrf());
646  const double fRotate(static_cast< double >(-rSwRotationGrf.GetValue()) * (M_PI/1800.0));
647 
648  return basegfx::normalizeToRange(fRotate, F_2PI);
649  }
650  }
651 
652  // no rotation
653  return 0.0;
654 }
655 
657 void SwNoTextFrame::Format( vcl::RenderContext* /*pRenderContext*/, const SwBorderAttrs * )
658 {
659  const Size aNewSize( GetSize() );
660 
661  // Did the height change?
662  SwTwips nChgHght = IsVertical() ?
663  static_cast<SwTwips>(aNewSize.Width() - getFramePrintArea().Width()) :
664  static_cast<SwTwips>(aNewSize.Height() - getFramePrintArea().Height());
665  if( nChgHght > 0)
666  Grow( nChgHght );
667  else if( nChgHght < 0)
668  Shrink( std::min(getFramePrintArea().Height(), -nChgHght) );
669 }
670 
671 bool SwNoTextFrame::GetCharRect( SwRect &rRect, const SwPosition& rPos,
672  SwCursorMoveState *pCMS, bool /*bAllowFarAway*/ ) const
673 {
674  if ( &rPos.nNode.GetNode() != static_cast<SwNode const *>(GetNode()) )
675  return false;
676 
677  Calc(getRootFrame()->GetCurrShell()->GetOut());
678  SwRect aFrameRect( getFrameArea() );
679  rRect = aFrameRect;
680  rRect.Pos( getFrameArea().Pos() + getFramePrintArea().Pos() );
681  rRect.SSize( getFramePrintArea().SSize() );
682 
683  rRect.Justify();
684 
685  // Is the Bitmap in the visible area at all?
686  if( !aFrameRect.IsOver( rRect ) )
687  {
688  // If not, then the Cursor is on the Frame
689  rRect = aFrameRect;
690  rRect.Width( 1 );
691  }
692  else
693  rRect.Intersection_( aFrameRect );
694 
695  if ( pCMS && pCMS->m_bRealHeight )
696  {
697  pCMS->m_aRealHeight.setY(rRect.Height());
698  pCMS->m_aRealHeight.setX(0);
699  }
700 
701  return true;
702 }
703 
705  SwCursorMoveState*, bool ) const
706 {
707  SwContentNode* pCNd = const_cast<SwContentNode*>(GetNode());
708  pPos->nNode = *pCNd;
709  pPos->nContent.Assign( pCNd, 0 );
710  return true;
711 }
712 
714 {
715  SwFlyFrame* pFly = FindFlyFrame();
716  if( pFly && pFly->GetFormat()->GetSurround().IsContour() )
717  {
718  ClrContourCache( pFly->GetVirtDrawObj() );
720  }
721 }
722 
723 void SwNoTextFrame::Modify( const SfxPoolItem* pOld, const SfxPoolItem* pNew )
724 {
725  sal_uInt16 nWhich = pNew ? pNew->Which() : pOld ? pOld->Which() : 0;
726 
727  // #i73788#
728  // no <SwContentFrame::Modify(..)> for RES_LINKED_GRAPHIC_STREAM_ARRIVED
729  if ( RES_GRAPHIC_PIECE_ARRIVED != nWhich &&
730  RES_GRAPHIC_ARRIVED != nWhich &&
731  RES_GRF_REREAD_AND_INCACHE != nWhich &&
733  {
734  SwContentFrame::Modify( pOld, pNew );
735  }
736 
737  bool bComplete = true;
738 
739  switch( nWhich )
740  {
741  case RES_OBJECTDYING:
742  break;
743 
745  if( SwNodeType::Grf == GetNode()->GetNodeType() )
746  {
747  // TODO: Remove - due to GraphicObject refactoring
748  bComplete = false;
749  }
750  break;
751 
752  case RES_UPDATE_ATTR:
753  if (GetNode()->GetNodeType() != SwNodeType::Grf) {
754  break;
755  }
756  [[fallthrough]];
757  case RES_FMT_CHG:
758  ClearCache();
759  break;
760 
761  case RES_ATTRSET_CHG:
762  {
763  sal_uInt16 n;
764  for( n = RES_GRFATR_BEGIN; n < RES_GRFATR_END; ++n )
765  if( SfxItemState::SET == static_cast<const SwAttrSetChg*>(pOld)->GetChgSet()->
766  GetItemState( n, false ))
767  {
768  ClearCache();
769 
770  if(RES_GRFATR_ROTATION == n)
771  {
772  // RotGrfFlyFrame: Update Handles in view, these may be rotation-dependent
773  // (e.g. crop handles) and need a visualisation update
774  if ( GetNode()->GetNodeType() == SwNodeType::Grf )
775  {
776  SwGrfNode* pNd = static_cast<SwGrfNode*>( GetNode());
778 
779  if(pVSh)
780  {
781  SdrView* pDrawView = pVSh->GetDrawView();
782 
783  if(pDrawView)
784  {
785  pDrawView->AdjustMarkHdl(nullptr);
786  }
787  }
788 
789  // RotateFlyFrame3 - invalidate needed for ContentFrame (inner, this)
790  // and LayoutFrame (outer, GetUpper). It is possible to only invalidate
791  // the outer frame, but that leads to an in-between state that gets
792  // potentially painted
793  if(GetUpper())
794  {
796  }
797 
798  InvalidateAll_();
799  }
800  }
801  break;
802  }
803  if( RES_GRFATR_END == n ) // not found
804  return ;
805  }
806  break;
807 
809  case RES_GRAPHIC_ARRIVED:
810  // i73788# - handle RES_LINKED_GRAPHIC_STREAM_ARRIVED as RES_GRAPHIC_ARRIVED
812  if ( GetNode()->GetNodeType() == SwNodeType::Grf )
813  {
814  bComplete = false;
815  SwGrfNode* pNd = static_cast<SwGrfNode*>( GetNode());
816 
817  ClearCache();
818 
819  SwRect aRect( getFrameArea() );
820 
822  if( !pVSh )
823  break;
824 
825  for(SwViewShell& rShell : pVSh->GetRingContainer())
826  {
827  SET_CURR_SHELL( &rShell );
828  if( rShell.IsPreview() )
829  {
830  if( rShell.GetWin() )
831  ::RepaintPagePreview( &rShell, aRect );
832  }
833  else if ( rShell.VisArea().IsOver( aRect ) &&
834  OUTDEV_WINDOW == rShell.GetOut()->GetOutDevType() )
835  {
836  // invalidate instead of painting
837  rShell.GetWin()->Invalidate( aRect.SVRect() );
838  }
839  }
840  }
841  break;
842 
843  default:
844  if ( !pNew || !isGRFATR(nWhich) )
845  return;
846  }
847 
848  if( bComplete )
849  {
850  InvalidatePrt();
852  }
853 }
854 
855 static void lcl_correctlyAlignRect( SwRect& rAlignedGrfArea, const SwRect& rInArea, vcl::RenderContext const * pOut )
856 {
857 
858  if(!pOut)
859  return;
860  tools::Rectangle aPxRect = pOut->LogicToPixel( rInArea.SVRect() );
861  tools::Rectangle aNewPxRect( aPxRect );
862  while( aNewPxRect.Left() < aPxRect.Left() )
863  {
864  rAlignedGrfArea.Left( rAlignedGrfArea.Left()+1 );
865  aNewPxRect = pOut->LogicToPixel( rAlignedGrfArea.SVRect() );
866  }
867  while( aNewPxRect.Top() < aPxRect.Top() )
868  {
869  rAlignedGrfArea.Top( rAlignedGrfArea.Top()+1 );
870  aNewPxRect = pOut->LogicToPixel( rAlignedGrfArea.SVRect() );
871  }
872  while( aNewPxRect.Bottom() > aPxRect.Bottom() )
873  {
874  rAlignedGrfArea.Bottom( rAlignedGrfArea.Bottom()-1 );
875  aNewPxRect = pOut->LogicToPixel( rAlignedGrfArea.SVRect() );
876  }
877  while( aNewPxRect.Right() > aPxRect.Right() )
878  {
879  rAlignedGrfArea.Right( rAlignedGrfArea.Right()-1 );
880  aNewPxRect = pOut->LogicToPixel( rAlignedGrfArea.SVRect() );
881  }
882 }
883 
885  vcl::RenderContext& rOutputDevice,
887  const basegfx::B2DRange& rSourceRange,
888  const basegfx::B2DRange& rTargetRange)
889 {
890  if(!rSequence.empty() && !basegfx::fTools::equalZero(rSourceRange.getWidth()) && !basegfx::fTools::equalZero(rSourceRange.getHeight()))
891  {
892  if(!basegfx::fTools::equalZero(rTargetRange.getWidth()) && !basegfx::fTools::equalZero(rTargetRange.getHeight()))
893  {
894  // map graphic range to target range. This will e.g. automatically include
895  // the mapping from 1/100th mm content to twips if needed when the target
896  // range is defined in twips
897  const basegfx::B2DHomMatrix aMappingTransform(
899  rSourceRange,
900  rTargetRange));
901 
902  // Fill ViewInformation. Use MappingTransform here, so there is no need to
903  // embed the primitives to it. Use original TargetRange here so there is also
904  // no need to embed the primitives to a MaskPrimitive for cropping. This works
905  // only in this case where the graphic object cannot be rotated, though.
906  const drawinglayer::geometry::ViewInformation2D aViewInformation2D(
907  aMappingTransform,
908  rOutputDevice.GetViewTransformation(),
909  rTargetRange,
910  nullptr,
911  0.0,
912  uno::Sequence< beans::PropertyValue >());
913 
914  // get a primitive processor for rendering
915  std::unique_ptr<drawinglayer::processor2d::BaseProcessor2D> pProcessor2D(
917  rOutputDevice, aViewInformation2D) );
918  if(pProcessor2D)
919  {
920  // render and cleanup
921  pProcessor2D->process(rSequence);
922  return true;
923  }
924  }
925  }
926 
927  return false;
928 }
929 
931  vcl::RenderContext & rOutputDevice,
932  GraphicObject const& rGrfObj,
933  GraphicAttr const& rGraphicAttr,
934  const basegfx::B2DHomMatrix& rGraphicTransform,
935  const OUString& rName,
936  const OUString& rTitle,
937  const OUString& rDescription)
938 {
939  // RotGrfFlyFrame: unify using GraphicPrimitive2D
940  // -> the primitive handles all crop and mirror stuff
941  // -> the primitive renderer will create the needed pdf export data
942  // -> if bitmap content, it will be cached system-dependent
944 
946  rGraphicTransform,
947  rGrfObj,
948  rGraphicAttr);
949 
950  // RotateFlyFrame3: If ClipRegion is set at OutputDevice, we
951  // need to use that. Usually the renderer would be a VCL-based
952  // PrimitiveRenderer, but there are system-specific shortcuts that
953  // will *not* use the VCL-Paint of Bitmap and thus ignore this.
954  // Anyways, indirectly using a CLipRegion set at the target OutDev
955  // when using a PrimitiveRenderer is a non-valid implication.
956  // First tried only to use when HasPolyPolygonOrB2DPolyPolygon(),
957  // but there is an optimization at ClipRegion creation that detects
958  // a single Rectangle in a tools::PolyPolygon and forces to a simple
959  // RegionBand-based implementation, so cannot use it here.
960  if(rOutputDevice.IsClipRegion())
961  {
962  const basegfx::B2DPolyPolygon aClip(rOutputDevice.GetClipRegion().GetAsB2DPolyPolygon());
963 
964  if(0 != aClip.count())
965  {
966  // tdf#114076: Expand ClipRange to next PixelBound
967  // Do this by going to basegfx::B2DRange, adding a
968  // single pixel size and using floor/ceil to go to
969  // full integer (as needed for pixels). Also need
970  // to go back to basegfx::B2DPolyPolygon for the
971  // creation of the needed MaskPrimitive2D.
972  // The general problem is that Writer is scrolling
973  // using blitting the unchanged parts, this forces
974  // this part of the scroll to pixel coordinate steps,
975  // while the ViewTransformation for paint nowadays has
976  // a sub-pixel precision. This results in an offset
977  // up to one pixel in radius. To solve this for now,
978  // we need to expand to the next outer pixel bound.
979  // Hopefully in the future we will someday be able to
980  // stay on the full available precision, but this
981  // will need a change in the repaint/scroll paradigm.
982  const basegfx::B2DRange aClipRange(aClip.getB2DRange());
983  const basegfx::B2DVector aSinglePixelXY(rOutputDevice.GetInverseViewTransformation() * basegfx::B2DVector(1.0, 1.0));
984  const basegfx::B2DRange aExpandedClipRange(
985  floor(aClipRange.getMinX() - aSinglePixelXY.getX()),
986  floor(aClipRange.getMinY() - aSinglePixelXY.getY()),
987  ceil(aClipRange.getMaxX() + aSinglePixelXY.getX()),
988  ceil(aClipRange.getMaxY() + aSinglePixelXY.getY()));
989 
990  // create the enclosing rectangle as polygon
992 
993  // tdf#124272 the fix above (tdf#114076) was too rough - the
994  // clip region used may be a PolyPolygon. In that case that
995  // PolyPolygon would have to be scaled to mentioned PixelBounds.
996  // Since that is not really possible geometrically (would need
997  // more some 'grow in outside direction' but with unequal grow
998  // values in all directions - just maaany problems
999  // involved), use a graphical trick: The topology of the
1000  // PolyPolygon uses the standard FillRule, so adding the now
1001  // guaranteed to be bigger or equal bounding (enclosing)
1002  // rectangle twice as polygon will expand the BoundRange, but
1003  // not change the geometry visualization at all
1004  if(!rOutputDevice.GetClipRegion().IsRectangle())
1005  {
1006  // double the outer rectangle range polygon to have it
1007  // included twice
1008  aTarget.append(aTarget.getB2DPolygon(0));
1009 
1010  // add the original clip 'inside' (due to being smaller
1011  // or equal). That PolyPolygon may have an unknown number
1012  // of polygons (>=1)
1013  aTarget.append(aClip);
1014  }
1015 
1017  aTarget,
1018  aContent);
1019  }
1020  }
1021 
1022  if(!rName.isEmpty() || !rTitle.isEmpty() || !rDescription.isEmpty())
1023  {
1024  // Embed to ObjectInfoPrimitive2D when we have Name/Title/Description
1025  // information available
1027  aContent,
1028  rName,
1029  rTitle,
1030  rDescription);
1031  }
1032 
1033  basegfx::B2DRange aTargetRange(0.0, 0.0, 1.0, 1.0);
1034  aTargetRange.transform(rGraphicTransform);
1035 
1037  rOutputDevice,
1038  aContent,
1039  aTargetRange,
1040  aTargetRange);
1041 }
1042 
1050 void SwNoTextFrame::PaintPicture( vcl::RenderContext* pOut, const SwRect &rGrfArea ) const
1051 {
1052  SwViewShell* pShell = getRootFrame()->GetCurrShell();
1053 
1054  SwNoTextNode& rNoTNd = const_cast<SwNoTextNode&>(*static_cast<const SwNoTextNode*>(GetNode()));
1055  SwGrfNode* pGrfNd = rNoTNd.GetGrfNode();
1056  SwOLENode* pOLENd = rNoTNd.GetOLENode();
1057 
1058  const bool bPrn = pOut == rNoTNd.getIDocumentDeviceAccess().getPrinter( false ) ||
1059  pOut->GetConnectMetaFile();
1060 
1061  const bool bIsChart = pOLENd && pOLENd->GetOLEObj().GetObject().IsChart();
1062 
1063  // calculate aligned rectangle from parameter <rGrfArea>.
1064  // Use aligned rectangle <aAlignedGrfArea> instead of <rGrfArea> in
1065  // the following code.
1066  SwRect aAlignedGrfArea = rGrfArea;
1067  ::SwAlignRect( aAlignedGrfArea, pShell, pOut );
1068 
1069  if( !bIsChart )
1070  {
1071  // Because for drawing a graphic left-top-corner and size coordinations are
1072  // used, these coordinations have to be determined on pixel level.
1073  ::SwAlignGrfRect( &aAlignedGrfArea, *pOut );
1074  }
1075  else //if( bIsChart )
1076  {
1077  // #i78025# charts own borders are not completely visible
1078  // the above pixel correction is not correct - at least not for charts
1079  // so a different pixel correction is chosen here
1080  // this might be a good idea for all other OLE objects also,
1081  // but as I cannot oversee the consequences I fix it only for charts for now
1082  lcl_correctlyAlignRect( aAlignedGrfArea, rGrfArea, pOut );
1083  }
1084 
1085  if( pGrfNd )
1086  {
1087  // Fix for bug fdo#33781
1088  const AntialiasingFlags nFormerAntialiasingAtOutput( pOut->GetAntialiasing() );
1089  if (pShell->Imp()->GetDrawView()->IsAntiAliasing())
1090  {
1091  pOut->SetAntialiasing( nFormerAntialiasingAtOutput | AntialiasingFlags::EnableB2dDraw );
1092  }
1093 
1094  bool bContinue = true;
1095  const GraphicObject& rGrfObj = pGrfNd->GetGrfObj(bPrn);
1096 
1097  GraphicAttr aGrfAttr;
1098  pGrfNd->GetGraphicAttr( aGrfAttr, this );
1099 
1100  if( !bPrn )
1101  {
1102  // #i73788#
1103  if ( pGrfNd->IsLinkedInputStreamReady() )
1104  {
1105  pGrfNd->UpdateLinkWithInputStream();
1106  }
1107  // #i85717#, #i90395# - check, if asynchronous retrieval
1108  // if input stream for the graphic is possible
1109  else if ( ( rGrfObj.GetType() == GraphicType::Default ||
1110  rGrfObj.GetType() == GraphicType::NONE ) &&
1111  pGrfNd->IsLinkedFile() &&
1113  {
1114  Size aTmpSz;
1115  ::sfx2::SvLinkSource* pGrfObj = pGrfNd->GetLink()->GetObj();
1116  if( !pGrfObj ||
1117  !pGrfObj->IsDataComplete() ||
1118  !(aTmpSz = pGrfNd->GetTwipSize()).Width() ||
1119  !aTmpSz.Height())
1120  {
1121  pGrfNd->TriggerAsyncRetrieveInputStream(); // #i73788#
1122  }
1123  OUString aText( pGrfNd->GetTitle() );
1124  if ( aText.isEmpty() )
1125  GetRealURL( *pGrfNd, aText );
1126  ::lcl_PaintReplacement( aAlignedGrfArea, aText, *pShell, this, false );
1127  bContinue = false;
1128  }
1129  }
1130 
1131  if( bContinue )
1132  {
1133  if( rGrfObj.GetGraphic().IsSupportedGraphic())
1134  {
1135  const bool bAnimate = rGrfObj.IsAnimated() &&
1136  !pShell->IsPreview() &&
1138  // #i9684# Stop animation during printing/pdf export
1139  pShell->GetWin();
1140 
1141  if( bAnimate &&
1142  FindFlyFrame() != ::GetFlyFromMarked( nullptr, pShell ))
1143  {
1144  OutputDevice* pVout;
1145  if( pOut == pShell->GetOut() && SwRootFrame::FlushVout() )
1146  {
1147  pVout = pOut;
1148  pOut = pShell->GetOut();
1149  }
1150  else if( pShell->GetWin() && pOut->IsVirtual() )
1151  {
1152  pVout = pOut;
1153  pOut = pShell->GetWin();
1154  }
1155  else
1156  pVout = nullptr;
1157 
1158  OSL_ENSURE( !pOut->IsVirtual() ||
1159  pShell->GetViewOptions()->IsPDFExport() || pShell->isOutputToWindow(),
1160  "pOut should not be a virtual device" );
1161 
1162  pGrfNd->StartGraphicAnimation(pOut, aAlignedGrfArea.Pos(),
1163  aAlignedGrfArea.SSize(), sal_IntPtr(this),
1164  pVout );
1165  }
1166  else
1167  {
1168  const basegfx::B2DHomMatrix aGraphicTransform(getFrameAreaTransformation());
1169 
1171  *pOut,
1172  rGrfObj,
1173  aGrfAttr,
1174  aGraphicTransform,
1175  nullptr == pGrfNd->GetFlyFormat() ? OUString() : pGrfNd->GetFlyFormat()->GetName(),
1176  rNoTNd.GetTitle(),
1177  rNoTNd.GetDescription());
1178  }
1179  }
1180  else
1181  {
1182  const char* pResId = nullptr;
1183 
1184  if( GraphicType::NONE == rGrfObj.GetType() )
1185  pResId = STR_COMCORE_READERROR;
1186  else if ( !rGrfObj.GetGraphic().IsSupportedGraphic() )
1187  pResId = STR_COMCORE_CANT_SHOW;
1188 
1189  OUString aText;
1190  if ( !pResId &&
1191  (aText = pGrfNd->GetTitle()).isEmpty() &&
1192  (!GetRealURL( *pGrfNd, aText ) || aText.isEmpty()))
1193  {
1194  pResId = STR_COMCORE_READERROR;
1195  }
1196  if (pResId)
1197  aText = SwResId(pResId);
1198 
1199  ::lcl_PaintReplacement( aAlignedGrfArea, aText, *pShell, this, true );
1200  }
1201  }
1202 
1203  if ( pShell->Imp()->GetDrawView()->IsAntiAliasing() )
1204  pOut->SetAntialiasing( nFormerAntialiasingAtOutput );
1205  }
1206  else // bIsChart || pOLENd
1207  {
1208  // Fix for bug fdo#33781
1209  const AntialiasingFlags nFormerAntialiasingAtOutput( pOut->GetAntialiasing() );
1210  if (pShell->Imp()->GetDrawView()->IsAntiAliasing())
1211  {
1212  AntialiasingFlags nNewAntialiasingAtOutput = nFormerAntialiasingAtOutput | AntialiasingFlags::EnableB2dDraw;
1213 
1214  // #i99665#
1215  // Adjust AntiAliasing mode at output device for chart OLE
1216  if ( pOLENd->IsChart() )
1217  nNewAntialiasingAtOutput |= AntialiasingFlags::PixelSnapHairline;
1218 
1219  pOut->SetAntialiasing( nNewAntialiasingAtOutput );
1220  }
1221 
1222  bool bDone(false);
1223 
1224  if(bIsChart)
1225  {
1226  basegfx::B2DRange aSourceRange;
1229  aSourceRange,
1230  bPrn));
1231 
1232  if(!aSequence.empty() && !aSourceRange.isEmpty())
1233  {
1234  const basegfx::B2DRange aTargetRange(
1235  aAlignedGrfArea.Left(), aAlignedGrfArea.Top(),
1236  aAlignedGrfArea.Right(), aAlignedGrfArea.Bottom());
1237 
1239  *pOut,
1240  aSequence,
1241  aSourceRange,
1242  aTargetRange);
1243  }
1244  }
1245 
1246  if(!bDone && pOLENd)
1247  {
1248  // SwOLENode does not have a known GraphicObject, need to
1249  // work with Graphic instead
1250  const Graphic* pGraphic = pOLENd->GetGraphic();
1251 
1252  if ( pGraphic && pGraphic->GetType() != GraphicType::NONE )
1253  {
1254  GraphicObject aTempGraphicObject(*pGraphic);
1255  GraphicAttr aGrfAttr;
1256  const basegfx::B2DHomMatrix aGraphicTransform(
1258  aAlignedGrfArea.Width(), aAlignedGrfArea.Height(),
1259  aAlignedGrfArea.Left(), aAlignedGrfArea.Top()));
1260 
1262  *pOut,
1263  aTempGraphicObject,
1264  aGrfAttr,
1265  aGraphicTransform,
1266  nullptr == pOLENd->GetFlyFormat() ? OUString() : pOLENd->GetFlyFormat()->GetName(),
1267  rNoTNd.GetTitle(),
1268  rNoTNd.GetDescription());
1269 
1270  // shade the representation if the object is activated outplace
1271  uno::Reference < embed::XEmbeddedObject > xObj = pOLENd->GetOLEObj().GetOleRef();
1272  if ( xObj.is() && xObj->getCurrentState() == embed::EmbedStates::ACTIVE )
1273  {
1274  const Point aPosition(aAlignedGrfArea.Pos());
1275  const Size aSize(aAlignedGrfArea.SSize());
1276 
1279  aPosition,
1280  aSize),
1281  pOut);
1282  }
1283  }
1284  else
1285  {
1286  const Point aPosition(aAlignedGrfArea.Pos());
1287  const Size aSize(aAlignedGrfArea.SSize());
1288 
1290  tools::Rectangle(aPosition, aSize),
1291  pOLENd->GetOLEObj().GetCurrentPersistName(),
1292  pOut);
1293  }
1294 
1295  sal_Int64 nMiscStatus = pOLENd->GetOLEObj().GetOleRef()->getStatus( pOLENd->GetAspect() );
1296  if ( !bPrn && dynamic_cast< const SwCursorShell *>( pShell ) != nullptr &&
1297  (nMiscStatus & embed::EmbedMisc::MS_EMBED_ACTIVATEWHENVISIBLE))
1298  {
1299  const SwFlyFrame *pFly = FindFlyFrame();
1300  assert( pFly != nullptr );
1301  static_cast<SwFEShell*>(pShell)->ConnectObj( pOLENd->GetOLEObj().GetObject(), pFly->getFramePrintArea(), pFly->getFrameArea());
1302  }
1303  }
1304 
1305  // see #i99665#
1306  if (pShell->Imp()->GetDrawView()->IsAntiAliasing())
1307  {
1308  pOut->SetAntialiasing( nFormerAntialiasingAtOutput );
1309  }
1310  }
1311 }
1312 
1314 {
1315  const SwViewShell* pSh = getRootFrame()->GetCurrShell();
1316 
1317  if ( !pSh || !pSh->GetViewOptions()->IsGraphic() )
1318  {
1319  return true;
1320  }
1321 
1322  const SwGrfNode *pNd;
1323 
1324  if( nullptr != (pNd = GetNode()->GetGrfNode()) )
1325  {
1326  if(pNd->IsTransparent())
1327  {
1328  return true;
1329  }
1330  }
1331 
1332  // RotateFlyFrame3: If we are transformed, there are 'free' areas between
1333  // the Graphic and the Border/Padding stuff - at least as long as those
1334  // (Border and Padding) are not transformed, too
1336  {
1337  // we can be more specific - rotations of multiples of
1338  // 90 degrees will leave no gaps. Go from [0.0 .. F_2PI]
1339  // to [0 .. 360] and check modulo 90
1340  const long nRot(static_cast<long>(basegfx::rad2deg(getLocalFrameRotation())));
1341  const bool bMultipleOf90(0 == (nRot % 90));
1342 
1343  if(!bMultipleOf90)
1344  {
1345  return true;
1346  }
1347  }
1348 
1349  //#29381# OLE are always transparent
1350  if(nullptr != GetNode()->GetOLENode())
1351  {
1352  return true;
1353  }
1354 
1355  // return false by default to avoid background paint
1356  return false;
1357 }
1358 
1360 {
1361  // Stop animated graphics
1362  const SwGrfNode* pGrfNd = GetNode()->GetGrfNode();
1363 
1364  if( pGrfNd && pGrfNd->IsAnimated() )
1365  {
1366  const_cast< SwGrfNode* >(pGrfNd)->StopGraphicAnimation( pOut, sal_IntPtr(this) );
1367  }
1368 }
1369 
1371 {
1372  const SwGrfNode* pGrfNd = GetNode()->GetGrfNode();
1373  return pGrfNd && pGrfNd->IsAnimated();
1374 }
1375 
1376 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
void SetFamily(FontFamily)
vcl::RenderContext * GetOut() const
Definition: viewsh.hxx:341
basegfx::B2DHomMatrix GetInverseViewTransformation() const
void SetClipRegion()
long Width() const
vcl::Region GetClipRegion() const
void transform(const basegfx::B2DHomMatrix &aTransform)
Definition: wsfrm.cxx:283
bool IsContour() const
Definition: fmtsrnd.hxx:53
const SwVirtFlyDrawObj * GetVirtDrawObj() const
Definition: fly.cxx:2727
Base class of the Writer layout elements.
Definition: frame.hxx:295
virtual basegfx::B2DHomMatrix getFramePrintAreaTransformation() const override
Definition: notxtfrm.cxx:601
TransformableSwFrame * getTransformableSwFrame()
Definition: notxtfrm.hxx:84
const SvxColorItem & GetColor(bool=true) const
Definition: charatr.hxx:131
#define RES_GRFATR_END
Definition: hintids.hxx:258
sal_Int64 GetAspect() const
Definition: ndole.hxx:132
virtual const SwFlyFrameFormat * GetFormat() const override
Definition: fly.cxx:2816
Marks a position in the document model.
Definition: pam.hxx:35
bool IsRectangle() const
sal_Int32 GetLeft() const
void MakePrtArea(const SwBorderAttrs &)
Definition: calcmove.cxx:1056
const tools::SvRef< sfx2::SvBaseLink > & GetLink() const
Definition: ndgrf.hxx:133
void SetAntialiasing(AntialiasingFlags nMode)
const SvxUnderlineItem & GetUnderline(bool=true) const
GetMethods: Bool indicates whether to search only in Set (FALSE) or also in Parents.
Definition: charatr.hxx:121
SdrView * GetDrawView()
Definition: vnew.cxx:376
bool IsGrfNode() const
Definition: node.hxx:656
SwTwips Grow(SwTwips, bool bTst=false, bool bInfo=false)
Definition: wsfrm.cxx:1462
double getHeight() const
void DrawGraphic(const SvxBrushItem *, vcl::RenderContext *, const SwRect &rOrg, const SwRect &rOut, const sal_uInt8 nGrfNum=GRFNUM_NO, const bool bConsiderBackgroundTransparency=false)
Definition: paintfrm.cxx:1793
SwOLENode * GetOLENode()
Inline methods from Node.hxx.
Definition: ndole.hxx:157
bool m_bRealHeight
should the real height be calculated?
Definition: crstate.hxx:141
SwRect getUntransformedFramePrintArea() const
Definition: wsfrm.cxx:185
#define RES_ATTRSET_CHG
Definition: hintids.hxx:285
long AdjustWidth(long n)
bool IsAntiAliasing() const
Definition: dview.cxx:129
virtual bool IsVirtual() const
const SwOLEObj & GetOLEObj() const
Definition: ndole.hxx:110
SwViewShellImp * Imp()
Definition: viewsh.hxx:185
TransformableSwFrame * getTransformableSwFrame()
Definition: flyfrms.hxx:132
const SwAccessibilityOptions * GetAccessibilityOptions() const
Definition: viewsh.hxx:434
double normalizeToRange(double v, const double fRange)
long Height() const
bool IsGraphic() const
Definition: viewopt.hxx:287
#define RES_GRF_REREAD_AND_INCACHE
Definition: hintids.hxx:305
virtual ~SwNoTextFrame() override
Definition: notxtfrm.cxx:170
virtual basegfx::B2DHomMatrix getFrameAreaTransformation() const override
Definition: notxtfrm.cxx:589
SwNodeIndex nNode
Definition: pam.hxx:37
const basegfx::B2DPolyPolygon GetAsB2DPolyPolygon() const
void SetCompletePaint() const
Definition: frame.hxx:970
constexpr::Color COL_RED(0x80, 0x00, 0x00)
virtual basegfx::B2DHomMatrix getFramePrintAreaTransformation() const
Definition: wsfrm.cxx:131
const SwRect & getFramePrintArea() const
Definition: frame.hxx:176
static void DrawShading(const tools::Rectangle &rRect, OutputDevice *pOut)
static SwCache & GetCache()
Definition: frame.hxx:500
css::uno::Reference< css::embed::XEmbeddedObject > const & GetOleRef()
Definition: ndole.cxx:900
SwNoTextFrame(SwNoTextNode *const, SwFrame *)
Definition: notxtfrm.cxx:150
bool IsSupportedGraphic() const
bool IsVisitedURL(const OUString &rURL)
Definition: visiturl.cxx:100
SVL_DLLPUBLIC OUString removePassword(OUString const &rURI, INetURLObject::EncodeMechanism eEncodeMechanism, INetURLObject::DecodeMechanism eDecodeMechanism=INetURLObject::DecodeMechanism::ToIUri, rtl_TextEncoding eCharset=RTL_TEXTENCODING_UTF8)
void Height(long nNew)
Definition: swrect.hxx:189
VclPtr< OutputDevice > mpOut
Window, Printer, VirtDev, ...
Definition: viewsh.hxx:117
void SetWeight(FontWeight)
bool IsLinkedFile() const
Definition: ndgrf.hxx:165
SwNode & GetNode() const
Definition: ndindex.hxx:118
MirrorGraph
Definition: grfatr.hxx:31
long SwTwips
Definition: swtypes.hxx:49
void IntersectClipRegion(const tools::Rectangle &rRect)
GDIMetaFile * GetConnectMetaFile() const
friend class SwNoTextFrame
Definition: ndnotxt.hxx:33
void Pos(const Point &rNew)
Definition: swrect.hxx:167
RotateFlyFrame3: Helper class when you want to make your SwFrame derivate transformable.
Definition: frame.hxx:231
size_t GetIMapObjectCount() const
virtual void Calc(vcl::RenderContext *pRenderContext) const
Definition: trvlfrm.cxx:1787
Of course Writer needs its own rectangles.
Definition: swrect.hxx:34
void Format(vcl::RenderContext *pRenderContext, const SwBorderAttrs *pAttrs=nullptr) override
Calculate the Bitmap's site, if needed.
Definition: notxtfrm.cxx:657
virtual void MakeAll(vcl::RenderContext *pRenderContext) override
Definition: notxtfrm.cxx:483
Center
virtual basegfx::B2DHomMatrix getFrameAreaTransformation() const
Definition: wsfrm.cxx:121
long AdjustHeight(long n)
constexpr double rad2deg(double v)
AntialiasingFlags GetAntialiasing() const
bool isFrameAreaDefinitionValid() const
Definition: frame.hxx:167
#define RES_LINKED_GRAPHIC_STREAM_ARRIVED
Definition: hintids.hxx:313
double getLocalFrameRotation() const
Definition: notxtfrm.cxx:634
std::unique_ptr< BaseProcessor2D > createProcessor2DFromOutputDevice(OutputDevice &rTargetOutDev, const drawinglayer::geometry::ViewInformation2D &rViewInformation2D)
bool IsLinkedInputStreamReady() const
Definition: ndgrf.hxx:145
WEIGHT_BOLD
SwRect & Intersection_(const SwRect &rRect)
Definition: swrect.cxx:81
bool IsChart() const
Definition: ndole.cxx:617
#define RES_UPDATE_ATTR
Definition: hintids.hxx:289
drawinglayer::primitive2d::Primitive2DContainer const & tryToGetChartContentAsPrimitive2DSequence(basegfx::B2DRange &rRange, bool bSynchron)
Definition: ndole.cxx:1031
bool IsAsyncRetrieveInputStreamPossible() const
Definition: ndgrf.cxx:862
B2DPolygon const & getB2DPolygon(sal_uInt32 nIndex) const
long Right() const
double getWidth() const
void Top(const long nTop)
Definition: swrect.hxx:202
bool isGRFATR(const sal_uInt16 nWhich)
Definition: hintids.hxx:376
void SwAlignRect(SwRect &rRect, const SwViewShell *pSh, const vcl::RenderContext *pRenderContext)
Function is also used outside this file.
Definition: paintfrm.cxx:1103
LINESTYLE_NONE
void restoreFrameAreas()
Definition: wsfrm.cxx:265
SwIndex nContent
Definition: pam.hxx:38
virtual void Modify(const SfxPoolItem *, const SfxPoolItem *) override
Definition: notxtfrm.cxx:723
const SwRect & getFrameArea() const
Definition: frame.hxx:175
void setX(long nX)
OUTDEV_WINDOW
void TriggerAsyncRetrieveInputStream()
Definition: ndgrf.cxx:801
GraphicAttr & GetGraphicAttr(GraphicAttr &, const SwFrame *pFrame) const
Returns the with our graphic attributes filled Graphic-Attr-Structure.
Definition: ndgrf.cxx:727
BASEGFX_DLLPUBLIC void transform(const B2DHomMatrix &rMatrix)
IDocumentStylePoolAccess const & getIDocumentStylePoolAccess() const
Definition: doc.cxx:458
bool isTransformableSwFrame() const
Definition: flyfrms.hxx:131
svt::EmbeddedObjectRef & GetObject()
Definition: ndole.cxx:952
const OUString & GetName() const
Definition: format.hxx:111
bool DrawFillAttributes(const drawinglayer::attribute::SdrAllFillAttributesHelperPtr &rFillAttributes, const SwRect &rOriginalLayoutRect, const SwRegionRects &rPaintRegion, const basegfx::utils::B2DClipState &rClipState, vcl::RenderContext &rOut)
Definition: paintfrm.cxx:1696
std::shared_ptr< SdrAllFillAttributesHelper > SdrAllFillAttributesHelperPtr
Definition: format.hxx:38
static void lcl_CalcRect(Point &rPt, Size &rDim, MirrorGraph nMirror)
Calculate the position and the size of the graphic in the Frame, corresponding to the current graphic...
Definition: notxtfrm.cxx:336
bool HasAnimation() const
Definition: notxtfrm.cxx:1370
#define RES_GRAPHIC_ARRIVED
Definition: hintids.hxx:298
B2DHomMatrix createScaleTranslateB2DHomMatrix(double fScaleX, double fScaleY, double fTranslateX, double fTranslateY)
const SwFormatSurround & GetSurround(bool=true) const
Definition: fmtsrnd.hxx:66
SwDoc * GetDoc() const
Definition: viewsh.hxx:284
long Top() const
void SetUnderline(FontLineStyle)
virtual bool GetCursorOfst(SwPosition *pPos, Point &aPoint, SwCursorMoveState *=nullptr, bool bTestBackground=false) const override
Definition: notxtfrm.cxx:704
SwFlyFrame * FindFlyFrame()
Definition: frame.hxx:1087
bool GetFileFilterNms(OUString *pFileNm, OUString *pFilterNm) const
Definition: ndgrf.cxx:488
void Right(const long nRight)
Definition: swrect.hxx:198
void setY(long nY)
const IDocumentDeviceAccess & getIDocumentDeviceAccess() const
Provides access to the document device interface.
Definition: node.cxx:2040
std::unique_ptr< TransformableSwFrame > mpTransformableSwFrame
Definition: notxtfrm.hxx:43
const OUString & GetCurrentPersistName() const
Definition: ndole.hxx:69
void DrawRect(const tools::Rectangle &rRect)
Base class for various Writer styles.
Definition: format.hxx:43
long getY() const
virtual void transform_translate(const Point &rOffset) override
Definition: notxtfrm.cxx:614
sal_uInt16 GetVirtPageNum() const
Definition: trvlfrm.cxx:1805
long getX() const
bool isEmpty() const
B2DHomMatrix createSourceRangeTargetRangeTransform(const B2DRange &rSourceRange, const B2DRange &rTargetRange)
#define RES_GRAPHIC_PIECE_ARRIVED
Definition: hintids.hxx:299
void StartGraphicAnimation(OutputDevice *pOut, const Point &rPt, const Size &rSz, long nExtraData, OutputDevice *pFirstFrameOutDev)
wrappers for non-const calls at GraphicObject
Definition: ndgrf.hxx:87
void SetLineColor()
void paintGraphicUsingPrimitivesHelper(vcl::RenderContext &rOutputDevice, GraphicObject const &rGrfObj, GraphicAttr const &rGraphicAttr, const basegfx::B2DHomMatrix &rGraphicTransform, const OUString &rName, const OUString &rTitle, const OUString &rDescription)
Definition: notxtfrm.cxx:930
void SetFamilyName(const OUString &rFamilyName)
void InvalidatePrt()
Definition: frame.hxx:1012
static void lcl_ClearArea(const SwFrame &rFrame, vcl::RenderContext &rOut, const SwRect &rPtArea, const SwRect &rGrfArea)
Definition: notxtfrm.cxx:179
Internet visited.
Definition: poolfmt.hxx:122
bool IsClipRegion() const
virtual bool IsDataComplete() const
GraphicType GetType() const
void PaintPicture(vcl::RenderContext *, const SwRect &) const
Paint the graphic.
Definition: notxtfrm.cxx:1050
void RepaintPagePreview(SwViewShell const *pVwSh, const SwRect &rRect)
Definition: edtwin3.cxx:116
SwIndex & Assign(SwIndexReg *, sal_Int32)
Definition: index.cxx:198
bool IsAnimated() const
Definition: ndgrf.hxx:96
#define RES_GRFATR_ROTATION
Definition: hintids.hxx:242
SwPageFrame * FindPageFrame()
Definition: frame.hxx:658
virtual SwFormat * GetFormatFromPool(sal_uInt16 nId)=0
Return required automatic format base class.
int i
static void lcl_PaintReplacement(const SwRect &rRect, const OUString &rText, const SwViewShell &rSh, const SwNoTextFrame *pFrame, bool bDefect)
Definition: notxtfrm.cxx:100
const Graphic * GetGraphic()
Definition: ndole.cxx:241
B2DPolygon createPolygonFromRect(const B2DRectangle &rRect, double fRadiusX, double fRadiusY)
bool IsPreview() const
Definition: viewsh.hxx:491
#define F_2PI
SwNoTextNode * GetNoTextNode()
Definition: ndnotxt.hxx:96
SwDoc * GetDoc()
Definition: node.hxx:702
const SwFormatURL & GetURL(bool=true) const
Definition: fmturl.hxx:78
SwLayoutFrame * GetUpper()
Definition: frame.hxx:656
static bool equalZero(const double &rfVal)
void SetFillColor()
AntialiasingFlags
bool isFramePrintAreaValid() const
Definition: frame.hxx:164
Internet normal.
Definition: poolfmt.hxx:121
long Bottom() const
virtual void PaintSwFrame(vcl::RenderContext &rRenderContext, SwRect const &, SwPrintData const *const pPrintData=nullptr) const override
Definition: notxtfrm.cxx:219
#define SET_CURR_SHELL(shell)
Definition: swtypes.hxx:101
SfxItemState GetItemState(sal_uInt16 nWhich, bool bSrchInParent=true, const SfxPoolItem **ppItem=nullptr) const
Definition: format.cxx:398
const IDocumentSettingAccess * getIDocumentSettingAccess() const
Provides access to the document setting interface.
Definition: node.cxx:2039
bool IsPDFExport() const
Definition: viewopt.hxx:371
bool isFrameAreaPositionValid() const
Definition: frame.hxx:162
static bool paintUsingPrimitivesHelper(vcl::RenderContext &rOutputDevice, const drawinglayer::primitive2d::Primitive2DContainer &rSequence, const basegfx::B2DRange &rSourceRange, const basegfx::B2DRange &rTargetRange)
Definition: notxtfrm.cxx:884
const Size & GetSize() const
By returning the surrounding Fly's size which equals the graphic's size.
Definition: notxtfrm.cxx:474
bool isOutputToWindow() const
Definition: viewsh.cxx:140
ring_container GetRingContainer()
Definition: ring.hxx:240
OUString SwResId(const char *pId)
Definition: swmodule.cxx:191
OUString GetDescription() const
Definition: ndnotxt.cxx:284
void SSize(const Size &rNew)
Definition: swrect.hxx:176
Point m_aRealHeight
contains then the position/height of the cursor
Definition: crstate.hxx:137
bool isFrameAreaSizeValid() const
Definition: frame.hxx:163
#define RES_FMT_CHG
Definition: hintids.hxx:284
virtual SfxPrinter * getPrinter(bool bCreate) const =0
Return the printer set at the document.
const GraphicObject & GetGrfObj(bool bWait=false) const
Definition: ndgrf.cxx:374
bool IsTransparent() const
Definition: notxtfrm.cxx:1313
long X() const
IDocumentLayoutAccess const & getIDocumentLayoutAccess() const
Definition: doc.cxx:437
GraphicType GetType() const
virtual Size GetTwipSize() const override
Definition: ndgrf.cxx:428
#define RES_GRFATR_BEGIN
Definition: hintids.hxx:238
static bool GetRealURL(const SwGrfNode &rNd, OUString &rText)
Definition: notxtfrm.cxx:89
SwBorderAttrs * Get()
Definition: frmtool.cxx:2377
SwTwips Shrink(SwTwips, bool bTst=false, bool bInfo=false)
Definition: wsfrm.cxx:1507
void SetColor(const Color &)
void SetFrameInPaint(bool b)
Definition: ndgrf.hxx:105
static void DrawPaintReplacement(const tools::Rectangle &rRect, const OUString &rText, OutputDevice *pOut)
Point LogicToPixel(const Point &rLogicPt) const
const ImageMap * GetMap() const
Definition: fmturl.hxx:68
sal_Int32 GetBottom() const
FontLineStyle GetLineStyle() const
const SwRect & GetUnclippedFrame() const
Definition: flyfrms.hxx:112
void append(const B2DPolygon &rPolygon, sal_uInt32 nCount=1)
sal_Int32 GetTop() const
void Left(const long nLeft)
Definition: swrect.hxx:193
void Bottom(const long nBottom)
Definition: swrect.hxx:207
const SwContentNode * GetNode() const
Definition: notxtfrm.hxx:60
bool HasBorder(bool bTreatPaddingAsBorder) const
void SetStyleName(const OUString &rStyleName)
void Justify()
Definition: swrect.cxx:136
tools::Rectangle SVRect() const
Definition: swrect.hxx:282
void StopAnimation(OutputDevice *=nullptr) const
Definition: notxtfrm.cxx:1359
SwDrawView * GetDrawView()
Definition: viewimp.hxx:156
general base class for all free-flowing frames
Definition: flyfrm.hxx:60
Color GetRetoucheColor() const
Definition: viewimp.cxx:252
const Graphic & GetGraphic() const
void GetGrfArea(SwRect &rRect, SwRect *) const
Calculate the Bitmap's position and the size within the passed rectangle.
Definition: notxtfrm.cxx:352
static void LeaveLock()
virtual const SwViewShell * GetCurrentViewShell() const =0
Returns the layout set at the document.
void ClrContourCache(const SdrObject *pObj)
Definition: txtfly.cxx:140
const SwViewOption * GetViewOptions() const
Definition: viewsh.hxx:426
void Width(long nNew)
Definition: swrect.hxx:185
vcl::Window * GetWin() const
Definition: viewsh.hxx:340
SwFlyFrame * GetFlyFromMarked(const SdrMarkList *pLst, SwViewShell *pSh)
Definition: feshview.cxx:147
OUString GetTitle() const
Definition: ndnotxt.cxx:260
void InvalidateAll_()
Definition: frame.hxx:781
void SetTransparent(bool bTransparent)
void SwAlignGrfRect(SwRect *pGrfRect, const vcl::RenderContext &rOut)
Method to pixel-align rectangle for drawing graphic object.
Definition: paintfrm.cxx:1209
void ClearCache()
Definition: notxtfrm.cxx:713
FAMILY_SWISS
static void EnterLock()
void AdjustMarkHdl(SfxViewShell *pOtherShell=nullptr)
SwRect getUntransformedFrameArea() const
Definition: wsfrm.cxx:161
void UpdateLinkWithInputStream()
Definition: ndgrf.cxx:843
void setFrameAreaSizeValid(bool bNew)
Definition: wsfrm.cxx:88
SwFrameType mnFrameType
Definition: frame.hxx:395
const basegfx::B2DHomMatrix & getLocalFrameAreaTransformation() const
Definition: frame.hxx:251
virtual bool GetCharRect(SwRect &, const SwPosition &, SwCursorMoveState *=nullptr, bool bAllowFarAway=true) const override
Definition: notxtfrm.cxx:671
long Left() const
bool IsChart() const
virtual bool get(DocumentSettingId id) const =0
Return the specified document setting.
const SwAttrSet & GetSwAttrSet() const
Does node has already its own auto-attributes? Access to SwAttrSet.
Definition: node.hxx:723
sal_Int32 GetRight() const
IMapObject * GetIMapObject(size_t nPos) const
#define RES_BOX
Definition: hintids.hxx:211
#define RES_OBJECTDYING
Definition: hintids.hxx:283
bool IsVertical() const
Definition: frame.hxx:949
virtual void Calc(vcl::RenderContext *pRenderContext) const override
Definition: fly.cxx:2826
virtual void NotifyBackground(SwPageFrame *_pPageFrame, const SwRect &_rRect, PrepareHint _eHint)=0
method to trigger notification of 'background'
virtual void DestroyImpl() override
Definition: notxtfrm.cxx:163
bool IsTransparent() const
Definition: ndgrf.cxx:795
bool GetContour(tools::PolyPolygon &rContour, const bool _bForPaint=false) const
OD 16.04.2003 #i13147# - If called for paint and the contains a graphic, load of intrinsic graphic has to be avoided.
Definition: fly.cxx:2579
bool IsAnimated() const
SwGrfNode * GetGrfNode()
Definition: ndgrf.hxx:155
virtual void MakePos()
Definition: calcmove.cxx:521
B2DHomMatrix createTranslateB2DHomMatrix(double fTranslateX, double fTranslateY)
bool IsOver(const SwRect &rRect) const
Definition: swrect.cxx:128
FontLineStyle
void adaptFrameAreasToTransformations()
Definition: wsfrm.cxx:230
void SetOutDev(SwViewShell *pSh, OutputDevice *pOut)
Definition: notxtfrm.cxx:174
static bool FlushVout()
Output virtual Device (e.g. for animations)
Definition: virtoutp.cxx:29
void Push(PushFlags nFlags=PushFlags::ALL)
SwViewShell * GetCurrShell() const
Definition: rootfrm.hxx:204
basegfx::B2DHomMatrix GetViewTransformation() const
void setWidth(long nWidth)
void createFrameAreaTransformations(double fRotation, const basegfx::B2DPoint &rCenter)
Definition: wsfrm.cxx:210
static void DrawEx(OutputDevice *pOutDev, const OUString &rText, vcl::Font &rFont, const BitmapEx &rBitmap, const Point &rDestPt, const Size &rDestSize)
const basegfx::B2DHomMatrix & getLocalFramePrintAreaTransformation() const
Definition: frame.hxx:257
SwFrameFormat * GetFlyFormat() const
If node is in a fly return the respective format.
Definition: node.cxx:710
virtual SwContentFrame * MakeFrame(SwFrame *) override
MakeFrame will be called for a certain layout pSib is another SwFrame of the same layout (e...
Definition: notxtfrm.cxx:158
const OUString & GetURL() const
bool isTransformableSwFrame() const
Definition: notxtfrm.hxx:83
sal_uInt16 Which() const
SwRootFrame * getRootFrame()
Definition: frame.hxx:657
virtual void Modify(const SfxPoolItem *, const SfxPoolItem *) override
Definition: wsfrm.cxx:2302
virtual void transform_translate(const Point &rOffset)
Definition: wsfrm.cxx:144
long Y() const
const Color & GetValue() const
virtual void DestroyImpl() override
Definition: ssfrm.cxx:421
static void lcl_correctlyAlignRect(SwRect &rAlignedGrfArea, const SwRect &rInArea, vcl::RenderContext const *pOut)
Definition: notxtfrm.cxx:855
const OUString & GetURL() const
Definition: fmturl.hxx:66
Base class of the Writer document model elements.
Definition: node.hxx:79
void setHeight(long nHeight)
bool GetBackgroundBrush(drawinglayer::attribute::SdrAllFillAttributesHelperPtr &rFillAttributes, const SvxBrushItem *&rpBrush, const Color *&rpColor, SwRect &rOrigRect, bool bLowerMode, bool bConsiderTextBox) const
Determine the background brush for the frame: the background brush is taken from it-self or from its ...
Definition: paintfrm.cxx:7146