/************************************************************** * * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. * *************************************************************/ // MARKER(update_precomp.py): autogen include statement, do not remove #include "precompiled_svx.hxx" #include #include #include #include #include #include #include #include #include #include #include #include #include "com/sun/star/style/VerticalAlignment.hpp" #include #include #include #include #include #include #include #include using namespace ::rtl; using namespace ::com::sun::star; // Konvertierung fuer UNO #define TWIP_TO_MM100(TWIP) ((TWIP) >= 0 ? (((TWIP)*127L+36L)/72L) : (((TWIP)*127L-36L)/72L)) #define MM100_TO_TWIP(MM100) ((MM100) >= 0 ? (((MM100)*72L+63L)/127L) : (((MM100)*72L-63L)/127L)) // STATIC DATA ----------------------------------------------------------- //TYPEINIT1_AUTOFACTORY( SvxHorJustifyItem, SfxEnumItem ); TYPEINIT1_FACTORY( SvxHorJustifyItem, SfxEnumItem, new SvxHorJustifyItem(SVX_HOR_JUSTIFY_STANDARD, 0)) TYPEINIT1_FACTORY( SvxVerJustifyItem, SfxEnumItem, new SvxVerJustifyItem(SVX_VER_JUSTIFY_STANDARD, 0) ); TYPEINIT1_FACTORY( SvxOrientationItem, SfxEnumItem, new SvxOrientationItem(SVX_ORIENTATION_STANDARD, 0) ); TYPEINIT1_FACTORY( SvxMarginItem, SfxPoolItem, new SvxMarginItem(0) ); // class SvxHorJustifyItem ----------------------------------------------- SvxHorJustifyItem::SvxHorJustifyItem( const sal_uInt16 nId ) : SfxEnumItem( nId, (sal_uInt16)SVX_HOR_JUSTIFY_STANDARD ) { } SvxHorJustifyItem::SvxHorJustifyItem( const SvxCellHorJustify eJustify, const sal_uInt16 nId ) : SfxEnumItem( nId, (sal_uInt16)eJustify ) { } //------------------------------------------------------------------------ SfxItemPresentation SvxHorJustifyItem::GetPresentation ( SfxItemPresentation ePres, SfxMapUnit /*eCoreUnit*/, SfxMapUnit /*ePresUnit*/, XubString& rText, const IntlWrapper *) const { switch ( ePres ) { case SFX_ITEM_PRESENTATION_NONE: rText.Erase(); return SFX_ITEM_PRESENTATION_NONE; case SFX_ITEM_PRESENTATION_NAMELESS: case SFX_ITEM_PRESENTATION_COMPLETE: rText = GetValueText( GetValue() ); return SFX_ITEM_PRESENTATION_COMPLETE; default: ; //prevent warning } return SFX_ITEM_PRESENTATION_NONE; } //------------------------------------------------------------------------ sal_Bool SvxHorJustifyItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const { // sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); nMemberId &= ~CONVERT_TWIPS; switch ( nMemberId ) { case MID_HORJUST_HORJUST: { table::CellHoriJustify eUno = table::CellHoriJustify_STANDARD; switch ( (SvxCellHorJustify)GetValue() ) { case SVX_HOR_JUSTIFY_STANDARD: eUno = table::CellHoriJustify_STANDARD; break; case SVX_HOR_JUSTIFY_LEFT: eUno = table::CellHoriJustify_LEFT; break; case SVX_HOR_JUSTIFY_CENTER: eUno = table::CellHoriJustify_CENTER; break; case SVX_HOR_JUSTIFY_RIGHT: eUno = table::CellHoriJustify_RIGHT; break; case SVX_HOR_JUSTIFY_BLOCK: eUno = table::CellHoriJustify_BLOCK; break; case SVX_HOR_JUSTIFY_REPEAT: eUno = table::CellHoriJustify_REPEAT; break; } rVal <<= eUno; } break; case MID_HORJUST_ADJUST: { // ParagraphAdjust values, as in SvxAdjustItem // (same value for ParaAdjust and ParaLastLineAdjust) sal_Int16 nAdjust = style::ParagraphAdjust_LEFT; switch ( (SvxCellHorJustify)GetValue() ) { // ParagraphAdjust_LEFT is used for STANDARD and REPEAT case SVX_HOR_JUSTIFY_STANDARD: case SVX_HOR_JUSTIFY_REPEAT: case SVX_HOR_JUSTIFY_LEFT: nAdjust = style::ParagraphAdjust_LEFT; break; case SVX_HOR_JUSTIFY_CENTER: nAdjust = style::ParagraphAdjust_CENTER; break; case SVX_HOR_JUSTIFY_RIGHT: nAdjust = style::ParagraphAdjust_RIGHT; break; case SVX_HOR_JUSTIFY_BLOCK: nAdjust = style::ParagraphAdjust_BLOCK; break; } rVal <<= nAdjust; // as sal_Int16 } break; } return sal_True; } sal_Bool SvxHorJustifyItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId ) { // sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); nMemberId &= ~CONVERT_TWIPS; switch ( nMemberId ) { case MID_HORJUST_HORJUST: { table::CellHoriJustify eUno; if(!(rVal >>= eUno)) { sal_Int32 nValue = 0; if(!(rVal >>= nValue)) return sal_False; eUno = (table::CellHoriJustify)nValue; } SvxCellHorJustify eSvx = SVX_HOR_JUSTIFY_STANDARD; switch (eUno) { case table::CellHoriJustify_STANDARD: eSvx = SVX_HOR_JUSTIFY_STANDARD; break; case table::CellHoriJustify_LEFT: eSvx = SVX_HOR_JUSTIFY_LEFT; break; case table::CellHoriJustify_CENTER: eSvx = SVX_HOR_JUSTIFY_CENTER; break; case table::CellHoriJustify_RIGHT: eSvx = SVX_HOR_JUSTIFY_RIGHT; break; case table::CellHoriJustify_BLOCK: eSvx = SVX_HOR_JUSTIFY_BLOCK; break; case table::CellHoriJustify_REPEAT: eSvx = SVX_HOR_JUSTIFY_REPEAT; break; default: ; //prevent warning } SetValue( (sal_uInt16)eSvx ); } break; case MID_HORJUST_ADJUST: { // property contains ParagraphAdjust values as sal_Int16 sal_Int16 nVal = sal_Int16(); if(!(rVal >>= nVal)) return sal_False; SvxCellHorJustify eSvx = SVX_HOR_JUSTIFY_STANDARD; switch (nVal) { // STRETCH is treated as BLOCK case style::ParagraphAdjust_LEFT: eSvx = SVX_HOR_JUSTIFY_LEFT; break; case style::ParagraphAdjust_RIGHT: eSvx = SVX_HOR_JUSTIFY_RIGHT; break; case style::ParagraphAdjust_STRETCH: case style::ParagraphAdjust_BLOCK: eSvx = SVX_HOR_JUSTIFY_BLOCK; break; case style::ParagraphAdjust_CENTER: eSvx = SVX_HOR_JUSTIFY_CENTER; break; } SetValue( (sal_uInt16)eSvx ); } } return sal_True; } //------------------------------------------------------------------------ XubString SvxHorJustifyItem::GetValueText( sal_uInt16 nVal ) const { DBG_ASSERT( nVal <= SVX_HOR_JUSTIFY_REPEAT, "enum overflow!" ); return SVX_RESSTR(RID_SVXITEMS_HORJUST_STANDARD + nVal); } //------------------------------------------------------------------------ SfxPoolItem* SvxHorJustifyItem::Clone( SfxItemPool* ) const { return new SvxHorJustifyItem( *this ); } //------------------------------------------------------------------------ SfxPoolItem* SvxHorJustifyItem::Create( SvStream& rStream, sal_uInt16 ) const { sal_uInt16 nVal; rStream >> nVal; return new SvxHorJustifyItem( (SvxCellHorJustify)nVal, Which() ); } //------------------------------------------------------------------------ sal_uInt16 SvxHorJustifyItem::GetValueCount() const { return SVX_HOR_JUSTIFY_REPEAT + 1; // letzter Enum-Wert + 1 } // class SvxVerJustifyItem ----------------------------------------------- SvxVerJustifyItem::SvxVerJustifyItem( const sal_uInt16 nId ) : SfxEnumItem( nId, (sal_uInt16)SVX_VER_JUSTIFY_STANDARD ) { } SvxVerJustifyItem::SvxVerJustifyItem( const SvxCellVerJustify eJustify, const sal_uInt16 nId ) : SfxEnumItem( nId, (sal_uInt16)eJustify ) { } //------------------------------------------------------------------------ SfxItemPresentation SvxVerJustifyItem::GetPresentation ( SfxItemPresentation ePres, SfxMapUnit /*eCoreUnit*/, SfxMapUnit /*ePresUnit*/, XubString& rText, const IntlWrapper * ) const { switch ( ePres ) { case SFX_ITEM_PRESENTATION_NONE: rText.Erase(); return SFX_ITEM_PRESENTATION_NONE; case SFX_ITEM_PRESENTATION_NAMELESS: case SFX_ITEM_PRESENTATION_COMPLETE: rText = GetValueText( GetValue() ); return SFX_ITEM_PRESENTATION_COMPLETE; default: ; //prevent warning } return SFX_ITEM_PRESENTATION_NONE; } //------------------------------------------------------------------------ sal_Bool SvxVerJustifyItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const { nMemberId &= ~CONVERT_TWIPS; switch ( nMemberId ) { case MID_HORJUST_ADJUST: { style::VerticalAlignment eUno = style::VerticalAlignment_TOP; switch ( (SvxCellVerJustify)GetValue() ) { case SVX_VER_JUSTIFY_TOP: eUno = style::VerticalAlignment_TOP; break; case SVX_VER_JUSTIFY_CENTER: eUno = style::VerticalAlignment_MIDDLE; break; case SVX_VER_JUSTIFY_BOTTOM: eUno = style::VerticalAlignment_BOTTOM; break; default: ; //prevent warning } rVal <<= eUno; break; } default: { table::CellVertJustify eUno = table::CellVertJustify_STANDARD; switch ( (SvxCellVerJustify)GetValue() ) { case SVX_VER_JUSTIFY_STANDARD: eUno = table::CellVertJustify_STANDARD; break; case SVX_VER_JUSTIFY_TOP: eUno = table::CellVertJustify_TOP; break; case SVX_VER_JUSTIFY_CENTER: eUno = table::CellVertJustify_CENTER; break; case SVX_VER_JUSTIFY_BOTTOM: eUno = table::CellVertJustify_BOTTOM; break; default: ; //prevent warning } rVal <<= eUno; break; } } return sal_True; } sal_Bool SvxVerJustifyItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId ) { nMemberId &= ~CONVERT_TWIPS; switch ( nMemberId ) { case MID_HORJUST_ADJUST: { // property contains ParagraphAdjust values as sal_Int16 style::VerticalAlignment nVal = style::VerticalAlignment_TOP; if(!(rVal >>= nVal)) return sal_False; SvxCellVerJustify eSvx = SVX_VER_JUSTIFY_STANDARD; switch (nVal) { case style::VerticalAlignment_TOP: eSvx = SVX_VER_JUSTIFY_TOP; break; case style::VerticalAlignment_MIDDLE: eSvx = SVX_VER_JUSTIFY_CENTER; break; case style::VerticalAlignment_BOTTOM: eSvx = SVX_VER_JUSTIFY_BOTTOM; break; default:; } SetValue( (sal_uInt16)eSvx ); break; } default: { table::CellVertJustify eUno; if(!(rVal >>= eUno)) { sal_Int32 nValue = 0; if(!(rVal >>= nValue)) return sal_False; eUno = (table::CellVertJustify)nValue; } SvxCellVerJustify eSvx = SVX_VER_JUSTIFY_STANDARD; switch (eUno) { case table::CellVertJustify_STANDARD: eSvx = SVX_VER_JUSTIFY_STANDARD; break; case table::CellVertJustify_TOP: eSvx = SVX_VER_JUSTIFY_TOP; break; case table::CellVertJustify_CENTER: eSvx = SVX_VER_JUSTIFY_CENTER; break; case table::CellVertJustify_BOTTOM: eSvx = SVX_VER_JUSTIFY_BOTTOM; break; default: ; //prevent warning } SetValue( (sal_uInt16)eSvx ); break; } } return sal_True; } //------------------------------------------------------------------------ XubString SvxVerJustifyItem::GetValueText( sal_uInt16 nVal ) const { DBG_ASSERT( nVal <= SVX_VER_JUSTIFY_BOTTOM, "enum overflow!" ); return SVX_RESSTR(RID_SVXITEMS_VERJUST_STANDARD + nVal); } //------------------------------------------------------------------------ SfxPoolItem* SvxVerJustifyItem::Clone( SfxItemPool* ) const { return new SvxVerJustifyItem( *this ); } //------------------------------------------------------------------------ SfxPoolItem* SvxVerJustifyItem::Create( SvStream& rStream, sal_uInt16 ) const { sal_uInt16 nVal; rStream >> nVal; return new SvxVerJustifyItem( (SvxCellVerJustify)nVal, Which() ); } //------------------------------------------------------------------------ sal_uInt16 SvxVerJustifyItem::GetValueCount() const { return SVX_VER_JUSTIFY_BOTTOM + 1; // letzter Enum-Wert + 1 } // class SvxOrientationItem ---------------------------------------------- SvxOrientationItem::SvxOrientationItem( const SvxCellOrientation eOrientation, const sal_uInt16 nId): SfxEnumItem( nId, (sal_uInt16)eOrientation ) { } SvxOrientationItem::SvxOrientationItem( sal_Int32 nRotation, sal_Bool bStacked, const sal_uInt16 nId ) : SfxEnumItem( nId ) { SetFromRotation( nRotation, bStacked ); } //------------------------------------------------------------------------ SfxItemPresentation SvxOrientationItem::GetPresentation ( SfxItemPresentation ePres, SfxMapUnit /*eCoreUnit*/, SfxMapUnit /*ePresUnit*/, XubString& rText, const IntlWrapper * ) const { switch ( ePres ) { case SFX_ITEM_PRESENTATION_NONE: rText.Erase(); return SFX_ITEM_PRESENTATION_NONE; case SFX_ITEM_PRESENTATION_NAMELESS: case SFX_ITEM_PRESENTATION_COMPLETE: rText = GetValueText( GetValue() ); return SFX_ITEM_PRESENTATION_COMPLETE; default: ; //prevent warning } return SFX_ITEM_PRESENTATION_NONE; } //------------------------------------------------------------------------ sal_Bool SvxOrientationItem::QueryValue( uno::Any& rVal, sal_uInt8 /*nMemberId*/ ) const { table::CellOrientation eUno = table::CellOrientation_STANDARD; switch ( (SvxCellOrientation)GetValue() ) { case SVX_ORIENTATION_STANDARD: eUno = table::CellOrientation_STANDARD; break; case SVX_ORIENTATION_TOPBOTTOM: eUno = table::CellOrientation_TOPBOTTOM; break; case SVX_ORIENTATION_BOTTOMTOP: eUno = table::CellOrientation_BOTTOMTOP; break; case SVX_ORIENTATION_STACKED: eUno = table::CellOrientation_STACKED; break; } rVal <<= eUno; return sal_True; } sal_Bool SvxOrientationItem::PutValue( const uno::Any& rVal, sal_uInt8 /*nMemberId*/ ) { table::CellOrientation eOrient; if(!(rVal >>= eOrient)) { sal_Int32 nValue = 0; if(!(rVal >>= nValue)) return sal_False; eOrient = (table::CellOrientation)nValue; } SvxCellOrientation eSvx = SVX_ORIENTATION_STANDARD; switch (eOrient) { case table::CellOrientation_STANDARD: eSvx = SVX_ORIENTATION_STANDARD; break; case table::CellOrientation_TOPBOTTOM: eSvx = SVX_ORIENTATION_TOPBOTTOM; break; case table::CellOrientation_BOTTOMTOP: eSvx = SVX_ORIENTATION_BOTTOMTOP; break; case table::CellOrientation_STACKED: eSvx = SVX_ORIENTATION_STACKED; break; default: ; //prevent warning } SetValue( (sal_uInt16)eSvx ); return sal_True; } //------------------------------------------------------------------------ XubString SvxOrientationItem::GetValueText( sal_uInt16 nVal ) const { DBG_ASSERT( nVal <= SVX_ORIENTATION_STACKED, "enum overflow!" ); return SVX_RESSTR(RID_SVXITEMS_ORI_STANDARD + nVal); } //------------------------------------------------------------------------ SfxPoolItem* SvxOrientationItem::Clone( SfxItemPool* ) const { return new SvxOrientationItem( *this ); } //------------------------------------------------------------------------ SfxPoolItem* SvxOrientationItem::Create( SvStream& rStream, sal_uInt16 ) const { sal_uInt16 nVal; rStream >> nVal; return new SvxOrientationItem( (SvxCellOrientation)nVal, Which() ); } //------------------------------------------------------------------------ sal_uInt16 SvxOrientationItem::GetValueCount() const { return SVX_ORIENTATION_STACKED + 1; // letzter Enum-Wert + 1 } //------------------------------------------------------------------------ sal_Bool SvxOrientationItem::IsStacked() const { return static_cast< SvxCellOrientation >( GetValue() ) == SVX_ORIENTATION_STACKED; } sal_Int32 SvxOrientationItem::GetRotation( sal_Int32 nStdAngle ) const { sal_Int32 nAngle = nStdAngle; switch( static_cast< SvxCellOrientation >( GetValue() ) ) { case SVX_ORIENTATION_BOTTOMTOP: nAngle = 9000; case SVX_ORIENTATION_TOPBOTTOM: nAngle = 27000; default: ; //prevent warning } return nAngle; } void SvxOrientationItem::SetFromRotation( sal_Int32 nRotation, sal_Bool bStacked ) { if( bStacked ) { SetValue( SVX_ORIENTATION_STACKED ); } else switch( nRotation ) { case 9000: SetValue( SVX_ORIENTATION_BOTTOMTOP ); break; case 27000: SetValue( SVX_ORIENTATION_TOPBOTTOM ); break; default: SetValue( SVX_ORIENTATION_STANDARD ); } } // class SvxMarginItem --------------------------------------------------- SvxMarginItem::SvxMarginItem( const sal_uInt16 nId ) : SfxPoolItem( nId ), nLeftMargin ( 20 ), nTopMargin ( 20 ), nRightMargin ( 20 ), nBottomMargin( 20 ) { } //------------------------------------------------------------------------ SvxMarginItem::SvxMarginItem( sal_Int16 nLeft, sal_Int16 nTop, sal_Int16 nRight, sal_Int16 nBottom, const sal_uInt16 nId ) : SfxPoolItem( nId ), nLeftMargin ( nLeft ), nTopMargin ( nTop ), nRightMargin ( nRight ), nBottomMargin( nBottom ) { } //------------------------------------------------------------------------ SvxMarginItem::SvxMarginItem( const SvxMarginItem& rItem ) : SfxPoolItem( rItem.Which() ) { nLeftMargin = rItem.nLeftMargin; nTopMargin = rItem.nTopMargin; nRightMargin = rItem.nRightMargin; nBottomMargin = rItem.nBottomMargin; } //------------------------------------------------------------------------ SfxItemPresentation SvxMarginItem::GetPresentation ( SfxItemPresentation ePres, SfxMapUnit eCoreUnit, SfxMapUnit ePresUnit, XubString& rText, const IntlWrapper *pIntl ) const { #ifndef SVX_LIGHT switch ( ePres ) { case SFX_ITEM_PRESENTATION_NONE: rText.Erase(); return SFX_ITEM_PRESENTATION_NONE; case SFX_ITEM_PRESENTATION_NAMELESS: { rText = GetMetricText( (long)nLeftMargin, eCoreUnit, ePresUnit, pIntl ); rText += cpDelim; rText += GetMetricText( (long)nTopMargin, eCoreUnit, ePresUnit, pIntl ); rText += cpDelim; rText += GetMetricText( (long)nRightMargin, eCoreUnit, ePresUnit, pIntl ); rText += cpDelim; rText += GetMetricText( (long)nBottomMargin, eCoreUnit, ePresUnit, pIntl ); return SFX_ITEM_PRESENTATION_NAMELESS; } case SFX_ITEM_PRESENTATION_COMPLETE: { rText = SVX_RESSTR(RID_SVXITEMS_MARGIN_LEFT); rText += GetMetricText( (long)nLeftMargin, eCoreUnit, ePresUnit, pIntl ); rText += sal_Unicode(' '); rText += SVX_RESSTR(GetMetricId(ePresUnit)); rText += cpDelim; rText += SVX_RESSTR(RID_SVXITEMS_MARGIN_TOP); rText += GetMetricText( (long)nTopMargin, eCoreUnit, ePresUnit, pIntl ); rText += sal_Unicode(' '); rText += SVX_RESSTR(GetMetricId(ePresUnit)); rText += cpDelim; rText += SVX_RESSTR(RID_SVXITEMS_MARGIN_RIGHT); rText += GetMetricText( (long)nRightMargin, eCoreUnit, ePresUnit, pIntl ); rText += sal_Unicode(' '); rText += SVX_RESSTR(GetMetricId(ePresUnit)); rText += cpDelim; rText += SVX_RESSTR(RID_SVXITEMS_MARGIN_BOTTOM); rText += GetMetricText( (long)nBottomMargin, eCoreUnit, ePresUnit, pIntl ); rText += sal_Unicode(' '); rText += SVX_RESSTR(GetMetricId(ePresUnit)); return SFX_ITEM_PRESENTATION_COMPLETE; } default: ; //prevent warning } #endif return SFX_ITEM_PRESENTATION_NONE; } //------------------------------------------------------------------------ int SvxMarginItem::operator==( const SfxPoolItem& rItem ) const { DBG_ASSERT( SfxPoolItem::operator==( rItem ), "unequal type" ); return ( ( nLeftMargin == ( (SvxMarginItem&)rItem ).nLeftMargin ) && ( nTopMargin == ( (SvxMarginItem&)rItem ).nTopMargin ) && ( nRightMargin == ( (SvxMarginItem&)rItem ).nRightMargin ) && ( nBottomMargin == ( (SvxMarginItem&)rItem ).nBottomMargin ) ); } //------------------------------------------------------------------------ SfxPoolItem* SvxMarginItem::Clone( SfxItemPool* ) const { return new SvxMarginItem(*this); } //------------------------------------------------------------------------ SfxPoolItem* SvxMarginItem::Create( SvStream& rStream, sal_uInt16 ) const { sal_Int16 nLeft; sal_Int16 nTop; sal_Int16 nRight; sal_Int16 nBottom; rStream >> nLeft; rStream >> nTop; rStream >> nRight; rStream >> nBottom; return new SvxMarginItem( nLeft, nTop, nRight, nBottom, Which() ); } //------------------------------------------------------------------------ SvStream& SvxMarginItem::Store( SvStream &rStream, sal_uInt16 /*nItemVersion*/) const { rStream << nLeftMargin; rStream << nTopMargin; rStream << nRightMargin; rStream << nBottomMargin; return rStream; } //------------------------------------------------------------------------ sal_Bool SvxMarginItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const { sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); nMemberId &= ~CONVERT_TWIPS; switch ( nMemberId ) { // jetzt alles signed case MID_MARGIN_L_MARGIN: rVal <<= (sal_Int32)( bConvert ? TWIP_TO_MM100(nLeftMargin) : nLeftMargin ); break; case MID_MARGIN_R_MARGIN: rVal <<= (sal_Int32)( bConvert ? TWIP_TO_MM100(nRightMargin) : nRightMargin ); break; case MID_MARGIN_UP_MARGIN: rVal <<= (sal_Int32)( bConvert ? TWIP_TO_MM100(nTopMargin) : nTopMargin ); break; case MID_MARGIN_LO_MARGIN: rVal <<= (sal_Int32)( bConvert ? TWIP_TO_MM100(nBottomMargin) : nBottomMargin ); break; default: DBG_ERROR("unknown MemberId"); return sal_False; } return sal_True; } //------------------------------------------------------------------------ sal_Bool SvxMarginItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId ) { sal_Bool bConvert = ( ( nMemberId & CONVERT_TWIPS ) != 0 ); long nMaxVal = bConvert ? TWIP_TO_MM100(SHRT_MAX) : SHRT_MAX; // Members sind sal_Int16 sal_Int32 nVal = 0; if(!(rVal >>= nVal) || (nVal > nMaxVal)) return sal_False; switch ( nMemberId & ~CONVERT_TWIPS ) { case MID_MARGIN_L_MARGIN: nLeftMargin = (sal_Int16)( bConvert ? MM100_TO_TWIP(nVal) : nVal ); break; case MID_MARGIN_R_MARGIN: nRightMargin = (sal_Int16)( bConvert ? MM100_TO_TWIP(nVal) : nVal ); break; case MID_MARGIN_UP_MARGIN: nTopMargin = (sal_Int16)( bConvert ? MM100_TO_TWIP(nVal) : nVal ); break; case MID_MARGIN_LO_MARGIN: nBottomMargin = (sal_Int16)( bConvert ? MM100_TO_TWIP(nVal) : nVal ); break; default: DBG_ERROR("unknown MemberId"); return sal_False; } return sal_True; } //------------------------------------------------------------------------ sal_Bool SvxMarginItem::SetLeftMargin( sal_Int16 nLeft ) { nLeftMargin = nLeft; return sal_True; } //------------------------------------------------------------------------ sal_Bool SvxMarginItem::SetTopMargin( sal_Int16 nTop ) { nTopMargin = nTop; return sal_True; } //------------------------------------------------------------------------ sal_Bool SvxMarginItem::SetRightMargin( sal_Int16 nRight ) { nRightMargin = nRight; return sal_True; } //------------------------------------------------------------------------ sal_Bool SvxMarginItem::SetBottomMargin( sal_Int16 nBottom ) { nBottomMargin = nBottom; return sal_True; }