LCOV - code coverage report
Current view: top level - sw/source/core/docnode - ndnotxt.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 81 136 59.6 %
Date: 2014-11-03 Functions: 15 20 75.0 %
Legend: Lines: hit not hit

          Line data    Source code
       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/poly.hxx>
      22             : #include <svl/stritem.hxx>
      23             : #include <svx/contdlg.hxx>
      24             : #include <vcl/svapp.hxx>
      25             : #include <docary.hxx>
      26             : #include <doc.hxx>
      27             : #include <fmtcol.hxx>
      28             : #include <ndnotxt.hxx>
      29             : #include <ndgrf.hxx>
      30             : #include <ndole.hxx>
      31             : #include <ndindex.hxx>
      32             : #include <hints.hxx>
      33             : #include <istyleaccess.hxx>
      34             : #include <SwStyleNameMapper.hxx>
      35             : 
      36             : #include <frmfmt.hxx>
      37             : 
      38        1992 : SwNoTxtNode::SwNoTxtNode( const SwNodeIndex & rWhere,
      39             :                   const sal_uInt8 nNdType,
      40             :                   SwGrfFmtColl *pGrfColl,
      41             :                   SwAttrSet* pAutoAttr ) :
      42             :     SwCntntNode( rWhere, nNdType, pGrfColl ),
      43             :     pContour( 0 ),
      44             :     bAutomaticContour( false ),
      45             :     bContourMapModeValid( true ),
      46        1992 :     bPixelContour( false )
      47             : {
      48             :     // Should this set a hard attribute?
      49        1992 :     if( pAutoAttr )
      50         278 :         SetAttr( *pAutoAttr );
      51        1992 : }
      52             : 
      53        3984 : SwNoTxtNode::~SwNoTxtNode()
      54             : {
      55        1992 :     delete pContour;
      56        1992 : }
      57             : 
      58             : /// Creates an AttrSet for all derivations with ranges for frame-
      59             : /// and graphics-attributes.
      60        1096 : void SwNoTxtNode::NewAttrSet( SwAttrPool& rPool )
      61             : {
      62             :     OSL_ENSURE( !mpAttrSet.get(), "AttrSet is already set" );
      63        1096 :     SwAttrSet aNewAttrSet( rPool, aNoTxtNodeSetRange );
      64             : 
      65             :     // put names of parent style and conditional style:
      66        1096 :     const SwFmtColl* pFmtColl = GetFmtColl();
      67        2192 :     OUString sVal;
      68        1096 :     SwStyleNameMapper::FillProgName( pFmtColl->GetName(), sVal, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL, true );
      69        2192 :     SfxStringItem aFmtColl( RES_FRMATR_STYLE_NAME, sVal );
      70        1096 :     aNewAttrSet.Put( aFmtColl );
      71             : 
      72        1096 :     aNewAttrSet.SetParent( &GetFmtColl()->GetAttrSet() );
      73        2192 :     mpAttrSet = GetDoc()->GetIStyleAccess().getAutomaticStyle( aNewAttrSet, IStyleAccess::AUTO_STYLE_NOTXT );
      74        1096 : }
      75             : 
      76             : /// Dummies for loading/saving of persistent data
      77             : /// when working with graphics and OLE objects
      78           0 : bool SwNoTxtNode::RestorePersistentData()
      79             : {
      80           0 :     return true;
      81             : }
      82             : 
      83           0 : bool SwNoTxtNode::SavePersistentData()
      84             : {
      85           0 :     return true;
      86             : }
      87             : 
      88         454 : void SwNoTxtNode::SetContour( const tools::PolyPolygon *pPoly, bool bAutomatic )
      89             : {
      90         454 :     delete pContour;
      91         454 :     if ( pPoly )
      92          14 :         pContour = new tools::PolyPolygon( *pPoly );
      93             :     else
      94         440 :         pContour = 0;
      95         454 :     bAutomaticContour = bAutomatic;
      96         454 :     bContourMapModeValid = true;
      97         454 :     bPixelContour = false;
      98         454 : }
      99             : 
     100           0 : void SwNoTxtNode::CreateContour()
     101             : {
     102             :     OSL_ENSURE( !pContour, "Contour available." );
     103           0 :     pContour = new tools::PolyPolygon(SvxContourDlg::CreateAutoContour(GetGraphic()));
     104           0 :     bAutomaticContour = true;
     105           0 :     bContourMapModeValid = true;
     106           0 :     bPixelContour = false;
     107           0 : }
     108             : 
     109         418 : const tools::PolyPolygon *SwNoTxtNode::HasContour() const
     110             : {
     111         418 :     if( !bContourMapModeValid )
     112             :     {
     113          20 :         const MapMode aGrfMap( GetGraphic().GetPrefMapMode() );
     114          20 :         bool bPixelGrf = aGrfMap.GetMapUnit() == MAP_PIXEL;
     115          40 :         const MapMode aContourMap( bPixelGrf ? MAP_PIXEL : MAP_100TH_MM );
     116          20 :         if( bPixelGrf ? !bPixelContour : aGrfMap != aContourMap )
     117             :         {
     118             :             // #i102238#
     119           0 :             double nGrfDPIx = 0.0;
     120           0 :             double nGrfDPIy = 0.0;
     121             :             {
     122           0 :                 if ( !bPixelGrf && bPixelContour )
     123             :                 {
     124           0 :                     const Size aGrfPixelSize( GetGraphic().GetSizePixel() );
     125           0 :                     const Size aGrfPrefMapModeSize( GetGraphic().GetPrefSize() );
     126           0 :                     if ( aGrfMap.GetMapUnit() == MAP_INCH )
     127             :                     {
     128           0 :                         nGrfDPIx = aGrfPixelSize.Width() / ( (double)aGrfMap.GetScaleX() * aGrfPrefMapModeSize.Width() );
     129           0 :                         nGrfDPIy = aGrfPixelSize.Height() / ( (double)aGrfMap.GetScaleY() * aGrfPrefMapModeSize.Height() );
     130             :                     }
     131             :                     else
     132             :                     {
     133             :                         const Size aGrf1000thInchSize =
     134             :                             OutputDevice::LogicToLogic( aGrfPrefMapModeSize,
     135           0 :                                                         aGrfMap, MAP_1000TH_INCH );
     136           0 :                         nGrfDPIx = 1000.0 * aGrfPixelSize.Width() / aGrf1000thInchSize.Width();
     137           0 :                         nGrfDPIy = 1000.0 * aGrfPixelSize.Height() / aGrf1000thInchSize.Height();
     138             :                     }
     139             :                 }
     140             :             }
     141             :             OSL_ENSURE( !bPixelGrf || aGrfMap == aContourMap,
     142             :                         "scale factor for pixel unsupported" );
     143             :             OutputDevice* pOutDev =
     144           0 :                 (bPixelGrf || bPixelContour) ? Application::GetDefaultDevice()
     145           0 :                                              : 0;
     146           0 :             sal_uInt16 nPolyCount = pContour->Count();
     147           0 :             for( sal_uInt16 j=0; j<nPolyCount; j++ )
     148             :             {
     149           0 :                 Polygon& rPoly = (*pContour)[j];
     150             : 
     151           0 :                 sal_uInt16 nCount = rPoly.GetSize();
     152           0 :                 for( sal_uInt16 i=0 ; i<nCount; i++ )
     153             :                 {
     154           0 :                     if( bPixelGrf )
     155           0 :                         rPoly[i] = pOutDev->LogicToPixel( rPoly[i],
     156           0 :                                                           aContourMap );
     157           0 :                     else if( bPixelContour )
     158             :                     {
     159           0 :                         rPoly[i] = pOutDev->PixelToLogic( rPoly[i], aGrfMap );
     160             :                         // #i102238#
     161           0 :                         if ( nGrfDPIx != 0 && nGrfDPIy != 0 )
     162             :                         {
     163           0 :                             rPoly[i] = Point( rPoly[i].getX() * pOutDev->GetDPIX() / nGrfDPIx,
     164           0 :                                               rPoly[i].getY() * pOutDev->GetDPIY() / nGrfDPIy );
     165             :                         }
     166             :                     }
     167             :                     else
     168           0 :                         rPoly[i] = OutputDevice::LogicToLogic( rPoly[i],
     169             :                                                                  aContourMap,
     170           0 :                                                                  aGrfMap );
     171             :                 }
     172             :             }
     173             :         }
     174          20 :         ((SwNoTxtNode *)this)->bContourMapModeValid = true;
     175          40 :         ((SwNoTxtNode *)this)->bPixelContour = false;
     176             :     }
     177             : 
     178         418 :     return pContour;
     179             : }
     180             : 
     181          12 : void SwNoTxtNode::GetContour( tools::PolyPolygon &rPoly ) const
     182             : {
     183             :     OSL_ENSURE( pContour, "Contour not available." );
     184          12 :     rPoly = *HasContour();
     185          12 : }
     186             : 
     187          20 : void SwNoTxtNode::SetContourAPI( const tools::PolyPolygon *pPoly )
     188             : {
     189          20 :     delete pContour;
     190          20 :     if ( pPoly )
     191          20 :         pContour = new tools::PolyPolygon( *pPoly );
     192             :     else
     193           0 :         pContour = 0;
     194          20 :     bContourMapModeValid = false;
     195          20 : }
     196             : 
     197          32 : bool SwNoTxtNode::GetContourAPI( tools::PolyPolygon &rContour ) const
     198             : {
     199          32 :     if( !pContour )
     200          22 :         return false;
     201             : 
     202          10 :     rContour = *pContour;
     203          10 :     if( bContourMapModeValid )
     204             :     {
     205          10 :         const MapMode aGrfMap( GetGraphic().GetPrefMapMode() );
     206          20 :         const MapMode aContourMap( MAP_100TH_MM );
     207             :         OSL_ENSURE( aGrfMap.GetMapUnit() != MAP_PIXEL ||
     208             :                 aGrfMap == MapMode( MAP_PIXEL ),
     209             :                     "scale factor for pixel unsupported" );
     210          20 :         if( aGrfMap.GetMapUnit() != MAP_PIXEL &&
     211          10 :             aGrfMap != aContourMap )
     212             :         {
     213           0 :             sal_uInt16 nPolyCount = rContour.Count();
     214           0 :             for( sal_uInt16 j=0; j<nPolyCount; j++ )
     215             :             {
     216             :                 // --> OD #i102238# - use the right <tools::PolyPolygon> instance
     217           0 :                 Polygon& rPoly = rContour[j];
     218             :                 // <--
     219             : 
     220           0 :                 sal_uInt16 nCount = rPoly.GetSize();
     221           0 :                 for( sal_uInt16 i=0 ; i<nCount; i++ )
     222             :                 {
     223           0 :                     rPoly[i] = OutputDevice::LogicToLogic( rPoly[i], aGrfMap,
     224           0 :                                                            aContourMap );
     225             :                 }
     226             :             }
     227          10 :         }
     228             :     }
     229             : 
     230          10 :     return true;
     231             : }
     232             : 
     233           0 : bool SwNoTxtNode::IsPixelContour() const
     234             : {
     235             :     bool bRet;
     236           0 :     if( bContourMapModeValid )
     237             :     {
     238           0 :         const MapMode aGrfMap( GetGraphic().GetPrefMapMode() );
     239           0 :         bRet = aGrfMap.GetMapUnit() == MAP_PIXEL;
     240             :     }
     241             :     else
     242             :     {
     243           0 :         bRet = bPixelContour;
     244             :     }
     245             : 
     246           0 :     return bRet;
     247             : }
     248             : 
     249          60 : Graphic SwNoTxtNode::GetGraphic() const
     250             : {
     251          60 :     Graphic aRet;
     252          60 :     if ( GetGrfNode() )
     253             :     {
     254          60 :         ((SwGrfNode*)this)->SwapIn( true );
     255          60 :         aRet = ((SwGrfNode*)this)->GetGrf();
     256             :     }
     257             :     else
     258             :     {
     259             :         OSL_ENSURE( GetOLENode(), "new type of Node?" );
     260           0 :         aRet = *((SwOLENode*)this)->SwOLENode::GetGraphic();
     261             :     }
     262          60 :     return aRet;
     263             : }
     264             : 
     265             : // #i73249#
     266         318 : void SwNoTxtNode::SetTitle( const OUString& rTitle, bool bBroadcast )
     267             : {
     268             :     // Title attribute of <SdrObject> replaces own AlternateText attribute
     269         318 :     SwFlyFrmFmt* pFlyFmt = dynamic_cast<SwFlyFrmFmt*>(GetFlyFmt());
     270             :     OSL_ENSURE( pFlyFmt, "<SwNoTxtNode::SetTitle(..)> - missing <SwFlyFrmFmt> instance" );
     271         318 :     if ( !pFlyFmt )
     272             :     {
     273         318 :         return;
     274             :     }
     275             : 
     276         318 :     pFlyFmt->SetObjTitle( rTitle, bBroadcast );
     277             : }
     278             : 
     279         470 : OUString SwNoTxtNode::GetTitle() const
     280             : {
     281         470 :     const SwFlyFrmFmt* pFlyFmt = dynamic_cast<const SwFlyFrmFmt*>(GetFlyFmt());
     282             :     OSL_ENSURE( pFlyFmt, "<SwNoTxtNode::GetTitle(..)> - missing <SwFlyFrmFmt> instance" );
     283         470 :     if ( !pFlyFmt )
     284             :     {
     285           0 :         return OUString();
     286             :     }
     287             : 
     288         470 :     return pFlyFmt->GetObjTitle();
     289             : }
     290             : 
     291         316 : void SwNoTxtNode::SetDescription( const OUString& rDescription, bool bBroadcast )
     292             : {
     293         316 :     SwFlyFrmFmt* pFlyFmt = dynamic_cast<SwFlyFrmFmt*>(GetFlyFmt());
     294             :     OSL_ENSURE( pFlyFmt, "<SwNoTxtNode::SetDescription(..)> - missing <SwFlyFrmFmt> instance" );
     295         316 :     if ( !pFlyFmt )
     296             :     {
     297         316 :         return;
     298             :     }
     299             : 
     300         316 :     pFlyFmt->SetObjDescription( rDescription, bBroadcast );
     301             : }
     302             : 
     303         388 : OUString SwNoTxtNode::GetDescription() const
     304             : {
     305         388 :     const SwFlyFrmFmt* pFlyFmt = dynamic_cast<const SwFlyFrmFmt*>(GetFlyFmt());
     306             :     OSL_ENSURE( pFlyFmt, "<SwNoTxtNode::GetDescription(..)> - missing <SwFlyFrmFmt> instance" );
     307         388 :     if ( !pFlyFmt )
     308             :     {
     309           0 :         return OUString();
     310             :     }
     311             : 
     312         388 :     return pFlyFmt->GetObjDescription();
     313         270 : }
     314             : 
     315             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10