LCOV - code coverage report
Current view: top level - chart2/source/controller/itemsetwrapper - GraphicPropertyItemConverter.cxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 0 342 0.0 %
Date: 2015-06-13 12:38:46 Functions: 0 14 0.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 "GraphicPropertyItemConverter.hxx"
      21             : #include "SchWhichPairs.hxx"
      22             : #include "macros.hxx"
      23             : #include "ItemPropertyMap.hxx"
      24             : #include "PropertyHelper.hxx"
      25             : #include "CommonConverters.hxx"
      26             : #include <editeng/memberids.hrc>
      27             : #include <svx/xflclit.hxx>
      28             : #include <svx/xlnclit.hxx>
      29             : #include <svx/xflbmtit.hxx>
      30             : #include <svx/xflbstit.hxx>
      31             : #include <svx/xbtmpit.hxx>
      32             : #include <svx/xflftrit.hxx>
      33             : #include <svx/xlndsit.hxx>
      34             : #include <svx/xflhtit.hxx>
      35             : #include <svx/xflgrit.hxx>
      36             : #include <svx/xfltrit.hxx>
      37             : #include <svx/xlntrit.hxx>
      38             : #include <editeng/eeitem.hxx>
      39             : #include <svl/eitem.hxx>
      40             : #include <svx/xgrscit.hxx>
      41             : #include <com/sun/star/beans/XPropertyState.hpp>
      42             : #include <com/sun/star/chart2/FillBitmap.hpp>
      43             : #include <com/sun/star/awt/Gradient.hpp>
      44             : #include <com/sun/star/container/XNameAccess.hpp>
      45             : 
      46             : using namespace ::com::sun::star;
      47             : 
      48             : namespace chart { namespace wrapper {
      49             : 
      50             : namespace {
      51             : 
      52           0 : ItemPropertyMapType & lcl_GetDataPointFilledPropertyMap()
      53             : {
      54             :     static ItemPropertyMapType aDataPointPropertyFilledMap(
      55             :         MakeItemPropertyMap
      56             :         IPM_MAP_ENTRY( XATTR_FILLSTYLE, "FillStyle", 0 )
      57           0 :         IPM_MAP_ENTRY( XATTR_FILLCOLOR, "Color", 0 )
      58           0 :         IPM_MAP_ENTRY( XATTR_LINECOLOR, "BorderColor", 0 )
      59           0 :         IPM_MAP_ENTRY( XATTR_LINESTYLE, "BorderStyle", 0 )
      60           0 :         IPM_MAP_ENTRY( XATTR_LINEWIDTH, "BorderWidth", 0 )
      61           0 :         IPM_MAP_ENTRY( XATTR_FILLBACKGROUND, "FillBackground", 0 )
      62           0 :         IPM_MAP_ENTRY( XATTR_FILLBMP_POS, "FillBitmapRectanglePoint", 0 )
      63           0 :         IPM_MAP_ENTRY( XATTR_FILLBMP_SIZEX, "FillBitmapSizeX", 0 )
      64           0 :         IPM_MAP_ENTRY( XATTR_FILLBMP_SIZEY, "FillBitmapSizeY", 0 )
      65           0 :         IPM_MAP_ENTRY( XATTR_FILLBMP_SIZELOG, "FillBitmapLogicalSize", 0 )
      66           0 :         IPM_MAP_ENTRY( XATTR_FILLBMP_TILEOFFSETX, "FillBitmapOffsetX", 0 )
      67           0 :         IPM_MAP_ENTRY( XATTR_FILLBMP_TILEOFFSETY, "FillBitmapOffsetY", 0 )
      68           0 :         IPM_MAP_ENTRY( XATTR_FILLBMP_POSOFFSETX, "FillBitmapPositionOffsetX", 0 )
      69           0 :         IPM_MAP_ENTRY( XATTR_FILLBMP_POSOFFSETY, "FillBitmapPositionOffsetY", 0 )
      70           0 :         );
      71             : 
      72           0 :     return aDataPointPropertyFilledMap;
      73             : }
      74           0 : ItemPropertyMapType & lcl_GetDataPointLinePropertyMap()
      75             : {
      76             :     static ItemPropertyMapType aDataPointPropertyLineMap(
      77             :         MakeItemPropertyMap
      78             :         IPM_MAP_ENTRY( XATTR_LINECOLOR, "Color", 0 )
      79           0 :         IPM_MAP_ENTRY( XATTR_LINESTYLE, "LineStyle", 0 )
      80           0 :         IPM_MAP_ENTRY( XATTR_LINEWIDTH, "LineWidth", 0 )
      81           0 :         );
      82             : 
      83           0 :     return aDataPointPropertyLineMap;
      84             : }
      85           0 : ItemPropertyMapType & lcl_GetLinePropertyMap()
      86             : {
      87             :     static ItemPropertyMapType aLinePropertyMap(
      88             :         MakeItemPropertyMap
      89             :         IPM_MAP_ENTRY( XATTR_LINESTYLE, "LineStyle", 0 )
      90           0 :         IPM_MAP_ENTRY( XATTR_LINEWIDTH, "LineWidth", 0 )
      91           0 :         IPM_MAP_ENTRY( XATTR_LINECOLOR, "LineColor", 0 )
      92           0 :         IPM_MAP_ENTRY( XATTR_LINEJOINT, "LineJoint", 0 )
      93           0 :         );
      94             : 
      95           0 :     return aLinePropertyMap;
      96             : }
      97           0 : ItemPropertyMapType & lcl_GetFillPropertyMap()
      98             : {
      99             :     static ItemPropertyMapType aFillPropertyMap(
     100             :         MakeItemPropertyMap
     101             :         IPM_MAP_ENTRY( XATTR_FILLSTYLE, "FillStyle", 0 )
     102           0 :         IPM_MAP_ENTRY( XATTR_FILLCOLOR, "FillColor", 0 )
     103           0 :         IPM_MAP_ENTRY( XATTR_FILLBACKGROUND, "FillBackground", 0 )
     104           0 :         IPM_MAP_ENTRY( XATTR_FILLBMP_POS, "FillBitmapRectanglePoint", 0 )
     105           0 :         IPM_MAP_ENTRY( XATTR_FILLBMP_SIZEX, "FillBitmapSizeX", 0 )
     106           0 :         IPM_MAP_ENTRY( XATTR_FILLBMP_SIZEY, "FillBitmapSizeY", 0 )
     107           0 :         IPM_MAP_ENTRY( XATTR_FILLBMP_SIZELOG, "FillBitmapLogicalSize", 0 )
     108           0 :         IPM_MAP_ENTRY( XATTR_FILLBMP_TILEOFFSETX, "FillBitmapOffsetX", 0 )
     109           0 :         IPM_MAP_ENTRY( XATTR_FILLBMP_TILEOFFSETY, "FillBitmapOffsetY", 0 )
     110           0 :         IPM_MAP_ENTRY( XATTR_FILLBMP_POSOFFSETX, "FillBitmapPositionOffsetX", 0 )
     111           0 :         IPM_MAP_ENTRY( XATTR_FILLBMP_POSOFFSETY, "FillBitmapPositionOffsetY", 0 )
     112           0 :         );
     113             : 
     114           0 :     return aFillPropertyMap;
     115             : }
     116             : 
     117           0 : bool lcl_supportsFillProperties( ::chart::wrapper::GraphicPropertyItemConverter::eGraphicObjectType eType )
     118             : {
     119           0 :     return ( eType == ::chart::wrapper::GraphicPropertyItemConverter::FILLED_DATA_POINT ||
     120           0 :              eType == ::chart::wrapper::GraphicPropertyItemConverter::FILL_PROPERTIES ||
     121           0 :              eType == ::chart::wrapper::GraphicPropertyItemConverter::LINE_AND_FILL_PROPERTIES );
     122             : }
     123             : 
     124           0 : bool lcl_supportsLineProperties( ::chart::wrapper::GraphicPropertyItemConverter::eGraphicObjectType eType )
     125             : {
     126           0 :     return ( eType != ::chart::wrapper::GraphicPropertyItemConverter::FILL_PROPERTIES );
     127             : }
     128             : 
     129           0 : bool lcl_SetContentForNamedProperty(
     130             :     const uno::Reference< lang::XMultiServiceFactory > & xFactory,
     131             :     const OUString & rTableName,
     132             :     NameOrIndex & rItem, sal_uInt8 nMemberId )
     133             : {
     134           0 :     bool bResult = false;
     135           0 :     if( xFactory.is())
     136             :     {
     137           0 :         OUString aPropertyValue( rItem.GetName());
     138             :         uno::Reference< container::XNameAccess > xNameAcc(
     139           0 :             xFactory->createInstance( rTableName ),
     140           0 :             uno::UNO_QUERY );
     141           0 :         if( xNameAcc.is() &&
     142           0 :             xNameAcc->hasByName( aPropertyValue ))
     143             :         {
     144           0 :             rItem.PutValue( xNameAcc->getByName( aPropertyValue ), nMemberId );
     145           0 :             bResult = true;
     146           0 :         }
     147             :     }
     148           0 :     return bResult;
     149             : }
     150             : 
     151             : } // anonymous namespace
     152             : 
     153           0 : GraphicPropertyItemConverter::GraphicPropertyItemConverter(
     154             :     const uno::Reference<
     155             :     beans::XPropertySet > & rPropertySet,
     156             :     SfxItemPool& rItemPool,
     157             :     SdrModel& rDrawModel,
     158             :     const uno::Reference< lang::XMultiServiceFactory > & xNamedPropertyContainerFactory,
     159             :     eGraphicObjectType eObjectType /* = FILL_PROPERTIES */ ) :
     160             :         ItemConverter( rPropertySet, rItemPool ),
     161             :         m_eGraphicObjectType( eObjectType ),
     162             :         m_rDrawModel( rDrawModel ),
     163           0 :         m_xNamedPropertyTableFactory( xNamedPropertyContainerFactory )
     164           0 : {}
     165             : 
     166           0 : GraphicPropertyItemConverter::~GraphicPropertyItemConverter()
     167           0 : {}
     168             : 
     169           0 : const sal_uInt16 * GraphicPropertyItemConverter::GetWhichPairs() const
     170             : {
     171           0 :     const sal_uInt16 * pResult = NULL;
     172             : 
     173           0 :     switch( m_eGraphicObjectType )
     174             :     {
     175             :         case LINE_DATA_POINT:
     176             :         case FILLED_DATA_POINT:
     177           0 :             pResult = nRowWhichPairs; break;
     178             :         case LINE_PROPERTIES:
     179           0 :             pResult = nLinePropertyWhichPairs; break;
     180             :         case FILL_PROPERTIES:
     181           0 :             pResult = nFillPropertyWhichPairs; break;
     182             :         case LINE_AND_FILL_PROPERTIES:
     183           0 :             pResult = nLineAndFillPropertyWhichPairs; break;
     184             :     }
     185             : 
     186           0 :     return pResult;
     187             : }
     188             : 
     189           0 : bool GraphicPropertyItemConverter::GetItemProperty( tWhichIdType nWhichId, tPropertyNameWithMemberId & rOutProperty ) const
     190             : {
     191           0 :     ItemPropertyMapType::const_iterator aEndIt;
     192           0 :     ItemPropertyMapType::const_iterator aIt;
     193             : 
     194           0 :     switch( m_eGraphicObjectType )
     195             :     {
     196             :         case LINE_DATA_POINT:
     197           0 :             aEndIt = lcl_GetDataPointLinePropertyMap().end();
     198           0 :             aIt = lcl_GetDataPointLinePropertyMap().find( nWhichId );
     199           0 :             break;
     200             :         case FILLED_DATA_POINT:
     201           0 :             aEndIt = lcl_GetDataPointFilledPropertyMap().end();
     202           0 :             aIt = lcl_GetDataPointFilledPropertyMap().find( nWhichId );
     203           0 :             break;
     204             :         case LINE_PROPERTIES:
     205           0 :             aEndIt = lcl_GetLinePropertyMap().end();
     206           0 :             aIt = lcl_GetLinePropertyMap().find( nWhichId );
     207           0 :             break;
     208             : 
     209             :         case FILL_PROPERTIES:
     210           0 :             aEndIt = lcl_GetFillPropertyMap().end();
     211           0 :             aIt = lcl_GetFillPropertyMap().find( nWhichId );
     212           0 :             break;
     213             : 
     214             :         case LINE_AND_FILL_PROPERTIES:
     215             :             // line
     216           0 :             aEndIt = lcl_GetLinePropertyMap().end();
     217           0 :             aIt = lcl_GetLinePropertyMap().find( nWhichId );
     218             : 
     219             :             // not found => try fill
     220           0 :             if( aIt == aEndIt )
     221             :             {
     222           0 :                 aEndIt = lcl_GetFillPropertyMap().end();
     223           0 :                 aIt = lcl_GetFillPropertyMap().find( nWhichId );
     224             :             }
     225           0 :             break;
     226             :     }
     227             : 
     228           0 :     if( aIt == aEndIt )
     229           0 :         return false;
     230             : 
     231           0 :     rOutProperty =(*aIt).second;
     232           0 :     return true;
     233             : }
     234             : 
     235           0 : void GraphicPropertyItemConverter::FillSpecialItem(
     236             :     sal_uInt16 nWhichId, SfxItemSet & rOutItemSet ) const
     237             :     throw (uno::Exception, std::exception)
     238             : {
     239           0 :     switch( nWhichId )
     240             :     {
     241             :         // bitmap property
     242             :         case XATTR_FILLBMP_TILE:
     243             :         case XATTR_FILLBMP_STRETCH:
     244             :         {
     245           0 :             drawing::BitmapMode aMode = drawing::BitmapMode_REPEAT;
     246           0 :             if( GetPropertySet()->getPropertyValue( "FillBitmapMode" ) >>= aMode )
     247             :             {
     248           0 :                 rOutItemSet.Put( XFillBmpTileItem( aMode == drawing::BitmapMode_REPEAT ));
     249           0 :                 rOutItemSet.Put( XFillBmpStretchItem( aMode == drawing::BitmapMode_STRETCH ));
     250             :             }
     251             :         }
     252           0 :         break;
     253             : 
     254             :         case XATTR_FILLFLOATTRANSPARENCE:
     255             :             try
     256             :             {
     257           0 :                 if( lcl_supportsFillProperties( m_eGraphicObjectType ))
     258             :                 {
     259             :                     OUString aPropName =
     260           0 :                           (m_eGraphicObjectType == FILLED_DATA_POINT)
     261             :                           ? OUString( "TransparencyGradientName" )
     262           0 :                           : OUString( "FillTransparenceGradientName" );
     263             : 
     264           0 :                     uno::Any aValue( GetPropertySet()->getPropertyValue( aPropName ));
     265           0 :                     if( aValue.hasValue())
     266             :                     {
     267           0 :                         XFillFloatTransparenceItem aItem;
     268           0 :                         aItem.PutValue( aValue, MID_NAME );
     269             : 
     270             :                         lcl_SetContentForNamedProperty(
     271             :                             m_xNamedPropertyTableFactory, "com.sun.star.drawing.TransparencyGradientTable" ,
     272           0 :                             aItem, MID_FILLGRADIENT );
     273             : 
     274             :                         // this is important to enable the item
     275           0 :                         OUString aName;
     276           0 :                         if( (aValue >>= aName) &&
     277           0 :                             !aName.isEmpty())
     278             :                         {
     279           0 :                             aItem.SetEnabled( true );
     280           0 :                             rOutItemSet.Put( aItem );
     281           0 :                         }
     282           0 :                     }
     283             :                 }
     284             :             }
     285           0 :             catch( const beans::UnknownPropertyException &ex )
     286             :             {
     287             :                 ASSERT_EXCEPTION( ex );
     288             :             }
     289           0 :         break;
     290             : 
     291             :         case XATTR_GRADIENTSTEPCOUNT:
     292           0 :             if( lcl_supportsFillProperties( m_eGraphicObjectType ))
     293             :             {
     294             :                 OUString aPropName =
     295           0 :                     (m_eGraphicObjectType == FILLED_DATA_POINT)
     296             :                     ? OUString( "GradientStepCount" )
     297           0 :                     : OUString( "FillGradientStepCount" );
     298             : 
     299           0 :                 uno::Any aValue( GetPropertySet()->getPropertyValue( aPropName ) );
     300           0 :                 if( hasLongOrShortValue(aValue) )
     301             :                 {
     302           0 :                     sal_Int16 nStepCount = getShortForLongAlso(aValue);
     303           0 :                     rOutItemSet.Put( XGradientStepCountItem( nStepCount ));
     304           0 :                 }
     305             :             }
     306           0 :         break;
     307             : 
     308             :         case XATTR_LINEDASH:
     309           0 :             if( lcl_supportsLineProperties( m_eGraphicObjectType ))
     310             :             {
     311             :                 OUString aPropName =
     312           0 :                     (m_eGraphicObjectType == FILLED_DATA_POINT)
     313             :                     ? OUString( "BorderDashName" )
     314           0 :                     : OUString( "LineDashName" );
     315             : 
     316           0 :                 XLineDashItem aItem;
     317           0 :                 aItem.PutValue( GetPropertySet()->getPropertyValue( aPropName ), MID_NAME );
     318             : 
     319             :                 lcl_SetContentForNamedProperty(
     320             :                     m_xNamedPropertyTableFactory, "com.sun.star.drawing.DashTable" ,
     321           0 :                     aItem, MID_LINEDASH );
     322             : 
     323             :                 // translate model name to UI-name for predefined entries, so
     324             :                 // that the correct entry is chosen in the list of UI-names
     325           0 :                 XLineDashItem* pItemToPut = aItem.checkForUniqueItem( & m_rDrawModel );
     326             : 
     327           0 :                 if(pItemToPut)
     328           0 :                     rOutItemSet.Put( *pItemToPut );
     329             :                 else
     330           0 :                     rOutItemSet.Put(aItem);
     331             :             }
     332           0 :         break;
     333             : 
     334             :         case XATTR_FILLGRADIENT:
     335           0 :             if( lcl_supportsFillProperties( m_eGraphicObjectType ))
     336             :             {
     337             :                 OUString aPropName =
     338           0 :                     (m_eGraphicObjectType == FILLED_DATA_POINT)
     339             :                     ? OUString( "GradientName" )
     340           0 :                     : OUString( "FillGradientName" );
     341             : 
     342           0 :                 XFillGradientItem aItem;
     343           0 :                 aItem.PutValue( GetPropertySet()->getPropertyValue( aPropName ), MID_NAME );
     344             : 
     345             :                 lcl_SetContentForNamedProperty(
     346             :                     m_xNamedPropertyTableFactory, "com.sun.star.drawing.GradientTable" ,
     347           0 :                     aItem, MID_FILLGRADIENT );
     348             : 
     349             :                 // translate model name to UI-name for predefined entries, so
     350             :                 // that the correct entry is chosen in the list of UI-names
     351           0 :                 XFillGradientItem* pItemToPut = aItem.checkForUniqueItem( & m_rDrawModel );
     352             : 
     353           0 :                 if(pItemToPut)
     354           0 :                     rOutItemSet.Put( *pItemToPut );
     355             :                 else
     356           0 :                     rOutItemSet.Put(aItem);
     357             :             }
     358           0 :         break;
     359             : 
     360             :         case XATTR_FILLHATCH:
     361           0 :             if( lcl_supportsFillProperties( m_eGraphicObjectType ))
     362             :             {
     363             :                 OUString aPropName =
     364           0 :                     (m_eGraphicObjectType == FILLED_DATA_POINT)
     365             :                     ? OUString( "HatchName" )
     366           0 :                     : OUString( "FillHatchName" );
     367             : 
     368           0 :                 XFillHatchItem aItem;
     369           0 :                 aItem.PutValue( GetPropertySet()->getPropertyValue( aPropName ), MID_NAME );
     370             : 
     371             :                 lcl_SetContentForNamedProperty(
     372             :                     m_xNamedPropertyTableFactory, "com.sun.star.drawing.HatchTable" ,
     373           0 :                     aItem, MID_FILLHATCH );
     374             : 
     375             :                 // translate model name to UI-name for predefined entries, so
     376             :                 // that the correct entry is chosen in the list of UI-names
     377           0 :                 XFillHatchItem* pItemToPut = aItem.checkForUniqueItem( & m_rDrawModel );
     378             : 
     379           0 :                 if(pItemToPut)
     380           0 :                     rOutItemSet.Put( *pItemToPut );
     381             :                 else
     382           0 :                     rOutItemSet.Put(aItem);
     383             :             }
     384           0 :         break;
     385             : 
     386             :         case XATTR_FILLBITMAP:
     387           0 :             if( lcl_supportsFillProperties( m_eGraphicObjectType ))
     388             :             {
     389           0 :                 XFillBitmapItem aItem;
     390           0 :                 aItem.PutValue( GetPropertySet()->getPropertyValue( "FillBitmapName" ), MID_NAME );
     391             : 
     392             :                 lcl_SetContentForNamedProperty(
     393             :                     m_xNamedPropertyTableFactory, "com.sun.star.drawing.BitmapTable" ,
     394           0 :                     aItem, MID_GRAFURL );
     395             : 
     396             :                 // translate model name to UI-name for predefined entries, so
     397             :                 // that the correct entry is chosen in the list of UI-names
     398           0 :                 XFillBitmapItem* pItemToPut = aItem.checkForUniqueItem( & m_rDrawModel );
     399             : 
     400           0 :                 if(pItemToPut)
     401           0 :                     rOutItemSet.Put( *pItemToPut );
     402             :                 else
     403           0 :                     rOutItemSet.Put(aItem);
     404             :             }
     405           0 :         break;
     406             : 
     407             :         // hack, because QueryValue of XLineTransparenceItem returns sal_Int32
     408             :         // instead of sal_Int16
     409             :         case XATTR_LINETRANSPARENCE:
     410           0 :             if( lcl_supportsLineProperties( m_eGraphicObjectType ))
     411             :             {
     412             :                 OUString aPropName =
     413           0 :                       (m_eGraphicObjectType == FILLED_DATA_POINT)
     414             :                       ? OUString( "BorderTransparency" )
     415           0 :                       : (m_eGraphicObjectType == LINE_DATA_POINT)
     416             :                       ? OUString( "Transparency" )
     417           0 :                       : OUString( "LineTransparence" );
     418             : 
     419           0 :                 XLineTransparenceItem aItem;
     420           0 :                 aItem.PutValue( GetPropertySet()->getPropertyValue( aPropName ) );
     421             : 
     422           0 :                 rOutItemSet.Put( aItem );
     423             :             }
     424           0 :             break;
     425             : 
     426             :         // hack, because QueryValue of XFillTransparenceItem returns sal_Int32
     427             :         // instead of sal_Int16
     428             :         case XATTR_FILLTRANSPARENCE:
     429           0 :             if( lcl_supportsFillProperties( m_eGraphicObjectType ))
     430             :             {
     431             :                 OUString aPropName =
     432           0 :                       (m_eGraphicObjectType == FILLED_DATA_POINT)
     433             :                       ? OUString( "Transparency" )
     434           0 :                       : OUString( "FillTransparence" );
     435             : 
     436           0 :                 XFillTransparenceItem aItem;
     437           0 :                 aItem.PutValue( GetPropertySet()->getPropertyValue( aPropName ) );
     438             : 
     439           0 :                 rOutItemSet.Put( aItem );
     440             :             }
     441           0 :             break;
     442             :     }
     443           0 : }
     444             : 
     445           0 : bool GraphicPropertyItemConverter::ApplySpecialItem(
     446             :     sal_uInt16 nWhichId, const SfxItemSet & rItemSet )
     447             :     throw( uno::Exception )
     448             : {
     449           0 :     bool bChanged = false;
     450           0 :     uno::Any aValue;
     451             : 
     452           0 :     switch( nWhichId )
     453             :     {
     454             :         // bitmap property
     455             :         case XATTR_FILLBMP_STRETCH:
     456           0 :             if( lcl_supportsFillProperties( m_eGraphicObjectType ))
     457             :             {
     458           0 :                 const OUString aModePropName("FillBitmapMode");
     459             :                 bool bStretched = static_cast< const XFillBmpStretchItem & >(
     460           0 :                     rItemSet.Get( XATTR_FILLBMP_STRETCH )).GetValue();
     461             :                 drawing::BitmapMode aMode =
     462           0 :                     (bStretched ? drawing::BitmapMode_STRETCH : drawing::BitmapMode_NO_REPEAT);
     463             : 
     464           0 :                 aValue <<= aMode;
     465           0 :                 if( aValue != GetPropertySet()->getPropertyValue( aModePropName ))
     466             :                 {
     467           0 :                     GetPropertySet()->setPropertyValue( aModePropName, aValue );
     468           0 :                     bChanged = true;
     469           0 :                 }
     470             :             }
     471           0 :             break;
     472             : 
     473             :         case XATTR_FILLBMP_TILE:
     474           0 :             if( lcl_supportsFillProperties( m_eGraphicObjectType ))
     475             :             {
     476           0 :                 const OUString aModePropName("FillBitmapMode");
     477             :                 bool bTiled = static_cast< const XFillBmpTileItem & >(
     478           0 :                     rItemSet.Get( XATTR_FILLBMP_TILE )).GetValue();
     479             :                 drawing::BitmapMode aMode =
     480           0 :                     (bTiled ? drawing::BitmapMode_REPEAT : drawing::BitmapMode_NO_REPEAT);
     481             : 
     482           0 :                 aValue <<= aMode;
     483           0 :                 if( aValue != GetPropertySet()->getPropertyValue( aModePropName ))
     484             :                 {
     485           0 :                     GetPropertySet()->setPropertyValue( aModePropName, aValue );
     486           0 :                     bChanged = true;
     487           0 :                 }
     488             :             }
     489           0 :             break;
     490             : 
     491             :         case XATTR_FILLFLOATTRANSPARENCE:
     492             :             try
     493             :             {
     494           0 :                 if( lcl_supportsFillProperties( m_eGraphicObjectType ))
     495             :                 {
     496             :                     OUString aPropName =
     497           0 :                           (m_eGraphicObjectType == FILLED_DATA_POINT)
     498             :                           ? OUString( "TransparencyGradientName" )
     499           0 :                           : OUString( "FillTransparenceGradientName" );
     500             : 
     501             :                     const XFillFloatTransparenceItem & rItem =
     502             :                         static_cast< const XFillFloatTransparenceItem & >(
     503           0 :                             rItemSet.Get( nWhichId ));
     504             : 
     505           0 :                     if( rItem.IsEnabled() &&
     506           0 :                         rItem.QueryValue( aValue, MID_NAME ))
     507             :                     {
     508           0 :                         uno::Any aGradient;
     509           0 :                         rItem.QueryValue( aGradient, MID_FILLGRADIENT );
     510             : 
     511             :                         // add TransparencyGradient to list if it does not already exist
     512           0 :                         OUString aPreferredName;
     513           0 :                         aValue >>= aPreferredName;
     514           0 :                         aValue <<= PropertyHelper::addTransparencyGradientUniqueNameToTable(
     515           0 :                             aGradient, m_xNamedPropertyTableFactory, aPreferredName );
     516             : 
     517           0 :                         if( aValue != GetPropertySet()->getPropertyValue( aPropName ))
     518             :                         {
     519           0 :                             GetPropertySet()->setPropertyValue( aPropName, aValue );
     520           0 :                             bChanged = true;
     521           0 :                         }
     522             :                     }
     523             :                     else
     524             :                     {
     525           0 :                         OUString aName;
     526           0 :                         if( ( GetPropertySet()->getPropertyValue( aPropName ) >>= aName )
     527           0 :                             && !aName.isEmpty() )
     528             :                         {
     529           0 :                             uno::Reference< beans::XPropertyState > xState( GetPropertySet(), uno::UNO_QUERY );
     530           0 :                             if( xState.is())
     531           0 :                                 xState->setPropertyToDefault( aPropName );
     532           0 :                             bChanged = true;
     533           0 :                         }
     534           0 :                     }
     535             :                 }
     536             :             }
     537           0 :             catch( const beans::UnknownPropertyException &ex )
     538             :             {
     539             :                 ASSERT_EXCEPTION( ex );
     540             :             }
     541           0 :         break;
     542             : 
     543             :         case XATTR_GRADIENTSTEPCOUNT:
     544             :         {
     545           0 :             if( lcl_supportsFillProperties( m_eGraphicObjectType ))
     546             :             {
     547             :                 OUString aPropName =
     548           0 :                     (m_eGraphicObjectType == FILLED_DATA_POINT)
     549             :                     ? OUString( "GradientStepCount" )
     550           0 :                     : OUString( "FillGradientStepCount" );
     551             : 
     552             :                 sal_Int16 nStepCount = ( static_cast< const XGradientStepCountItem & >(
     553           0 :                             rItemSet.Get( nWhichId ))).GetValue();
     554             : 
     555           0 :                 aValue <<= nStepCount;
     556           0 :                 if( aValue != GetPropertySet()->getPropertyValue( aPropName ))
     557             :                 {
     558           0 :                     GetPropertySet()->setPropertyValue( aPropName, aValue );
     559           0 :                     bChanged = true;
     560           0 :                 }
     561             :             }
     562             :         }
     563           0 :         break;
     564             : 
     565             :         case XATTR_LINEDASH:
     566             :         {
     567           0 :             if( lcl_supportsLineProperties( m_eGraphicObjectType ))
     568             :             {
     569             : 
     570             :                 OUString aPropName =
     571           0 :                     (m_eGraphicObjectType == FILLED_DATA_POINT)
     572             :                     ? OUString( "BorderDashName" )
     573           0 :                     : OUString( "LineDashName" );
     574             : 
     575             :                 const XLineDashItem & rItem =
     576             :                     static_cast< const XLineDashItem & >(
     577           0 :                         rItemSet.Get( nWhichId ));
     578             : 
     579           0 :                 if( rItem.QueryValue( aValue, MID_NAME ))
     580             :                 {
     581           0 :                     if( aValue != GetPropertySet()->getPropertyValue( aPropName ))
     582             :                     {
     583             :                         // add LineDash to list
     584           0 :                         uno::Any aLineDash;
     585           0 :                         rItem.QueryValue( aLineDash, MID_LINEDASH );
     586           0 :                         OUString aPreferredName;
     587           0 :                         aValue >>= aPreferredName;
     588           0 :                         aValue <<= PropertyHelper::addLineDashUniqueNameToTable(
     589           0 :                             aLineDash, m_xNamedPropertyTableFactory, aPreferredName );
     590             : 
     591           0 :                         GetPropertySet()->setPropertyValue( aPropName, aValue );
     592           0 :                         bChanged = true;
     593             :                     }
     594           0 :                 }
     595             :             }
     596             :         }
     597           0 :         break;
     598             : 
     599             :         case XATTR_FILLGRADIENT:
     600             :         {
     601           0 :             if( lcl_supportsFillProperties( m_eGraphicObjectType ))
     602             :             {
     603             :                 OUString aPropName =
     604           0 :                     (m_eGraphicObjectType == FILLED_DATA_POINT)
     605             :                     ? OUString( "GradientName" )
     606           0 :                     : OUString( "FillGradientName" );
     607             : 
     608             :                 const XFillGradientItem & rItem =
     609             :                     static_cast< const XFillGradientItem & >(
     610           0 :                         rItemSet.Get( nWhichId ));
     611             : 
     612           0 :                 if( rItem.QueryValue( aValue, MID_NAME ))
     613             :                 {
     614           0 :                     if( aValue != GetPropertySet()->getPropertyValue( aPropName ))
     615             :                     {
     616             :                         // add Gradient to list
     617           0 :                         uno::Any aGradient;
     618           0 :                         rItem.QueryValue( aGradient, MID_FILLGRADIENT );
     619           0 :                         OUString aPreferredName;
     620           0 :                         aValue >>= aPreferredName;
     621           0 :                         aValue <<= PropertyHelper::addGradientUniqueNameToTable(
     622           0 :                             aGradient, m_xNamedPropertyTableFactory, aPreferredName );
     623             : 
     624           0 :                         GetPropertySet()->setPropertyValue( aPropName, aValue );
     625           0 :                         bChanged = true;
     626             :                     }
     627           0 :                 }
     628             :             }
     629             :         }
     630           0 :         break;
     631             : 
     632             :         case XATTR_FILLHATCH:
     633             :         {
     634           0 :             if( lcl_supportsFillProperties( m_eGraphicObjectType ))
     635             :             {
     636             :                 OUString aPropName =
     637           0 :                     (m_eGraphicObjectType == FILLED_DATA_POINT)
     638             :                     ? OUString( "HatchName" )
     639           0 :                     : OUString( "FillHatchName" );
     640             : 
     641             :                 const XFillHatchItem & rItem =
     642             :                     static_cast< const XFillHatchItem & >(
     643           0 :                         rItemSet.Get( nWhichId ));
     644             : 
     645           0 :                 if( rItem.QueryValue( aValue, MID_NAME ))
     646             :                 {
     647           0 :                     if( aValue != GetPropertySet()->getPropertyValue( aPropName ))
     648             :                     {
     649             :                         // add Hatch to list
     650           0 :                         uno::Any aHatch;
     651           0 :                         rItem.QueryValue( aHatch, MID_FILLHATCH );
     652           0 :                         OUString aPreferredName;
     653           0 :                         aValue >>= aPreferredName;
     654           0 :                         aValue <<= PropertyHelper::addHatchUniqueNameToTable(
     655           0 :                             aHatch, m_xNamedPropertyTableFactory, aPreferredName );
     656             : 
     657           0 :                         GetPropertySet()->setPropertyValue( aPropName, aValue );
     658           0 :                         bChanged = true;
     659             :                     }
     660           0 :                 }
     661             :             }
     662             :         }
     663           0 :         break;
     664             : 
     665             :         case XATTR_FILLBITMAP:
     666             :         {
     667           0 :             if( lcl_supportsFillProperties( m_eGraphicObjectType ))
     668             :             {
     669             :                 const XFillBitmapItem & rItem =
     670             :                     static_cast< const XFillBitmapItem & >(
     671           0 :                         rItemSet.Get( nWhichId ));
     672             : 
     673           0 :                 if( rItem.QueryValue( aValue, MID_NAME ))
     674             :                 {
     675           0 :                     if( aValue != GetPropertySet()->getPropertyValue( "FillBitmapName" ))
     676             :                     {
     677             :                         // add Bitmap to list
     678           0 :                         uno::Any aBitmap;
     679           0 :                         rItem.QueryValue( aBitmap, MID_GRAFURL );
     680           0 :                         OUString aPreferredName;
     681           0 :                         aValue >>= aPreferredName;
     682           0 :                         aValue <<= PropertyHelper::addBitmapUniqueNameToTable(
     683           0 :                             aBitmap, m_xNamedPropertyTableFactory, aPreferredName );
     684             : 
     685           0 :                         GetPropertySet()->setPropertyValue( "FillBitmapName" , aValue );
     686           0 :                         bChanged = true;
     687             :                     }
     688             :                 }
     689             :             }
     690             :         }
     691           0 :         break;
     692             : 
     693             :         // hack, because QueryValue of XLineTransparenceItem returns sal_Int32
     694             :         // instead of sal_Int16
     695             :         case XATTR_LINETRANSPARENCE:
     696           0 :             if( lcl_supportsLineProperties( m_eGraphicObjectType ))
     697             :             {
     698             :                 OUString aPropName =
     699           0 :                       (m_eGraphicObjectType == FILLED_DATA_POINT)
     700             :                       ? OUString( "BorderTransparency" )
     701           0 :                       : (m_eGraphicObjectType == LINE_DATA_POINT)
     702             :                       ? OUString( "Transparency" )
     703           0 :                       : OUString( "LineTransparence" );
     704             : 
     705             :                 const XLineTransparenceItem & rItem =
     706             :                     static_cast< const XLineTransparenceItem & >(
     707           0 :                         rItemSet.Get( nWhichId ));
     708             : 
     709           0 :                 if( rItem.QueryValue( aValue ))
     710             :                 {
     711             :                     OSL_ENSURE( ! aValue.isExtractableTo(
     712             :                                     cppu::UnoType<sal_Int16>::get()),
     713             :                                 "TransparenceItem QueryValue bug is fixed. Remove hack." );
     714           0 :                     sal_Int32 nValue = 0;
     715           0 :                     if( aValue >>= nValue )
     716             :                     {
     717             :                         OSL_ENSURE( nValue < SAL_MAX_INT16, "Transparency value too large" );
     718           0 :                         sal_Int16 nValueToSet( static_cast< sal_Int16 >( nValue ));
     719           0 :                         aValue <<= nValueToSet;
     720             : 
     721           0 :                         GetPropertySet()->setPropertyValue( aPropName, aValue );
     722           0 :                         bChanged = true;
     723             :                     }
     724             :                     else
     725             :                     {
     726             :                         OSL_FAIL( "Wrong type in Transparency Any" );
     727             :                     }
     728           0 :                 }
     729             :             }
     730           0 :             break;
     731             : 
     732             :         // hack, because QueryValue of XFillTransparenceItem returns sal_Int32
     733             :         // instead of sal_Int16
     734             :         case XATTR_FILLTRANSPARENCE:
     735           0 :             if( lcl_supportsFillProperties( m_eGraphicObjectType ))
     736             :             {
     737             :                 OUString aPropName =
     738           0 :                       (m_eGraphicObjectType == FILLED_DATA_POINT)
     739             :                       ? OUString( "Transparency" )
     740           0 :                       : OUString( "FillTransparence" );
     741             : 
     742             :                 const XFillTransparenceItem & rItem =
     743             :                     static_cast< const XFillTransparenceItem & >(
     744           0 :                         rItemSet.Get( nWhichId ));
     745             : 
     746           0 :                 if( rItem.QueryValue( aValue ))
     747             :                 {
     748             :                     OSL_ENSURE( ! aValue.isExtractableTo(
     749             :                                     cppu::UnoType<sal_Int16>::get()),
     750             :                                 "TransparenceItem QueryValue bug is fixed. Remove hack." );
     751           0 :                     sal_Int32 nValue = 0;
     752           0 :                     if( aValue >>= nValue )
     753             :                     {
     754             :                         OSL_ENSURE( nValue < SAL_MAX_INT16, "Transparency value too large" );
     755           0 :                         sal_Int16 nValueToSet( static_cast< sal_Int16 >( nValue ));
     756           0 :                         aValue <<= nValueToSet;
     757             : 
     758           0 :                         GetPropertySet()->setPropertyValue( aPropName, aValue );
     759             :                         // if linear or no transparence is set, delete the gradient
     760             :                         OUString aTransGradPropName =
     761           0 :                               (m_eGraphicObjectType == FILLED_DATA_POINT)
     762             :                               ? OUString( "TransparencyGradientName" )
     763           0 :                               : OUString( "FillTransparenceGradientName" );
     764           0 :                         GetPropertySet()->setPropertyValue(
     765           0 :                             aTransGradPropName, uno::makeAny( OUString() ));
     766             : 
     767           0 :                         bChanged = true;
     768             :                     }
     769             :                     else
     770             :                     {
     771             :                         OSL_FAIL( "Wrong type in Transparency Any" );
     772             :                     }
     773           0 :                 }
     774             :             }
     775           0 :             break;
     776             :     }
     777             : 
     778           0 :     return bChanged;
     779             : }
     780             : 
     781             : } //  namespace wrapper
     782             : } //  namespace chart
     783             : 
     784             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.11