| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_sw.hxx" |
| |
| #include <hintids.hxx> |
| #include <tools/urlobj.hxx> |
| #include <vcl/print.hxx> |
| #include <vcl/virdev.hxx> |
| #include <vcl/svapp.hxx> |
| #include <svtools/imapobj.hxx> |
| #include <svtools/imap.hxx> |
| #include <svl/urihelper.hxx> |
| #include <svtools/soerr.hxx> |
| #include <sfx2/progress.hxx> |
| #include <sfx2/docfile.hxx> |
| #include <sfx2/printer.hxx> |
| #include <editeng/udlnitem.hxx> |
| #include <editeng/colritem.hxx> |
| #include <svx/xoutbmp.hxx> |
| #include <vcl/window.hxx> |
| #include <fmturl.hxx> |
| #include <fmtsrnd.hxx> |
| #include <frmfmt.hxx> |
| #include <swrect.hxx> |
| #include <fesh.hxx> |
| #include <doc.hxx> |
| #include <flyfrm.hxx> |
| #include <frmtool.hxx> |
| #include <viewopt.hxx> |
| #include <viewimp.hxx> |
| #include <pam.hxx> |
| #include <hints.hxx> |
| #include <rootfrm.hxx> |
| #include <dflyobj.hxx> |
| #include <pagefrm.hxx> |
| #include <notxtfrm.hxx> |
| #include <grfatr.hxx> |
| #include <charatr.hxx> |
| #include <fmtornt.hxx> |
| #include <ndnotxt.hxx> |
| #include <ndgrf.hxx> |
| #include <ndole.hxx> |
| #include <swregion.hxx> |
| #include <poolfmt.hxx> |
| #include <mdiexp.hxx> |
| #include <swwait.hxx> |
| #include <comcore.hrc> |
| #include <accessibilityoptions.hxx> |
| #include <com/sun/star/embed/EmbedMisc.hpp> |
| #include <com/sun/star/embed/EmbedStates.hpp> |
| #include <svtools/embedhlp.hxx> |
| #include <svx/charthelper.hxx> |
| #include <dview.hxx> |
| #include <basegfx/matrix/b2dhommatrix.hxx> |
| #include <drawinglayer/processor2d/baseprocessor2d.hxx> |
| #include <basegfx/matrix/b2dhommatrixtools.hxx> |
| #include <drawinglayer/processor2d/processor2dtools.hxx> |
| #include <basegfx/matrix/b2dhommatrixtools.hxx> |
| #include <drawinglayer/primitive2d/graphicprimitive2d.hxx> |
| #include <vcl/pdfextoutdevdata.hxx> |
| #include <svtools/filter.hxx> |
| |
| using namespace com::sun::star; |
| |
| #define DEFTEXTSIZE 12 |
| |
| extern void ClrContourCache( const SdrObject *pObj ); // TxtFly.Cxx |
| |
| |
| inline sal_Bool GetRealURL( const SwGrfNode& rNd, String& rTxt ) |
| { |
| sal_Bool bRet = rNd.GetFileFilterNms( &rTxt, 0 ); |
| if( bRet ) |
| rTxt = URIHelper::removePassword( rTxt, INetURLObject::WAS_ENCODED, |
| INetURLObject::DECODE_UNAMBIGUOUS); |
| return bRet; |
| } |
| |
| void lcl_PaintReplacement( const SwRect &rRect, const String &rText, |
| const ViewShell &rSh, const SwNoTxtFrm *pFrm, |
| sal_Bool bDefect ) |
| { |
| static Font *pFont = 0; |
| if ( !pFont ) |
| { |
| pFont = new Font(); |
| pFont->SetWeight( WEIGHT_BOLD ); |
| pFont->SetStyleName( aEmptyStr ); |
| pFont->SetName( String::CreateFromAscii( |
| RTL_CONSTASCII_STRINGPARAM( "Arial Unicode" ))); |
| pFont->SetFamily( FAMILY_SWISS ); |
| pFont->SetTransparent( sal_True ); |
| } |
| |
| Color aCol( COL_RED ); |
| FontUnderline eUnderline = UNDERLINE_NONE; |
| const SwFmtURL &rURL = pFrm->FindFlyFrm()->GetFmt()->GetURL(); |
| if( rURL.GetURL().Len() || rURL.GetMap() ) |
| { |
| sal_Bool bVisited = sal_False; |
| if ( rURL.GetMap() ) |
| { |
| ImageMap *pMap = (ImageMap*)rURL.GetMap(); |
| for( sal_uInt16 i = 0; i < pMap->GetIMapObjectCount(); i++ ) |
| { |
| IMapObject *pObj = pMap->GetIMapObject( i ); |
| if( rSh.GetDoc()->IsVisitedURL( pObj->GetURL() ) ) |
| { |
| bVisited = sal_True; |
| break; |
| } |
| } |
| } |
| else if ( rURL.GetURL().Len() ) |
| bVisited = rSh.GetDoc()->IsVisitedURL( rURL.GetURL() ); |
| |
| SwFmt *pFmt = rSh.GetDoc()->GetFmtFromPool( static_cast<sal_uInt16> |
| (bVisited ? RES_POOLCHR_INET_VISIT : RES_POOLCHR_INET_NORMAL ) ); |
| aCol = pFmt->GetColor().GetValue(); |
| eUnderline = pFmt->GetUnderline().GetLineStyle(); |
| } |
| |
| pFont->SetUnderline( eUnderline ); |
| pFont->SetColor( aCol ); |
| |
| const BitmapEx& rBmp = ViewShell::GetReplacementBitmap( bDefect != sal_False ); |
| Graphic::DrawEx( rSh.GetOut(), rText, *pFont, rBmp, rRect.Pos(), rRect.SSize() ); |
| } |
| |
| /************************************************************************* |
| |* |
| |* SwGrfFrm::SwGrfFrm(ViewShell * const,SwGrfNode *) |
| |* |
| |* Beschreibung |
| |* Ersterstellung JP 05.03.91 |
| |* Letzte Aenderung MA 03. Mar. 93 |
| |* |
| *************************************************************************/ |
| |
| |
| SwNoTxtFrm::SwNoTxtFrm(SwNoTxtNode * const pNode, SwFrm* pSib ) |
| : SwCntntFrm( pNode, pSib ) |
| { |
| InitCtor(); |
| } |
| |
| // Initialisierung: z.Zt. Eintragen des Frames im Cache |
| |
| |
| void SwNoTxtFrm::InitCtor() |
| { |
| nType = FRMC_NOTXT; |
| // Das Gewicht der Grafik ist 0, wenn sie noch nicht |
| // gelesen ist, < 0, wenn ein Lesefehler auftrat und |
| // Ersatzdarstellung angewendet werden musste und >0, |
| // wenn sie zur Verfuegung steht. |
| nWeight = 0; |
| } |
| |
| /************************************************************************* |
| |* |
| |* SwNoTxtNode::MakeFrm() |
| |* |
| |* Beschreibung |
| |* Ersterstellung JP 05.03.91 |
| |* Letzte Aenderung MA 03. Mar. 93 |
| |* |
| *************************************************************************/ |
| |
| |
| SwCntntFrm *SwNoTxtNode::MakeFrm( SwFrm* pSib ) |
| { |
| return new SwNoTxtFrm(this, pSib); |
| } |
| |
| /************************************************************************* |
| |* |
| |* SwNoTxtFrm::~SwNoTxtFrm() |
| |* |
| |* Beschreibung |
| |* Ersterstellung JP 05.03.91 |
| |* Letzte Aenderung MA 30. Apr. 96 |
| |* |
| *************************************************************************/ |
| |
| SwNoTxtFrm::~SwNoTxtFrm() |
| { |
| StopAnimation(); |
| } |
| |
| /************************************************************************* |
| |* |
| |* void SwNoTxtFrm::Modify( SwHint * pOld, SwHint * pNew ) |
| |* |
| |* Beschreibung |
| |* Ersterstellung JP 05.03.91 |
| |* Letzte Aenderung JP 05.03.91 |
| |* |
| *************************************************************************/ |
| |
| void SetOutDev( ViewShell *pSh, OutputDevice *pOut ) |
| { |
| pSh->pOut = pOut; |
| } |
| |
| |
| |
| |
| void lcl_ClearArea( const SwFrm &rFrm, |
| OutputDevice &rOut, const SwRect& rPtArea, |
| const SwRect &rGrfArea ) |
| { |
| SwRegionRects aRegion( rPtArea, 4, 4 ); |
| aRegion -= rGrfArea; |
| |
| if ( aRegion.Count() ) |
| { |
| const SvxBrushItem *pItem; const Color *pCol; SwRect aOrigRect; |
| if ( rFrm.GetBackgroundBrush( pItem, pCol, aOrigRect, sal_False ) ) |
| for( sal_uInt16 i = 0; i < aRegion.Count(); ++i ) |
| ::DrawGraphic( pItem, &rOut, aOrigRect, aRegion[i] ); |
| else |
| { |
| // OD 2004-04-23 #116347# |
| rOut.Push( PUSH_FILLCOLOR|PUSH_LINECOLOR ); |
| rOut.SetFillColor( rFrm.getRootFrm()->GetCurrShell()->Imp()->GetRetoucheColor()); |
| rOut.SetLineColor(); |
| for( sal_uInt16 i = 0; i < aRegion.Count(); ++i ) |
| rOut.DrawRect( aRegion[i].SVRect() ); |
| rOut.Pop(); |
| } |
| } |
| } |
| |
| /************************************************************************* |
| |* |
| |* void SwNoTxtFrm::Paint() |
| |* |
| |* Beschreibung |
| |* Ersterstellung JP 05.03.91 |
| |* Letzte Aenderung MA 10. Jan. 97 |
| |* |
| *************************************************************************/ |
| |
| void SwNoTxtFrm::Paint(SwRect const& rRect, SwPrintData const*const) const |
| { |
| if ( Frm().IsEmpty() ) |
| return; |
| |
| const ViewShell* pSh = getRootFrm()->GetCurrShell(); |
| if( !pSh->GetViewOptions()->IsGraphic() ) |
| { |
| StopAnimation(); |
| // OD 10.01.2003 #i6467# - no paint of placeholder for page preview |
| if ( pSh->GetWin() && !pSh->IsPreView() ) |
| { |
| const SwNoTxtNode* pNd = GetNode()->GetNoTxtNode(); |
| String aTxt( pNd->GetTitle() ); |
| if ( !aTxt.Len() && pNd->IsGrfNode() ) |
| GetRealURL( *(SwGrfNode*)pNd, aTxt ); |
| if( !aTxt.Len() ) |
| aTxt = FindFlyFrm()->GetFmt()->GetName(); |
| lcl_PaintReplacement( Frm(), aTxt, *pSh, this, sal_False ); |
| } |
| return; |
| } |
| |
| if( pSh->GetAccessibilityOptions()->IsStopAnimatedGraphics() || |
| // --> FME 2004-06-21 #i9684# Stop animation during printing/pdf export |
| !pSh->GetWin() ) |
| // <-- |
| StopAnimation(); |
| |
| SfxProgress::EnterLock(); //Keine Progress-Reschedules im Paint (SwapIn) |
| |
| OutputDevice *pOut = pSh->GetOut(); |
| pOut->Push(); |
| sal_Bool bClip = sal_True; |
| PolyPolygon aPoly; |
| |
| SwNoTxtNode& rNoTNd = *(SwNoTxtNode*)GetNode(); |
| SwGrfNode* pGrfNd = rNoTNd.GetGrfNode(); |
| if( pGrfNd ) |
| pGrfNd->SetFrameInPaint( sal_True ); |
| |
| // OD 16.04.2003 #i13147# - add 2nd parameter with value <sal_True> to |
| // method call <FindFlyFrm().GetContour(..)> to indicate that it is called |
| // for paint in order to avoid load of the intrinsic graphic. |
| if ( ( !pOut->GetConnectMetaFile() || |
| !pSh->GetWin() ) && |
| FindFlyFrm()->GetContour( aPoly, sal_True ) |
| ) |
| { |
| pOut->SetClipRegion( aPoly ); |
| bClip = sal_False; |
| } |
| |
| SwRect aOrigPaint( rRect ); |
| if ( HasAnimation() && pSh->GetWin() ) |
| { |
| aOrigPaint = Frm(); aOrigPaint += Prt().Pos(); |
| } |
| |
| SwRect aGrfArea( Frm() ); |
| SwRect aPaintArea( aGrfArea ); |
| aPaintArea._Intersection( aOrigPaint ); |
| |
| SwRect aNormal( Frm().Pos() + Prt().Pos(), Prt().SSize() ); |
| aNormal.Justify(); //Normalisiertes Rechteck fuer die Vergleiche |
| |
| if( aPaintArea.IsOver( aNormal ) ) |
| { |
| // berechne die 4 zu loeschenden Rechtecke |
| if( pSh->GetWin() ) |
| ::lcl_ClearArea( *this, *pSh->GetOut(), aPaintArea, aNormal ); |
| |
| // in der Schnittmenge vom PaintBereich und der Bitmap liegt |
| // der absolut sichtbare Bereich vom Frame |
| aPaintArea._Intersection( aNormal ); |
| |
| if ( bClip ) |
| pOut->IntersectClipRegion( aPaintArea.SVRect() ); |
| /// OD 25.09.2002 #99739# - delete unused 3rd parameter |
| PaintPicture( pOut, aGrfArea ); |
| } |
| else |
| // wenn nicht sichtbar, loesche einfach den angegebenen Bereich |
| lcl_ClearArea( *this, *pSh->GetOut(), aPaintArea, SwRect() ); |
| if( pGrfNd ) |
| pGrfNd->SetFrameInPaint( sal_False ); |
| |
| pOut->Pop(); |
| SfxProgress::LeaveLock(); |
| } |
| |
| /************************************************************************* |
| |* |
| |* void lcl_CalcRect( Point & aPt, Size & aDim, |
| |* sal_uInt16 nMirror ) |
| |* |
| |* Beschreibung Errechne die Position und die Groesse der Grafik im |
| |* Frame, entsprechen der aktuellen Grafik-Attribute |
| |* |
| |* Parameter Point& die Position im Frame ( auch Return-Wert ) |
| |* Size& die Groesse der Grafik ( auch Return-Wert ) |
| |* MirrorGrf akt. Spiegelungs-Attribut |
| |* Ersterstellung JP 04.03.91 |
| |* Letzte Aenderung JP 31.08.94 |
| |* |
| *************************************************************************/ |
| |
| |
| void lcl_CalcRect( Point& rPt, Size& rDim, sal_uInt16 nMirror ) |
| { |
| if( nMirror == RES_MIRROR_GRAPH_VERT || nMirror == RES_MIRROR_GRAPH_BOTH ) |
| { |
| rPt.X() += rDim.Width() -1; |
| rDim.Width() = -rDim.Width(); |
| } |
| |
| if( nMirror == RES_MIRROR_GRAPH_HOR || nMirror == RES_MIRROR_GRAPH_BOTH ) |
| { |
| rPt.Y() += rDim.Height() -1; |
| rDim.Height() = -rDim.Height(); |
| } |
| } |
| |
| /************************************************************************* |
| |* |
| |* void SwNoTxtFrm::GetGrfArea() |
| |* |
| |* Beschreibung Errechne die Position und die Groesse der Bitmap |
| |* innerhalb des uebergebenem Rechtecks. |
| |* |
| |* Ersterstellung JP 03.09.91 |
| |* Letzte Aenderung MA 11. Oct. 94 |
| |* |
| *************************************************************************/ |
| |
| void SwNoTxtFrm::GetGrfArea( SwRect &rRect, SwRect* pOrigRect, |
| sal_Bool ) const |
| { |
| // JP 23.01.2001: currently only used for scaling, cropping and mirroring |
| // the contour of graphics! |
| // all other is handled by the GraphicObject |
| |
| //In rRect wird das sichbare Rechteck der Grafik gesteckt. |
| //In pOrigRect werden Pos+Size der Gesamtgrafik gesteck. |
| |
| const SwAttrSet& rAttrSet = GetNode()->GetSwAttrSet(); |
| const SwCropGrf& rCrop = rAttrSet.GetCropGrf(); |
| sal_uInt16 nMirror = rAttrSet.GetMirrorGrf().GetValue(); |
| |
| if( rAttrSet.GetMirrorGrf().IsGrfToggle() ) |
| { |
| if( !(FindPageFrm()->GetVirtPageNum() % 2) ) |
| { |
| switch ( nMirror ) |
| { |
| case RES_MIRROR_GRAPH_DONT: nMirror = RES_MIRROR_GRAPH_VERT; break; |
| case RES_MIRROR_GRAPH_VERT: nMirror = RES_MIRROR_GRAPH_DONT; break; |
| case RES_MIRROR_GRAPH_HOR: nMirror = RES_MIRROR_GRAPH_BOTH; break; |
| default: nMirror = RES_MIRROR_GRAPH_HOR; break; |
| } |
| } |
| } |
| |
| //Grafik wird vom Node eingelesen falls notwendig. Kann aber schiefgehen. |
| long nLeftCrop, nRightCrop, nTopCrop, nBottomCrop; |
| Size aOrigSz( ((SwNoTxtNode*)GetNode())->GetTwipSize() ); |
| if ( !aOrigSz.Width() ) |
| { |
| aOrigSz.Width() = Prt().Width(); |
| nLeftCrop = -rCrop.GetLeft(); |
| nRightCrop = -rCrop.GetRight(); |
| } |
| else |
| { |
| nLeftCrop = Max( aOrigSz.Width() - |
| (rCrop.GetRight() + rCrop.GetLeft()), long(1) ); |
| const double nScale = double(Prt().Width()) / double(nLeftCrop); |
| nLeftCrop = long(nScale * -rCrop.GetLeft() ); |
| nRightCrop = long(nScale * -rCrop.GetRight() ); |
| } |
| |
| // crop values have to be mirrored too |
| if( nMirror == RES_MIRROR_GRAPH_VERT || nMirror == RES_MIRROR_GRAPH_BOTH ) |
| { |
| long nTmpCrop = nLeftCrop; |
| nLeftCrop = nRightCrop; |
| nRightCrop= nTmpCrop; |
| } |
| |
| if( !aOrigSz.Height() ) |
| { |
| aOrigSz.Height() = Prt().Height(); |
| nTopCrop = -rCrop.GetTop(); |
| nBottomCrop= -rCrop.GetBottom(); |
| } |
| else |
| { |
| nTopCrop = Max( aOrigSz.Height() - (rCrop.GetTop() + rCrop.GetBottom()), long(1) ); |
| const double nScale = double(Prt().Height()) / double(nTopCrop); |
| nTopCrop = long(nScale * -rCrop.GetTop() ); |
| nBottomCrop= long(nScale * -rCrop.GetBottom() ); |
| } |
| |
| // crop values have to be mirrored too |
| if( nMirror == RES_MIRROR_GRAPH_HOR || nMirror == RES_MIRROR_GRAPH_BOTH ) |
| { |
| long nTmpCrop = nTopCrop; |
| nTopCrop = nBottomCrop; |
| nBottomCrop= nTmpCrop; |
| } |
| |
| Size aVisSz( Prt().SSize() ); |
| Size aGrfSz( aVisSz ); |
| Point aVisPt( Frm().Pos() + Prt().Pos() ); |
| Point aGrfPt( aVisPt ); |
| |
| //Erst das 'sichtbare' Rect einstellen. |
| if ( nLeftCrop > 0 ) |
| { |
| aVisPt.X() += nLeftCrop; |
| aVisSz.Width() -= nLeftCrop; |
| } |
| if ( nTopCrop > 0 ) |
| { |
| aVisPt.Y() += nTopCrop; |
| aVisSz.Height() -= nTopCrop; |
| } |
| if ( nRightCrop > 0 ) |
| aVisSz.Width() -= nRightCrop; |
| if ( nBottomCrop > 0 ) |
| aVisSz.Height() -= nBottomCrop; |
| |
| rRect.Pos ( aVisPt ); |
| rRect.SSize( aVisSz ); |
| |
| //Ggf. Die Gesamtgrafik berechnen |
| if ( pOrigRect ) |
| { |
| Size aTmpSz( aGrfSz ); |
| aGrfPt.X() += nLeftCrop; |
| aTmpSz.Width() -= nLeftCrop + nRightCrop; |
| aGrfPt.Y() += nTopCrop; |
| aTmpSz.Height()-= nTopCrop + nBottomCrop; |
| |
| if( RES_MIRROR_GRAPH_DONT != nMirror ) |
| lcl_CalcRect( aGrfPt, aTmpSz, nMirror ); |
| |
| pOrigRect->Pos ( aGrfPt ); |
| pOrigRect->SSize( aTmpSz ); |
| } |
| } |
| |
| /************************************************************************* |
| |* |
| |* Size SwNoTxtFrm::GetSize() |
| |* |
| |* Beschreibung Gebe die Groesse des umgebenen FLys und |
| |* damit die der Grafik zurueck. |
| |* Ersterstellung JP 04.03.91 |
| |* Letzte Aenderung JP 31.08.94 |
| |* |
| *************************************************************************/ |
| |
| |
| const Size& SwNoTxtFrm::GetSize() const |
| { |
| // gebe die Groesse des Frames zurueck |
| const SwFrm *pFly = FindFlyFrm(); |
| if( !pFly ) |
| pFly = this; |
| return pFly->Prt().SSize(); |
| } |
| |
| /************************************************************************* |
| |* |
| |* SwNoTxtFrm::MakeAll() |
| |* |
| |* Ersterstellung MA 29. Nov. 96 |
| |* Letzte Aenderung MA 29. Nov. 96 |
| |* |
| *************************************************************************/ |
| |
| |
| void SwNoTxtFrm::MakeAll() |
| { |
| SwCntntNotify aNotify( this ); |
| SwBorderAttrAccess aAccess( SwFrm::GetCache(), this ); |
| const SwBorderAttrs &rAttrs = *aAccess.Get(); |
| |
| while ( !bValidPos || !bValidSize || !bValidPrtArea ) |
| { |
| MakePos(); |
| |
| if ( !bValidSize ) |
| Frm().Width( GetUpper()->Prt().Width() ); |
| |
| MakePrtArea( rAttrs ); |
| |
| if ( !bValidSize ) |
| { bValidSize = sal_True; |
| Format(); |
| } |
| } |
| } |
| |
| /************************************************************************* |
| |* |
| |* SwNoTxtFrm::Format() |
| |* |
| |* Beschreibung Errechne die Groesse der Bitmap, wenn noetig |
| |* Ersterstellung JP 11.03.91 |
| |* Letzte Aenderung MA 13. Mar. 96 |
| |* |
| *************************************************************************/ |
| |
| |
| void SwNoTxtFrm::Format( const SwBorderAttrs * ) |
| { |
| const Size aNewSize( GetSize() ); |
| |
| // hat sich die Hoehe geaendert? |
| SwTwips nChgHght = IsVertical() ? |
| (SwTwips)(aNewSize.Width() - Prt().Width()) : |
| (SwTwips)(aNewSize.Height() - Prt().Height()); |
| if( nChgHght > 0) |
| Grow( nChgHght ); |
| else if( nChgHght < 0) |
| Shrink( Min(Prt().Height(), -nChgHght) ); |
| } |
| |
| /************************************************************************* |
| |* |
| |* SwNoTxtFrm::GetCharRect() |
| |* |
| |* Beschreibung |
| |* Ersterstellung SS 29-Apr-1991 |
| |* Letzte Aenderung MA 10. Oct. 94 |
| |* |
| |*************************************************************************/ |
| |
| |
| sal_Bool SwNoTxtFrm::GetCharRect( SwRect &rRect, const SwPosition& rPos, |
| SwCrsrMoveState *pCMS ) const |
| { |
| if ( &rPos.nNode.GetNode() != (SwNode*)GetNode() ) |
| return sal_False; |
| |
| Calc(); |
| SwRect aFrameRect( Frm() ); |
| rRect = aFrameRect; |
| rRect.Pos( Frm().Pos() + Prt().Pos() ); |
| rRect.SSize( Prt().SSize() ); |
| |
| rRect.Justify(); |
| |
| // liegt die Bitmap ueberhaupt im sichtbaren Berich ? |
| if( !aFrameRect.IsOver( rRect ) ) |
| { |
| // wenn nicht dann steht der Cursor auf dem Frame |
| rRect = aFrameRect; |
| rRect.Width( 1 ); |
| } |
| else |
| rRect._Intersection( aFrameRect ); |
| |
| if ( pCMS ) |
| { |
| if ( pCMS->bRealHeight ) |
| { |
| pCMS->aRealHeight.Y() = rRect.Height(); |
| pCMS->aRealHeight.X() = 0; |
| } |
| } |
| |
| return sal_True; |
| } |
| |
| |
| sal_Bool SwNoTxtFrm::GetCrsrOfst(SwPosition* pPos, Point& , |
| SwCrsrMoveState* ) const |
| { |
| SwCntntNode* pCNd = (SwCntntNode*)GetNode(); |
| pPos->nNode = *pCNd; |
| pPos->nContent.Assign( pCNd, 0 ); |
| return sal_True; |
| } |
| |
| #define CLEARCACHE( pNd ) {\ |
| (pNd)->ReleaseGraphicFromCache();\ |
| SwFlyFrm* pFly = FindFlyFrm();\ |
| if( pFly && pFly->GetFmt()->GetSurround().IsContour() )\ |
| {\ |
| ClrContourCache( pFly->GetVirtDrawObj() );\ |
| pFly->NotifyBackground( FindPageFrm(), Prt(), PREP_FLY_ATTR_CHG );\ |
| }\ |
| } |
| |
| void SwNoTxtFrm::Modify( const SfxPoolItem* pOld, const SfxPoolItem* pNew ) |
| { |
| sal_uInt16 nWhich = pNew ? pNew->Which() : pOld ? pOld->Which() : 0; |
| |
| // --> OD 2007-03-06 #i73788# |
| // no <SwCntntFrm::Modify(..)> for RES_LINKED_GRAPHIC_STREAM_ARRIVED |
| if ( RES_GRAPHIC_PIECE_ARRIVED != nWhich && |
| RES_GRAPHIC_ARRIVED != nWhich && |
| RES_GRF_REREAD_AND_INCACHE != nWhich && |
| RES_LINKED_GRAPHIC_STREAM_ARRIVED != nWhich ) |
| // <-- |
| { |
| SwCntntFrm::Modify( pOld, pNew ); |
| } |
| |
| sal_Bool bComplete = sal_True; |
| |
| switch( nWhich ) |
| { |
| case RES_OBJECTDYING: |
| break; |
| |
| case RES_GRF_REREAD_AND_INCACHE: |
| if( ND_GRFNODE == GetNode()->GetNodeType() ) |
| { |
| bComplete = sal_False; |
| SwGrfNode* pNd = (SwGrfNode*) GetNode(); |
| |
| ViewShell *pVSh = 0; |
| pNd->GetDoc()->GetEditShell( &pVSh ); |
| if( pVSh ) |
| { |
| GraphicAttr aAttr; |
| if( pNd->GetGrfObj().IsCached( pVSh->GetOut(), Point(), |
| Prt().SSize(), &pNd->GetGraphicAttr( aAttr, this ) )) |
| { |
| ViewShell *pSh = pVSh; |
| do { |
| SET_CURR_SHELL( pSh ); |
| if( pSh->GetWin() ) |
| { |
| if( pSh->IsPreView() ) |
| ::RepaintPagePreview( pSh, Frm().SVRect() ); |
| else |
| pSh->GetWin()->Invalidate( Frm().SVRect() ); |
| } |
| } while( pVSh != (pSh = (ViewShell*)pSh->GetNext() )); |
| } |
| else |
| pNd->SwapIn(); |
| } |
| } |
| break; |
| |
| case RES_UPDATE_ATTR: |
| case RES_FMT_CHG: |
| CLEARCACHE( (SwGrfNode*) GetNode() ) |
| break; |
| |
| case RES_ATTRSET_CHG: |
| { |
| sal_uInt16 n; |
| for( n = RES_GRFATR_BEGIN; n < RES_GRFATR_END; ++n ) |
| if( SFX_ITEM_SET == ((SwAttrSetChg*)pOld)->GetChgSet()-> |
| GetItemState( n, sal_False )) |
| { |
| CLEARCACHE( (SwGrfNode*) GetNode() ) |
| break; |
| } |
| if( RES_GRFATR_END == n ) // not found |
| return ; |
| } |
| break; |
| |
| case RES_GRAPHIC_PIECE_ARRIVED: |
| case RES_GRAPHIC_ARRIVED: |
| // --> OD 2007-03-06 #i73788# |
| // handle RES_LINKED_GRAPHIC_STREAM_ARRIVED as RES_GRAPHIC_ARRIVED |
| case RES_LINKED_GRAPHIC_STREAM_ARRIVED: |
| // <-- |
| if ( GetNode()->GetNodeType() == ND_GRFNODE ) |
| { |
| bComplete = sal_False; |
| SwGrfNode* pNd = (SwGrfNode*) GetNode(); |
| |
| CLEARCACHE( pNd ) |
| |
| SwRect aRect( Frm() ); |
| |
| ViewShell *pVSh = 0; |
| pNd->GetDoc()->GetEditShell( &pVSh ); |
| if( !pVSh ) |
| break; |
| |
| ViewShell *pSh = pVSh; |
| do { |
| SET_CURR_SHELL( pSh ); |
| if( pSh->IsPreView() ) |
| { |
| if( pSh->GetWin() ) |
| ::RepaintPagePreview( pSh, aRect ); |
| } |
| else if ( pSh->VisArea().IsOver( aRect ) && |
| OUTDEV_WINDOW == pSh->GetOut()->GetOutDevType() ) |
| { |
| // OD 27.11.2002 #105519# - invalidate instead of painting |
| pSh->GetWin()->Invalidate( aRect.SVRect() ); |
| } |
| |
| pSh = (ViewShell *)pSh->GetNext(); |
| } while( pSh != pVSh ); |
| } |
| break; |
| |
| default: |
| if ( !pNew || !isGRFATR(nWhich) ) |
| return; |
| } |
| |
| if( bComplete ) |
| { |
| InvalidatePrt(); |
| SetCompletePaint(); |
| } |
| } |
| |
| void lcl_correctlyAlignRect( SwRect& rAlignedGrfArea, const SwRect& rInArea, OutputDevice* pOut ) |
| { |
| |
| if(!pOut) |
| return; |
| Rectangle aPxRect = pOut->LogicToPixel( rInArea.SVRect() ); |
| Rectangle aNewPxRect( aPxRect ); |
| while( aNewPxRect.Left() < aPxRect.Left() ) |
| { |
| rAlignedGrfArea.Left( rAlignedGrfArea.Left()+1 ); |
| aNewPxRect = pOut->LogicToPixel( rAlignedGrfArea.SVRect() ); |
| } |
| while( aNewPxRect.Top() < aPxRect.Top() ) |
| { |
| rAlignedGrfArea.Top( rAlignedGrfArea.Top()+1 ); |
| aNewPxRect = pOut->LogicToPixel( rAlignedGrfArea.SVRect() ); |
| } |
| while( aNewPxRect.Bottom() > aPxRect.Bottom() ) |
| { |
| rAlignedGrfArea.Bottom( rAlignedGrfArea.Bottom()-1 ); |
| aNewPxRect = pOut->LogicToPixel( rAlignedGrfArea.SVRect() ); |
| } |
| while( aNewPxRect.Right() > aPxRect.Right() ) |
| { |
| rAlignedGrfArea.Right( rAlignedGrfArea.Right()-1 ); |
| aNewPxRect = pOut->LogicToPixel( rAlignedGrfArea.SVRect() ); |
| } |
| } |
| |
| bool paintUsingPrimitivesHelper( |
| OutputDevice& rOutputDevice, |
| const drawinglayer::primitive2d::Primitive2DSequence& rSequence, |
| const basegfx::B2DRange& rSourceRange, |
| const basegfx::B2DRange& rTargetRange) |
| { |
| if(rSequence.hasElements() && !basegfx::fTools::equalZero(rSourceRange.getWidth()) && !basegfx::fTools::equalZero(rSourceRange.getHeight())) |
| { |
| if(!basegfx::fTools::equalZero(rTargetRange.getWidth()) && !basegfx::fTools::equalZero(rTargetRange.getHeight())) |
| { |
| // map graphic range to target range. This will e.g. automatically include |
| // tme mapping from 1/100th mm content to twips if needed when the target |
| // range is defined in twips |
| const basegfx::B2DHomMatrix aMappingTransform( |
| basegfx::tools::createSourceRangeTargetRangeTransform( |
| rSourceRange, |
| rTargetRange)); |
| |
| // Fill ViewInformation. Use MappingTransform here, so there is no need to |
| // embed the primitives to it. Use original TargetRange here so there is also |
| // no need to embed the primitives to a MaskPrimitive for cropping. This works |
| // only in this case where the graphic object cannot be rotated, though. |
| const drawinglayer::geometry::ViewInformation2D aViewInformation2D( |
| aMappingTransform, |
| rOutputDevice.GetViewTransformation(), |
| rTargetRange, |
| 0, |
| 0.0, |
| uno::Sequence< beans::PropertyValue >()); |
| |
| // get a primitive processor for rendering |
| drawinglayer::processor2d::BaseProcessor2D* pProcessor2D = drawinglayer::processor2d::createProcessor2DFromOutputDevice( |
| rOutputDevice, |
| aViewInformation2D); |
| |
| if(pProcessor2D) |
| { |
| // render and cleanup |
| pProcessor2D->process(rSequence); |
| delete pProcessor2D; |
| return true; |
| } |
| } |
| } |
| |
| return false; |
| } |
| |
| // Ausgabe der Grafik. Hier wird entweder eine QuickDraw-Bmp oder |
| // eine Grafik vorausgesetzt. Ist nichts davon vorhanden, wird |
| // eine Ersatzdarstellung ausgegeben. |
| /// OD 25.09.2002 #99739# - delete unused 3rd parameter. |
| /// OD 25.09.2002 #99739# - use aligned rectangle for drawing graphic. |
| /// OD 25.09.2002 #99739# - pixel-align coordinations for drawing graphic. |
| void SwNoTxtFrm::PaintPicture( OutputDevice* pOut, const SwRect &rGrfArea ) const |
| { |
| ViewShell* pShell = getRootFrm()->GetCurrShell(); |
| |
| SwNoTxtNode& rNoTNd = *(SwNoTxtNode*)GetNode(); |
| SwGrfNode* pGrfNd = rNoTNd.GetGrfNode(); |
| SwOLENode* pOLENd = rNoTNd.GetOLENode(); |
| |
| const sal_Bool bPrn = pOut == rNoTNd.getIDocumentDeviceAccess()->getPrinter( false ) || |
| pOut->GetConnectMetaFile(); |
| |
| const bool bIsChart = pOLENd && ChartHelper::IsChart( pOLENd->GetOLEObj().GetObject() ); |
| |
| /// OD 25.09.2002 #99739# - calculate aligned rectangle from parameter <rGrfArea>. |
| /// Use aligned rectangle <aAlignedGrfArea> instead of <rGrfArea> in |
| /// the following code. |
| SwRect aAlignedGrfArea = rGrfArea; |
| ::SwAlignRect( aAlignedGrfArea, pShell ); |
| |
| if( !bIsChart ) |
| { |
| /// OD 25.09.2002 #99739# |
| /// Because for drawing a graphic left-top-corner and size coordinations are |
| /// used, these coordinations have to be determined on pixel level. |
| ::SwAlignGrfRect( &aAlignedGrfArea, *pOut ); |
| } |
| else //if( bIsChart ) |
| { |
| //#i78025# charts own borders are not completely visible |
| //the above pixel correction is not correct - at least not for charts |
| //so a different pixel correction is choosen here |
| //this might be a good idea for all other OLE objects also, |
| //but as I cannot oversee the consequences I fix it only for charts for now |
| lcl_correctlyAlignRect( aAlignedGrfArea, rGrfArea, pOut ); |
| } |
| |
| if( pGrfNd ) |
| { |
| sal_Bool bForceSwap = sal_False, bContinue = sal_True; |
| const GraphicObject& rGrfObj = pGrfNd->GetGrfObj(); |
| |
| GraphicAttr aGrfAttr; |
| pGrfNd->GetGraphicAttr( aGrfAttr, this ); |
| |
| if( !bPrn ) |
| { |
| // --> OD 2007-01-02 #i73788# |
| if ( pGrfNd->IsLinkedInputStreamReady() ) |
| { |
| pGrfNd->UpdateLinkWithInputStream(); |
| } |
| // <-- |
| // --> OD 2008-01-30 #i85717# |
| // --> OD 2008-07-21 #i90395# - check, if asynchronous retrieval |
| // if input stream for the graphic is possible |
| // else if( GRAPHIC_DEFAULT == rGrfObj.GetType() && |
| else if ( ( rGrfObj.GetType() == GRAPHIC_DEFAULT || |
| rGrfObj.GetType() == GRAPHIC_NONE ) && |
| pGrfNd->IsLinkedFile() && |
| pGrfNd->IsAsyncRetrieveInputStreamPossible() ) |
| // <-- |
| { |
| Size aTmpSz; |
| ::sfx2::SvLinkSource* pGrfObj = pGrfNd->GetLink()->GetObj(); |
| if( !pGrfObj || |
| !pGrfObj->IsDataComplete() || |
| !(aTmpSz = pGrfNd->GetTwipSize()).Width() || |
| !aTmpSz.Height() || !pGrfNd->GetAutoFmtLvl() ) |
| { |
| // --> OD 2006-12-22 #i73788# |
| pGrfNd->TriggerAsyncRetrieveInputStream(); |
| // <-- |
| } |
| String aTxt( pGrfNd->GetTitle() ); |
| if ( !aTxt.Len() ) |
| GetRealURL( *pGrfNd, aTxt ); |
| ::lcl_PaintReplacement( aAlignedGrfArea, aTxt, *pShell, this, sal_False ); |
| bContinue = sal_False; |
| } |
| } |
| |
| if( bContinue ) |
| { |
| const sal_Bool bSwapped = rGrfObj.IsSwappedOut(); |
| const sal_Bool bSwappedIn = 0 != pGrfNd->SwapIn( bPrn ); |
| if( bSwappedIn && rGrfObj.GetGraphic().IsSupportedGraphic()) |
| { |
| const sal_Bool bAnimate = rGrfObj.IsAnimated() && |
| !pShell->IsPreView() && |
| !pShell->GetAccessibilityOptions()->IsStopAnimatedGraphics() && |
| // --> FME 2004-06-21 #i9684# Stop animation during printing/pdf export |
| pShell->GetWin(); |
| // <-- |
| |
| if( bAnimate && |
| FindFlyFrm() != ::GetFlyFromMarked( 0, pShell )) |
| { |
| OutputDevice* pVout; |
| if( pOut == pShell->GetOut() && SwRootFrm::FlushVout() ) |
| pVout = pOut, pOut = pShell->GetOut(); |
| else if( pShell->GetWin() && |
| OUTDEV_VIRDEV == pOut->GetOutDevType() ) |
| pVout = pOut, pOut = pShell->GetWin(); |
| else |
| pVout = 0; |
| |
| ASSERT( OUTDEV_VIRDEV != pOut->GetOutDevType() || |
| pShell->GetViewOptions()->IsPDFExport(), |
| "pOut sollte kein virtuelles Device sein" ); |
| |
| pGrfNd->StartGraphicAnimation(pOut, aAlignedGrfArea.Pos(), |
| aAlignedGrfArea.SSize(), long(this), |
| 0, GRFMGR_DRAW_STANDARD, pVout ); |
| } |
| else |
| { |
| // unify using GraphicPrimitive2D |
| // -> the primitive handles all crop and mirror stuff |
| // -> the primitive renderer will create the needed pdf export data |
| // -> if bitmap conent, it will be cached system-dependent |
| const basegfx::B2DRange aTargetRange( |
| aAlignedGrfArea.Left(), aAlignedGrfArea.Top(), |
| aAlignedGrfArea.Right(), aAlignedGrfArea.Bottom()); |
| const basegfx::B2DHomMatrix aTargetTransform( |
| basegfx::tools::createScaleTranslateB2DHomMatrix( |
| aTargetRange.getRange(), |
| aTargetRange.getMinimum())); |
| drawinglayer::primitive2d::Primitive2DSequence aContent(1); |
| bool bDone(false); |
| |
| // #i125171# The mechanism to get lossless jpegs into pdf is based on having the original |
| // file data (not the bitmap data) at the Graphic in the GfxLink (which has *nothing* to |
| // do with the graphic being linked). This works well for DrawingLayer GraphicObjects (linked |
| // and unlinked) but fails for linked Writer GraphicObjects. These have the URL in the |
| // GraphicObject, but no GfxLink with the original file data when it's a linked graphic. |
| // Since this blows up PDF size by a factor of 10 (the graphics get embedded as pixel maps |
| // then) it is okay to add this workarund: In the needed case, load the graphic in a way to |
| // get the GfxLink in the needed form and use that Graphic temporarily. Do this only when |
| // - we have PDF export |
| // - the GraphicObject is linked |
| // - the Graphic has no GfxLink |
| // - LosslessCompression is activated |
| // - it's indeed a jpeg graphic (could be checked by the url ending, but is more reliable to check later) |
| // In all other cases (normal repaint, print, etc...) use the available Graphic with the |
| // already loaded pixel graphic as before this change. |
| if(pOut->GetExtOutDevData() && rGrfObj.HasLink() && !rGrfObj.GetGraphic().IsLink()) |
| { |
| const vcl::PDFExtOutDevData* pPDFExt = dynamic_cast< const vcl::PDFExtOutDevData* >(pOut->GetExtOutDevData()); |
| |
| if(pPDFExt && pPDFExt->GetIsLosslessCompression()) |
| { |
| Graphic aTempGraphic; |
| INetURLObject aURL(rGrfObj.GetLink()); |
| |
| if(GRFILTER_OK == GraphicFilter::GetGraphicFilter()->ImportGraphic(aTempGraphic, aURL)) |
| { |
| if(aTempGraphic.IsLink() && GFX_LINK_TYPE_NATIVE_JPG == aTempGraphic.GetLink().GetType()) |
| { |
| aContent[0] = new drawinglayer::primitive2d::GraphicPrimitive2D( |
| aTargetTransform, |
| aTempGraphic, |
| aGrfAttr); |
| bDone = true; |
| } |
| } |
| } |
| } |
| |
| if(!bDone) |
| { |
| aContent[0] = new drawinglayer::primitive2d::GraphicPrimitive2D( |
| aTargetTransform, |
| rGrfObj.GetGraphic(), |
| aGrfAttr); |
| } |
| |
| paintUsingPrimitivesHelper( |
| *pOut, |
| aContent, |
| aTargetRange, |
| aTargetRange); |
| |
| // need to reset the timer manually (was in original paints at GraphicManager) |
| rGrfObj.restartSwapOutTimer(); |
| } |
| } |
| else |
| { |
| sal_uInt16 nResId = 0; |
| if( bSwappedIn ) |
| { |
| if( GRAPHIC_NONE == rGrfObj.GetType() ) |
| nResId = STR_COMCORE_READERROR; |
| else if ( !rGrfObj.GetGraphic().IsSupportedGraphic() ) |
| nResId = STR_COMCORE_CANT_SHOW; |
| } |
| ((SwNoTxtFrm*)this)->nWeight = -1; |
| String aText; |
| if ( !nResId && |
| !(aText = pGrfNd->GetTitle()).Len() && |
| (!GetRealURL( *pGrfNd, aText ) || !aText.Len())) |
| { |
| nResId = STR_COMCORE_READERROR; |
| } |
| if ( nResId ) |
| aText = SW_RESSTR( nResId ); |
| |
| ::lcl_PaintReplacement( aAlignedGrfArea, aText, *pShell, this, sal_True ); |
| } |
| |
| //Beim Drucken duerfen wir nicht die Grafiken sammeln... |
| if( bSwapped && bPrn ) |
| bForceSwap = sal_True; |
| } |
| if( bForceSwap ) |
| pGrfNd->SwapOut(); |
| } |
| else // bIsChart || pOLENd |
| { |
| // --> OD 2009-03-05 #i99665# |
| // Adjust AntiAliasing mode at output device for chart OLE |
| const sal_uInt16 nFormerAntialiasingAtOutput( pOut->GetAntialiasing() ); |
| if ( pOLENd->IsChart() && |
| pShell->Imp()->GetDrawView()->IsAntiAliasing() ) |
| { |
| const sal_uInt16 nAntialiasingForChartOLE = |
| nFormerAntialiasingAtOutput | ANTIALIASING_PIXELSNAPHAIRLINE; |
| pOut->SetAntialiasing( nAntialiasingForChartOLE ); |
| } |
| // <-- |
| |
| bool bDone(false); |
| |
| if(bIsChart) |
| { |
| const uno::Reference< frame::XModel > aXModel(pOLENd->GetOLEObj().GetOleRef()->getComponent(), uno::UNO_QUERY); |
| |
| if(aXModel.is()) |
| { |
| basegfx::B2DRange aSourceRange; |
| |
| const drawinglayer::primitive2d::Primitive2DSequence aSequence( |
| ChartHelper::tryToGetChartContentAsPrimitive2DSequence( |
| aXModel, |
| aSourceRange)); |
| |
| if(aSequence.hasElements() && !aSourceRange.isEmpty()) |
| { |
| const basegfx::B2DRange aTargetRange( |
| aAlignedGrfArea.Left(), aAlignedGrfArea.Top(), |
| aAlignedGrfArea.Right(), aAlignedGrfArea.Bottom()); |
| |
| bDone = paintUsingPrimitivesHelper( |
| *pOut, |
| aSequence, |
| aSourceRange, |
| aTargetRange); |
| } |
| } |
| } |
| |
| if(!bDone && pOLENd) |
| { |
| Point aPosition(aAlignedGrfArea.Pos()); |
| Size aSize(aAlignedGrfArea.SSize()); |
| |
| // Im BrowseModus gibt es nicht unbedingt einen Drucker und |
| // damit kein JobSetup, also legen wir eines an ... |
| const JobSetup* pJobSetup = pOLENd->getIDocumentDeviceAccess()->getJobsetup(); |
| sal_Bool bDummyJobSetup = 0 == pJobSetup; |
| if( bDummyJobSetup ) |
| pJobSetup = new JobSetup(); |
| |
| // #i42323# |
| // The reason for #114233# is gone, so i remove it again |
| //TODO/LATER: is it a problem that the JopSetup isn't used? |
| //xRef->DoDraw( pOut, aAlignedGrfArea.Pos(), aAlignedGrfArea.SSize(), *pJobSetup ); |
| |
| // get hi-contrast image, but never for printing |
| Graphic* pGraphic = NULL; |
| if (pOut && !bPrn && Application::GetSettings().GetStyleSettings().GetHighContrastMode() ) |
| pGraphic = pOLENd->GetHCGraphic(); |
| |
| // when it is not possible to get HC-representation, the original image should be used |
| if ( !pGraphic ) |
| pGraphic = pOLENd->GetGraphic(); |
| |
| if ( pGraphic && pGraphic->GetType() != GRAPHIC_NONE ) |
| { |
| pGraphic->Draw( pOut, aPosition, aSize ); |
| |
| // shade the representation if the object is activated outplace |
| uno::Reference < embed::XEmbeddedObject > xObj = pOLENd->GetOLEObj().GetOleRef(); |
| if ( xObj.is() && xObj->getCurrentState() == embed::EmbedStates::ACTIVE ) |
| { |
| ::svt::EmbeddedObjectRef::DrawShading( Rectangle( aPosition, aSize ), pOut ); |
| } |
| } |
| else |
| ::svt::EmbeddedObjectRef::DrawPaintReplacement( Rectangle( aPosition, aSize ), pOLENd->GetOLEObj().GetCurrentPersistName(), pOut ); |
| |
| if( bDummyJobSetup ) |
| delete pJobSetup; // ... und raeumen wieder auf. |
| |
| sal_Int64 nMiscStatus = pOLENd->GetOLEObj().GetOleRef()->getStatus( pOLENd->GetAspect() ); |
| if ( !bPrn && pShell->ISA( SwCrsrShell ) && |
| nMiscStatus & embed::EmbedMisc::MS_EMBED_ACTIVATEWHENVISIBLE ) |
| { |
| const SwFlyFrm *pFly = FindFlyFrm(); |
| ASSERT( pFly, "OLE not in FlyFrm" ); |
| ((SwFEShell*)pShell)->ConnectObj( pOLENd->GetOLEObj().GetObject(), pFly->Prt(), pFly->Frm()); |
| } |
| } |
| |
| // --> OD 2009-03-05 #i99665# |
| if ( pOLENd->IsChart() && |
| pShell->Imp()->GetDrawView()->IsAntiAliasing() ) |
| { |
| pOut->SetAntialiasing( nFormerAntialiasingAtOutput ); |
| } |
| // <-- |
| } |
| } |
| |
| |
| sal_Bool SwNoTxtFrm::IsTransparent() const |
| { |
| const ViewShell* pSh = getRootFrm()->GetCurrShell(); |
| if ( !pSh || !pSh->GetViewOptions()->IsGraphic() ) |
| return sal_True; |
| |
| const SwGrfNode *pNd; |
| if( 0 != (pNd = GetNode()->GetGrfNode()) ) |
| return pNd->IsTransparent(); |
| |
| //#29381# OLE sind immer Transparent. |
| return sal_True; |
| } |
| |
| |
| void SwNoTxtFrm::StopAnimation( OutputDevice* pOut ) const |
| { |
| //animierte Grafiken anhalten |
| const SwGrfNode* pGrfNd = dynamic_cast< const SwGrfNode* >(GetNode()->GetGrfNode()); |
| |
| if( pGrfNd && pGrfNd->IsAnimated() ) |
| { |
| const_cast< SwGrfNode* >(pGrfNd)->StopGraphicAnimation( pOut, long(this) ); |
| } |
| } |
| |
| |
| sal_Bool SwNoTxtFrm::HasAnimation() const |
| { |
| const SwGrfNode* pGrfNd = GetNode()->GetGrfNode(); |
| return pGrfNd && pGrfNd->IsAnimated(); |
| } |
| |
| |
| |
