LCOV - code coverage report
Current view: top level - svx/source/items - pageitem.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 126 0.0 %
Date: 2014-04-14 Functions: 0 22 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 <tools/stream.hxx>
      21             : 
      22             : 
      23             : #include <svx/pageitem.hxx>
      24             : #include <editeng/itemtype.hxx>
      25             : #include <svx/unomid.hxx>
      26             : #include <com/sun/star/style/PageStyleLayout.hpp>
      27             : #include <com/sun/star/style/BreakType.hpp>
      28             : #include <svl/itemset.hxx>
      29             : #include <svx/svxitems.hrc>
      30             : #include <svx/dialmgr.hxx>
      31             : 
      32             : using namespace ::rtl;
      33             : using namespace ::com::sun::star;
      34             : 
      35             : // STATIC DATA -----------------------------------------------------------
      36             : 
      37           0 : TYPEINIT1_FACTORY( SvxPageItem, SfxPoolItem , new  SvxPageItem(0));
      38             : 
      39             : /*--------------------------------------------------------------------
      40             :     Beschreibung: Konstruktor
      41             :  --------------------------------------------------------------------*/
      42             : 
      43           0 : SvxPageItem::SvxPageItem( const sal_uInt16 nId ) : SfxPoolItem( nId ),
      44             : 
      45             :     eNumType    ( SVX_ARABIC ),
      46             :     bLandscape  ( false ),
      47           0 :     eUse        ( SVX_PAGE_ALL )
      48             : {
      49           0 : }
      50             : 
      51             : /*--------------------------------------------------------------------
      52             :     Beschreibung: Copy-Konstruktor
      53             :  --------------------------------------------------------------------*/
      54             : 
      55           0 : SvxPageItem::SvxPageItem( const SvxPageItem& rItem )
      56           0 :     : SfxPoolItem( rItem )
      57             : {
      58           0 :     eNumType    = rItem.eNumType;
      59           0 :     bLandscape  = rItem.bLandscape;
      60           0 :     eUse        = rItem.eUse;
      61           0 : }
      62             : 
      63             : /*--------------------------------------------------------------------
      64             :     Beschreibung: Clonen
      65             :  --------------------------------------------------------------------*/
      66             : 
      67           0 : SfxPoolItem* SvxPageItem::Clone( SfxItemPool * ) const
      68             : {
      69           0 :     return new SvxPageItem( *this );
      70             : }
      71             : 
      72             : /*--------------------------------------------------------------------
      73             :     Beschreibung: Abfrage auf Gleichheit
      74             :  --------------------------------------------------------------------*/
      75             : 
      76           0 : bool SvxPageItem::operator==( const SfxPoolItem& rAttr ) const
      77             : {
      78             :     DBG_ASSERT( SfxPoolItem::operator==(rAttr), "unequal types" );
      79           0 :     const SvxPageItem& rItem = (SvxPageItem&)rAttr;
      80           0 :     return ( eNumType   == rItem.eNumType   &&
      81           0 :              bLandscape == rItem.bLandscape &&
      82           0 :              eUse       == rItem.eUse );
      83             : }
      84             : 
      85           0 : inline OUString GetUsageText( const sal_uInt16 eU )
      86             : {
      87           0 :     switch( eU & 0x000f )
      88             :     {
      89           0 :         case SVX_PAGE_LEFT  : return SVX_RESSTR(RID_SVXITEMS_PAGE_USAGE_LEFT);
      90           0 :         case SVX_PAGE_RIGHT : return SVX_RESSTR(RID_SVXITEMS_PAGE_USAGE_RIGHT);
      91           0 :         case SVX_PAGE_ALL   : return SVX_RESSTR(RID_SVXITEMS_PAGE_USAGE_ALL);
      92           0 :         case SVX_PAGE_MIRROR: return SVX_RESSTR(RID_SVXITEMS_PAGE_USAGE_MIRROR);
      93           0 :         default:              return OUString();
      94             :     }
      95             : }
      96             : 
      97             : 
      98             : 
      99           0 : SfxItemPresentation SvxPageItem::GetPresentation
     100             : (
     101             :     SfxItemPresentation ePres,
     102             :     SfxMapUnit          /*eCoreUnit*/,
     103             :     SfxMapUnit          /*ePresUnit*/,
     104             :     OUString&           rText, const IntlWrapper *
     105             : )   const
     106             : {
     107           0 :     rText = OUString();
     108           0 :     OUString cpDelimTmp = OUString(cpDelim);
     109             : 
     110           0 :     switch ( ePres )
     111             :     {
     112             :         case SFX_ITEM_PRESENTATION_NONE:
     113           0 :             return SFX_ITEM_PRESENTATION_NONE;
     114             :         case SFX_ITEM_PRESENTATION_NAMELESS:
     115             :         {
     116           0 :             if ( !aDescName.isEmpty() )
     117             :             {
     118           0 :                 rText = aDescName + cpDelimTmp;
     119             :             }
     120             :             DBG_ASSERT( eNumType <= SVX_NUMBER_NONE, "enum overflow" );
     121           0 :             rText += SVX_RESSTR(RID_SVXITEMS_PAGE_NUM_BEGIN + eNumType) + cpDelimTmp;
     122           0 :             if ( bLandscape )
     123           0 :                 rText += SVX_RESSTR(RID_SVXITEMS_PAGE_LAND_TRUE);
     124             :             else
     125           0 :                 rText += SVX_RESSTR(RID_SVXITEMS_PAGE_LAND_FALSE);
     126           0 :             OUString aUsageText = GetUsageText( eUse );
     127           0 :             if (!aUsageText.isEmpty())
     128             :             {
     129           0 :                 rText += cpDelimTmp + aUsageText;
     130             :             }
     131           0 :             return SFX_ITEM_PRESENTATION_NAMELESS;
     132             :         }
     133             :         case SFX_ITEM_PRESENTATION_COMPLETE:
     134             :         {
     135           0 :             rText += SVX_RESSTR(RID_SVXITEMS_PAGE_COMPLETE);
     136           0 :             if ( !aDescName.isEmpty() )
     137             :             {
     138           0 :                 rText += aDescName + cpDelimTmp;
     139             :             }
     140             :             DBG_ASSERT( eNumType <= SVX_NUMBER_NONE, "enum overflow" );
     141           0 :             rText += SVX_RESSTR(RID_SVXITEMS_PAGE_NUM_BEGIN + eNumType) + cpDelimTmp;
     142           0 :             if ( bLandscape )
     143           0 :                 rText += SVX_RESSTR(RID_SVXITEMS_PAGE_LAND_TRUE);
     144             :             else
     145           0 :                 rText += SVX_RESSTR(RID_SVXITEMS_PAGE_LAND_FALSE);
     146           0 :             OUString aUsageText = GetUsageText( eUse );
     147           0 :             if (!aUsageText.isEmpty())
     148             :             {
     149           0 :                 rText += cpDelimTmp + aUsageText;
     150             :             }
     151           0 :             return SFX_ITEM_PRESENTATION_COMPLETE;
     152             :         }
     153             :         default: ;//prevent warning
     154             :     }
     155           0 :     return SFX_ITEM_PRESENTATION_NONE;
     156             : }
     157             : 
     158             : 
     159           0 : bool SvxPageItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
     160             : {
     161             : //    sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
     162           0 :     nMemberId &= ~CONVERT_TWIPS;
     163           0 :     switch( nMemberId )
     164             :     {
     165             :         case MID_PAGE_NUMTYPE:
     166             :         {
     167             :             //! die Konstanten sind nicht mehr in den IDLs ?!?
     168           0 :             rVal <<= (sal_Int16)( eNumType );
     169             :         }
     170           0 :         break;
     171             :         case MID_PAGE_ORIENTATION:
     172             :             //Landscape= sal_True
     173           0 :             rVal = Bool2Any(bLandscape);
     174           0 :         break;
     175             :         case MID_PAGE_LAYOUT     :
     176             :         {
     177             :             style::PageStyleLayout eRet;
     178           0 :             switch(eUse & 0x0f)
     179             :             {
     180           0 :                 case SVX_PAGE_LEFT  : eRet = style::PageStyleLayout_LEFT;      break;
     181           0 :                 case SVX_PAGE_RIGHT : eRet = style::PageStyleLayout_RIGHT;     break;
     182           0 :                 case SVX_PAGE_ALL   : eRet = style::PageStyleLayout_ALL;       break;
     183           0 :                 case SVX_PAGE_MIRROR: eRet = style::PageStyleLayout_MIRRORED; break;
     184             :                 default:
     185             :                     OSL_FAIL("was fuer ein Layout ist das?");
     186           0 :                     return false;
     187             :             }
     188           0 :             rVal <<= eRet;
     189             :         }
     190           0 :         break;
     191             :     }
     192             : 
     193           0 :     return true;
     194             : }
     195             : 
     196           0 : bool SvxPageItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
     197             : {
     198           0 :     switch( nMemberId )
     199             :     {
     200             :         case MID_PAGE_NUMTYPE:
     201             :         {
     202           0 :             sal_Int32 nValue = 0;
     203           0 :             if(!(rVal >>= nValue))
     204           0 :                 return false;
     205             : 
     206           0 :             eNumType = (SvxNumType)nValue;
     207             :         }
     208           0 :         break;
     209             :         case MID_PAGE_ORIENTATION:
     210           0 :             bLandscape = Any2Bool(rVal);
     211           0 :         break;
     212             :         case MID_PAGE_LAYOUT     :
     213             :         {
     214             :             style::PageStyleLayout eLayout;
     215           0 :             if(!(rVal >>= eLayout))
     216             :             {
     217           0 :                 sal_Int32 nValue = 0;
     218           0 :                 if(!(rVal >>= nValue))
     219           0 :                     return false;
     220           0 :                 eLayout = (style::PageStyleLayout)nValue;
     221             :             }
     222           0 :             eUse &= 0xfff0;
     223           0 :             switch( eLayout )
     224             :             {
     225           0 :                 case style::PageStyleLayout_LEFT     : eUse |= SVX_PAGE_LEFT ; break;
     226           0 :                 case style::PageStyleLayout_RIGHT   : eUse |= SVX_PAGE_RIGHT; break;
     227           0 :                 case style::PageStyleLayout_ALL     : eUse |= SVX_PAGE_ALL  ; break;
     228           0 :                 case style::PageStyleLayout_MIRRORED: eUse |= SVX_PAGE_MIRROR;break;
     229             :                 default: ;//prevent warning
     230             :             }
     231             :         }
     232           0 :         break;
     233             :     }
     234           0 :     return true;
     235             : }
     236             : 
     237             : 
     238             : 
     239           0 : SfxPoolItem* SvxPageItem::Create( SvStream& rStream, sal_uInt16 ) const
     240             : {
     241             :     sal_uInt8 eType;
     242             :     sal_Bool bLand;
     243             :     sal_uInt16 nUse;
     244             : 
     245             :     // UNICODE: rStream >> sStr;
     246           0 :     OUString sStr = rStream.ReadUniOrByteString( rStream.GetStreamCharSet() );
     247             : 
     248           0 :     rStream.ReadUChar( eType );
     249           0 :     rStream.ReadUChar( bLand );
     250           0 :     rStream.ReadUInt16( nUse );
     251             : 
     252           0 :     SvxPageItem* pPage = new SvxPageItem( Which() );
     253           0 :     pPage->SetDescName( sStr );
     254           0 :     pPage->SetNumType( (SvxNumType)eType );
     255           0 :     pPage->SetLandscape( bLand );
     256           0 :     pPage->SetPageUsage( nUse );
     257           0 :     return pPage;
     258             : }
     259             : 
     260             : 
     261             : 
     262           0 : SvStream& SvxPageItem::Store( SvStream &rStrm, sal_uInt16 /*nItemVersion*/ ) const
     263             : {
     264             :     // UNICODE: rStrm << aDescName;
     265           0 :     rStrm.WriteUniOrByteString(aDescName, rStrm.GetStreamCharSet());
     266             : 
     267           0 :     rStrm.WriteUChar( (sal_uInt8)eNumType ).WriteUChar( bLandscape ).WriteUInt16( eUse );
     268           0 :     return rStrm;
     269             : }
     270             : 
     271             : /*--------------------------------------------------------------------
     272             :     Beschreibung:   HeaderFooterSet
     273             :  --------------------------------------------------------------------*/
     274             : 
     275           0 : SvxSetItem::SvxSetItem( const sal_uInt16 nId, const SfxItemSet& rSet ) :
     276             : 
     277           0 :     SfxSetItem( nId, rSet )
     278             : {
     279           0 : }
     280             : 
     281           0 : SvxSetItem::SvxSetItem( const SvxSetItem& rItem ) :
     282             : 
     283           0 :     SfxSetItem( rItem )
     284             : {
     285           0 : }
     286             : 
     287           0 : SvxSetItem::SvxSetItem( const sal_uInt16 nId, SfxItemSet* _pSet ) :
     288             : 
     289           0 :     SfxSetItem( nId, _pSet )
     290             : {
     291           0 : }
     292             : 
     293           0 : SfxPoolItem* SvxSetItem::Clone( SfxItemPool * ) const
     294             : {
     295           0 :     return new SvxSetItem(*this);
     296             : }
     297             : 
     298             : 
     299             : 
     300           0 : SfxItemPresentation SvxSetItem::GetPresentation
     301             : (
     302             :     SfxItemPresentation /*ePres*/,
     303             :     SfxMapUnit          /*eCoreUnit*/,
     304             :     SfxMapUnit          /*ePresUnit*/,
     305             :     OUString&           rText, const IntlWrapper *
     306             : )   const
     307             : {
     308           0 :     rText = OUString();
     309           0 :     return SFX_ITEM_PRESENTATION_NONE;
     310             : }
     311             : 
     312           0 : SfxPoolItem* SvxSetItem::Create(SvStream &rStrm, sal_uInt16 /*nVersion*/) const
     313             : {
     314           0 :     SfxItemSet* _pSet = new SfxItemSet( *GetItemSet().GetPool(),
     315           0 :                                        GetItemSet().GetRanges() );
     316             : 
     317           0 :     _pSet->Load( rStrm );
     318             : 
     319           0 :     return new SvxSetItem( Which(), *_pSet );
     320             : }
     321             : 
     322           0 : SvStream& SvxSetItem::Store(SvStream &rStrm, sal_uInt16 nItemVersion) const
     323             : {
     324           0 :     GetItemSet().Store( rStrm, nItemVersion );
     325             : 
     326           0 :     return rStrm;
     327             : }
     328             : 
     329             : 
     330             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10