LCOV - code coverage report
Current view: top level - svx/source/items - algitem.cxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 94 163 57.7 %
Date: 2015-06-13 12:38:46 Functions: 20 36 55.6 %
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 <svx/svxitems.hrc>
      21             : 
      22             : #include <tools/stream.hxx>
      23             : #include <tools/mapunit.hxx>
      24             : #include <com/sun/star/table/BorderLine.hpp>
      25             : #include <com/sun/star/table/ShadowLocation.hpp>
      26             : #include <com/sun/star/table/TableBorder.hpp>
      27             : #include <com/sun/star/table/ShadowFormat.hpp>
      28             : #include <com/sun/star/table/CellRangeAddress.hpp>
      29             : #include <com/sun/star/table/CellContentType.hpp>
      30             : #include <com/sun/star/table/TableOrientation.hpp>
      31             : #include <com/sun/star/util/SortField.hpp>
      32             : #include <com/sun/star/util/SortFieldType.hpp>
      33             : #include <com/sun/star/table/CellOrientation.hpp>
      34             : #include <com/sun/star/table/CellAddress.hpp>
      35             : 
      36             : #include <svx/algitem.hxx>
      37             : #include <svx/dialmgr.hxx>
      38             : #include <editeng/itemtype.hxx>
      39             : #include <svx/unomid.hxx>
      40             : 
      41             : using namespace ::com::sun::star;
      42             : 
      43           0 : TYPEINIT1_FACTORY( SvxOrientationItem, SfxEnumItem, new SvxOrientationItem(SVX_ORIENTATION_STANDARD, 0) );
      44       57345 : TYPEINIT1_FACTORY( SvxMarginItem, SfxPoolItem, new SvxMarginItem(0) );
      45             : 
      46        1026 : SvxOrientationItem::SvxOrientationItem( const SvxCellOrientation eOrientation,
      47             :                                         const sal_uInt16 nId):
      48        1026 :     SfxEnumItem( nId, (sal_uInt16)eOrientation )
      49             : {
      50        1026 : }
      51             : 
      52         592 : SvxOrientationItem::SvxOrientationItem( sal_Int32 nRotation, bool bStacked, const sal_uInt16 nId ) :
      53         592 :     SfxEnumItem( nId )
      54             : {
      55         592 :     SetFromRotation( nRotation, bStacked );
      56         592 : }
      57             : 
      58             : 
      59             : 
      60           0 : bool SvxOrientationItem::GetPresentation
      61             : (
      62             :     SfxItemPresentation /*ePres*/,
      63             :     SfxMapUnit          /*eCoreUnit*/,
      64             :     SfxMapUnit          /*ePresUnit*/,
      65             :     OUString&           rText, const IntlWrapper * ) const
      66             : {
      67           0 :     rText = GetValueText( GetValue() );
      68           0 :     return true;
      69             : }
      70             : 
      71             : 
      72             : 
      73          64 : bool SvxOrientationItem::QueryValue( uno::Any& rVal, sal_uInt8 /*nMemberId*/ ) const
      74             : {
      75          64 :     table::CellOrientation eUno = table::CellOrientation_STANDARD;
      76          64 :     switch ( (SvxCellOrientation)GetValue() )
      77             :     {
      78          33 :     case SVX_ORIENTATION_STANDARD:  eUno = table::CellOrientation_STANDARD;  break;
      79          13 :     case SVX_ORIENTATION_TOPBOTTOM: eUno = table::CellOrientation_TOPBOTTOM; break;
      80           9 :     case SVX_ORIENTATION_BOTTOMTOP: eUno = table::CellOrientation_BOTTOMTOP; break;
      81           9 :     case SVX_ORIENTATION_STACKED:   eUno = table::CellOrientation_STACKED;    break;
      82             :     }
      83          64 :     rVal <<= eUno;
      84          64 :     return true;
      85             : }
      86             : 
      87           0 : bool SvxOrientationItem::PutValue( const uno::Any& rVal, sal_uInt8 /*nMemberId*/ )
      88             : {
      89             :     table::CellOrientation eOrient;
      90           0 :     if(!(rVal >>= eOrient))
      91             :     {
      92           0 :         sal_Int32 nValue = 0;
      93           0 :         if(!(rVal >>= nValue))
      94           0 :             return false;
      95           0 :         eOrient = (table::CellOrientation)nValue;
      96             :     }
      97           0 :     SvxCellOrientation eSvx = SVX_ORIENTATION_STANDARD;
      98           0 :     switch (eOrient)
      99             :     {
     100           0 :         case table::CellOrientation_STANDARD:   eSvx = SVX_ORIENTATION_STANDARD;  break;
     101           0 :         case table::CellOrientation_TOPBOTTOM:  eSvx = SVX_ORIENTATION_TOPBOTTOM; break;
     102           0 :         case table::CellOrientation_BOTTOMTOP:  eSvx = SVX_ORIENTATION_BOTTOMTOP; break;
     103           0 :         case table::CellOrientation_STACKED:    eSvx = SVX_ORIENTATION_STACKED;   break;
     104             :         default: ; //prevent warning
     105             :     }
     106           0 :     SetValue( (sal_uInt16)eSvx );
     107           0 :     return true;
     108             : }
     109             : 
     110             : 
     111             : 
     112           0 : OUString SvxOrientationItem::GetValueText( sal_uInt16 nVal )
     113             : {
     114             :     DBG_ASSERT( nVal <= SVX_ORIENTATION_STACKED, "enum overflow!" );
     115           0 :     return SVX_RESSTR(RID_SVXITEMS_ORI_STANDARD + nVal);
     116             : }
     117             : 
     118             : 
     119             : 
     120           0 : SfxPoolItem* SvxOrientationItem::Clone( SfxItemPool* ) const
     121             : {
     122           0 :     return new SvxOrientationItem( *this );
     123             : }
     124             : 
     125             : 
     126             : 
     127         512 : SfxPoolItem* SvxOrientationItem::Create( SvStream& rStream, sal_uInt16 ) const
     128             : {
     129             :     sal_uInt16 nVal;
     130         512 :     rStream.ReadUInt16( nVal );
     131         512 :     return new SvxOrientationItem( (SvxCellOrientation)nVal, Which() );
     132             : }
     133             : 
     134             : 
     135             : 
     136           0 : sal_uInt16 SvxOrientationItem::GetValueCount() const
     137             : {
     138           0 :     return SVX_ORIENTATION_STACKED + 1; // letzter Enum-Wert + 1
     139             : }
     140             : 
     141             : 
     142             : 
     143         512 : bool SvxOrientationItem::IsStacked() const
     144             : {
     145         512 :     return static_cast< SvxCellOrientation >( GetValue() ) == SVX_ORIENTATION_STACKED;
     146             : }
     147             : 
     148         512 : sal_Int32 SvxOrientationItem::GetRotation( sal_Int32 nStdAngle ) const
     149             : {
     150         512 :     sal_Int32 nAngle = nStdAngle;
     151         512 :     switch( static_cast< SvxCellOrientation >( GetValue() ) )
     152             :     {
     153           0 :         case SVX_ORIENTATION_BOTTOMTOP: nAngle = 9000;break;
     154           0 :         case SVX_ORIENTATION_TOPBOTTOM: nAngle = 27000;break;
     155             :         default: ; //prevent warning
     156             :     }
     157         512 :     return nAngle;
     158             : }
     159             : 
     160         592 : void SvxOrientationItem::SetFromRotation( sal_Int32 nRotation, bool bStacked )
     161             : {
     162         592 :     if( bStacked )
     163             :     {
     164           9 :         SetValue( SVX_ORIENTATION_STACKED );
     165             :     }
     166         583 :     else switch( nRotation )
     167             :     {
     168           9 :         case 9000:  SetValue( SVX_ORIENTATION_BOTTOMTOP );  break;
     169          13 :         case 27000: SetValue( SVX_ORIENTATION_TOPBOTTOM );  break;
     170         561 :         default:    SetValue( SVX_ORIENTATION_STANDARD );
     171             :     }
     172         592 : }
     173             : 
     174        1940 : SvxMarginItem::SvxMarginItem( const sal_uInt16 nId ) :
     175             : 
     176             :     SfxPoolItem( nId ),
     177             : 
     178             :     nLeftMargin  ( 20 ),
     179             :     nTopMargin   ( 20 ),
     180             :     nRightMargin ( 20 ),
     181        1940 :     nBottomMargin( 20 )
     182             : {
     183        1940 : }
     184             : 
     185             : 
     186             : 
     187        2376 : SvxMarginItem::SvxMarginItem( sal_Int16 nLeft,
     188             :                               sal_Int16 nTop,
     189             :                               sal_Int16 nRight,
     190             :                               sal_Int16 nBottom,
     191             :                               const sal_uInt16 nId ) :
     192             :     SfxPoolItem( nId ),
     193             : 
     194             :     nLeftMargin  ( nLeft ),
     195             :     nTopMargin   ( nTop ),
     196             :     nRightMargin ( nRight ),
     197        2376 :     nBottomMargin( nBottom )
     198             : {
     199        2376 : }
     200             : 
     201             : 
     202             : 
     203             : 
     204        3033 : SvxMarginItem::SvxMarginItem( const SvxMarginItem& rItem ) :
     205             : 
     206        3033 :     SfxPoolItem( rItem.Which() )
     207             : {
     208        3033 :     nLeftMargin = rItem.nLeftMargin;
     209        3033 :     nTopMargin = rItem.nTopMargin;
     210        3033 :     nRightMargin = rItem.nRightMargin;
     211        3033 :     nBottomMargin = rItem.nBottomMargin;
     212        3033 : }
     213             : 
     214             : 
     215             : 
     216           0 : bool SvxMarginItem::GetPresentation
     217             : (
     218             :     SfxItemPresentation ePres,
     219             :     SfxMapUnit          eCoreUnit,
     220             :     SfxMapUnit          ePresUnit,
     221             :     OUString&           rText, const IntlWrapper *pIntl
     222             : )   const
     223             : {
     224           0 :     OUString cpDelimTmp = OUString(cpDelim);
     225             : 
     226           0 :     switch ( ePres )
     227             :     {
     228             :         case SFX_ITEM_PRESENTATION_NAMELESS:
     229             :         {
     230           0 :             rText = GetMetricText( (long)nLeftMargin, eCoreUnit, ePresUnit, pIntl ) +
     231           0 :                         cpDelimTmp +
     232           0 :                         GetMetricText( (long)nTopMargin, eCoreUnit, ePresUnit, pIntl ) +
     233           0 :                         cpDelimTmp +
     234           0 :                         GetMetricText( (long)nRightMargin, eCoreUnit, ePresUnit, pIntl ) +
     235           0 :                         cpDelimTmp +
     236           0 :                         GetMetricText( (long)nBottomMargin, eCoreUnit, ePresUnit, pIntl );
     237           0 :             return true;
     238             :         }
     239             :         case SFX_ITEM_PRESENTATION_COMPLETE:
     240             :         {
     241           0 :             rText = SVX_RESSTR(RID_SVXITEMS_MARGIN_LEFT) +
     242           0 :                         GetMetricText( (long)nLeftMargin, eCoreUnit, ePresUnit, pIntl ) +
     243           0 :                         " " + EE_RESSTR(GetMetricId(ePresUnit)) +
     244           0 :                         cpDelimTmp +
     245           0 :                         SVX_RESSTR(RID_SVXITEMS_MARGIN_TOP) +
     246           0 :                         GetMetricText( (long)nTopMargin, eCoreUnit, ePresUnit, pIntl ) +
     247           0 :                         " " + EE_RESSTR(GetMetricId(ePresUnit)) +
     248           0 :                         cpDelimTmp +
     249           0 :                         SVX_RESSTR(RID_SVXITEMS_MARGIN_RIGHT) +
     250           0 :                         GetMetricText( (long)nRightMargin, eCoreUnit, ePresUnit, pIntl ) +
     251           0 :                         " " + EE_RESSTR(GetMetricId(ePresUnit)) +
     252           0 :                         cpDelimTmp +
     253           0 :                         SVX_RESSTR(RID_SVXITEMS_MARGIN_BOTTOM) +
     254           0 :                         GetMetricText( (long)nBottomMargin, eCoreUnit, ePresUnit, pIntl ) +
     255           0 :                         " " + EE_RESSTR(GetMetricId(ePresUnit));
     256           0 :             return true;
     257             :         }
     258             :         default: ; //prevent warning
     259             :     }
     260           0 :     return false;
     261             : }
     262             : 
     263             : 
     264             : 
     265        7029 : bool SvxMarginItem::operator==( const SfxPoolItem& rItem ) const
     266             : {
     267             :     DBG_ASSERT( SfxPoolItem::operator==( rItem ), "unequal type" );
     268             : 
     269       12427 :     return ( ( nLeftMargin == static_cast<const SvxMarginItem&>(rItem).nLeftMargin )   &&
     270        8858 :              ( nTopMargin == static_cast<const SvxMarginItem&>(rItem).nTopMargin )     &&
     271       12814 :              ( nRightMargin == static_cast<const SvxMarginItem&>(rItem).nRightMargin ) &&
     272        9354 :              ( nBottomMargin == static_cast<const SvxMarginItem&>(rItem).nBottomMargin ) );
     273             : }
     274             : 
     275             : 
     276             : 
     277        3001 : SfxPoolItem* SvxMarginItem::Clone( SfxItemPool* ) const
     278             : {
     279        3001 :     return new SvxMarginItem(*this);
     280             : }
     281             : 
     282             : 
     283             : 
     284         512 : SfxPoolItem* SvxMarginItem::Create( SvStream& rStream, sal_uInt16 ) const
     285             : {
     286             :     sal_Int16   nLeft;
     287             :     sal_Int16   nTop;
     288             :     sal_Int16   nRight;
     289             :     sal_Int16   nBottom;
     290         512 :     rStream.ReadInt16( nLeft );
     291         512 :     rStream.ReadInt16( nTop );
     292         512 :     rStream.ReadInt16( nRight );
     293         512 :     rStream.ReadInt16( nBottom );
     294         512 :     return new SvxMarginItem( nLeft, nTop, nRight, nBottom, Which() );
     295             : }
     296             : 
     297             : 
     298             : 
     299         528 : SvStream& SvxMarginItem::Store( SvStream &rStream, sal_uInt16 /*nItemVersion*/) const
     300             : {
     301         528 :     rStream.WriteInt16( nLeftMargin );
     302         528 :     rStream.WriteInt16( nTopMargin );
     303         528 :     rStream.WriteInt16( nRightMargin );
     304         528 :     rStream.WriteInt16( nBottomMargin );
     305         528 :     return rStream;
     306             : }
     307             : 
     308             : 
     309             : 
     310             : 
     311         116 : bool SvxMarginItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
     312             : {
     313         116 :     bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
     314         116 :     nMemberId &= ~CONVERT_TWIPS;
     315         116 :     switch ( nMemberId )
     316             :     {
     317             :         //  jetzt alles signed
     318             :         case MID_MARGIN_L_MARGIN:
     319          29 :             rVal <<= (sal_Int32)( bConvert ? convertTwipToMm100(nLeftMargin) : nLeftMargin );
     320          29 :             break;
     321             :         case MID_MARGIN_R_MARGIN:
     322          29 :             rVal <<= (sal_Int32)( bConvert ? convertTwipToMm100(nRightMargin) : nRightMargin );
     323          29 :             break;
     324             :         case MID_MARGIN_UP_MARGIN:
     325          29 :             rVal <<= (sal_Int32)( bConvert ? convertTwipToMm100(nTopMargin) : nTopMargin );
     326          29 :             break;
     327             :         case MID_MARGIN_LO_MARGIN:
     328          29 :             rVal <<= (sal_Int32)( bConvert ? convertTwipToMm100(nBottomMargin) : nBottomMargin );
     329          29 :             break;
     330             :         default:
     331             :             OSL_FAIL("unknown MemberId");
     332           0 :             return false;
     333             :     }
     334         116 :     return true;
     335             : }
     336             : 
     337             : 
     338             : 
     339        1728 : bool SvxMarginItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
     340             : {
     341        1728 :     bool bConvert = ( ( nMemberId & CONVERT_TWIPS ) != 0 );
     342        1728 :     long nMaxVal = bConvert ? convertTwipToMm100(SHRT_MAX) : SHRT_MAX;   // Members sind sal_Int16
     343        1728 :     sal_Int32 nVal = 0;
     344        1728 :     if(!(rVal >>= nVal) || (nVal > nMaxVal))
     345           0 :         return false;
     346             : 
     347        1728 :     switch ( nMemberId & ~CONVERT_TWIPS )
     348             :     {
     349             :         case MID_MARGIN_L_MARGIN:
     350         432 :             nLeftMargin = (sal_Int16)( bConvert ? convertMm100ToTwip(nVal) : nVal );
     351         432 :             break;
     352             :         case MID_MARGIN_R_MARGIN:
     353         432 :             nRightMargin = (sal_Int16)( bConvert ? convertMm100ToTwip(nVal) : nVal );
     354         432 :             break;
     355             :         case MID_MARGIN_UP_MARGIN:
     356         432 :             nTopMargin = (sal_Int16)( bConvert ? convertMm100ToTwip(nVal) : nVal );
     357         432 :             break;
     358             :         case MID_MARGIN_LO_MARGIN:
     359         432 :             nBottomMargin = (sal_Int16)( bConvert ? convertMm100ToTwip(nVal) : nVal );
     360         432 :             break;
     361             :         default:
     362             :             OSL_FAIL("unknown MemberId");
     363           0 :             return false;
     364             :     }
     365        1728 :     return true;
     366             : }
     367             : 
     368             : 
     369             : 
     370           0 : void SvxMarginItem::SetLeftMargin( sal_Int16 nLeft )
     371             : {
     372           0 :     nLeftMargin = nLeft;
     373           0 : }
     374             : 
     375             : 
     376             : 
     377           0 : void SvxMarginItem::SetTopMargin( sal_Int16 nTop )
     378             : {
     379           0 :     nTopMargin = nTop;
     380           0 : }
     381             : 
     382             : 
     383             : 
     384           0 : void SvxMarginItem::SetRightMargin( sal_Int16 nRight )
     385             : {
     386           0 :     nRightMargin = nRight;
     387           0 : }
     388             : 
     389             : 
     390             : 
     391           0 : void SvxMarginItem::SetBottomMargin( sal_Int16 nBottom )
     392             : {
     393           0 :     nBottomMargin = nBottom;
     394           0 : }
     395             : 
     396             : 
     397             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.11