diff options
Diffstat (limited to 'binfilter/bf_svx/source/items')
25 files changed, 13004 insertions, 0 deletions
diff --git a/binfilter/bf_svx/source/items/makefile.mk b/binfilter/bf_svx/source/items/makefile.mk new file mode 100644 index 000000000000..7fd6452ecb55 --- /dev/null +++ b/binfilter/bf_svx/source/items/makefile.mk @@ -0,0 +1,86 @@ +#************************************************************************* +# +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# Copyright 2000, 2010 Oracle and/or its affiliates. +# +# OpenOffice.org - a multi-platform office productivity suite +# +# This file is part of OpenOffice.org. +# +# OpenOffice.org is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License version 3 +# only, as published by the Free Software Foundation. +# +# OpenOffice.org is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License version 3 for more details +# (a copy is included in the LICENSE file that accompanied this code). +# +# You should have received a copy of the GNU Lesser General Public License +# version 3 along with OpenOffice.org. If not, see +# <http://www.openoffice.org/license.html> +# for a copy of the LGPLv3 License. +# +#************************************************************************* + +EXTERNAL_WARNINGS_NOT_ERRORS := TRUE + +PRJ=..$/..$/.. +BFPRJ=..$/.. + +PROJECTPCH4DLL=TRUE +PROJECTPCH=svxpch +PROJECTPCHSOURCE=$(BFPRJ)$/util$/svx_svxpch + +PRJNAME=binfilter +TARGET=svx_items + +NO_HIDS=TRUE + +# --- Settings ----------------------------------------------------- + +.INCLUDE : settings.mk +.INCLUDE : $(BFPRJ)$/util$/makefile.pmk +INC+= -I$(PRJ)$/inc$/bf_svx + +# --- Files -------------------------------------------------------- + +SRS1NAME=svx_svxitems +SRC1FILES = \ + svx_svxerr.src \ + svx_svxitems.src + +SLOFILES= \ + $(SLO)$/svx_writingmodeitem.obj \ + $(SLO)$/svx_frmitems.obj \ + $(SLO)$/svx_paraitem.obj \ + $(SLO)$/svx_textitem.obj \ + $(SLO)$/svx_postattr.obj \ + $(SLO)$/svx_flditem.obj \ + $(SLO)$/svx_hlnkitem.obj \ + $(SLO)$/svx_svxfont.obj \ + $(SLO)$/svx_pageitem.obj \ + $(SLO)$/svx_paperinf.obj \ + $(SLO)$/svx_drawitem.obj \ + $(SLO)$/svx_algitem.obj \ + $(SLO)$/svx_rotmodit.obj \ + $(SLO)$/svx_svxerr.obj \ + $(SLO)$/svx_zoomitem.obj \ + $(SLO)$/svx_chrtitem.obj \ + $(SLO)$/svx_bulitem.obj \ + $(SLO)$/svx_e3ditem.obj \ + $(SLO)$/svx_numitem.obj \ + $(SLO)$/svx_grfitem.obj \ + $(SLO)$/svx_clipfmtitem.obj \ + $(SLO)$/svx_xmlcnitm.obj + +EXCEPTIONSFILES= \ + $(SLO)$/svx_paraitem.obj \ + $(SLO)$/svx_frmitems.obj \ + $(SLO)$/svx_numitem.obj\ + $(SLO)$/svx_xmlcnitm.obj + +.INCLUDE : target.mk + diff --git a/binfilter/bf_svx/source/items/svx_algitem.cxx b/binfilter/bf_svx/source/items/svx_algitem.cxx new file mode 100644 index 000000000000..7adbd71dd515 --- /dev/null +++ b/binfilter/bf_svx/source/items/svx_algitem.cxx @@ -0,0 +1,518 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +// include --------------------------------------------------------------- + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +#include "svxitems.hrc" + +#define ITEMID_HORJUSTIFY 0 +#define ITEMID_VERJUSTIFY 0 +#define ITEMID_ORIENTATION 0 +#define ITEMID_LINEBREAK 0 +#define ITEMID_MARGIN 0 + +#include <tools/stream.hxx> + +#include <com/sun/star/table/CellVertJustify.hpp> +#include <com/sun/star/table/CellHoriJustify.hpp> +#include <com/sun/star/style/ParagraphAdjust.hpp> +#include <com/sun/star/table/CellOrientation.hpp> + +#include "algitem.hxx" +namespace binfilter { + +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 ----------------------------------------------------------- + +/*N*/ TYPEINIT1_AUTOFACTORY( SvxHorJustifyItem, SfxEnumItem ); +/*N*/ TYPEINIT1_AUTOFACTORY( SvxVerJustifyItem, SfxEnumItem ); +/*N*/ TYPEINIT1_AUTOFACTORY( SvxOrientationItem, SfxEnumItem ); +/*N*/ TYPEINIT1_AUTOFACTORY( SvxMarginItem, SfxPoolItem ); + +// class SvxHorJustifyItem ----------------------------------------------- + +/*N*/ SvxHorJustifyItem::SvxHorJustifyItem( const SvxCellHorJustify eJustify, +/*N*/ const USHORT nId ) : +/*N*/ SfxEnumItem( nId, eJustify ) +/*N*/ { +/*N*/ } + +//------------------------------------------------------------------------ + + +/*N*/ //------------------------------------------------------------------------ + +/*N*/ bool SvxHorJustifyItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const +/*N*/ { +/*N*/ sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); +/*N*/ nMemberId &= ~CONVERT_TWIPS; +/*N*/ switch ( nMemberId ) +/*N*/ { +/*N*/ case MID_HORJUST_HORJUST: +/*N*/ { +/*N*/ table::CellHoriJustify eUno = table::CellHoriJustify_STANDARD; +/*N*/ switch ( (SvxCellHorJustify)GetValue() ) +/*N*/ { +/*N*/ case SVX_HOR_JUSTIFY_STANDARD: eUno = table::CellHoriJustify_STANDARD; break; +/*N*/ case SVX_HOR_JUSTIFY_LEFT: eUno = table::CellHoriJustify_LEFT; break; +/*N*/ case SVX_HOR_JUSTIFY_CENTER: eUno = table::CellHoriJustify_CENTER; break; +/*N*/ case SVX_HOR_JUSTIFY_RIGHT: eUno = table::CellHoriJustify_RIGHT; break; +/*N*/ case SVX_HOR_JUSTIFY_BLOCK: eUno = table::CellHoriJustify_BLOCK; break; +/*?*/ case SVX_HOR_JUSTIFY_REPEAT: eUno = table::CellHoriJustify_REPEAT; break; +/*N*/ } +/*N*/ rVal <<= eUno; +/*N*/ } +/*N*/ break; +/*N*/ case MID_HORJUST_ADJUST: +/*N*/ { +/*N*/ // ParagraphAdjust values, as in SvxAdjustItem +/*N*/ // (same value for ParaAdjust and ParaLastLineAdjust) +/*N*/ +/*?*/ 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 +/*N*/ } +/*N*/ break; +/*N*/ } +/*N*/ return sal_True; +/*N*/ } + +/*N*/ bool SvxHorJustifyItem::PutValue( const uno::Any& rVal, BYTE nMemberId ) +/*N*/ { +/*N*/ sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); +/*N*/ nMemberId &= ~CONVERT_TWIPS; +/*N*/ switch ( nMemberId ) +/*N*/ { +/*N*/ case MID_HORJUST_HORJUST: +/*N*/ { +/*N*/ table::CellHoriJustify eUno; +/*N*/ if(!(rVal >>= eUno)) +/*N*/ { +/*N*/ sal_Int32 nValue; +/*?*/ if(!(rVal >>= nValue)) +/*?*/ return sal_False; +/*?*/ eUno = (table::CellHoriJustify)nValue; +/*N*/ } +/*N*/ SvxCellHorJustify eSvx = SVX_HOR_JUSTIFY_STANDARD; +/*N*/ switch (eUno) +/*N*/ { +/*N*/ case table::CellHoriJustify_STANDARD: eSvx = SVX_HOR_JUSTIFY_STANDARD; break; +/*N*/ case table::CellHoriJustify_LEFT: eSvx = SVX_HOR_JUSTIFY_LEFT; break; +/*N*/ case table::CellHoriJustify_CENTER: eSvx = SVX_HOR_JUSTIFY_CENTER; break; +/*N*/ case table::CellHoriJustify_RIGHT: eSvx = SVX_HOR_JUSTIFY_RIGHT; break; +/*N*/ case table::CellHoriJustify_BLOCK: eSvx = SVX_HOR_JUSTIFY_BLOCK; break; +/*?*/ case table::CellHoriJustify_REPEAT: eSvx = SVX_HOR_JUSTIFY_REPEAT; break; +/*N*/ } +/*N*/ SetValue( eSvx ); +/*N*/ } +/*N*/ break; +/*N*/ case MID_HORJUST_ADJUST: +/*N*/ { +/*N*/ // property contains ParagraphAdjust values as sal_Int16 +/*N*/ sal_Int16 nVal; +/*?*/ 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( eSvx ); +/*N*/ } +/*N*/ } +/*N*/ return sal_True; +/*N*/ } + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + +/*N*/ SfxPoolItem* SvxHorJustifyItem::Clone( SfxItemPool* ) const +/*N*/ { +/*N*/ return new SvxHorJustifyItem( *this ); +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ SfxPoolItem* SvxHorJustifyItem::Create( SvStream& rStream, USHORT ) const +/*N*/ { +/*N*/ USHORT nVal; +/*N*/ rStream >> nVal; +/*N*/ return new SvxHorJustifyItem( (SvxCellHorJustify)nVal, Which() ); +/*N*/ } +//------------------------------------------------------------------------ + +/*?*/ USHORT SvxHorJustifyItem::GetValueCount() const +/*?*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); return 0;//STRIP001 return SVX_HOR_JUSTIFY_REPEAT + 1; // letzter Enum-Wert + 1 +/*?*/ } + +// class SvxVerJustifyItem ----------------------------------------------- + +/*N*/ SvxVerJustifyItem::SvxVerJustifyItem( const SvxCellVerJustify eJustify, +/*N*/ const USHORT nId ) : +/*N*/ SfxEnumItem( nId, eJustify ) +/*N*/ { +/*N*/ } + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + +/*N*/ bool SvxVerJustifyItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const +/*N*/ { +/*N*/ table::CellVertJustify eUno = table::CellVertJustify_STANDARD; +/*N*/ switch ( (SvxCellVerJustify)GetValue() ) +/*N*/ { +/*N*/ case SVX_VER_JUSTIFY_STANDARD: eUno = table::CellVertJustify_STANDARD; break; +/*N*/ case SVX_VER_JUSTIFY_TOP: eUno = table::CellVertJustify_TOP; break; +/*N*/ case SVX_VER_JUSTIFY_CENTER: eUno = table::CellVertJustify_CENTER; break; +/*N*/ case SVX_VER_JUSTIFY_BOTTOM: eUno = table::CellVertJustify_BOTTOM; break; +/*N*/ } +/*N*/ rVal <<= eUno; +/*N*/ return sal_True; +/*N*/ } + +/*N*/ bool SvxVerJustifyItem::PutValue( const uno::Any& rVal, BYTE nMemberId ) +/*N*/ { +/*N*/ table::CellVertJustify eUno; +/*N*/ if(!(rVal >>= eUno)) +/*N*/ { +/*?*/ sal_Int32 nValue; +/*?*/ if(!(rVal >>= nValue)) +/*?*/ return sal_False; +/*?*/ eUno = (table::CellVertJustify)nValue; +/*N*/ } +/*N*/ +/*N*/ SvxCellVerJustify eSvx = SVX_VER_JUSTIFY_STANDARD; +/*N*/ switch (eUno) +/*N*/ { +/*N*/ case table::CellVertJustify_STANDARD: eSvx = SVX_VER_JUSTIFY_STANDARD; break; +/*N*/ case table::CellVertJustify_TOP: eSvx = SVX_VER_JUSTIFY_TOP; break; +/*N*/ case table::CellVertJustify_CENTER: eSvx = SVX_VER_JUSTIFY_CENTER; break; +/*N*/ case table::CellVertJustify_BOTTOM: eSvx = SVX_VER_JUSTIFY_BOTTOM; break; +/*N*/ } +/*N*/ SetValue( eSvx ); +/*N*/ +/*N*/ return sal_True; +/*N*/ } + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + +/*N*/ SfxPoolItem* SvxVerJustifyItem::Clone( SfxItemPool* ) const +/*N*/ { +/*N*/ return new SvxVerJustifyItem( *this ); +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ SfxPoolItem* SvxVerJustifyItem::Create( SvStream& rStream, USHORT ) const +/*N*/ { +/*N*/ USHORT nVal; +/*N*/ rStream >> nVal; +/*N*/ return new SvxVerJustifyItem( (SvxCellVerJustify)nVal, Which() ); +/*N*/ } + +//------------------------------------------------------------------------ + +/*?*/ USHORT SvxVerJustifyItem::GetValueCount() const +/*?*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); return 0;//STRIP001 return SVX_VER_JUSTIFY_BOTTOM + 1; // letzter Enum-Wert + 1 +/*?*/ } + +// class SvxOrientationItem ---------------------------------------------- + +/*N*/ SvxOrientationItem::SvxOrientationItem( const SvxCellOrientation eOrientation, +/*N*/ const USHORT nId): +/*N*/ SfxEnumItem( nId, eOrientation ) +/*N*/ { +/*N*/ } + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + +/*N*/ bool SvxOrientationItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const +/*N*/ { +/*N*/ table::CellOrientation eUno = table::CellOrientation_STANDARD; +/*N*/ switch ( (SvxCellOrientation)GetValue() ) +/*N*/ { +/*N*/ case SVX_ORIENTATION_STANDARD: eUno = table::CellOrientation_STANDARD; break; +/*N*/ case SVX_ORIENTATION_TOPBOTTOM: eUno = table::CellOrientation_TOPBOTTOM; break; +/*N*/ case SVX_ORIENTATION_BOTTOMTOP: eUno = table::CellOrientation_BOTTOMTOP; break; +/*N*/ case SVX_ORIENTATION_STACKED: eUno = table::CellOrientation_STACKED; break; +/*N*/ } +/*N*/ rVal <<= eUno; +/*N*/ return sal_True; +/*N*/ } + +/*N*/ bool SvxOrientationItem::PutValue( const uno::Any& rVal, BYTE nMemberId ) +/*N*/ { +/*N*/ table::CellOrientation eOrient; +/*N*/ if(!(rVal >>= eOrient)) +/*N*/ { +/*?*/ sal_Int32 nValue; +/*?*/ if(!(rVal >>= nValue)) +/*?*/ return sal_False; +/*?*/ eOrient = (table::CellOrientation)nValue; +/*N*/ } +/*N*/ SvxCellOrientation eSvx = SVX_ORIENTATION_STANDARD; +/*N*/ switch (eOrient) +/*N*/ { +/*N*/ 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; +/*N*/ case table::CellOrientation_STACKED: eSvx = SVX_ORIENTATION_STACKED; break; +/*N*/ } +/*N*/ SetValue( eSvx ); +/*N*/ return sal_True; +/*N*/ } + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + +/*N*/ SfxPoolItem* SvxOrientationItem::Clone( SfxItemPool* ) const +/*N*/ { +/*N*/ return new SvxOrientationItem( *this ); +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ SfxPoolItem* SvxOrientationItem::Create( SvStream& rStream, USHORT ) const +/*N*/ { +/*N*/ USHORT nVal; +/*N*/ rStream >> nVal; +/*N*/ return new SvxOrientationItem( (SvxCellOrientation)nVal, Which() ); +/*N*/ } + +//------------------------------------------------------------------------ + +/*?*/ USHORT SvxOrientationItem::GetValueCount() const +/*?*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); return 0;//STRIP001 return SVX_ORIENTATION_STACKED + 1; // letzter Enum-Wert + 1 +/*?*/ } + +// class SvxMarginItem --------------------------------------------------- + +/*N*/ SvxMarginItem::SvxMarginItem( const USHORT nId ) : +/*N*/ +/*N*/ SfxPoolItem( nId ), +/*N*/ +/*N*/ nLeftMargin ( 20 ), +/*N*/ nTopMargin ( 20 ), +/*N*/ nRightMargin ( 20 ), +/*N*/ nBottomMargin( 20 ) +/*N*/ { +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ SvxMarginItem::SvxMarginItem( sal_Int16 nLeft, +/*N*/ sal_Int16 nTop, +/*N*/ sal_Int16 nRight, +/*N*/ sal_Int16 nBottom, +/*N*/ const USHORT nId ) : +/*N*/ SfxPoolItem( nId ), +/*N*/ +/*N*/ nLeftMargin ( nLeft ), +/*N*/ nTopMargin ( nTop ), +/*N*/ nRightMargin ( nRight ), +/*N*/ nBottomMargin( nBottom ) +/*N*/ { +/*N*/ } + + +//------------------------------------------------------------------------ + +/*N*/ SvxMarginItem::SvxMarginItem( const SvxMarginItem& rItem ) : +/*N*/ +/*N*/ SfxPoolItem( rItem.Which() ) +/*N*/ { +/*N*/ nLeftMargin = rItem.nLeftMargin; +/*N*/ nTopMargin = rItem.nTopMargin; +/*N*/ nRightMargin = rItem.nRightMargin; +/*N*/ nBottomMargin = rItem.nBottomMargin; +/*N*/ } + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + +/*N*/ int SvxMarginItem::operator==( const SfxPoolItem& rItem ) const +/*N*/ { +/*N*/ DBG_ASSERT( SfxPoolItem::operator==( rItem ), "unequal type" ); +/*N*/ +/*N*/ return ( ( nLeftMargin == ( (SvxMarginItem&)rItem ).nLeftMargin ) && +/*N*/ ( nTopMargin == ( (SvxMarginItem&)rItem ).nTopMargin ) && +/*N*/ ( nRightMargin == ( (SvxMarginItem&)rItem ).nRightMargin ) && +/*N*/ ( nBottomMargin == ( (SvxMarginItem&)rItem ).nBottomMargin ) ); +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ SfxPoolItem* SvxMarginItem::Clone( SfxItemPool* ) const +/*N*/ { +/*N*/ return new SvxMarginItem(*this); +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ SfxPoolItem* SvxMarginItem::Create( SvStream& rStream, USHORT ) const +/*N*/ { +/*N*/ sal_Int16 nLeft; +/*N*/ sal_Int16 nTop; +/*N*/ sal_Int16 nRight; +/*N*/ sal_Int16 nBottom; +/*N*/ rStream >> nLeft; +/*N*/ rStream >> nTop; +/*N*/ rStream >> nRight; +/*N*/ rStream >> nBottom; +/*N*/ return new SvxMarginItem( nLeft, nTop, nRight, nBottom, Which() ); +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ SvStream& SvxMarginItem::Store( SvStream &rStream, USHORT nItemVersion) const +/*N*/ { +/*N*/ rStream << nLeftMargin; +/*N*/ rStream << nTopMargin; +/*N*/ rStream << nRightMargin; +/*N*/ rStream << nBottomMargin; +/*N*/ return rStream; +/*N*/ } + + +//------------------------------------------------------------------------ + +/*N*/ bool SvxMarginItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const +/*N*/ { +/*N*/ sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); +/*N*/ nMemberId &= ~CONVERT_TWIPS; +/*N*/ switch ( nMemberId ) +/*N*/ { +/*N*/ // jetzt alles signed +/*N*/ case MID_MARGIN_L_MARGIN: +/*N*/ rVal <<= (sal_Int32)( bConvert ? TWIP_TO_MM100(nLeftMargin) : nLeftMargin ); +/*N*/ break; +/*N*/ case MID_MARGIN_R_MARGIN: +/*N*/ rVal <<= (sal_Int32)( bConvert ? TWIP_TO_MM100(nRightMargin) : nRightMargin ); +/*N*/ break; +/*N*/ case MID_MARGIN_UP_MARGIN: +/*N*/ rVal <<= (sal_Int32)( bConvert ? TWIP_TO_MM100(nTopMargin) : nTopMargin ); +/*N*/ break; +/*N*/ case MID_MARGIN_LO_MARGIN: +/*N*/ rVal <<= (sal_Int32)( bConvert ? TWIP_TO_MM100(nBottomMargin) : nBottomMargin ); +/*N*/ break; +/*N*/ default: +/*N*/ DBG_ERROR("unknown MemberId"); +/*N*/ return sal_False; +/*N*/ } +/*N*/ return sal_True; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ bool SvxMarginItem::PutValue( const uno::Any& rVal, BYTE nMemberId ) +/*N*/ { +/*N*/ sal_Bool bConvert = ( ( nMemberId & CONVERT_TWIPS ) != 0 ); +/*N*/ long nMaxVal = bConvert ? TWIP_TO_MM100(SHRT_MAX) : SHRT_MAX; // Members sind sal_Int16 +/*N*/ sal_Int32 nVal; +/*N*/ if(!(rVal >>= nVal) || (nVal > nMaxVal)) +/*N*/ return sal_False; +/*N*/ +/*N*/ switch ( nMemberId & ~CONVERT_TWIPS ) +/*N*/ { +/*N*/ case MID_MARGIN_L_MARGIN: +/*N*/ nLeftMargin = (sal_Int16)( bConvert ? MM100_TO_TWIP(nVal) : nVal ); +/*N*/ break; +/*N*/ case MID_MARGIN_R_MARGIN: +/*N*/ nRightMargin = (sal_Int16)( bConvert ? MM100_TO_TWIP(nVal) : nVal ); +/*N*/ break; +/*N*/ case MID_MARGIN_UP_MARGIN: +/*N*/ nTopMargin = (sal_Int16)( bConvert ? MM100_TO_TWIP(nVal) : nVal ); +/*N*/ break; +/*N*/ case MID_MARGIN_LO_MARGIN: +/*N*/ nBottomMargin = (sal_Int16)( bConvert ? MM100_TO_TWIP(nVal) : nVal ); +/*N*/ break; +/*N*/ default: +/*N*/ DBG_ERROR("unknown MemberId"); +/*N*/ return sal_False; +/*N*/ } +/*N*/ return sal_True; +/*N*/ } + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_svx/source/items/svx_bulitem.cxx b/binfilter/bf_svx/source/items/svx_bulitem.cxx new file mode 100644 index 000000000000..f830d7ae509e --- /dev/null +++ b/binfilter/bf_svx/source/items/svx_bulitem.cxx @@ -0,0 +1,384 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +#include <vcl/outdev.hxx> + +#define _SVX_BULITEM_CXX + +#include "bulitem.hxx" + +// #90477# +#include <tools/tenccvt.hxx> +namespace binfilter { + +#define BULITEM_VERSION ((USHORT)2) + +// ----------------------------------------------------------------------- + +/*N*/ TYPEINIT1(SvxBulletItem,SfxPoolItem); + +// ----------------------------------------------------------------------- + +/*N*/ void SvxBulletItem::StoreFont( SvStream& rStream, const Font& rFont ) +/*N*/ { +/*N*/ USHORT nTemp; +/*N*/ +/*N*/ rStream << rFont.GetColor(); +/*N*/ nTemp = (USHORT)rFont.GetFamily(); rStream << nTemp; +/*N*/ +/*N*/ // #90477# nTemp = (USHORT)GetStoreCharSet( rFont.GetCharSet(), rStream.GetVersion() ); +/*N*/ nTemp = (USHORT)GetSOStoreTextEncoding((rtl_TextEncoding)rFont.GetCharSet(), (sal_uInt16)rStream.GetVersion()); +/*N*/ rStream << nTemp; +/*N*/ +/*N*/ nTemp = (USHORT)rFont.GetPitch(); rStream << nTemp; +/*N*/ nTemp = (USHORT)rFont.GetAlign(); rStream << nTemp; +/*N*/ nTemp = (USHORT)rFont.GetWeight(); rStream << nTemp; +/*N*/ nTemp = (USHORT)rFont.GetUnderline(); rStream << nTemp; +/*N*/ nTemp = (USHORT)rFont.GetStrikeout(); rStream << nTemp; +/*N*/ nTemp = (USHORT)rFont.GetItalic(); rStream << nTemp; +/*N*/ +/*N*/ // UNICODE: rStream << rFont.GetName(); +/*N*/ rStream.WriteByteString(rFont.GetName()); +/*N*/ +/*N*/ rStream << rFont.IsOutline(); +/*N*/ rStream << rFont.IsShadow(); +/*N*/ rStream << rFont.IsTransparent(); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ Font SvxBulletItem::CreateFont( SvStream& rStream, USHORT nVer ) +/*N*/ { +/*N*/ Font aFont; +/*N*/ Color aColor; +/*N*/ rStream >> aColor; aFont.SetColor( aColor ); +/*N*/ USHORT nTemp; +/*N*/ rStream >> nTemp; aFont.SetFamily((FontFamily)nTemp); +/*N*/ +/*N*/ // #90477# +/*N*/ rStream >> nTemp; +/*N*/ nTemp = (sal_uInt16)GetSOLoadTextEncoding((rtl_TextEncoding)nTemp, (sal_uInt16)rStream.GetVersion()); +/*N*/ aFont.SetCharSet((rtl_TextEncoding)nTemp); +/*N*/ +/*N*/ rStream >> nTemp; aFont.SetPitch((FontPitch)nTemp); +/*N*/ rStream >> nTemp; aFont.SetAlign((FontAlign)nTemp); +/*N*/ rStream >> nTemp; aFont.SetWeight((FontWeight)nTemp); +/*N*/ rStream >> nTemp; aFont.SetUnderline((FontUnderline)nTemp); +/*N*/ rStream >> nTemp; aFont.SetStrikeout((FontStrikeout)nTemp); +/*N*/ rStream >> nTemp; aFont.SetItalic((FontItalic)nTemp); +/*N*/ +/*N*/ // UNICODE: rStream >> aName; aFont.SetName( aName ); +/*N*/ String aName; +/*N*/ rStream.ReadByteString(aName); +/*N*/ aFont.SetName( aName ); +/*N*/ +/*N*/ if( nVer == 1 ) +/*N*/ { +/*N*/ long nHeight, nWidth; +/*?*/ rStream >> nHeight; rStream >> nWidth; Size aSize( nWidth, nHeight ); +/*?*/ aFont.SetSize( aSize ); +/*N*/ } +/*N*/ +/*N*/ BOOL bTemp; +/*N*/ rStream >> bTemp; aFont.SetOutline( bTemp ); +/*N*/ rStream >> bTemp; aFont.SetShadow( bTemp ); +/*N*/ rStream >> bTemp; aFont.SetTransparent( bTemp ); +/*N*/ return aFont; +/*N*/ } + + +// ----------------------------------------------------------------------- + +/*N*/ SvxBulletItem::SvxBulletItem( USHORT nWhich ) : SfxPoolItem( nWhich ) +/*N*/ { +/*N*/ SetDefaultFont_Impl(); +/*N*/ SetDefaults_Impl(); +/*N*/ nValidMask = 0xFFFF; +/*N*/ } + +// ----------------------------------------------------------------------- + + +// ----------------------------------------------------------------------- + + +// ----------------------------------------------------------------------- + + +// ----------------------------------------------------------------------- + + +// ----------------------------------------------------------------------- + +/*N*/ SvxBulletItem::SvxBulletItem( SvStream& rStrm, USHORT nWhich ) : +/*N*/ SfxPoolItem( nWhich ), +/*N*/ pGraphicObject( NULL ) +/*N*/ { +/*N*/ rStrm >> nStyle; +/*N*/ +/*N*/ if( nStyle != BS_BMP ) +/*N*/ aFont = CreateFont( rStrm, BULITEM_VERSION ); +/*N*/ else +/*N*/ { +/*N*/ // Sicheres Laden mit Test auf leere Bitmap +/*?*/ Bitmap aBmp; +/*?*/ const UINT32 nOldPos = rStrm.Tell(); +/*?*/ // #69345# Errorcode beim Bitmap lesen ignorieren, +/*?*/ // siehe Kommentar #67581# in SvxBulletItem::Store() +/*?*/ BOOL bOldError = rStrm.GetError() ? TRUE : FALSE; +/*?*/ rStrm >> aBmp; +/*?*/ if ( !bOldError && rStrm.GetError() ) +/*?*/ { +/*?*/ rStrm.ResetError(); +/*?*/ // #71493# Keine Warnung: Das BulletItem interessiert seit 5.0 im Dateiformat nicht mehr. +/*?*/ // rStrm.SetError(ERRCODE_CLASS_READ | ERRCODE_SVX_BULLETITEM_NOBULLET | ERRCODE_WARNING_MASK); +/*?*/ } +/*?*/ +/*?*/ if( aBmp.IsEmpty() ) +/*?*/ { +/*?*/ rStrm.Seek( nOldPos ); +/*?*/ nStyle = BS_NONE; +/*?*/ } +/*?*/ else +/*?*/ pGraphicObject = new BfGraphicObject( aBmp ); +/*N*/ } +/*N*/ +/*N*/ rStrm >> nWidth; +/*N*/ rStrm >> nStart; +/*N*/ rStrm >> nJustify; +/*N*/ +/*N*/ char cTmpSymbol; +/*N*/ rStrm >> cTmpSymbol; +/*N*/ cSymbol = ByteString::ConvertToUnicode( cTmpSymbol, aFont.GetCharSet() ); +/*N*/ +/*N*/ rStrm >> nScale; +/*N*/ +/*N*/ // UNICODE: rStrm >> aPrevText; +/*N*/ rStrm.ReadByteString(aPrevText); +/*N*/ +/*N*/ // UNICODE: rStrm >> aFollowText; +/*N*/ rStrm.ReadByteString(aFollowText); +/*N*/ +/*N*/ nValidMask = 0xFFFF; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvxBulletItem::SvxBulletItem( const SvxBulletItem& rItem) : SfxPoolItem( rItem ) +/*N*/ { +/*N*/ aFont = rItem.aFont; +/*N*/ pGraphicObject = ( rItem.pGraphicObject ? new BfGraphicObject( *rItem.pGraphicObject ) : NULL ); +/*N*/ aPrevText = rItem.aPrevText; +/*N*/ aFollowText = rItem.aFollowText; +/*N*/ nStart = rItem.nStart; +/*N*/ nStyle = rItem.nStyle; +/*N*/ nWidth = rItem.nWidth; +/*N*/ nScale = rItem.nScale; +/*N*/ cSymbol = rItem.cSymbol; +/*N*/ nJustify = rItem.nJustify; +/*N*/ nValidMask = rItem.nValidMask; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvxBulletItem::~SvxBulletItem() +/*N*/ { +/*N*/ if( pGraphicObject ) +/*?*/ delete pGraphicObject; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxBulletItem::Clone( SfxItemPool *pPool ) const +/*N*/ { +/*N*/ return new SvxBulletItem( *this ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxBulletItem::Create( SvStream& rStrm, USHORT nVersion ) const +/*N*/ { +/*N*/ return new SvxBulletItem( rStrm, Which() ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ void SvxBulletItem::SetDefaultFont_Impl() +/*N*/ { +/*N*/ aFont = OutputDevice::GetDefaultFont( DEFAULTFONT_FIXED, LANGUAGE_SYSTEM, 0 ); +/*N*/ aFont.SetAlign( ALIGN_BOTTOM); +/*N*/ aFont.SetTransparent( TRUE ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ void SvxBulletItem::SetDefaults_Impl() +/*N*/ { +/*N*/ pGraphicObject = NULL; +/*N*/ nWidth = 1200; // 1.2cm +/*N*/ nStart = 1; +/*N*/ nStyle = BS_123; +/*N*/ nJustify = BJ_HLEFT | BJ_VCENTER; +/*N*/ cSymbol = sal_Unicode(' '); +/*N*/ nScale = 75; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ USHORT SvxBulletItem::GetVersion( USHORT nVersion ) const +/*N*/ { +/*N*/ return BULITEM_VERSION; +/*N*/ } + +// ----------------------------------------------------------------------- + + + +// ----------------------------------------------------------------------- + +/*N*/ int SvxBulletItem::operator==( const SfxPoolItem& rItem ) const +/*N*/ { +/*N*/ DBG_ASSERT(rItem.ISA(SvxBulletItem),"operator==Types not matching"); +/*N*/ const SvxBulletItem& rBullet = (const SvxBulletItem&)rItem; +/*N*/ // ValidMask mitvergleichen, da sonst kein Putten in ein AttrSet moeglich, +/*N*/ // wenn sich das Item nur in der ValidMask von einem existierenden unterscheidet. +/*N*/ if( nValidMask != rBullet.nValidMask || +/*N*/ nStyle != rBullet.nStyle || +/*N*/ nScale != rBullet.nScale || +/*N*/ nJustify != rBullet.nJustify || +/*N*/ nWidth != rBullet.nWidth || +/*N*/ nStart != rBullet.nStart || +/*N*/ cSymbol != rBullet.cSymbol || +/*N*/ aPrevText != rBullet.aPrevText || +/*N*/ aFollowText != rBullet.aFollowText ) +/*N*/ return 0; +/*N*/ +/*N*/ if( ( nStyle != BS_BMP ) && ( aFont != rBullet.aFont ) ) +/*N*/ return 0; +/*N*/ +/*N*/ if( nStyle == BS_BMP ) +/*N*/ { +/*?*/ if( ( pGraphicObject && !rBullet.pGraphicObject ) || ( !pGraphicObject && rBullet.pGraphicObject ) ) +/*?*/ return 0; +/*?*/ +/*?*/ if( ( pGraphicObject && rBullet.pGraphicObject ) && +/*?*/ ( ( !(*pGraphicObject == *rBullet.pGraphicObject) ) || +/*?*/ ( pGraphicObject->GetPrefSize() != rBullet.pGraphicObject->GetPrefSize() ) ) ) +/*?*/ { +/*?*/ return 0; +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ return 1; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvStream& SvxBulletItem::Store( SvStream& rStrm, USHORT nItemVersion ) const +/*N*/ { +/*N*/ // Korrektur bei leerer Bitmap +/*N*/ if( ( nStyle == BS_BMP ) && +/*N*/ ( !pGraphicObject || ( GRAPHIC_NONE == pGraphicObject->GetType() ) || ( GRAPHIC_DEFAULT == pGraphicObject->GetType() ) ) ) +/*N*/ { +/*?*/ if( pGraphicObject ) +/*?*/ { +/*?*/ delete( const_cast< SvxBulletItem* >( this )->pGraphicObject ); +/*?*/ const_cast< SvxBulletItem* >( this )->pGraphicObject = NULL; +/*?*/ } +/*?*/ +/*?*/ const_cast< SvxBulletItem* >( this )->nStyle = BS_NONE; +/*N*/ } +/*N*/ +/*N*/ rStrm << nStyle; +/*N*/ +/*N*/ if( nStyle != BS_BMP ) +/*N*/ StoreFont( rStrm, aFont ); +/*N*/ else +/*N*/ { +/*?*/ ULONG nStart = rStrm.Tell(); +/*?*/ +/*?*/ // Kleine Vorab-Schaetzung der Groesse... +/*?*/ USHORT nFac = ( rStrm.GetCompressMode() != COMPRESSMODE_NONE ) ? 3 : 1; +/*?*/ const Bitmap aBmp( pGraphicObject->GetGraphic().GetBitmap() ); +/*?*/ ULONG nBytes = aBmp.GetSizeBytes(); +/*?*/ if ( nBytes < ULONG(0xFF00*nFac) ) +/*?*/ rStrm << aBmp; +/*?*/ +/*?*/ ULONG nEnd = rStrm.Tell(); +/*?*/ // #67581# Item darf mit Overhead nicht mehr als 64K schreiben, +/*?*/ // sonst platzt der SfxMultiRecord +/*?*/ // Dann lieber auf die Bitmap verzichten, ist nur fuer Outliner +/*?*/ // und auch nur fuer <= 5.0 wichtig. +/*?*/ // Beim Einlesen merkt der Stream-Operator der Bitmap, dass dort keine steht. +/*?*/ // Hiermit funktioniert jetzt der Fall das die grosse Bitmap aus einem anderen +/*?*/ // Fileformat entstanden ist, welches keine 64K belegt, aber wenn eine +/*?*/ // Bitmap > 64K verwendet wird, hat das SvxNumBulletItem beim Laden ein Problem, +/*?*/ // stuerzt aber nicht ab. +/*?*/ +/*?*/ if ( (nEnd-nStart) > 0xFF00 ) +/*?*/ rStrm.Seek( nStart ); +/*N*/ } +/*N*/ rStrm << nWidth; +/*N*/ rStrm << nStart; +/*N*/ rStrm << nJustify; +/*N*/ rStrm << (char)ByteString::ConvertFromUnicode( cSymbol, aFont.GetCharSet() ); +/*N*/ rStrm << nScale; +/*N*/ +/*N*/ // UNICODE: rStrm << aPrevText; +/*N*/ rStrm.WriteByteString(aPrevText); +/*N*/ +/*N*/ // UNICODE: rStrm << aFollowText; +/*N*/ rStrm.WriteByteString(aFollowText); +/*N*/ +/*N*/ return rStrm; +/*N*/ } + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_svx/source/items/svx_chrtitem.cxx b/binfilter/bf_svx/source/items/svx_chrtitem.cxx new file mode 100644 index 000000000000..c2ff778f57ed --- /dev/null +++ b/binfilter/bf_svx/source/items/svx_chrtitem.cxx @@ -0,0 +1,376 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +// include --------------------------------------------------------------- + +#include <tools/stream.hxx> +#if defined UNX && !defined LINUX +#include <wchar.h> +#endif + +#ifdef MAC +#include <stdlib.h> +#endif + +#include <stdio.h> +#include <float.h> + +#define ITEMID_CHARTSTYLE 0 +#define ITEMID_CHARTDATADESCR 0 +#define ITEMID_CHARTLEGENDPOS 0 +#define ITEMID_CHARTTEXTORDER 0 +#define ITEMID_CHARTTEXTORIENT 0 +#define ITEMID_CHARTKINDERROR 0 +#define ITEMID_CHARTINDICATE 0 +#define ITEMID_DOUBLE 0 +#define ITEMID_CHARTREGRESS 0 + +#include <bf_svtools/eitem.hxx> + +#include "chrtitem.hxx" + +#ifdef _MSC_VER +#pragma hdrstop +#endif +namespace binfilter { + +using namespace ::rtl; +using namespace ::com::sun::star; +// ----------------------------------------------------------------------- + +/*N*/ TYPEINIT1_AUTOFACTORY(SvxChartStyleItem, SfxEnumItem); +/*N*/ TYPEINIT1(SvxChartDataDescrItem, SfxEnumItem); +/*N*/ TYPEINIT1(SvxChartLegendPosItem, SfxEnumItem); +/*N*/ TYPEINIT1(SvxChartTextOrderItem, SfxEnumItem); +/*N*/ TYPEINIT1(SvxChartTextOrientItem, SfxEnumItem); +/*N*/ TYPEINIT1(SvxDoubleItem, SfxPoolItem); + +/************************************************************************* +|* +|* SvxChartStyleItem +|* +*************************************************************************/ + +/*N*/ SvxChartStyleItem::SvxChartStyleItem(SvxChartStyle eStyle, USHORT nId) : +/*N*/ SfxEnumItem(nId, eStyle) +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- + + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxChartStyleItem::Clone(SfxItemPool* pPool) const +/*N*/ { +/*N*/ return new SvxChartStyleItem(*this); +/*N*/ } + +// ----------------------------------------------------------------------- + + +/************************************************************************* +|* +|* SvxChartDataDescrItem +|* +*************************************************************************/ + +/*N*/ SvxChartDataDescrItem::SvxChartDataDescrItem(SvxChartDataDescr eDataDescr, +/*N*/ USHORT nId) : +/*N*/ SfxEnumItem(nId, eDataDescr) +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvxChartDataDescrItem::SvxChartDataDescrItem(SvStream& rIn, USHORT nId) : +/*N*/ SfxEnumItem(nId, rIn) +/*N*/ { +/*N*/ } + +/*N*/ // ----------------------------------------------------------------------- +/*N*/ +/*N*/ SfxPoolItem* SvxChartDataDescrItem::Clone(SfxItemPool* pPool) const +/*N*/ { +/*N*/ return new SvxChartDataDescrItem(*this); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxChartDataDescrItem::Create(SvStream& rIn, USHORT nVer) const +/*N*/ { +/*N*/ return new SvxChartDataDescrItem(rIn, Which()); +/*N*/ } + +/************************************************************************* +|* +|* SvxChartLegendPosItem +|* +*************************************************************************/ + +/*N*/ SvxChartLegendPosItem::SvxChartLegendPosItem(SvxChartLegendPos eLegendPos, +/*N*/ USHORT nId) : +/*N*/ SfxEnumItem(nId, eLegendPos) +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvxChartLegendPosItem::SvxChartLegendPosItem(SvStream& rIn, USHORT nId) : +/*N*/ SfxEnumItem(nId, rIn) +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxChartLegendPosItem::Clone(SfxItemPool* pPool) const +/*N*/ { +/*N*/ return new SvxChartLegendPosItem(*this); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxChartLegendPosItem::Create(SvStream& rIn, USHORT nVer) const +/*N*/ { +/*N*/ return new SvxChartLegendPosItem(rIn, Which()); +/*N*/ } + +/************************************************************************* +|* +|* SvxChartTextOrderItem +|* +*************************************************************************/ + +/*N*/ SvxChartTextOrderItem::SvxChartTextOrderItem(SvxChartTextOrder eOrder, +/*N*/ USHORT nId) : +/*N*/ SfxEnumItem(nId, eOrder) +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvxChartTextOrderItem::SvxChartTextOrderItem(SvStream& rIn, USHORT nId) : +/*N*/ SfxEnumItem(nId, rIn) +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxChartTextOrderItem::Clone(SfxItemPool* pPool) const +/*N*/ { +/*N*/ return new SvxChartTextOrderItem(*this); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxChartTextOrderItem::Create(SvStream& rIn, USHORT nVer) const +/*N*/ { +/*N*/ return new SvxChartTextOrderItem(rIn, Which()); +/*N*/ } + +/************************************************************************* +|* +|* SvxChartTextOrientItem +|* +*************************************************************************/ + +/*N*/ SvxChartTextOrientItem::SvxChartTextOrientItem(SvxChartTextOrient eOrient, +/*N*/ USHORT nId) : +/*N*/ SfxEnumItem(nId, eOrient) +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvxChartTextOrientItem::SvxChartTextOrientItem(SvStream& rIn, USHORT nId) : +/*N*/ SfxEnumItem(nId, rIn) +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxChartTextOrientItem::Clone(SfxItemPool* pPool) const +/*N*/ { +/*N*/ return new SvxChartTextOrientItem(*this); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxChartTextOrientItem::Create(SvStream& rIn, USHORT nVer) const +/*N*/ { +/*N*/ return new SvxChartTextOrientItem(rIn, Which()); +/*N*/ } + +/************************************************************************* +|* +|* SvxDoubleItem +|* +*************************************************************************/ + +/*N*/ SvxDoubleItem::SvxDoubleItem(double fValue, USHORT nId) : +/*N*/ SfxPoolItem(nId), +/*N*/ fVal(fValue) +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- + + +// ----------------------------------------------------------------------- + +/*N*/ SvxDoubleItem::SvxDoubleItem(const SvxDoubleItem& rItem) : +/*N*/ SfxPoolItem(rItem), +/*N*/ fVal(rItem.fVal) +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- + + +// ----------------------------------------------------------------------- + + +// ----------------------------------------------------------------------- + +/*N*/ int SvxDoubleItem::operator == (const SfxPoolItem& rItem) const +/*N*/ { +/*N*/ return (((SvxDoubleItem&)rItem).fVal == fVal); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxDoubleItem::Clone(SfxItemPool* Pool) const +/*N*/ { +/*N*/ return new SvxDoubleItem(*this); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxDoubleItem::Create(SvStream& rIn, USHORT nVersion) const +/*N*/ { +/*N*/ double fVal; +/*N*/ rIn >> fVal; +/*N*/ return new SvxDoubleItem(fVal, Which()); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvStream& SvxDoubleItem::Store(SvStream& rOut, USHORT nItemVersion) const +/*N*/ { +/*N*/ rOut << fVal; +/*N*/ return rOut; +/*N*/ } + +// ----------------------------------------------------------------------- + + +// ----------------------------------------------------------------------- + + +// ----------------------------------------------------------------------- + + + + + +// ----------------------------------------------------------------------- +/*N*/ bool SvxDoubleItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const +/*N*/ { +/*N*/ rVal <<= fVal; +/*N*/ return sal_True; +/*N*/ } + +// ----------------------------------------------------------------------- +/*N*/ bool SvxDoubleItem::PutValue( const uno::Any& rVal, BYTE nMemberId ) +/*N*/ { +/*N*/ return rVal >>= fVal; +/*N*/ } + + + +/************************************************************************* +|* +|* SvxChartKindErrorItem +|* +*************************************************************************/ + + +// ----------------------------------------------------------------------- + + +// ----------------------------------------------------------------------- + + +// ----------------------------------------------------------------------- + + +// ----------------------------------------------------------------------- + + +/************************************************************************* +|* +|* SvxChartIndicateItem +|* +*************************************************************************/ + + +// ----------------------------------------------------------------------- + + +// ----------------------------------------------------------------------- + + +// ----------------------------------------------------------------------- + + +// ----------------------------------------------------------------------- + + +/************************************************************************* +|* +|* SvxChartRegressItem +|* +*************************************************************************/ + + +// ----------------------------------------------------------------------- + + +// ----------------------------------------------------------------------- + + +// ----------------------------------------------------------------------- + + +// ----------------------------------------------------------------------- + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_svx/source/items/svx_clipfmtitem.cxx b/binfilter/bf_svx/source/items/svx_clipfmtitem.cxx new file mode 100644 index 000000000000..d77890cfae3f --- /dev/null +++ b/binfilter/bf_svx/source/items/svx_clipfmtitem.cxx @@ -0,0 +1,109 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +#define _SVSTDARR_ULONGS +#define _SVSTDARR_STRINGSDTOR + +#include <bf_svtools/svstdarr.hxx> +#include <clipfmtitem.hxx> +namespace binfilter { + + + +struct SvxClipboardFmtItem_Impl +{ + SvStringsDtor aFmtNms; + SvULongs aFmtIds; + static String sEmptyStr; + + SvxClipboardFmtItem_Impl() : aFmtNms( 8, 8 ), aFmtIds( 8, 8 ) {} + SvxClipboardFmtItem_Impl( const SvxClipboardFmtItem_Impl& ); +}; + +String SvxClipboardFmtItem_Impl::sEmptyStr; + +/*N*/ TYPEINIT1( SvxClipboardFmtItem, SfxPoolItem ); + +/*N*/ SvxClipboardFmtItem_Impl::SvxClipboardFmtItem_Impl( +/*N*/ const SvxClipboardFmtItem_Impl& rCpy ) +/*N*/ { +/*N*/ aFmtIds.Insert( &rCpy.aFmtIds, 0 ); +/*N*/ for( USHORT n = 0, nEnd = rCpy.aFmtNms.Count(); n < nEnd; ++n ) +/*N*/ { +/*N*/ String* pStr = rCpy.aFmtNms[ n ]; +/*N*/ if( pStr ) +/*N*/ pStr = new String( *pStr ); +/*N*/ aFmtNms.Insert( pStr, n ); +/*N*/ } +/*N*/ } + +/*N*/ SvxClipboardFmtItem::SvxClipboardFmtItem( const SvxClipboardFmtItem& rCpy ) +/*N*/ : SfxPoolItem( rCpy.Which() ), +/*N*/ pImpl( new SvxClipboardFmtItem_Impl( *rCpy.pImpl ) ) +/*N*/ { +/*N*/ } + +/*N*/ SvxClipboardFmtItem::~SvxClipboardFmtItem() +/*N*/ { +/*N*/ delete pImpl; +/*N*/ } + +/*N*/ int SvxClipboardFmtItem::operator==( const SfxPoolItem& rComp ) const +/*N*/ { +/*N*/ int nRet = 0; +/*N*/ const SvxClipboardFmtItem& rCmp = (SvxClipboardFmtItem&)rComp; +/*N*/ if( rCmp.pImpl->aFmtNms.Count() == pImpl->aFmtNms.Count() ) +/*N*/ { +/*N*/ nRet = 1; +/*N*/ const String* pStr1, *pStr2; +/*N*/ for( USHORT n = 0, nEnd = rCmp.pImpl->aFmtNms.Count(); n < nEnd; ++n ) +/*N*/ { +/*N*/ if( pImpl->aFmtIds[ n ] != rCmp.pImpl->aFmtIds[ n ] || +/*N*/ ( (0 == ( pStr1 = pImpl->aFmtNms[ n ] )) ^ +/*N*/ (0 == ( pStr2 = rCmp.pImpl->aFmtNms[ n ] ) )) || +/*N*/ ( pStr1 && *pStr1 != *pStr2 )) +/*N*/ { +/*N*/ nRet = 0; +/*N*/ break; +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ return nRet; +/*N*/ } + +/*N*/ SfxPoolItem* SvxClipboardFmtItem::Clone( SfxItemPool *pPool ) const +/*N*/ { +/*N*/ return new SvxClipboardFmtItem( *this ); +/*N*/ } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_svx/source/items/svx_drawitem.cxx b/binfilter/bf_svx/source/items/svx_drawitem.cxx new file mode 100644 index 000000000000..41141f0fc612 --- /dev/null +++ b/binfilter/bf_svx/source/items/svx_drawitem.cxx @@ -0,0 +1,322 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +// include --------------------------------------------------------------- + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +#include "svxids.hrc" + +#define ITEMID_COLOR_TABLE SID_COLOR_TABLE +#define ITEMID_GRADIENT_LIST SID_GRADIENT_LIST +#define ITEMID_HATCH_LIST SID_HATCH_LIST +#define ITEMID_BITMAP_LIST SID_BITMAP_LIST +#define ITEMID_DASH_LIST SID_DASH_LIST +#define ITEMID_LINEEND_LIST SID_LINEEND_LIST + + +#include <bf_svtools/poolitem.hxx> + +#include "drawitem.hxx" +namespace binfilter { + +// ----------------------------------------------------------------------- + +/*N*/ TYPEINIT1_AUTOFACTORY( SvxColorTableItem, SfxPoolItem ); +/*N*/ TYPEINIT1_AUTOFACTORY( SvxGradientListItem, SfxPoolItem ); +/*N*/ TYPEINIT1_AUTOFACTORY( SvxHatchListItem, SfxPoolItem ); +/*N*/ TYPEINIT1_AUTOFACTORY( SvxBitmapListItem, SfxPoolItem ); +/*N*/ TYPEINIT1_AUTOFACTORY( SvxDashListItem, SfxPoolItem ); +/*N*/ TYPEINIT1_AUTOFACTORY( SvxLineEndListItem, SfxPoolItem ); + +//================================================================== +// +// SvxColorTableItem +// +//================================================================== + +/*?*/ SvxColorTableItem::SvxColorTableItem() +/*?*/ { +/*?*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvxColorTableItem::SvxColorTableItem( XColorTable* pTable, sal_uInt16 nW ) : +/*N*/ SfxPoolItem( nW ), +/*N*/ pColorTable( pTable ) +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvxColorTableItem::SvxColorTableItem( const SvxColorTableItem& rItem ) : +/*N*/ SfxPoolItem( rItem ), +/*N*/ pColorTable( rItem.pColorTable ) +/*N*/ { +/*N*/ } + +//------------------------------------------------------------------------ + + +// ----------------------------------------------------------------------- + +/*?*/ int SvxColorTableItem::operator==( const SfxPoolItem& rItem ) const +/*?*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); return 0;//STRIP001 DBG_ASSERT( SfxPoolItem::operator==( rItem ), "unequal type" ); +/*?*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxColorTableItem::Clone( SfxItemPool * ) const +/*N*/ { +/*N*/ return new SvxColorTableItem( *this ); +/*N*/ } + +//================================================================== +// +// SvxGradientListItem +// +//================================================================== + +/*?*/ SvxGradientListItem::SvxGradientListItem() +/*?*/ { +/*?*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvxGradientListItem::SvxGradientListItem( XGradientList* pList, sal_uInt16 nW ) : +/*N*/ SfxPoolItem( nW ), +/*N*/ pGradientList( pList ) +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvxGradientListItem::SvxGradientListItem( const SvxGradientListItem& rItem ) : +/*N*/ SfxPoolItem( rItem ), +/*N*/ pGradientList( rItem.pGradientList ) +/*N*/ { +/*N*/ } + +//------------------------------------------------------------------------ + + +// ----------------------------------------------------------------------- + +/*?*/ int SvxGradientListItem::operator==( const SfxPoolItem& rItem ) const +/*?*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); return 0;//STRIP001 DBG_ASSERT( SfxPoolItem::operator==( rItem ), "unequal type" ); +/*?*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxGradientListItem::Clone( SfxItemPool * ) const +/*N*/ { +/*N*/ return new SvxGradientListItem( *this ); +/*N*/ } + +//================================================================== +// +// SvxHatchListItem +// +//================================================================== + +/*?*/ SvxHatchListItem::SvxHatchListItem() +/*?*/ { +/*?*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvxHatchListItem::SvxHatchListItem( XHatchList* pList, sal_uInt16 nW ) : +/*N*/ SfxPoolItem( nW ), +/*N*/ pHatchList( pList ) +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvxHatchListItem::SvxHatchListItem( const SvxHatchListItem& rItem ) : +/*N*/ SfxPoolItem( rItem ), +/*N*/ pHatchList( rItem.pHatchList ) +/*N*/ { +/*N*/ } + +//------------------------------------------------------------------------ + + +// ----------------------------------------------------------------------- + +/*?*/ int SvxHatchListItem::operator==( const SfxPoolItem& rItem ) const +/*?*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); return 0;//STRIP001 DBG_ASSERT( SfxPoolItem::operator==( rItem ), "unequal type" ); +/*?*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxHatchListItem::Clone( SfxItemPool * ) const +/*N*/ { +/*N*/ return new SvxHatchListItem( *this ); +/*N*/ } + +//================================================================== +// +// SvxBitmapListItem +// +//================================================================== + +/*?*/ SvxBitmapListItem::SvxBitmapListItem() +/*?*/ { +/*?*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvxBitmapListItem::SvxBitmapListItem( XBitmapList* pList, sal_uInt16 nW ) : +/*N*/ SfxPoolItem( nW ), +/*N*/ pBitmapList( pList ) +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvxBitmapListItem::SvxBitmapListItem( const SvxBitmapListItem& rItem ) : +/*N*/ SfxPoolItem( rItem ), +/*N*/ pBitmapList( rItem.pBitmapList ) +/*N*/ { +/*N*/ } + +//------------------------------------------------------------------------ + + +// ----------------------------------------------------------------------- + +/*?*/ int SvxBitmapListItem::operator==( const SfxPoolItem& rItem ) const +/*?*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); return 0;//STRIP001 DBG_ASSERT( SfxPoolItem::operator==( rItem ), "unequal type" ); +/*?*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxBitmapListItem::Clone( SfxItemPool * ) const +/*N*/ { +/*N*/ return new SvxBitmapListItem( *this ); +/*N*/ } + + +//================================================================== +// +// SvxDashListItem +// +//================================================================== + +/*?*/ SvxDashListItem::SvxDashListItem() +/*?*/ { +/*?*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvxDashListItem::SvxDashListItem( XDashList* pList, sal_uInt16 nW ) : +/*N*/ SfxPoolItem( nW ), +/*N*/ pDashList( pList ) +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvxDashListItem::SvxDashListItem( const SvxDashListItem& rItem ) : +/*N*/ SfxPoolItem( rItem ), +/*N*/ pDashList( rItem.pDashList ) +/*N*/ { +/*N*/ } + +//------------------------------------------------------------------------ + + +// ----------------------------------------------------------------------- + +/*?*/ int SvxDashListItem::operator==( const SfxPoolItem& rItem ) const +/*?*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); return 0;//STRIP001 DBG_ASSERT( SfxPoolItem::operator==( rItem ), "unequal type" ); +/*?*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxDashListItem::Clone( SfxItemPool * ) const +/*N*/ { +/*N*/ return new SvxDashListItem( *this ); +/*N*/ } + +//================================================================== +// +// SvxLineEndListItem +// +//================================================================== + +/*?*/ SvxLineEndListItem::SvxLineEndListItem() +/*?*/ { +/*?*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvxLineEndListItem::SvxLineEndListItem( XLineEndList* pList, sal_uInt16 nW ) : +/*N*/ SfxPoolItem( nW ), +/*N*/ pLineEndList( pList ) +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvxLineEndListItem::SvxLineEndListItem( const SvxLineEndListItem& rItem ) : +/*N*/ SfxPoolItem( rItem ), +/*N*/ pLineEndList( rItem.pLineEndList ) +/*N*/ { +/*N*/ } + +//------------------------------------------------------------------------ + + +// ----------------------------------------------------------------------- + +/*N*/ int SvxLineEndListItem::operator==( const SfxPoolItem& rItem ) const +/*N*/ { +/*N*/ DBG_ASSERT( SfxPoolItem::operator==( rItem ), "unequal type" ); +/*N*/ return ( ( SvxLineEndListItem& ) rItem).pLineEndList == pLineEndList; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxLineEndListItem::Clone( SfxItemPool * ) const +/*N*/ { +/*N*/ return new SvxLineEndListItem( *this ); +/*N*/ } + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_svx/source/items/svx_e3ditem.cxx b/binfilter/bf_svx/source/items/svx_e3ditem.cxx new file mode 100644 index 000000000000..ec2aea3ccf23 --- /dev/null +++ b/binfilter/bf_svx/source/items/svx_e3ditem.cxx @@ -0,0 +1,155 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#include <com/sun/star/drawing/Direction3D.hpp> +#include <tools/stream.hxx> +#ifdef _MSC_VER +#pragma hdrstop +#endif + +#include "e3ditem.hxx" +namespace binfilter { + +using namespace ::rtl; +using namespace ::com::sun::star; + +// STATIC DATA ----------------------------------------------------------- + +/*N*/ DBG_NAME(SvxVector3DItem) + +// ----------------------------------------------------------------------- + +/*N*/ TYPEINIT1_AUTOFACTORY(SvxVector3DItem, SfxPoolItem); + +// ----------------------------------------------------------------------- + +/*?*/ SvxVector3DItem::SvxVector3DItem() +/*?*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 /*?*/ DBG_CTOR(SvxVector3DItem, 0); +/*?*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvxVector3DItem::SvxVector3DItem( USHORT nWhich, const Vector3D& rVal ) : +/*N*/ SfxPoolItem( nWhich ), +/*N*/ aVal( rVal ) +/*N*/ { +/*N*/ DBG_CTOR(SvxVector3DItem, 0); +/*N*/ } + +// ----------------------------------------------------------------------- + + +// ----------------------------------------------------------------------- + +/*N*/ SvxVector3DItem::SvxVector3DItem( const SvxVector3DItem& rItem ) : +/*N*/ SfxPoolItem( rItem ), +/*N*/ aVal( rItem.aVal ) +/*N*/ { +/*N*/ DBG_CTOR(SvxVector3DItem, 0); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ int SvxVector3DItem::operator==( const SfxPoolItem &rItem ) const +/*N*/ { +/*N*/ DBG_CHKTHIS(SvxVector3DItem, 0); +/*N*/ DBG_ASSERT( SfxPoolItem::operator==( rItem ), "unequal type" ); +/*N*/ return ((SvxVector3DItem&)rItem).aVal == aVal; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxVector3DItem::Clone( SfxItemPool *pPool ) const +/*N*/ { +/*N*/ DBG_CHKTHIS(SvxVector3DItem, 0); +/*N*/ return new SvxVector3DItem( *this ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxVector3DItem::Create(SvStream &rStream, USHORT nVersion) const +/*N*/ { +/*N*/ DBG_CHKTHIS(SvxVector3DItem, 0); +/*N*/ Vector3D aStr; +/*N*/ rStream >> aStr; +/*N*/ return new SvxVector3DItem(Which(), aStr); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvStream& SvxVector3DItem::Store(SvStream &rStream, USHORT nItemVersion) const +/*N*/ { +/*N*/ DBG_CHKTHIS(SvxVector3DItem, 0); +/*N*/ +/*N*/ // ## if (nItemVersion) +/*N*/ rStream << aVal; +/*N*/ +/*N*/ return rStream; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ bool SvxVector3DItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const +/*N*/ { +/*N*/ drawing::Direction3D aDirection; +/*N*/ +/*N*/ // Werte eintragen +/*N*/ aDirection.DirectionX = aVal.X(); +/*N*/ aDirection.DirectionY = aVal.Y(); +/*N*/ aDirection.DirectionZ = aVal.Z(); +/*N*/ +/*N*/ rVal <<= aDirection; +/*N*/ return( sal_True ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ bool SvxVector3DItem::PutValue( const uno::Any& rVal, BYTE nMemberId ) +/*N*/ { +/*N*/ drawing::Direction3D aDirection; +/*N*/ if(!(rVal >>= aDirection)) +/*N*/ return sal_False; +/*N*/ +/*N*/ aVal.X() = aDirection.DirectionX; +/*N*/ aVal.Y() = aDirection.DirectionY; +/*N*/ aVal.Z() = aDirection.DirectionZ; +/*N*/ return sal_True; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ USHORT SvxVector3DItem::GetVersion (USHORT nFileFormatVersion) const +/*N*/ { +/*N*/ return (nFileFormatVersion == SOFFICE_FILEFORMAT_31) ? USHRT_MAX : 0; +/*N*/ } + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_svx/source/items/svx_flditem.cxx b/binfilter/bf_svx/source/items/svx_flditem.cxx new file mode 100644 index 000000000000..ba88c096d3cd --- /dev/null +++ b/binfilter/bf_svx/source/items/svx_flditem.cxx @@ -0,0 +1,759 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#include <bf_svtools/zforlist.hxx> +#include <tools/urlobj.hxx> +#ifdef _MSC_VER +#pragma hdrstop +#endif + +#define _SVX_FLDITEM_CXX + +#include <unotools/localfilehelper.hxx> + +#define ITEMID_FIELD 0 + +#include <bf_svtools/poolitem.hxx> + + +#include <bf_svx/itemdata.hxx> + +#include "flditem.hxx" +#include "adritem.hxx" + +// #90477# +#include <tools/tenccvt.hxx> +#include "bf_so3/staticbaseurl.hxx" +namespace binfilter { + +#define FRAME_MARKER (sal_uInt32)0x21981357 +#define CHARSET_MARKER (FRAME_MARKER+1) + +// ----------------------------------------------------------------------- + +/*N*/ TYPEINIT1( SvxFieldItem, SfxPoolItem ); + +/*N*/ SV_IMPL_PERSIST1( SvxFieldData, SvPersistBase ); + +// ----------------------------------------------------------------------- + +/*N*/ SvxFieldData::SvxFieldData() +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvxFieldData::~SvxFieldData() +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvxFieldData* SvxFieldData::Clone() const +/*N*/ { +/*N*/ return new SvxFieldData; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ int SvxFieldData::operator==( const SvxFieldData& rFld ) const +/*N*/ { +/*N*/ DBG_ASSERT( Type() == rFld.Type(), "==: Verschiedene Typen" ); +/*N*/ return TRUE; // Basicklasse immer gleich. +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ void SvxFieldData::Load( SvPersistStream & rStm ) +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ void SvxFieldData::Save( SvPersistStream & rStm ) +/*N*/ { +/*N*/ } + + +/*?*/ MetaAction* SvxFieldData::createBeginComment() const +/*?*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); return NULL;//STRIP001 return new MetaCommentAction( "FIELD_SEQ_BEGIN" ); +/*?*/ } + +/*?*/ MetaAction* SvxFieldData::createEndComment() const +/*?*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP");return NULL;//STRIP001 return new MetaCommentAction( "FIELD_SEQ_END" ); +/*?*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvxFieldItem::SvxFieldItem( SvxFieldData* pFld, const USHORT nId ) : +/*N*/ SfxPoolItem( nId ) +/*N*/ { +/*N*/ pField = pFld; // gehoert direkt dem Item +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvxFieldItem::SvxFieldItem( const SvxFieldData& rField, const USHORT nId ) : +/*N*/ SfxPoolItem( nId ) +/*N*/ { +/*N*/ pField = rField.Clone(); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvxFieldItem::SvxFieldItem( const SvxFieldItem& rItem ) : +/*N*/ SfxPoolItem ( rItem ) +/*N*/ { +/*N*/ pField = rItem.GetField() ? rItem.GetField()->Clone() : 0; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvxFieldItem::~SvxFieldItem() +/*N*/ { +/*N*/ delete pField; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxFieldItem::Clone( SfxItemPool* ) const +/*N*/ { +/*N*/ return new SvxFieldItem(*this); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxFieldItem::Create( SvStream& rStrm, USHORT ) const +/*N*/ { +/*N*/ SvxFieldData* pData = 0; +/*N*/ SvPersistStream aPStrm( GetClassManager(), &rStrm ); +/*N*/ aPStrm >> pData; +/*N*/ +/*N*/ if( aPStrm.IsEof() ) +/*?*/ aPStrm.SetError( SVSTREAM_GENERALERROR ); +/*N*/ +/*N*/ if ( aPStrm.GetError() == ERRCODE_IO_NOFACTORY ) +/*?*/ aPStrm.ResetError(); // Eigentlich einen Code, dass nicht alle Attr gelesen wurden... +/*N*/ +/*N*/ return new SvxFieldItem( pData, Which() ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvStream& SvxFieldItem::Store( SvStream& rStrm, USHORT nItemVersion ) const +/*N*/ { +/*N*/ DBG_ASSERT( pField, "SvxFieldItem::Store: Feld?!" ); +/*N*/ SvPersistStream aPStrm( GetClassManager(), &rStrm ); +/*N*/ // Das ResetError in der obigen Create-Methode gab es in 3.1 noch nicht, +/*N*/ // deshalb duerfen beim 3.x-Export neuere Items nicht gespeichert werden! +/*N*/ if ( ( rStrm.GetVersion() <= SOFFICE_FILEFORMAT_31 ) && pField && +/*N*/ pField->GetClassId() == 50 /* SdrMeasureField */ ) +/*N*/ { +/*N*/ // SvxFieldData reicht nicht, weil auch nicht am ClassMgr angemeldet +/*?*/ SvxURLField aDummyData; +/*?*/ aPStrm << &aDummyData; +/*N*/ } +/*N*/ else +/*N*/ aPStrm << pField; +/*N*/ +/*N*/ return rStrm; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ int SvxFieldItem::operator==( const SfxPoolItem& rItem ) const +/*N*/ { +/*N*/ DBG_ASSERT( SfxPoolItem::operator==( rItem ), "unequal which or type" ); +/*N*/ +/*N*/ const SvxFieldData* pOtherFld = ((const SvxFieldItem&)rItem).GetField(); +/*N*/ if ( !pField && !pOtherFld ) +/*N*/ return TRUE; +/*N*/ +/*N*/ if ( ( !pField && pOtherFld ) || ( pField && !pOtherFld ) ) +/*N*/ return FALSE; +/*N*/ +/*N*/ return ( ( pField->Type() == pOtherFld->Type() ) +/*N*/ && ( *pField == *pOtherFld ) ); +/*N*/ } + +// ================================================================= +// Es folgen die Ableitungen von SvxFieldData... +// ================================================================= + +/*N*/ SV_IMPL_PERSIST1( SvxDateField, SvxFieldData ); + +// ----------------------------------------------------------------------- + +/*N*/ SvxDateField::SvxDateField() +/*N*/ { +/*N*/ nFixDate = Date().GetDate(); +/*N*/ eType = SVXDATETYPE_VAR; +/*N*/ eFormat = SVXDATEFORMAT_STDSMALL; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvxDateField::SvxDateField( const Date& rDate, SvxDateType eT, SvxDateFormat eF ) +/*N*/ { +/*N*/ nFixDate = rDate.GetDate(); +/*N*/ eType = eT; +/*N*/ eFormat = eF; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvxFieldData* SvxDateField::Clone() const +/*N*/ { +/*N*/ return new SvxDateField( *this ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ int SvxDateField::operator==( const SvxFieldData& rOther ) const +/*N*/ { +/*N*/ if ( rOther.Type() != Type() ) +/*N*/ return FALSE; +/*N*/ +/*N*/ const SvxDateField& rOtherFld = (const SvxDateField&) rOther; +/*N*/ return ( ( nFixDate == rOtherFld.nFixDate ) && +/*N*/ ( eType == rOtherFld.eType ) && +/*N*/ ( eFormat == rOtherFld.eFormat ) ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ void SvxDateField::Load( SvPersistStream & rStm ) +/*N*/ { +/*N*/ USHORT nType, nFormat; +/*N*/ +/*N*/ rStm >> nFixDate; +/*N*/ rStm >> nType; +/*N*/ rStm >> nFormat; +/*N*/ +/*N*/ eType = (SvxDateType)nType; +/*N*/ eFormat= (SvxDateFormat)nFormat; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ void SvxDateField::Save( SvPersistStream & rStm ) +/*N*/ { +/*N*/ rStm << nFixDate; +/*N*/ rStm << (USHORT)eType; +/*N*/ rStm << (USHORT)eFormat; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SV_IMPL_PERSIST1( SvxURLField, SvxFieldData ); + +// ----------------------------------------------------------------------- + +/*N*/ SvxURLField::SvxURLField() +/*N*/ { +/*N*/ eFormat = SVXURLFORMAT_URL; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvxURLField::SvxURLField( const XubString& rURL, const XubString& rRepres, SvxURLFormat eFmt ) +/*N*/ : aURL( rURL ), aRepresentation( rRepres ) +/*N*/ { +/*N*/ eFormat = eFmt; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvxFieldData* SvxURLField::Clone() const +/*N*/ { +/*N*/ return new SvxURLField( *this ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ int SvxURLField::operator==( const SvxFieldData& rOther ) const +/*N*/ { +/*N*/ if ( rOther.Type() != Type() ) +/*N*/ return FALSE; +/*N*/ +/*N*/ const SvxURLField& rOtherFld = (const SvxURLField&) rOther; +/*N*/ return ( ( eFormat == rOtherFld.eFormat ) && +/*N*/ ( aURL == rOtherFld.aURL ) && +/*N*/ ( aRepresentation == rOtherFld.aRepresentation ) && +/*N*/ ( aTargetFrame == rOtherFld.aTargetFrame ) ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ void SvxURLField::Load( SvPersistStream & rStm ) +/*N*/ { +/*N*/ USHORT nFormat; +/*N*/ sal_uInt32 nFrameMarker, nCharSetMarker; +/*N*/ long nUlongSize = (long)sizeof(sal_uInt32); +/*N*/ String aTmpURL; +/*N*/ +/*N*/ rStm >> nFormat; +/*N*/ +/*N*/ // UNICODE: rStm >> aTmpURL; +/*N*/ rStm.ReadByteString(aTmpURL); +/*N*/ +/*N*/ // UNICODE: rStm >> aRepresentation; +/*N*/ // read to a temp string first, read text encoding and +/*N*/ // convert later to stay compatible to fileformat +/*N*/ ByteString aTempString; +/*N*/ rtl_TextEncoding aTempEncoding = RTL_TEXTENCODING_MS_1252; // #101493# Init for old documents +/*N*/ rStm.ReadByteString(aTempString); +/*N*/ +/*N*/ rStm >> nFrameMarker; +/*N*/ if ( nFrameMarker == FRAME_MARKER ) +/*N*/ { +/*N*/ // UNICODE: rStm >> aTargetFrame; +/*N*/ rStm.ReadByteString(aTargetFrame); +/*N*/ +/*N*/ rStm >> nCharSetMarker; +/*N*/ if ( nCharSetMarker == CHARSET_MARKER ) +/*N*/ { +/*N*/ USHORT nCharSet; +/*N*/ rStm >> nCharSet; +/*N*/ +/*N*/ // remember encoding +/*N*/ aTempEncoding = (rtl_TextEncoding)nCharSet; +/*N*/ } +/*N*/ else +/*?*/ rStm.SeekRel( -nUlongSize ); +/*N*/ } +/*N*/ else +/*?*/ rStm.SeekRel( -nUlongSize ); +/*N*/ +/*N*/ // now build representation string due to known encoding +/*N*/ aRepresentation = String(aTempString, aTempEncoding); +/*N*/ +/*N*/ eFormat= (SvxURLFormat)nFormat; +/*N*/ +/*N*/ // Relatives Speichern => Beim laden absolut machen. +/*N*/ aURL = ::binfilter::StaticBaseUrl::RelToAbs( aTmpURL ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ void SvxURLField::Save( SvPersistStream & rStm ) +/*N*/ { +/*N*/ // Relatives Speichern der URL +/*N*/ String aTmpURL = ::binfilter::StaticBaseUrl::AbsToRel( aURL ); +/*N*/ +/*N*/ rStm << (USHORT)eFormat; +/*N*/ +/*N*/ // UNICODE: rStm << aTmpURL; +/*N*/ rStm.WriteByteString(aTmpURL); +/*N*/ +/*N*/ // UNICODE: rStm << aRepresentation; +/*N*/ rStm.WriteByteString(aRepresentation); +/*N*/ +/*N*/ rStm << FRAME_MARKER; +/*N*/ +/*N*/ // UNICODE: rStm << aTargetFrame; +/*N*/ rStm.WriteByteString(aTargetFrame); +/*N*/ +/*N*/ rStm << CHARSET_MARKER; +/*N*/ +/*N*/ // #90477# rStm << (USHORT)GetStoreCharSet(gsl_getSystemTextEncoding(), rStm.GetVersion()); +/*N*/ rStm << (USHORT)GetSOStoreTextEncoding(gsl_getSystemTextEncoding(), (sal_uInt16)rStm.GetVersion()); +/*N*/ } + + +// ================================================================= +// Die Felder, die aus Calc ausgebaut wurden: +// ================================================================= + +/*N*/ SV_IMPL_PERSIST1( SvxPageField, SvxFieldData ); + +/*N*/ SvxFieldData* __EXPORT SvxPageField::Clone() const +/*N*/ { +/*N*/ return new SvxPageField; // leer +/*N*/ } + +/*N*/ int __EXPORT SvxPageField::operator==( const SvxFieldData& rCmp ) const +/*N*/ { +/*N*/ return ( rCmp.Type() == TYPE(SvxPageField) ); +/*N*/ } + +/*N*/ void __EXPORT SvxPageField::Load( SvPersistStream & rStm ) +/*N*/ { +/*N*/ } + +/*N*/ void __EXPORT SvxPageField::Save( SvPersistStream & rStm ) +/*N*/ { +/*N*/ } + + + +/*N*/ SV_IMPL_PERSIST1( SvxPagesField, SvxFieldData ); + +/*N*/ SvxFieldData* __EXPORT SvxPagesField::Clone() const +/*N*/ { +/*N*/ return new SvxPagesField; // leer +/*N*/ } + +/*N*/ int __EXPORT SvxPagesField::operator==( const SvxFieldData& rCmp ) const +/*N*/ { +/*N*/ return ( rCmp.Type() == TYPE(SvxPagesField) ); +/*N*/ } + +/*N*/ void __EXPORT SvxPagesField::Load( SvPersistStream & rStm ) +/*N*/ { +/*N*/ } + +/*N*/ void __EXPORT SvxPagesField::Save( SvPersistStream & rStm ) +/*N*/ { +/*N*/ } + +/*N*/ SV_IMPL_PERSIST1( SvxTimeField, SvxFieldData ); + +/*N*/ SvxFieldData* __EXPORT SvxTimeField::Clone() const +/*N*/ { +/*N*/ return new SvxTimeField; // leer +/*N*/ } + +/*N*/ int __EXPORT SvxTimeField::operator==( const SvxFieldData& rCmp ) const +/*N*/ { +/*N*/ return ( rCmp.Type() == TYPE(SvxTimeField) ); +/*N*/ } + +/*N*/ void __EXPORT SvxTimeField::Load( SvPersistStream & rStm ) +/*N*/ { +/*N*/ } + +/*N*/ void __EXPORT SvxTimeField::Save( SvPersistStream & rStm ) +/*N*/ { +/*N*/ } + + +/*N*/ SV_IMPL_PERSIST1( SvxFileField, SvxFieldData ); + +/*N*/ SvxFieldData* __EXPORT SvxFileField::Clone() const +/*N*/ { +/*N*/ return new SvxFileField; // leer +/*N*/ } + +/*N*/ int __EXPORT SvxFileField::operator==( const SvxFieldData& rCmp ) const +/*N*/ { +/*N*/ return ( rCmp.Type() == TYPE(SvxFileField) ); +/*N*/ } + +/*N*/ void __EXPORT SvxFileField::Load( SvPersistStream & rStm ) +/*N*/ { +/*N*/ } + +/*N*/ void __EXPORT SvxFileField::Save( SvPersistStream & rStm ) +/*N*/ { +/*N*/ } + +/*N*/ SV_IMPL_PERSIST1( SvxTableField, SvxFieldData ); + +/*N*/ SvxFieldData* __EXPORT SvxTableField::Clone() const +/*N*/ { +/*N*/ return new SvxTableField; // leer +/*N*/ } + +/*N*/ int __EXPORT SvxTableField::operator==( const SvxFieldData& rCmp ) const +/*N*/ { +/*N*/ return ( rCmp.Type() == TYPE(SvxTableField) ); +/*N*/ } + +/*N*/ void __EXPORT SvxTableField::Load( SvPersistStream & rStm ) +/*N*/ { +/*N*/ } + +/*N*/ void __EXPORT SvxTableField::Save( SvPersistStream & rStm ) +/*N*/ { +/*N*/ } + +//---------------------------------------------------------------------------- +// SvxExtTimeField +//---------------------------------------------------------------------------- + +/*N*/ SV_IMPL_PERSIST1( SvxExtTimeField, SvxFieldData ); + +//---------------------------------------------------------------------------- + +/*N*/ SvxExtTimeField::SvxExtTimeField() +/*N*/ { +/*N*/ nFixTime = Time().GetTime(); +/*N*/ eType = SVXTIMETYPE_VAR; +/*N*/ eFormat = SVXTIMEFORMAT_STANDARD; +/*N*/ } + +//---------------------------------------------------------------------------- + +/*N*/ SvxExtTimeField::SvxExtTimeField( const Time& rTime, SvxTimeType eT, SvxTimeFormat eF ) +/*N*/ { +/*N*/ nFixTime = rTime.GetTime(); +/*N*/ eType = eT; +/*N*/ eFormat = eF; +/*N*/ } + +//---------------------------------------------------------------------------- + +/*N*/ SvxFieldData* SvxExtTimeField::Clone() const +/*N*/ { +/*N*/ return new SvxExtTimeField( *this ); +/*N*/ } + +//---------------------------------------------------------------------------- + +/*N*/ int SvxExtTimeField::operator==( const SvxFieldData& rOther ) const +/*N*/ { +/*N*/ if ( rOther.Type() != Type() ) +/*N*/ return FALSE; +/*N*/ +/*N*/ const SvxExtTimeField& rOtherFld = (const SvxExtTimeField&) rOther; +/*N*/ return ( ( nFixTime == rOtherFld.nFixTime ) && +/*N*/ ( eType == rOtherFld.eType ) && +/*N*/ ( eFormat == rOtherFld.eFormat ) ); +/*N*/ } + +//---------------------------------------------------------------------------- + +/*N*/ void SvxExtTimeField::Load( SvPersistStream & rStm ) +/*N*/ { +/*N*/ USHORT nType, nFormat; +/*N*/ +/*N*/ rStm >> nFixTime; +/*N*/ rStm >> nType; +/*N*/ rStm >> nFormat; +/*N*/ +/*N*/ eType = (SvxTimeType) nType; +/*N*/ eFormat= (SvxTimeFormat) nFormat; +/*N*/ } + +//---------------------------------------------------------------------------- + +/*N*/ void SvxExtTimeField::Save( SvPersistStream & rStm ) +/*N*/ { +/*N*/ rStm << nFixTime; +/*N*/ rStm << (USHORT) eType; +/*N*/ rStm << (USHORT) eFormat; +/*N*/ } + +//---------------------------------------------------------------------------- + +//---------------------------------------------------------------------------- +// SvxExtFileField +//---------------------------------------------------------------------------- + +/*N*/ SV_IMPL_PERSIST1( SvxExtFileField, SvxFieldData ); + +//---------------------------------------------------------------------------- + +/*N*/ SvxExtFileField::SvxExtFileField() +/*N*/ { +/*N*/ eType = SVXFILETYPE_VAR; +/*N*/ eFormat = SVXFILEFORMAT_FULLPATH; +/*N*/ } + +//---------------------------------------------------------------------------- + +/*N*/ SvxExtFileField::SvxExtFileField( const XubString& rStr, SvxFileType eT, SvxFileFormat eF ) +/*N*/ { +/*N*/ aFile = rStr; +/*N*/ eType = eT; +/*N*/ eFormat = eF; +/*N*/ } + +//---------------------------------------------------------------------------- + +/*N*/ SvxFieldData* SvxExtFileField::Clone() const +/*N*/ { +/*N*/ return new SvxExtFileField( *this ); +/*N*/ } + +//---------------------------------------------------------------------------- + +/*N*/ int SvxExtFileField::operator==( const SvxFieldData& rOther ) const +/*N*/ { +/*N*/ if ( rOther.Type() != Type() ) +/*N*/ return FALSE; +/*N*/ +/*N*/ const SvxExtFileField& rOtherFld = (const SvxExtFileField&) rOther; +/*N*/ return ( ( aFile == rOtherFld.aFile ) && +/*N*/ ( eType == rOtherFld.eType ) && +/*N*/ ( eFormat == rOtherFld.eFormat ) ); +/*N*/ } + +//---------------------------------------------------------------------------- + +/*N*/ void SvxExtFileField::Load( SvPersistStream & rStm ) +/*N*/ { +/*N*/ USHORT nType, nFormat; +/*N*/ +/*N*/ // UNICODE: rStm >> aFile; +/*N*/ rStm.ReadByteString(aFile); +/*N*/ +/*N*/ rStm >> nType; +/*N*/ rStm >> nFormat; +/*N*/ +/*N*/ eType = (SvxFileType) nType; +/*N*/ eFormat= (SvxFileFormat) nFormat; +/*N*/ } + +//---------------------------------------------------------------------------- + +/*N*/ void SvxExtFileField::Save( SvPersistStream & rStm ) +/*N*/ { +/*N*/ // UNICODE: rStm << aFile; +/*N*/ rStm.WriteByteString(aFile); +/*N*/ +/*N*/ rStm << (USHORT) eType; +/*N*/ rStm << (USHORT) eFormat; +/*N*/ } + +//---------------------------------------------------------------------------- + +//---------------------------------------------------------------------------- +// SvxAuthorField +//---------------------------------------------------------------------------- + +/*N*/ SV_IMPL_PERSIST1( SvxAuthorField, SvxFieldData ); + +//---------------------------------------------------------------------------- + +/*N*/ SvxAuthorField::SvxAuthorField() +/*N*/ { +/*N*/ eType = SVXAUTHORTYPE_VAR; +/*N*/ eFormat = SVXAUTHORFORMAT_FULLNAME; +/*N*/ } + +//---------------------------------------------------------------------------- + +/*N*/ SvxAuthorField::SvxAuthorField( const SvxAddressItem& rAdrItem, +/*N*/ SvxAuthorType eT, SvxAuthorFormat eF ) +/*N*/ { +/*N*/ aName = rAdrItem.GetName(); +/*N*/ aFirstName = rAdrItem.GetFirstName(); +/*N*/ aShortName = rAdrItem.GetShortName(); +/*N*/ eType = eT; +/*N*/ eFormat = eF; +/*N*/ } + +//---------------------------------------------------------------------------- + +/*N*/ SvxFieldData* SvxAuthorField::Clone() const +/*N*/ { +/*N*/ return new SvxAuthorField( *this ); +/*N*/ } + +//---------------------------------------------------------------------------- + +/*N*/ int SvxAuthorField::operator==( const SvxFieldData& rOther ) const +/*N*/ { +/*N*/ if ( rOther.Type() != Type() ) +/*N*/ return FALSE; +/*N*/ +/*N*/ const SvxAuthorField& rOtherFld = (const SvxAuthorField&) rOther; +/*N*/ return ( ( aName == rOtherFld.aName ) && +/*N*/ ( aFirstName == rOtherFld.aFirstName ) && +/*N*/ ( aShortName == rOtherFld.aShortName ) && +/*N*/ ( eType == rOtherFld.eType ) && +/*N*/ ( eFormat == rOtherFld.eFormat ) ); +/*N*/ } + +//---------------------------------------------------------------------------- + +/*N*/ void SvxAuthorField::Load( SvPersistStream & rStm ) +/*N*/ { +/*N*/ USHORT nType, nFormat; +/*N*/ +/*N*/ // UNICODE: rStm >> aName; +/*N*/ rStm.ReadByteString(aName); +/*N*/ +/*N*/ // UNICODE: rStm >> aFirstName; +/*N*/ rStm.ReadByteString(aFirstName); +/*N*/ +/*N*/ // UNICODE: rStm >> aShortName; +/*N*/ rStm.ReadByteString(aShortName); +/*N*/ +/*N*/ rStm >> nType; +/*N*/ rStm >> nFormat; +/*N*/ +/*N*/ eType = (SvxAuthorType) nType; +/*N*/ eFormat= (SvxAuthorFormat) nFormat; +/*N*/ } + +//---------------------------------------------------------------------------- + +/*N*/ void SvxAuthorField::Save( SvPersistStream & rStm ) +/*N*/ { +/*N*/ // UNICODE: rStm << aName; +/*N*/ rStm.WriteByteString(aName); +/*N*/ +/*N*/ // UNICODE: rStm << aFirstName; +/*N*/ rStm.WriteByteString(aFirstName); +/*N*/ +/*N*/ // UNICODE: rStm << aShortName; +/*N*/ rStm.WriteByteString(aShortName); +/*N*/ +/*N*/ rStm << (USHORT) eType; +/*N*/ rStm << (USHORT) eFormat; +/*N*/ } + +//---------------------------------------------------------------------------- + +/*N*/ XubString SvxAuthorField::GetFormatted() const +/*N*/ { +/*N*/ XubString aString; +/*N*/ +/*N*/ switch( eFormat ) +/*N*/ { +/*N*/ case SVXAUTHORFORMAT_FULLNAME: +/*N*/ aString = aFirstName; +/*N*/ aString += sal_Unicode(' '); +/*N*/ aString += aName; +/*N*/ break; +/*N*/ +/*N*/ case SVXAUTHORFORMAT_NAME: +/*N*/ aString = aName; +/*N*/ break; +/*N*/ +/*N*/ case SVXAUTHORFORMAT_FIRSTNAME: +/*N*/ aString = aFirstName; +/*N*/ break; +/*N*/ +/*N*/ case SVXAUTHORFORMAT_SHORTNAME: +/*N*/ aString = aShortName; +/*N*/ break; +/*N*/ } +/*N*/ +/*N*/ return( aString ); +/*N*/ } + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_svx/source/items/svx_frmitems.cxx b/binfilter/bf_svx/source/items/svx_frmitems.cxx new file mode 100644 index 000000000000..4403c1b67645 --- /dev/null +++ b/binfilter/bf_svx/source/items/svx_frmitems.cxx @@ -0,0 +1,2882 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +// include --------------------------------------------------------------- + +#include <com/sun/star/uno/Any.hxx> + +#include <com/sun/star/script/XTypeConverter.hpp> + +#include <limits.h> +#include <comphelper/processfactory.hxx> + +#define ITEMID_PAPERBIN 0 +#define ITEMID_SIZE 0 +#define ITEMID_LRSPACE 0 +#define ITEMID_ULSPACE 0 +#define ITEMID_PRINT 0 +#define ITEMID_OPAQUE 0 +#define ITEMID_PROTECT 0 +#define ITEMID_SHADOW 0 +#define ITEMID_BOX 0 +#define ITEMID_BOXINFO 0 +#define ITEMID_FMTBREAK 0 +#define ITEMID_FMTKEEP 0 +#define ITEMID_LINE 0 +#define ITEMID_BRUSH 0 +#define ITEMID_FRAMEDIR 0 + +#include <bf_goodies/graphicobject.hxx> +#include <tools/urlobj.hxx> +#ifndef SVX_LIGHT +#include <bf_sfx2/docfile.hxx> +#include <bf_sfx2/objsh.hxx> +#endif // !SVX_LIGHT +#include "bf_basic/sbx.hxx" +#define GLOBALOVERFLOW3 + +#define _SVX_FRMITEMS_CXX + +#include <bf_svtools/memberid.hrc> + +#include <bf_svtools/wallitem.hxx> +#include <bf_svtools/cntwall.hxx> + +#include "rtl/ustring.hxx" +#include <rtl/ustrbuf.hxx> + +#include <impgrf.hxx> +#include "svxids.hrc" +#include "svxitems.hrc" +#include "dialogs.hrc" + +#include "pbinitem.hxx" +#include "sizeitem.hxx" +#include "lrspitem.hxx" +#include "ulspitem.hxx" +#include "prntitem.hxx" +#include "opaqitem.hxx" +#include "protitem.hxx" +#include "shaditem.hxx" +#include "boxitem.hxx" +#include "brkitem.hxx" +#include "keepitem.hxx" +#include "bolnitem.hxx" +#include "brshitem.hxx" +#include "frmdiritem.hxx" + +#include "itemtype.hxx" +#include "dialmgr.hxx" +#include "svxerr.hxx" +#include "unoprnms.hxx" + +#include <com/sun/star/table/BorderLine.hpp> +#include <com/sun/star/table/CellVertJustify.hpp> +#include <com/sun/star/table/ShadowLocation.hpp> +#include <com/sun/star/table/TableBorder.hpp> +#include <com/sun/star/table/ShadowFormat.hpp> +#include <com/sun/star/table/CellRangeAddress.hpp> +#include <com/sun/star/table/CellContentType.hpp> +#include <com/sun/star/table/TableOrientation.hpp> +#include <com/sun/star/table/CellHoriJustify.hpp> +#include <com/sun/star/util/SortField.hpp> +#include <com/sun/star/util/SortFieldType.hpp> +#include <com/sun/star/table/CellOrientation.hpp> +#include <com/sun/star/table/CellAddress.hpp> +#include <com/sun/star/style/PageStyleLayout.hpp> +#include <com/sun/star/style/BreakType.hpp> +#include <com/sun/star/style/GraphicLocation.hpp> +#include <com/sun/star/awt/Rectangle.hpp> +#include <com/sun/star/awt/Selection.hpp> +#include <com/sun/star/awt/Size.hpp> +#include <com/sun/star/text/WritingMode2.hpp> + +#include <comphelper/types.hxx> + +#include <unomid.hxx> +#include <legacysmgr/legacy_binfilters_smgr.hxx> //STRIP002 + +#include "bf_so3/staticbaseurl.hxx" +namespace binfilter { +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 ----------------------------------------------------------- + + +/*?*/ inline void SetValueProp( XubString& rStr, const sal_uInt16 nValue, +/*?*/ const sal_uInt16 nProp ) +/*?*/ { +/*?*/ if( 100 == nProp ) +/*?*/ rStr += String::CreateFromInt32( nValue ); +/*?*/ else +/*?*/ ( rStr += String::CreateFromInt32( nProp )) += sal_Unicode('%'); +/*?*/ } + +/*?*/ inline void SetValueProp( XubString& rStr, const short nValue, +/*?*/ const sal_uInt16 nProp ) +/*?*/ { +/*?*/ if( 100 == nProp ) +/*?*/ rStr += String::CreateFromInt32( nValue ); +/*?*/ else +/*?*/ ( rStr += String::CreateFromInt32( nProp )) += sal_Unicode('%'); +/*?*/ } + +// ----------------------------------------------------------------------- + +/*N*/ TYPEINIT1_AUTOFACTORY(SvxPaperBinItem, SfxByteItem); +/*N*/ TYPEINIT1_AUTOFACTORY(SvxSizeItem, SfxPoolItem); +/*N*/ TYPEINIT1_AUTOFACTORY(SvxLRSpaceItem, SfxPoolItem); +/*N*/ TYPEINIT1_AUTOFACTORY(SvxULSpaceItem, SfxPoolItem); +/*N*/ TYPEINIT1_AUTOFACTORY(SvxPrintItem, SfxBoolItem); +/*N*/ TYPEINIT1_AUTOFACTORY(SvxOpaqueItem, SfxBoolItem); +/*N*/ TYPEINIT1_AUTOFACTORY(SvxProtectItem, SfxPoolItem); +/*N*/ TYPEINIT1_AUTOFACTORY(SvxBrushItem, SfxPoolItem); +/*N*/ TYPEINIT1_AUTOFACTORY(SvxShadowItem, SfxPoolItem); +/*N*/ TYPEINIT1_AUTOFACTORY(SvxBoxItem, SfxPoolItem); +/*N*/ TYPEINIT1_AUTOFACTORY(SvxBoxInfoItem, SfxPoolItem); +/*N*/ TYPEINIT1_AUTOFACTORY(SvxFmtBreakItem, SfxEnumItem); +/*N*/ TYPEINIT1_AUTOFACTORY(SvxFmtKeepItem, SfxBoolItem); +/*N*/ TYPEINIT1_AUTOFACTORY(SvxLineItem, SfxPoolItem); +/*N*/ TYPEINIT1_AUTOFACTORY(SvxFrameDirectionItem, SfxUInt16Item); + + +// class SvxPaperBinItem ------------------------------------------------ + +/*N*/ SfxPoolItem* SvxPaperBinItem::Clone( SfxItemPool* ) const +/*N*/ { +/*N*/ return new SvxPaperBinItem( *this ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvStream& SvxPaperBinItem::Store( SvStream& rStrm , sal_uInt16 nItemVersion ) const +/*N*/ { +/*N*/ rStrm << GetValue(); +/*N*/ return rStrm; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxPaperBinItem::Create( SvStream& rStrm, sal_uInt16 ) const +/*N*/ { +/*N*/ sal_Int8 nBin; +/*N*/ rStrm >> nBin; +/*N*/ return new SvxPaperBinItem( Which(), nBin ); +/*N*/ } + +// ----------------------------------------------------------------------- + + +// class SvxSizeItem ----------------------------------------------------- + +/*N*/ SvxSizeItem::SvxSizeItem( const sal_uInt16 nId, const Size& rSize ) : +/*N*/ +/*N*/ SfxPoolItem( nId ), +/*N*/ +/*N*/ aSize( rSize ) +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- +/*N*/ bool SvxSizeItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const +/*N*/ { +/*N*/ sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); +/*N*/ nMemberId &= ~CONVERT_TWIPS; +/*N*/ +/*N*/ awt::Size aTmp(aSize.Width(), aSize.Height()); +/*N*/ if( bConvert ) +/*N*/ { +/*N*/ aTmp.Height = TWIP_TO_MM100(aTmp.Height); +/*N*/ aTmp.Width = TWIP_TO_MM100(aTmp.Width); +/*N*/ } +/*N*/ +/*N*/ switch( nMemberId ) +/*N*/ { +/*N*/ case MID_SIZE_SIZE: rVal <<= aTmp; break; +/*N*/ case MID_SIZE_WIDTH: rVal <<= aTmp.Width; break; +/*N*/ case MID_SIZE_HEIGHT: rVal <<= aTmp.Height; break; +/*N*/ default: DBG_ERROR("Wrong MemberId!"); return sal_False; +/*N*/ } +/*N*/ +/*N*/ return sal_True; +/*N*/ } +// ----------------------------------------------------------------------- +/*N*/ bool SvxSizeItem::PutValue( const uno::Any& rVal, BYTE nMemberId ) +/*N*/ { +/*N*/ sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); +/*N*/ nMemberId &= ~CONVERT_TWIPS; +/*N*/ +/*N*/ switch( nMemberId ) +/*N*/ { +/*N*/ case MID_SIZE_SIZE: +/*N*/ { +/*?*/ awt::Size aTmp; +/*?*/ if( rVal >>= aTmp ) +/*?*/ { +/*?*/ if(bConvert) +/*?*/ { +/*?*/ aTmp.Height = MM100_TO_TWIP(aTmp.Height); +/*?*/ aTmp.Width = MM100_TO_TWIP(aTmp.Width); +/*?*/ } +/*?*/ aSize = Size( aTmp.Width, aTmp.Height ); +/*?*/ } +/*?*/ else +/*?*/ { +/*?*/ return sal_False; +/*?*/ } +/*N*/ } +/*N*/ break; +/*N*/ case MID_SIZE_WIDTH: +/*N*/ { +/*N*/ sal_Int32 nVal; +/*N*/ if(!(rVal >>= nVal )) +/*N*/ return sal_False; +/*N*/ +/*N*/ aSize.Width() = bConvert ? MM100_TO_TWIP(nVal) : nVal; +/*N*/ } +/*N*/ break; +/*N*/ case MID_SIZE_HEIGHT: +/*N*/ { +/*N*/ sal_Int32 nVal; +/*N*/ if(!(rVal >>= nVal)) +/*N*/ return sal_True; +/*N*/ +/*N*/ aSize.Height() = bConvert ? MM100_TO_TWIP(nVal) : nVal; +/*N*/ } +/*N*/ break; +/*N*/ default: DBG_ERROR("Wrong MemberId!"); +/*N*/ return sal_False; +/*N*/ } +/*N*/ return sal_True; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvxSizeItem::SvxSizeItem( const sal_uInt16 nId ) : +/*N*/ +/*N*/ SfxPoolItem( nId ) +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ int SvxSizeItem::operator==( const SfxPoolItem& rAttr ) const +/*N*/ { +/*N*/ DBG_ASSERT( SfxPoolItem::operator==(rAttr), "unequal types" ); +/*N*/ +/*N*/ return ( aSize == ( (SvxSizeItem&)rAttr ).GetSize() ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxSizeItem::Clone( SfxItemPool* ) const +/*N*/ { +/*N*/ return new SvxSizeItem( *this ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvStream& SvxSizeItem::Store( SvStream& rStrm , sal_uInt16 nItemVersion ) const +/*N*/ { +/*N*/ rStrm << aSize.Width(); +/*N*/ rStrm << aSize.Height(); +/*N*/ return rStrm; +/*N*/ } + +// ----------------------------------------------------------------------- + + +/*N*/ SfxPoolItem* SvxSizeItem::Create( SvStream& rStrm, sal_uInt16 ) const +/*N*/ { +/*N*/ long nWidth, nHeight; +/*N*/ rStrm >> nWidth >> nHeight; +/*N*/ +/*N*/ SvxSizeItem* pAttr = new SvxSizeItem( Which() ); +/*N*/ pAttr->SetSize(Size(nWidth, nHeight)); +/*N*/ +/*N*/ return pAttr; +/*N*/ } + +// class SvxLRSpaceItem -------------------------------------------------- + +/*N*/ SvxLRSpaceItem::SvxLRSpaceItem( const sal_uInt16 nId ) : +/*N*/ +/*N*/ SfxPoolItem( nId ), +/*N*/ +/*N*/ nFirstLineOfst ( 0 ), nPropFirstLineOfst( 100 ), +/*N*/ nTxtLeft ( 0 ), +/*N*/ nLeftMargin ( 0 ), nPropLeftMargin( 100 ), +/*N*/ nRightMargin ( 0 ), nPropRightMargin( 100 ), +/*N*/ bBulletFI ( 0 ), +/*N*/ bAutoFirst ( 0 ) +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvxLRSpaceItem::SvxLRSpaceItem( const long nLeft, const long nRight, +/*N*/ const long nTLeft, const short nOfset, +/*N*/ const sal_uInt16 nId ) : +/*N*/ +/*N*/ SfxPoolItem( nId ), +/*N*/ +/*N*/ nFirstLineOfst ( nOfset ), nPropFirstLineOfst( 100 ), +/*N*/ nTxtLeft ( nTLeft ), +/*N*/ nLeftMargin ( nLeft ), nPropLeftMargin( 100 ), +/*N*/ nRightMargin ( nRight ), nPropRightMargin( 100 ), +/*N*/ bBulletFI ( 0 ), +/*N*/ bAutoFirst ( 0 ) +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- +/*N*/ bool SvxLRSpaceItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const +/*N*/ { +/*N*/ sal_Bool bRet = sal_True; +/*N*/ sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); +/*N*/ nMemberId &= ~CONVERT_TWIPS; +/*N*/ switch( nMemberId ) +/*N*/ { +/*N*/ // jetzt alles signed +/*N*/ case MID_L_MARGIN: +/*N*/ rVal <<= (sal_Int32)(bConvert ? TWIP_TO_MM100(nLeftMargin) : nLeftMargin); +/*N*/ break; +/*N*/ +/*N*/ case MID_TXT_LMARGIN : +/*N*/ rVal <<= (sal_Int32)(bConvert ? TWIP_TO_MM100(nTxtLeft) : nTxtLeft); +/*N*/ break; +/*N*/ case MID_R_MARGIN: +/*N*/ rVal <<= (sal_Int32)(bConvert ? TWIP_TO_MM100(nRightMargin) : nRightMargin); +/*N*/ break; +/*N*/ case MID_L_REL_MARGIN: +/*N*/ rVal <<= (sal_Int16)nPropLeftMargin; +/*N*/ break; +/*N*/ case MID_R_REL_MARGIN: +/*N*/ rVal <<= (sal_Int16)nPropRightMargin; +/*N*/ break; +/*N*/ +/*N*/ case MID_FIRST_LINE_INDENT: +/*N*/ rVal <<= (sal_Int32)(bConvert ? TWIP_TO_MM100(nFirstLineOfst) : nFirstLineOfst); +/*N*/ break; +/*N*/ +/*N*/ case MID_FIRST_LINE_REL_INDENT: +/*N*/ rVal <<= (sal_Int16)(nPropFirstLineOfst); +/*N*/ break; +/*N*/ +/*N*/ case MID_FIRST_AUTO: +/*N*/ rVal = Bool2Any(IsAutoFirst()); +/*N*/ break; +/*N*/ +/*N*/ default: +/*N*/ bRet = sal_False; +/*N*/ DBG_ERROR("unknown MemberId"); +/*N*/ } +/*N*/ return bRet; +/*N*/ } + +// ----------------------------------------------------------------------- +/*N*/ bool SvxLRSpaceItem::PutValue( const uno::Any& rVal, BYTE nMemberId ) +/*N*/ { +/*N*/ sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); +/*N*/ nMemberId &= ~CONVERT_TWIPS; +/*N*/ sal_Int32 nMaxVal = bConvert ? TWIP_TO_MM100(USHRT_MAX) : USHRT_MAX; +/*N*/ sal_Int32 nVal; +/*N*/ if( nMemberId != MID_FIRST_AUTO && +/*N*/ nMemberId != MID_L_REL_MARGIN && nMemberId != MID_R_REL_MARGIN) +/*N*/ if(!(rVal >>= nVal)) +/*N*/ return sal_False; +/*N*/ +/*N*/ switch( nMemberId ) +/*N*/ { +/*N*/ case MID_L_MARGIN: +/*N*/ SetLeft((sal_Int32)bConvert ? MM100_TO_TWIP(nVal) : nVal); +/*N*/ break; +/*N*/ +/*N*/ case MID_TXT_LMARGIN : +/*N*/ SetTxtLeft((sal_Int32)bConvert ? MM100_TO_TWIP(nVal) : nVal); +/*N*/ break; +/*N*/ +/*N*/ case MID_R_MARGIN: +/*N*/ SetRight((sal_Int32) bConvert ? MM100_TO_TWIP(nVal) : nVal); +/*N*/ break; +/*N*/ case MID_L_REL_MARGIN: +/*N*/ case MID_R_REL_MARGIN: +/*N*/ { +/*N*/ sal_Int32 nRel; +/*N*/ if((rVal >>= nRel) && nRel >= 0 && nRel < USHRT_MAX) +/*N*/ { +/*N*/ if(MID_L_REL_MARGIN== nMemberId) +/*N*/ nPropLeftMargin = (USHORT)nRel; +/*N*/ else +/*N*/ nPropRightMargin = (USHORT)nRel; +/*N*/ } +/*N*/ else +/*N*/ return FALSE; +/*N*/ } +/*N*/ break; +/*N*/ case MID_FIRST_LINE_INDENT : +/*N*/ SetTxtFirstLineOfst((short)(bConvert ? MM100_TO_TWIP(nVal) : nVal)); +/*N*/ break; +/*N*/ +/*N*/ case MID_FIRST_LINE_REL_INDENT: +/*?*/ SetPropTxtFirstLineOfst ( nVal ); +/*N*/ break; +/*N*/ +/*N*/ case MID_FIRST_AUTO: +/*N*/ SetAutoFirst( Any2Bool(rVal) ); +/*N*/ break; +/*N*/ +/*N*/ default: +/*N*/ DBG_ERROR("unknown MemberId"); +/*N*/ return sal_False; +/*N*/ } +/*N*/ return sal_True; +/*N*/ } + +// ----------------------------------------------------------------------- + +// nLeftMargin und nTxtLeft anpassen. + +/*N*/ void SvxLRSpaceItem::AdjustLeft() +/*N*/ { +/*N*/ if ( 0 > nFirstLineOfst ) +/*N*/ nLeftMargin = nTxtLeft + nFirstLineOfst; +/*N*/ else +/*N*/ nLeftMargin = nTxtLeft; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ int SvxLRSpaceItem::operator==( const SfxPoolItem& rAttr ) const +/*N*/ { +/*N*/ DBG_ASSERT( SfxPoolItem::operator==(rAttr), "unequal types" ); +/*N*/ +/*N*/ return ( +/*N*/ nLeftMargin == ((SvxLRSpaceItem&)rAttr).GetLeft() && +/*N*/ nRightMargin == ((SvxLRSpaceItem&)rAttr).GetRight() && +/*N*/ nFirstLineOfst == ((SvxLRSpaceItem&)rAttr).GetTxtFirstLineOfst() && +/*N*/ nPropLeftMargin == ((SvxLRSpaceItem&)rAttr).GetPropLeft() && +/*N*/ nPropRightMargin == ((SvxLRSpaceItem&)rAttr).GetPropRight() && +/*N*/ nPropFirstLineOfst == ((SvxLRSpaceItem&)rAttr).GetPropTxtFirstLineOfst() && +/*N*/ bBulletFI == ((SvxLRSpaceItem&)rAttr).IsBulletFI() && +/*N*/ bAutoFirst == ((SvxLRSpaceItem&)rAttr).IsAutoFirst() ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxLRSpaceItem::Clone( SfxItemPool* ) const +/*N*/ { +/*N*/ return new SvxLRSpaceItem( *this ); +/*N*/ } + +// ----------------------------------------------------------------------- + +// MT: BulletFI: Vor 501 wurde im Outliner das Bullet nicht auf der Position des +// FI positioniert, deshalb muss in aelteren Dokumenten der FI auf 0 stehen. + +#define BULLETLR_MARKER 0x599401FE + +/*N*/ SvStream& SvxLRSpaceItem::Store( SvStream& rStrm , sal_uInt16 nItemVersion ) const +/*N*/ { +/*N*/ short nSaveFI = nFirstLineOfst; +/*N*/ if ( IsBulletFI() ) +/*N*/ ((SvxLRSpaceItem*)this)->SetTxtFirstLineOfst( 0 ); // nLeftMargin wird mitmanipuliert, siehe Create() +/*N*/ +/*N*/ sal_uInt16 nMargin = 0; +/*N*/ if( nLeftMargin > 0 ) +/*N*/ nMargin = sal_uInt16( nLeftMargin ); +/*N*/ rStrm << nMargin; +/*N*/ rStrm << nPropLeftMargin; +/*N*/ if( nRightMargin > 0 ) +/*N*/ nMargin = sal_uInt16( nRightMargin ); +/*N*/ else +/*N*/ nMargin = 0; +/*N*/ rStrm << nMargin; +/*N*/ rStrm << nPropRightMargin; +/*N*/ rStrm << nFirstLineOfst; +/*N*/ rStrm << nPropFirstLineOfst; +/*N*/ if( nTxtLeft > 0 ) +/*N*/ nMargin = sal_uInt16( nTxtLeft ); +/*N*/ else +/*N*/ nMargin = 0; +/*N*/ rStrm << nMargin; +/*N*/ if( nItemVersion >= LRSPACE_AUTOFIRST_VERSION ) +/*N*/ { +/*N*/ sal_Int8 nAutoFirst = bAutoFirst ? 1 : 0; +/*N*/ if( nItemVersion >= LRSPACE_NEGATIVE_VERSION && +/*N*/ ( nLeftMargin < 0 || nRightMargin < 0 || nTxtLeft < 0 ) ) +/*N*/ nAutoFirst |= 0x80; +/*N*/ rStrm << nAutoFirst; +/*N*/ +/*N*/ if ( IsBulletFI() ) +/*N*/ { +/*N*/ // Ab 6.0 keine Magicnumber schreiben... +/*N*/ DBG_ASSERT( rStrm.GetVersion() <= SOFFICE_FILEFORMAT_50, "MT: Fileformat SvxLRSpaceItem aendern!" ); +/*N*/ rStrm << (sal_uInt32) BULLETLR_MARKER; +/*N*/ rStrm << nSaveFI; +/*N*/ } +/*N*/ if( 0x80 & nAutoFirst ) +/*N*/ { +/*N*/ rStrm << nLeftMargin; +/*N*/ rStrm << nRightMargin; +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ if ( IsBulletFI() ) +/*N*/ ((SvxLRSpaceItem*)this)->SetTxtFirstLineOfst( nSaveFI ); +/*N*/ +/*N*/ return rStrm; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxLRSpaceItem::Create( SvStream& rStrm, sal_uInt16 nVersion ) const +/*N*/ { +/*N*/ sal_uInt16 left, prpleft, right, prpright, prpfirstline, txtleft; +/*N*/ short firstline; +/*N*/ sal_Int8 autofirst = 0; +/*N*/ +/*N*/ if ( nVersion >= LRSPACE_AUTOFIRST_VERSION ) +/*N*/ { +/*N*/ rStrm >> left >> prpleft >> right >> prpright >> firstline >> +/*N*/ prpfirstline >> txtleft >> autofirst; +/*N*/ +/*N*/ sal_uInt32 nPos = rStrm.Tell(); +/*N*/ sal_uInt32 nMarker; +/*N*/ rStrm >> nMarker; +/*N*/ if ( nMarker == BULLETLR_MARKER ) +/*N*/ { +/*N*/ rStrm >> firstline; +/*N*/ if ( firstline < 0 ) +/*N*/ left += firstline; // s.u.: txtleft = ... +/*N*/ } +/*N*/ else +/*N*/ rStrm.Seek( nPos ); +/*N*/ } +/*N*/ else if ( nVersion == LRSPACE_TXTLEFT_VERSION ) +/*N*/ { +/*N*/ rStrm >> left >> prpleft >> right >> prpright >> firstline >> +/*N*/ prpfirstline >> txtleft; +/*N*/ } +/*N*/ else if ( nVersion == LRSPACE_16_VERSION ) +/*N*/ { +/*N*/ rStrm >> left >> prpleft >> right >> prpright >> firstline >> +/*N*/ prpfirstline; +/*N*/ } +/*N*/ else +/*N*/ { +/*?*/ sal_Int8 nL, nR, nFL; +/*?*/ rStrm >> left >> nL >> right >> nR >> firstline >> nFL; +/*?*/ prpleft = (sal_uInt16)nL; +/*?*/ prpright = (sal_uInt16)nR; +/*?*/ prpfirstline = (sal_uInt16)nFL; +/*N*/ } +/*N*/ +/*N*/ txtleft = firstline >= 0 ? left : left - firstline; +/*N*/ SvxLRSpaceItem* pAttr = new SvxLRSpaceItem( Which() ); +/*N*/ +/*N*/ pAttr->nLeftMargin = left; +/*N*/ pAttr->nPropLeftMargin = prpleft; +/*N*/ pAttr->nRightMargin = right; +/*N*/ pAttr->nPropRightMargin = prpright; +/*N*/ pAttr->nFirstLineOfst = firstline; +/*N*/ pAttr->nPropFirstLineOfst = prpfirstline; +/*N*/ pAttr->nTxtLeft = txtleft; +/*N*/ pAttr->bAutoFirst = autofirst & 0x01; +/*N*/ if( nVersion >= LRSPACE_NEGATIVE_VERSION && ( autofirst & 0x80 ) ) +/*N*/ { +/*N*/ sal_Int32 nMargin; +/*N*/ rStrm >> nMargin; +/*N*/ pAttr->nLeftMargin = nMargin; +/*N*/ pAttr->nTxtLeft = firstline >= 0 ? nMargin : nMargin - firstline; +/*N*/ rStrm >> nMargin; +/*N*/ pAttr->nRightMargin = nMargin; +/*N*/ } +/*N*/ return pAttr; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ sal_uInt16 SvxLRSpaceItem::GetVersion( sal_uInt16 nFileVersion ) const +/*N*/ { +/*N*/ return (nFileVersion == SOFFICE_FILEFORMAT_31) +/*N*/ ? LRSPACE_TXTLEFT_VERSION +/*N*/ : LRSPACE_NEGATIVE_VERSION; +/*N*/ } + +// ----------------------------------------------------------------------- + + +// class SvxULSpaceItem -------------------------------------------------- + +/*N*/ SvxULSpaceItem::SvxULSpaceItem( const sal_uInt16 nId ) : +/*N*/ +/*N*/ SfxPoolItem( nId ), +/*N*/ +/*N*/ nUpper( 0 ), nPropUpper( 100 ), +/*N*/ nLower( 0 ), nPropLower( 100 ) +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvxULSpaceItem::SvxULSpaceItem( const sal_uInt16 nUp, const sal_uInt16 nLow, +/*N*/ const sal_uInt16 nId ) : +/*N*/ +/*N*/ SfxPoolItem( nId ), +/*N*/ +/*N*/ nUpper( nUp ), nPropUpper( 100 ), +/*N*/ nLower( nLow ), nPropLower( 100 ) +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- +/*N*/ bool SvxULSpaceItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const +/*N*/ { +/*N*/ sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); +/*N*/ nMemberId &= ~CONVERT_TWIPS; +/*N*/ switch( nMemberId ) +/*N*/ { +/*N*/ // jetzt alles signed +/*N*/ case MID_UP_MARGIN: rVal <<= (sal_Int32)(bConvert ? TWIP_TO_MM100(nUpper) : nUpper); break; +/*N*/ case MID_LO_MARGIN: rVal <<= (sal_Int32)(bConvert ? TWIP_TO_MM100(nLower) : nLower); break; +/*N*/ case MID_UP_REL_MARGIN: rVal <<= (sal_Int16) nPropUpper; break; +/*N*/ case MID_LO_REL_MARGIN: rVal <<= (sal_Int16) nPropLower; break; +/*N*/ } +/*N*/ return sal_True; +/*N*/ } + +// ----------------------------------------------------------------------- +/*N*/ bool SvxULSpaceItem::PutValue( const uno::Any& rVal, BYTE nMemberId ) +/*N*/ { +/*N*/ sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); +/*N*/ nMemberId &= ~CONVERT_TWIPS; +/*N*/ sal_Int32 nVal; +/*N*/ switch( nMemberId ) +/*N*/ { +/*N*/ case MID_UP_MARGIN : +/*N*/ if(!(rVal >>= nVal) || nVal < 0) +/*N*/ return sal_False; +/*N*/ SetUpper((sal_uInt16)bConvert ? MM100_TO_TWIP(nVal) : nVal); +/*N*/ break; +/*N*/ case MID_LO_MARGIN : +/*N*/ if(!(rVal >>= nVal) || nVal < 0) +/*N*/ return sal_False; +/*N*/ SetLower((sal_uInt16)bConvert ? MM100_TO_TWIP(nVal) : nVal); +/*N*/ break; +/*N*/ case MID_UP_REL_MARGIN: +/*N*/ case MID_LO_REL_MARGIN: +/*N*/ { +/*N*/ sal_Int32 nRel; +/*?*/ if((rVal >>= nRel) && nRel > 1 ) +/*?*/ { +/*?*/ if(MID_UP_REL_MARGIN == nMemberId) +/*?*/ nPropUpper = nRel; +/*?*/ else +/*?*/ nPropLower = nRel; +/*?*/ } +/*?*/ else +/*?*/ return FALSE; +/*?*/ } +/*?*/ break; +/*N*/ +/*N*/ +/*N*/ default: +/*N*/ DBG_ERROR("unknown MemberId"); +/*N*/ return sal_False; +/*N*/ } +/*N*/ return sal_True; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ int SvxULSpaceItem::operator==( const SfxPoolItem& rAttr ) const +/*N*/ { +/*N*/ DBG_ASSERT( SfxPoolItem::operator==(rAttr), "unequal types" ); +/*N*/ +/*N*/ return ( nUpper == ( (SvxULSpaceItem&)rAttr ).nUpper && +/*N*/ nLower == ( (SvxULSpaceItem&)rAttr ).nLower && +/*N*/ nPropUpper == ( (SvxULSpaceItem&)rAttr ).nPropUpper && +/*N*/ nPropLower == ( (SvxULSpaceItem&)rAttr ).nPropLower ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxULSpaceItem::Clone( SfxItemPool* ) const +/*N*/ { +/*N*/ return new SvxULSpaceItem( *this ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvStream& SvxULSpaceItem::Store( SvStream& rStrm , sal_uInt16 nItemVersion ) const +/*N*/ { +/*N*/ rStrm << GetUpper() +/*N*/ << GetPropUpper() +/*N*/ << GetLower() +/*N*/ << GetPropLower(); +/*N*/ return rStrm; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxULSpaceItem::Create( SvStream& rStrm, sal_uInt16 nVersion ) const +/*N*/ { +/*N*/ sal_uInt16 upper, lower, nPL = 0, nPU = 0; +/*N*/ +/*N*/ if ( nVersion == ULSPACE_16_VERSION ) +/*N*/ rStrm >> upper >> nPU >> lower >> nPL; +/*N*/ else +/*N*/ { +/*?*/ sal_Int8 nU, nL; +/*?*/ rStrm >> upper >> nU >> lower >> nL; +/*?*/ nPL = (sal_uInt16)nL; +/*?*/ nPU = (sal_uInt16)nU; +/*N*/ } +/*N*/ +/*N*/ SvxULSpaceItem* pAttr = new SvxULSpaceItem( Which() ); +/*N*/ pAttr->SetUpperValue( upper ); +/*N*/ pAttr->SetLowerValue( lower ); +/*N*/ pAttr->SetPropUpper( nPU ); +/*N*/ pAttr->SetPropLower( nPL ); +/*N*/ return pAttr; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ sal_uInt16 SvxULSpaceItem::GetVersion( sal_uInt16 nFileVersion ) const +/*N*/ { +/*N*/ return ULSPACE_16_VERSION; +/*N*/ } + +// ----------------------------------------------------------------------- + +// class SvxPrintItem ---------------------------------------------------- + +/*N*/ SfxPoolItem* SvxPrintItem::Clone( SfxItemPool* ) const +/*N*/ { +/*N*/ return new SvxPrintItem( *this ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvStream& SvxPrintItem::Store( SvStream& rStrm , sal_uInt16 nItemVersion ) const +/*N*/ { +/*N*/ rStrm << (sal_Int8)GetValue(); +/*N*/ return rStrm; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxPrintItem::Create( SvStream& rStrm, sal_uInt16 ) const +/*N*/ { +/*N*/ sal_Int8 bIsPrint; +/*N*/ rStrm >> bIsPrint; +/*N*/ return new SvxPrintItem( Which(), sal_Bool( bIsPrint != 0 ) ); +/*N*/ } + +//------------------------------------------------------------------------ + + +// class SvxOpaqueItem --------------------------------------------------- + +/*N*/ SfxPoolItem* SvxOpaqueItem::Clone( SfxItemPool* ) const +/*N*/ { +/*N*/ return new SvxOpaqueItem( *this ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvStream& SvxOpaqueItem::Store( SvStream& rStrm , sal_uInt16 nItemVersion ) const +/*N*/ { +/*N*/ rStrm << (sal_Int8)GetValue(); +/*N*/ return rStrm; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxOpaqueItem::Create( SvStream& rStrm, sal_uInt16 ) const +/*N*/ { +/*N*/ sal_Int8 bIsOpaque; +/*N*/ rStrm >> bIsOpaque; +/*N*/ return new SvxOpaqueItem( Which(), sal_Bool( bIsOpaque != 0 ) ); +/*N*/ } + +//------------------------------------------------------------------------ + + +// class SvxProtectItem -------------------------------------------------- + +/*N*/ int SvxProtectItem::operator==( const SfxPoolItem& rAttr ) const +/*N*/ { +/*N*/ DBG_ASSERT( SfxPoolItem::operator==(rAttr), "unequal types" ); +/*N*/ +/*N*/ return ( bCntnt == ( (SvxProtectItem&)rAttr ).bCntnt && +/*N*/ bSize == ( (SvxProtectItem&)rAttr ).bSize && +/*N*/ bPos == ( (SvxProtectItem&)rAttr ).bPos ); +/*N*/ } + +/*-----------------16.03.98 12:42------------------- +--------------------------------------------------*/ +/*N*/ bool SvxProtectItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const +/*N*/ { +/*N*/ sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); +/*N*/ nMemberId &= ~CONVERT_TWIPS; +/*N*/ sal_Bool bValue; +/*N*/ switch(nMemberId) +/*N*/ { +/*N*/ case MID_PROTECT_CONTENT : bValue = bCntnt; break; +/*N*/ case MID_PROTECT_SIZE : bValue = bSize; break; +/*N*/ case MID_PROTECT_POSITION: bValue = bPos; break; +/*N*/ default: +/*N*/ DBG_ERROR("falsche MemberId"); +/*N*/ return sal_False; +/*N*/ } +/*N*/ +/*N*/ rVal = Bool2Any( bValue ); +/*N*/ return sal_True; +/*N*/ } +/*-----------------16.03.98 12:42------------------- + +--------------------------------------------------*/ +/*N*/ bool SvxProtectItem::PutValue( const uno::Any& rVal, BYTE nMemberId ) +/*N*/ { +/*N*/ sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); +/*N*/ nMemberId &= ~CONVERT_TWIPS; +/*N*/ sal_Bool bVal( Any2Bool(rVal) ); +/*N*/ switch(nMemberId) +/*N*/ { +/*N*/ case MID_PROTECT_CONTENT : bCntnt = bVal; break; +/*N*/ case MID_PROTECT_SIZE : bSize = bVal; break; +/*N*/ case MID_PROTECT_POSITION: bPos = bVal; break; +/*N*/ default: +/*N*/ DBG_ERROR("falsche MemberId"); +/*N*/ return sal_False; +/*N*/ } +/*N*/ return sal_True; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxProtectItem::Clone( SfxItemPool* ) const +/*N*/ { +/*N*/ return new SvxProtectItem( *this ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvStream& SvxProtectItem::Store( SvStream& rStrm , sal_uInt16 nItemVersion ) const +/*N*/ { +/*N*/ sal_Int8 cProt = 0; +/*N*/ if( IsPosProtected() ) cProt |= 0x01; +/*N*/ if( IsSizeProtected() ) cProt |= 0x02; +/*N*/ if( IsCntntProtected() ) cProt |= 0x04; +/*N*/ rStrm << (sal_Int8) cProt; +/*N*/ return rStrm; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxProtectItem::Create( SvStream& rStrm, sal_uInt16 ) const +/*N*/ { +/*N*/ sal_Int8 cFlags; +/*N*/ rStrm >> cFlags; +/*N*/ SvxProtectItem* pAttr = new SvxProtectItem( Which() ); +/*N*/ pAttr->SetPosProtect( sal_Bool( ( cFlags & 0x01 ) != 0 ) ); +/*N*/ pAttr->SetSizeProtect( sal_Bool( ( cFlags & 0x02 ) != 0 ) ); +/*N*/ pAttr->SetCntntProtect( sal_Bool( ( cFlags & 0x04 ) != 0 ) ); +/*N*/ return pAttr; +/*N*/ } + +// class SvxShadowItem --------------------------------------------------- + +/*N*/ SvxShadowItem::SvxShadowItem( const USHORT nId, +/*N*/ const Color *pColor, const USHORT nW, +/*N*/ const SvxShadowLocation eLoc ) : +/*N*/ SfxEnumItemInterface( nId ), +/*N*/ aShadowColor(COL_GRAY), +/*N*/ nWidth ( nW ), +/*N*/ eLocation ( eLoc ) +/*N*/ { +/*N*/ if ( pColor ) +/*N*/ aShadowColor = *pColor; +/*N*/ } + +// ----------------------------------------------------------------------- +/*N*/ bool SvxShadowItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const +/*N*/ { +/*N*/ sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); +/*N*/ nMemberId &= ~CONVERT_TWIPS; +/*N*/ +/*N*/ table::ShadowFormat aShadow; +/*N*/ table::ShadowLocation eSet = table::ShadowLocation_NONE; +/*N*/ switch( eLocation ) +/*N*/ { +/*N*/ case SVX_SHADOW_TOPLEFT : eSet = table::ShadowLocation_TOP_LEFT ; break; +/*N*/ case SVX_SHADOW_TOPRIGHT : eSet = table::ShadowLocation_TOP_RIGHT ; break; +/*N*/ case SVX_SHADOW_BOTTOMLEFT : eSet = table::ShadowLocation_BOTTOM_LEFT ; break; +/*N*/ case SVX_SHADOW_BOTTOMRIGHT: eSet = table::ShadowLocation_BOTTOM_RIGHT; break; +/*N*/ } +/*N*/ aShadow.Location = eSet; +/*N*/ aShadow.ShadowWidth = bConvert ? TWIP_TO_MM100(nWidth) : nWidth; +/*N*/ aShadow.IsTransparent = aShadowColor.GetTransparency() > 0; +/*N*/ aShadow.Color = aShadowColor.GetRGBColor(); +/*N*/ +/*N*/ switch ( nMemberId ) +/*N*/ { +/*?*/ case MID_LOCATION: rVal <<= aShadow.Location; break; +/*?*/ case MID_WIDTH: rVal <<= aShadow.ShadowWidth; break; +/*?*/ case MID_TRANSPARENT: rVal <<= aShadow.IsTransparent; break; +/*?*/ case MID_BG_COLOR: rVal <<= aShadow.Color; break; +/*N*/ case 0: rVal <<= aShadow; break; +/*N*/ default: DBG_ERROR("Wrong MemberId!"); return sal_False; +/*N*/ } +/*N*/ +/*N*/ return sal_True; +/*N*/ } +// ----------------------------------------------------------------------- +/*N*/ bool SvxShadowItem::PutValue( const uno::Any& rVal, BYTE nMemberId ) +/*N*/ { +/*N*/ sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); +/*N*/ nMemberId &= ~CONVERT_TWIPS; +/*N*/ +/*N*/ table::ShadowFormat aShadow; +/*N*/ uno::Any aAny; +/*N*/ bool bRet = QueryValue( aAny, bConvert ? CONVERT_TWIPS : 0 ) && ( aAny >>= aShadow ); +/*N*/ switch ( nMemberId ) +/*N*/ { +/*N*/ case MID_LOCATION: +/*N*/ { +/*?*/ bRet = (rVal >>= aShadow.Location); +/*?*/ if ( !bRet ) +/*?*/ { +/*?*/ sal_Int16 nVal; +/*?*/ bRet = (rVal >>= nVal); +/*?*/ aShadow.Location = (table::ShadowLocation) nVal; +/*?*/ } +/*?*/ +/*?*/ break; +/*N*/ } +/*N*/ +/*N*/ case MID_WIDTH: rVal >>= aShadow.ShadowWidth; break; +/*?*/ case MID_TRANSPARENT: rVal >>= aShadow.IsTransparent; break; +/*?*/ case MID_BG_COLOR: rVal >>= aShadow.Color; break; +/*N*/ case 0: rVal >>= aShadow; break; +/*N*/ default: DBG_ERROR("Wrong MemberId!"); return sal_False; +/*N*/ } +/*N*/ +/*N*/ if ( bRet ) +/*N*/ { +/*N*/ SvxShadowLocation eSet = SVX_SHADOW_NONE; +/*N*/ switch( aShadow.Location ) +/*N*/ { +/*N*/ case table::ShadowLocation_TOP_LEFT : eLocation = SVX_SHADOW_TOPLEFT; break; +/*N*/ case table::ShadowLocation_TOP_RIGHT : eLocation = SVX_SHADOW_TOPRIGHT; break; +/*N*/ case table::ShadowLocation_BOTTOM_LEFT : eLocation = SVX_SHADOW_BOTTOMLEFT ; break; +/*N*/ case table::ShadowLocation_BOTTOM_RIGHT: eLocation = SVX_SHADOW_BOTTOMRIGHT; break; +/*N*/ } +/*N*/ +/*N*/ nWidth = bConvert ? MM100_TO_TWIP(aShadow.ShadowWidth) : aShadow.ShadowWidth; +/*N*/ Color aSet(aShadow.Color); +/*N*/ aSet.SetTransparency(aShadow.IsTransparent ? 0xff : 0); +/*N*/ aShadowColor = aSet; +/*N*/ } +/*N*/ +/*N*/ return bRet; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ int SvxShadowItem::operator==( const SfxPoolItem& rAttr ) const +/*N*/ { +/*N*/ DBG_ASSERT( SfxPoolItem::operator==(rAttr), "unequal types" ); +/*N*/ +/*N*/ return ( ( aShadowColor == ( (SvxShadowItem&)rAttr ).aShadowColor ) && +/*N*/ ( nWidth == ( (SvxShadowItem&)rAttr ).GetWidth() ) && +/*N*/ ( eLocation == ( (SvxShadowItem&)rAttr ).GetLocation() ) ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxShadowItem::Clone( SfxItemPool* ) const +/*N*/ { +/*N*/ return new SvxShadowItem( *this ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ sal_uInt16 SvxShadowItem::CalcShadowSpace( sal_uInt16 nShadow ) const +/*N*/ { +/*N*/ sal_uInt16 nSpace = 0; +/*N*/ +/*N*/ switch ( nShadow ) +/*N*/ { +/*N*/ case SHADOW_TOP: +/*N*/ if ( eLocation == SVX_SHADOW_TOPLEFT || +/*N*/ eLocation == SVX_SHADOW_TOPRIGHT ) +/*N*/ nSpace = nWidth; +/*N*/ break; +/*N*/ +/*N*/ case SHADOW_BOTTOM: +/*N*/ if ( eLocation == SVX_SHADOW_BOTTOMLEFT || +/*N*/ eLocation == SVX_SHADOW_BOTTOMRIGHT ) +/*N*/ nSpace = nWidth; +/*N*/ break; +/*N*/ +/*N*/ case SHADOW_LEFT: +/*N*/ if ( eLocation == SVX_SHADOW_TOPLEFT || +/*N*/ eLocation == SVX_SHADOW_BOTTOMLEFT ) +/*N*/ nSpace = nWidth; +/*N*/ break; +/*N*/ +/*N*/ case SHADOW_RIGHT: +/*N*/ if ( eLocation == SVX_SHADOW_TOPRIGHT || +/*N*/ eLocation == SVX_SHADOW_BOTTOMRIGHT ) +/*N*/ nSpace = nWidth; +/*N*/ break; +/*N*/ +/*N*/ default: +/*N*/ DBG_ERROR( "wrong shadow" ); +/*N*/ } +/*N*/ return nSpace; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvStream& SvxShadowItem::Store( SvStream& rStrm , sal_uInt16 nItemVersion ) const +/*N*/ { +/*N*/ rStrm << (sal_Int8) GetLocation() +/*N*/ << (sal_uInt16) GetWidth() +/*N*/ << (sal_Bool)(aShadowColor.GetTransparency() > 0) +/*N*/ << GetColor() +/*N*/ << GetColor() +/*N*/ << (sal_Int8)(aShadowColor.GetTransparency() > 0 ? 0 : 1); //BRUSH_NULL : BRUSH_SOLID +/*N*/ return rStrm; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxShadowItem::Create( SvStream& rStrm, sal_uInt16 ) const +/*N*/ { +/*N*/ sal_Int8 cLoc; +/*N*/ sal_uInt16 nWidth; +/*N*/ sal_Bool bTrans; +/*N*/ Color aColor; +/*N*/ Color aFillColor; +/*N*/ sal_Int8 nStyle; +/*N*/ rStrm >> cLoc >> nWidth +/*N*/ >> bTrans >> aColor >> aFillColor >> nStyle; +/*N*/ aColor.SetTransparency(bTrans ? 0xff : 0); +/*N*/ return new SvxShadowItem( Which(), &aColor, nWidth, (SvxShadowLocation)cLoc ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*?*/ sal_uInt16 SvxShadowItem::GetValueCount() const +/*?*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); return 0;//STRIP001 return SVX_SHADOW_END; // SVX_SHADOW_BOTTOMRIGHT + 1 +/*?*/ } + +// ----------------------------------------------------------------------- + +/*?*/ sal_uInt16 SvxShadowItem::GetEnumValue() const +/*?*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); return 0;//STRIP001 return GetLocation(); +/*?*/ } + +// ----------------------------------------------------------------------- + +/*?*/ void SvxShadowItem::SetEnumValue( sal_uInt16 nVal ) +/*?*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 SetLocation( (const SvxShadowLocation)nVal ); +/*?*/ } + +// class SvxBorderLine -------------------------------------------------- + +/*N*/ SvxBorderLine::SvxBorderLine( const Color *pCol, sal_uInt16 nOut, sal_uInt16 nIn, +/*N*/ sal_uInt16 nDist ) : +/*N*/ +/*N*/ nOutWidth( nOut ), +/*N*/ nInWidth ( nIn ), +/*N*/ nDistance( nDist ) +/*N*/ +/*N*/ { +/*N*/ if ( pCol ) +/*N*/ aColor = *pCol; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ sal_Bool SvxBorderLine::operator==( const SvxBorderLine& rCmp ) const +/*N*/ { +/*N*/ return ( ( aColor == rCmp.GetColor() ) && +/*N*/ ( nInWidth == rCmp.GetInWidth() ) && +/*N*/ ( nOutWidth == rCmp.GetOutWidth() ) && +/*N*/ ( nDistance == rCmp.GetDistance() ) ); +/*N*/ } + +// ----------------------------------------------------------------------- + +// class SvxBoxItem ------------------------------------------------------ + +/*N*/ SvxBoxItem::SvxBoxItem( const SvxBoxItem& rCpy ) : +/*N*/ +/*N*/ SfxPoolItem ( rCpy ), +/*N*/ nTopDist ( rCpy.nTopDist ), +/*N*/ nBottomDist ( rCpy.nBottomDist ), +/*N*/ nLeftDist ( rCpy.nLeftDist ), +/*N*/ nRightDist ( rCpy.nRightDist ) +/*N*/ +/*N*/ { +/*N*/ pTop = rCpy.GetTop() ? new SvxBorderLine( *rCpy.GetTop() ) : 0; +/*N*/ pBottom = rCpy.GetBottom() ? new SvxBorderLine( *rCpy.GetBottom() ) : 0; +/*N*/ pLeft = rCpy.GetLeft() ? new SvxBorderLine( *rCpy.GetLeft() ) : 0; +/*N*/ pRight = rCpy.GetRight() ? new SvxBorderLine( *rCpy.GetRight() ) : 0; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvxBoxItem::SvxBoxItem( const sal_uInt16 nId ) : +/*N*/ SfxPoolItem( nId ), +/*N*/ +/*N*/ pTop ( 0 ), +/*N*/ pBottom ( 0 ), +/*N*/ pLeft ( 0 ), +/*N*/ pRight ( 0 ), +/*N*/ nTopDist ( 0 ), +/*N*/ nBottomDist ( 0 ), +/*N*/ nLeftDist ( 0 ), +/*N*/ nRightDist ( 0 ) +/*N*/ +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvxBoxItem::~SvxBoxItem() +/*N*/ { +/*N*/ delete pTop; +/*N*/ delete pBottom; +/*N*/ delete pLeft; +/*N*/ delete pRight; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvxBoxItem& SvxBoxItem::operator=( const SvxBoxItem& rBox ) +/*N*/ {DBG_BF_ASSERT(0, "STRIP"); return *this;//STRIP001 +/*N*/ } + +// ----------------------------------------------------------------------- + +/*?*/ inline sal_Bool CmpBrdLn( const SvxBorderLine* pBrd1, const SvxBorderLine* pBrd2 ) +/*?*/ { +/*?*/ sal_Bool bRet; +/*?*/ if( 0 != pBrd1 ? 0 == pBrd2 : 0 != pBrd2 ) +/*?*/ bRet = sal_False; +/*?*/ else +/*?*/ if( !pBrd1 ) +/*?*/ bRet = sal_True; +/*?*/ else +/*?*/ bRet = (*pBrd1 == *pBrd2); +/*?*/ return bRet; +/*?*/ } + +// ----------------------------------------------------------------------- + +/*N*/ int SvxBoxItem::operator==( const SfxPoolItem& rAttr ) const +/*N*/ { +/*N*/ DBG_ASSERT( SfxPoolItem::operator==(rAttr), "unequal types" ); +/*N*/ +/*N*/ return ( +/*N*/ ( nTopDist == ( (SvxBoxItem&)rAttr ).nTopDist ) && +/*N*/ ( nBottomDist == ( (SvxBoxItem&)rAttr ).nBottomDist ) && +/*N*/ ( nLeftDist == ( (SvxBoxItem&)rAttr ).nLeftDist ) && +/*N*/ ( nRightDist == ( (SvxBoxItem&)rAttr ).nRightDist ) && +/*N*/ CmpBrdLn( pTop, ( (SvxBoxItem&)rAttr ).GetTop() ) && +/*N*/ CmpBrdLn( pBottom, ( (SvxBoxItem&)rAttr ).GetBottom() ) && +/*N*/ CmpBrdLn( pLeft, ( (SvxBoxItem&)rAttr ).GetLeft() ) && +/*N*/ CmpBrdLn( pRight, ( (SvxBoxItem&)rAttr ).GetRight() ) ); +/*N*/ } + +// ----------------------------------------------------------------------- +/*N*/ table::BorderLine lcl_SvxLineToLine(const SvxBorderLine* pLine, sal_Bool bConvert) +/*N*/ { +/*N*/ table::BorderLine aLine; +/*N*/ if(pLine) +/*N*/ { +/*N*/ aLine.Color = pLine->GetColor().GetColor() ; +/*N*/ aLine.InnerLineWidth = bConvert ? TWIP_TO_MM100(pLine->GetInWidth() ): pLine->GetInWidth() ; +/*N*/ aLine.OuterLineWidth = bConvert ? TWIP_TO_MM100(pLine->GetOutWidth()): pLine->GetOutWidth() ; +/*N*/ aLine.LineDistance = bConvert ? TWIP_TO_MM100(pLine->GetDistance()): pLine->GetDistance() ; +/*N*/ } +/*N*/ else +/*N*/ aLine.Color = aLine.InnerLineWidth = aLine.OuterLineWidth = aLine.LineDistance = 0; +/*N*/ return aLine; +/*N*/ } +// ----------------------------------------------------------------------- +/*N*/ bool SvxBoxItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const +/*N*/ { +/*N*/ sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); +/*N*/ table::BorderLine aRetLine; +/*N*/ sal_uInt16 nDist; +/*N*/ sal_Bool bDistMember = sal_False; +/*N*/ nMemberId &= ~CONVERT_TWIPS; +/*N*/ sal_Bool bSerialize = sal_False; +/*N*/ switch(nMemberId) +/*N*/ { +/*N*/ case MID_LEFT_BORDER: +/*N*/ bSerialize = sal_True; // intentionally no break! +/*N*/ case LEFT_BORDER: +/*N*/ aRetLine = lcl_SvxLineToLine(GetLeft(), bConvert); +/*N*/ break; +/*N*/ case MID_RIGHT_BORDER: +/*N*/ bSerialize = sal_True; // intentionally no break! +/*N*/ case RIGHT_BORDER: +/*N*/ aRetLine = lcl_SvxLineToLine(GetRight(), bConvert); +/*N*/ break; +/*N*/ case MID_BOTTOM_BORDER: +/*N*/ bSerialize = sal_True; // intentionally no break! +/*N*/ case BOTTOM_BORDER: +/*N*/ aRetLine = lcl_SvxLineToLine(GetBottom(), bConvert); +/*N*/ break; +/*N*/ case MID_TOP_BORDER: +/*N*/ bSerialize = sal_True; // intentionally no break! +/*N*/ case TOP_BORDER: +/*N*/ aRetLine = lcl_SvxLineToLine(GetTop(), bConvert); +/*N*/ break; +/*N*/ case BORDER_DISTANCE: +/*?*/ nDist = GetDistance(); +/*?*/ bDistMember = sal_True; +/*?*/ break; +/*N*/ case TOP_BORDER_DISTANCE: +/*N*/ nDist = nTopDist; +/*N*/ bDistMember = sal_True; +/*N*/ break; +/*N*/ case BOTTOM_BORDER_DISTANCE: +/*N*/ nDist = nBottomDist; +/*N*/ bDistMember = sal_True; +/*N*/ break; +/*N*/ case LEFT_BORDER_DISTANCE: +/*N*/ nDist = nLeftDist; +/*N*/ bDistMember = sal_True; +/*N*/ break; +/*N*/ case RIGHT_BORDER_DISTANCE: +/*N*/ nDist = nRightDist; +/*N*/ bDistMember = sal_True; +/*N*/ break; +/*N*/ } +/*N*/ +/*N*/ if( bDistMember ) +/*N*/ rVal <<= (sal_Int32)(bConvert ? TWIP_TO_MM100(nDist) : nDist); +/*N*/ else +/*N*/ { +/* + if ( bSerialize ) + { + ::com::sun::star::uno::Sequence < ::com::sun::star::uno::Any > aSeq(4); + aSeq[0] <<= aRetLine.Color; + aSeq[1] <<= aRetLine.InnerLineWidth; + aSeq[2] <<= aRetLine.OuterLineWidth; + aSeq[3] <<= aRetLine.LineDistance; + rVal <<= aSeq; + } + else +*/ +/*N*/ rVal <<= aRetLine; +/*N*/ } +/*N*/ +/*N*/ return sal_True; +/*N*/ } + +// ----------------------------------------------------------------------- +/*N*/ sal_Bool lcl_LineToSvxLine(const ::com::sun::star::table::BorderLine& rLine, SvxBorderLine& rSvxLine, sal_Bool bConvert) +/*N*/ { +/*N*/ rSvxLine.SetColor( Color(rLine.Color)); +/*N*/ rSvxLine.SetInWidth( bConvert ? MM100_TO_TWIP(rLine.InnerLineWidth) : rLine.InnerLineWidth ); +/*N*/ rSvxLine.SetOutWidth(bConvert ? MM100_TO_TWIP(rLine.OuterLineWidth) : rLine.OuterLineWidth ); +/*N*/ rSvxLine.SetDistance(bConvert ? MM100_TO_TWIP(rLine.LineDistance ) : rLine.LineDistance ); +/*N*/ sal_Bool bRet = rLine.InnerLineWidth > 0 || rLine.OuterLineWidth > 0; +/*N*/ return bRet; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ bool SvxBoxItem::PutValue( const uno::Any& rVal, BYTE nMemberId ) +/*N*/ { +/*N*/ sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); +/*N*/ sal_uInt16 nLine = BOX_LINE_TOP; +/*N*/ sal_Bool bDistMember = sal_False; +/*N*/ nMemberId &= ~CONVERT_TWIPS; +/*N*/ switch(nMemberId) +/*N*/ { +/*N*/ case LEFT_BORDER_DISTANCE: +/*N*/ bDistMember = sal_True; +/*N*/ case LEFT_BORDER: +/*N*/ case MID_LEFT_BORDER: +/*N*/ nLine = BOX_LINE_LEFT; +/*N*/ break; +/*N*/ case RIGHT_BORDER_DISTANCE: +/*N*/ bDistMember = sal_True; +/*N*/ case RIGHT_BORDER: +/*N*/ case MID_RIGHT_BORDER: +/*N*/ nLine = BOX_LINE_RIGHT; +/*N*/ break; +/*N*/ case BOTTOM_BORDER_DISTANCE: +/*N*/ bDistMember = sal_True; +/*N*/ case BOTTOM_BORDER: +/*N*/ case MID_BOTTOM_BORDER: +/*N*/ nLine = BOX_LINE_BOTTOM; +/*N*/ break; +/*N*/ case TOP_BORDER_DISTANCE: +/*N*/ bDistMember = sal_True; +/*N*/ case TOP_BORDER: +/*N*/ case MID_TOP_BORDER: +/*N*/ nLine = BOX_LINE_TOP; +/*N*/ break; +/*N*/ } +/*N*/ +/*N*/ if( bDistMember || nMemberId == BORDER_DISTANCE ) +/*N*/ { +/*N*/ sal_Int32 nDist; +/*N*/ if(!(rVal >>= nDist)) +/*N*/ return sal_False; +/*N*/ +/*N*/ if(nDist >= 0) +/*N*/ { +/*N*/ if( bConvert ) +/*N*/ nDist = MM100_TO_TWIP(nDist); +/*N*/ if( nMemberId == BORDER_DISTANCE ) +/*?*/ SetDistance( nDist ); +/*N*/ else +/*N*/ SetDistance( nDist, nLine ); +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ SvxBorderLine aLine; +/*N*/ if( !rVal.hasValue() ) +/*N*/ return sal_False; +/*N*/ +/*N*/ table::BorderLine aBorderLine; +/*N*/ if( rVal >>= aBorderLine ) +/*N*/ { +/*N*/ // usual struct +/*N*/ } +/*N*/ else if (rVal.getValueTypeClass() == uno::TypeClass_SEQUENCE ) +/*N*/ { +/*N*/ // serialization for basic macro recording +/*?*/ uno::Reference < script::XTypeConverter > xConverter +/*?*/ ( ::legacy_binfilters::getLegacyProcessServiceFactory()->createInstance(::rtl::OUString::createFromAscii("com.sun.star.script.Converter")), +/*?*/ uno::UNO_QUERY ); +/*?*/ uno::Sequence < uno::Any > aSeq; +/*?*/ uno::Any aNew; +/*?*/ try { aNew = xConverter->convertTo( rVal, ::getCppuType((const uno::Sequence < uno::Any >*)0) ); } +/*?*/ catch (uno::Exception&) {} +/*?*/ +/*?*/ aNew >>= aSeq; +/*?*/ if ( aSeq.getLength() == 4 ) +/*?*/ { +/*?*/ sal_Int32 nVal; +/*?*/ if ( aSeq[0] >>= nVal ) +/*?*/ aBorderLine.Color = nVal; +/*?*/ if ( aSeq[1] >>= nVal ) +/*?*/ aBorderLine.InnerLineWidth = (sal_Int16) nVal; +/*?*/ if ( aSeq[2] >>= nVal ) +/*?*/ aBorderLine.OuterLineWidth = (sal_Int16) nVal; +/*?*/ if ( aSeq[3] >>= nVal ) +/*?*/ aBorderLine.LineDistance = (sal_Int16) nVal; +/*?*/ } +/*?*/ else +/*N*/ return sal_False; +/*N*/ } +/*N*/ else +/*N*/ return sal_False; +/*N*/ +/*N*/ sal_Bool bSet = lcl_LineToSvxLine(aBorderLine, aLine, bConvert); +/*N*/ SetLine(bSet ? &aLine : 0, nLine); +/*N*/ } +/*N*/ +/*N*/ return sal_True; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxBoxItem::Clone( SfxItemPool* ) const +/*N*/ { +/*N*/ return new SvxBoxItem( *this ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvStream& SvxBoxItem::Store( SvStream& rStrm , sal_uInt16 nItemVersion ) const +/*N*/ { +/*N*/ rStrm << (sal_uInt16) GetDistance(); +/*N*/ const SvxBorderLine* pLine[ 4 ]; // top, left, right, bottom +/*N*/ pLine[ 0 ] = GetTop(); +/*N*/ pLine[ 1 ] = GetLeft(); +/*N*/ pLine[ 2 ] = GetRight(); +/*N*/ pLine[ 3 ] = GetBottom(); +/*N*/ +/*N*/ for( int i = 0; i < 4; i++ ) +/*N*/ { +/*N*/ const SvxBorderLine* l = pLine[ i ]; +/*N*/ if( l ) +/*N*/ { +/*N*/ rStrm << (sal_Int8) i +/*N*/ << l->GetColor() +/*N*/ << (sal_uInt16) l->GetOutWidth() +/*N*/ << (sal_uInt16) l->GetInWidth() +/*N*/ << (sal_uInt16) l->GetDistance(); +/*N*/ } +/*N*/ } +/*N*/ sal_Int8 cLine = 4; +/*N*/ if( nItemVersion >= BOX_4DISTS_VERSION && +/*N*/ !(nTopDist == nLeftDist && +/*N*/ nTopDist == nRightDist && +/*N*/ nTopDist == nBottomDist) ) +/*N*/ { +/*?*/ cLine |= 0x10; +/*N*/ } +/*N*/ +/*N*/ rStrm << cLine; +/*N*/ +/*N*/ if( nItemVersion >= BOX_4DISTS_VERSION && (cLine & 0x10) != 0 ) +/*N*/ { +/*N*/ rStrm << (sal_uInt16)nTopDist +/*N*/ << (sal_uInt16)nLeftDist +/*N*/ << (sal_uInt16)nRightDist +/*?*/ << (sal_uInt16)nBottomDist; +/*N*/ } +/*N*/ +/*N*/ return rStrm; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ sal_uInt16 SvxBoxItem::GetVersion( sal_uInt16 nFFVer ) const +/*N*/ { +/*N*/ DBG_ASSERT( SOFFICE_FILEFORMAT_31==nFFVer || +/*N*/ SOFFICE_FILEFORMAT_40==nFFVer || +/*N*/ SOFFICE_FILEFORMAT_50==nFFVer, +/*N*/ "SvxBoxItem: Gibt es ein neues Fileformat?" ); +/*N*/ return SOFFICE_FILEFORMAT_31==nFFVer || +/*N*/ SOFFICE_FILEFORMAT_40==nFFVer ? 0 : BOX_4DISTS_VERSION; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxBoxItem::Create( SvStream& rStrm, sal_uInt16 nIVersion ) const +/*N*/ { +/*N*/ sal_uInt16 nDistance; +/*N*/ rStrm >> nDistance; +/*N*/ SvxBoxItem* pAttr = new SvxBoxItem( Which() ); +/*N*/ +/*N*/ sal_uInt16 aLineMap[4] = { BOX_LINE_TOP, BOX_LINE_LEFT, +/*N*/ BOX_LINE_RIGHT, BOX_LINE_BOTTOM }; +/*N*/ +/*N*/ sal_Int8 cLine; +/*N*/ while( sal_True ) +/*N*/ { +/*N*/ rStrm >> cLine; +/*N*/ +/*N*/ if( cLine > 3 ) +/*N*/ break; +/*N*/ sal_uInt16 nOutline, nInline, nDistance; +/*N*/ Color aColor; +/*N*/ rStrm >> aColor >> nOutline >> nInline >> nDistance; +/*N*/ SvxBorderLine aBorder( &aColor, nOutline, nInline, nDistance ); +/*N*/ +/*N*/ pAttr->SetLine( &aBorder, aLineMap[cLine] ); +/*N*/ } +/*N*/ +/*N*/ if( nIVersion >= BOX_4DISTS_VERSION && (cLine&0x10) != 0 ) +/*N*/ { +/*N*/ for( sal_uInt16 i=0; i < 4; i++ ) +/*N*/ { +/*?*/ sal_uInt16 nDist; +/*?*/ rStrm >> nDist; +/*?*/ pAttr->SetDistance( nDist, aLineMap[i] ); +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ pAttr->SetDistance( nDistance ); +/*N*/ } +/*N*/ +/*N*/ return pAttr; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ void SvxBoxItem::SetLine( const SvxBorderLine* pNew, sal_uInt16 nLine ) +/*N*/ { +/*N*/ SvxBorderLine* pTmp = pNew ? new SvxBorderLine( *pNew ) : 0; +/*N*/ +/*N*/ switch ( nLine ) +/*N*/ { +/*N*/ case BOX_LINE_TOP: +/*N*/ delete pTop; +/*N*/ pTop = pTmp; +/*N*/ break; +/*N*/ case BOX_LINE_BOTTOM: +/*N*/ delete pBottom; +/*N*/ pBottom = pTmp; +/*N*/ break; +/*N*/ case BOX_LINE_LEFT: +/*N*/ delete pLeft; +/*N*/ pLeft = pTmp; +/*N*/ break; +/*N*/ case BOX_LINE_RIGHT: +/*N*/ delete pRight; +/*N*/ pRight = pTmp; +/*N*/ break; +/*N*/ default: +/*N*/ if ( pTmp ) +/*N*/ delete pTmp; +/*N*/ DBG_ERROR( "wrong line" ); +/*N*/ } +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ sal_uInt16 SvxBoxItem::GetDistance() const +/*N*/ { +/*N*/ // The smallest distance that is not 0 will be returned. +/*N*/ sal_uInt16 nDist = nTopDist; +/*N*/ if( nBottomDist && (!nDist || nBottomDist < nDist) ) +/*N*/ nDist = nBottomDist; +/*N*/ if( nLeftDist && (!nDist || nLeftDist < nDist) ) +/*N*/ nDist = nLeftDist; +/*N*/ if( nRightDist && (!nDist || nRightDist < nDist) ) +/*N*/ nDist = nRightDist; +/*N*/ +/*N*/ return nDist; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ sal_uInt16 SvxBoxItem::GetDistance( sal_uInt16 nLine ) const +/*N*/ { +/*N*/ sal_uInt16 nDist = 0; +/*N*/ switch ( nLine ) +/*N*/ { +/*N*/ case BOX_LINE_TOP: +/*N*/ nDist = nTopDist; +/*N*/ break; +/*N*/ case BOX_LINE_BOTTOM: +/*N*/ nDist = nBottomDist; +/*N*/ break; +/*N*/ case BOX_LINE_LEFT: +/*N*/ nDist = nLeftDist; +/*N*/ break; +/*N*/ case BOX_LINE_RIGHT: +/*N*/ nDist = nRightDist; +/*N*/ break; +/*N*/ default: +/*N*/ DBG_ERROR( "wrong line" ); +/*N*/ } +/*N*/ +/*N*/ return nDist; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ void SvxBoxItem::SetDistance( sal_uInt16 nNew, sal_uInt16 nLine ) +/*N*/ { +/*N*/ switch ( nLine ) +/*N*/ { +/*N*/ case BOX_LINE_TOP: +/*N*/ nTopDist = nNew; +/*N*/ break; +/*N*/ case BOX_LINE_BOTTOM: +/*N*/ nBottomDist = nNew; +/*N*/ break; +/*N*/ case BOX_LINE_LEFT: +/*N*/ nLeftDist = nNew; +/*N*/ break; +/*N*/ case BOX_LINE_RIGHT: +/*N*/ nRightDist = nNew; +/*N*/ break; +/*N*/ default: +/*N*/ DBG_ERROR( "wrong line" ); +/*N*/ } +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ sal_uInt16 SvxBoxItem::CalcLineSpace( sal_uInt16 nLine, sal_Bool bIgnoreLine ) const +/*N*/ { +/*N*/ SvxBorderLine* pTmp = 0; +/*N*/ sal_uInt16 nDist = 0; +/*N*/ switch ( nLine ) +/*N*/ { +/*N*/ case BOX_LINE_TOP: +/*N*/ pTmp = pTop; +/*N*/ nDist = nTopDist; +/*N*/ break; +/*N*/ case BOX_LINE_BOTTOM: +/*N*/ pTmp = pBottom; +/*N*/ nDist = nBottomDist; +/*N*/ break; +/*N*/ case BOX_LINE_LEFT: +/*N*/ pTmp = pLeft; +/*N*/ nDist = nLeftDist; +/*N*/ break; +/*N*/ case BOX_LINE_RIGHT: +/*N*/ pTmp = pRight; +/*N*/ nDist = nRightDist; +/*N*/ break; +/*N*/ default: +/*N*/ DBG_ERROR( "wrong line" ); +/*N*/ } +/*N*/ +/*N*/ if( pTmp ) +/*N*/ { +/*N*/ nDist += pTmp->GetOutWidth(); +/*N*/ nDist += pTmp->GetInWidth(); +/*N*/ nDist += pTmp->GetDistance(); +/*N*/ } +/*N*/ else if( !bIgnoreLine ) +/*N*/ nDist = 0; +/*N*/ return nDist; +/*N*/ } + +// class SvxBoxInfoItem -------------------------------------------------- + +/*N*/ SvxBoxInfoItem::SvxBoxInfoItem( const sal_uInt16 nId ) : +/*N*/ +/*N*/ SfxPoolItem( nId ), +/*N*/ +/*N*/ pHori ( 0 ), +/*N*/ pVert ( 0 ), +/*N*/ nDefDist( 0 ) +/*N*/ +/*N*/ { +/*N*/ bTable = bDist = bMinDist = sal_False; +/*N*/ ResetFlags(); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvxBoxInfoItem::SvxBoxInfoItem( const SvxBoxInfoItem& rCpy ) : +/*N*/ +/*N*/ SfxPoolItem( rCpy ) +/*N*/ +/*N*/ { +/*N*/ pHori = rCpy.GetHori() ? new SvxBorderLine( *rCpy.GetHori() ) : 0; +/*N*/ pVert = rCpy.GetVert() ? new SvxBorderLine( *rCpy.GetVert() ) : 0; +/*N*/ bTable = rCpy.IsTable(); +/*N*/ bDist = rCpy.IsDist(); +/*N*/ bMinDist = rCpy.IsMinDist(); +/*N*/ nValidFlags = rCpy.nValidFlags; +/*N*/ nDefDist = rCpy.GetDefDist(); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvxBoxInfoItem::~SvxBoxInfoItem() +/*N*/ { +/*N*/ delete pHori; +/*N*/ delete pVert; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ int SvxBoxInfoItem::operator==( const SfxPoolItem& rAttr ) const +/*N*/ { +/*N*/ SvxBoxInfoItem& rBoxInfo = (SvxBoxInfoItem&)rAttr; +/*N*/ +/*N*/ DBG_ASSERT( SfxPoolItem::operator==(rAttr), "unequal types" ); +/*N*/ +/*N*/ return ( bTable == rBoxInfo.IsTable() +/*N*/ && bDist == rBoxInfo.IsDist() +/*N*/ && bMinDist == rBoxInfo.IsMinDist() +/*N*/ && nValidFlags == rBoxInfo.nValidFlags +/*N*/ && nDefDist == rBoxInfo.GetDefDist() +/*N*/ && CmpBrdLn( pHori, rBoxInfo.GetHori() ) +/*N*/ && CmpBrdLn( pVert, rBoxInfo.GetVert() ) +/*N*/ ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ void SvxBoxInfoItem::SetLine( const SvxBorderLine* pNew, sal_uInt16 nLine ) +/*N*/ { +/*N*/ SvxBorderLine* pTmp = pNew ? new SvxBorderLine( *pNew ) : 0; +/*N*/ +/*N*/ if ( BOXINFO_LINE_HORI == nLine ) +/*N*/ { +/*N*/ delete pHori; +/*N*/ pHori = pTmp; +/*N*/ } +/*N*/ else if ( BOXINFO_LINE_VERT == nLine ) +/*N*/ { +/*N*/ delete pVert; +/*N*/ pVert = pTmp; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ if ( pTmp ) +/*N*/ delete pTmp; +/*N*/ DBG_ERROR( "wrong line" ); +/*N*/ } +/*N*/ } + + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxBoxInfoItem::Clone( SfxItemPool* ) const +/*N*/ { +/*N*/ return new SvxBoxInfoItem( *this ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvStream& SvxBoxInfoItem::Store( SvStream& rStrm , sal_uInt16 nItemVersion ) const +/*N*/ { +/*N*/ sal_Int8 cFlags = 0; +/*N*/ +/*N*/ if ( IsTable() ) +/*N*/ cFlags |= 0x01; +/*N*/ if ( IsDist() ) +/*N*/ cFlags |= 0x02; +/*N*/ if ( IsMinDist() ) +/*N*/ cFlags |= 0x04; +/*N*/ rStrm << (sal_Int8) cFlags +/*N*/ << (sal_uInt16) GetDefDist(); +/*N*/ const SvxBorderLine* pLine[ 2 ]; +/*N*/ pLine[ 0 ] = GetHori(); +/*N*/ pLine[ 1 ] = GetVert(); +/*N*/ +/*N*/ for( int i = 0; i < 2; i++ ) +/*N*/ { +/*N*/ const SvxBorderLine* l = pLine[ i ]; +/*N*/ if( l ) +/*N*/ { +/*N*/ rStrm << (char) i +/*N*/ << l->GetColor() +/*N*/ << (short) l->GetOutWidth() +/*N*/ << (short) l->GetInWidth() +/*?*/ << (short) l->GetDistance(); +/*N*/ } +/*N*/ } +/*N*/ rStrm << (char) 2; +/*N*/ return rStrm; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxBoxInfoItem::Create( SvStream& rStrm, sal_uInt16 ) const +/*N*/ { +/*N*/ sal_Int8 cFlags; +/*N*/ sal_uInt16 nDefDist; +/*N*/ rStrm >> cFlags >> nDefDist; +/*N*/ +/*N*/ SvxBoxInfoItem* pAttr = new SvxBoxInfoItem( Which() ); +/*N*/ +/*N*/ pAttr->SetTable ( ( cFlags & 0x01 ) != 0 ); +/*N*/ pAttr->SetDist ( ( cFlags & 0x02 ) != 0 ); +/*N*/ pAttr->SetMinDist( ( cFlags & 0x04 ) != 0 ); +/*N*/ pAttr->SetDefDist( nDefDist ); +/*N*/ +/*N*/ while( sal_True ) +/*N*/ { +/*N*/ sal_Int8 cLine; +/*N*/ rStrm >> cLine; +/*N*/ +/*N*/ if( cLine > 1 ) +/*N*/ break; +/*?*/ short nOutline, nInline, nDistance; +/*?*/ Color aColor; +/*?*/ rStrm >> aColor >> nOutline >> nInline >> nDistance; +/*?*/ SvxBorderLine aBorder( &aColor, nOutline, nInline, nDistance ); +/*?*/ +/*?*/ switch( cLine ) +/*?*/ { +/*?*/ case 0: pAttr->SetLine( &aBorder, BOXINFO_LINE_HORI ); break; +/*?*/ case 1: pAttr->SetLine( &aBorder, BOXINFO_LINE_VERT ); break; +/*?*/ } +/*N*/ } +/*N*/ return pAttr; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ void SvxBoxInfoItem::ResetFlags() +/*N*/ { +/*N*/ nValidFlags = 0x7F; // alles g"ultig au/ser Disable +/*N*/ } + + +// ----------------------------------------------------------------------- + + +// class SvxFmtBreakItem ------------------------------------------------- + +/*N*/ int SvxFmtBreakItem::operator==( const SfxPoolItem& rAttr ) const +/*N*/ { +/*N*/ DBG_ASSERT( SfxPoolItem::operator==( rAttr ), "unequal types" ); +/*N*/ +/*N*/ return GetValue() == ( (SvxFmtBreakItem&)rAttr ).GetValue(); +/*N*/ } + +// ----------------------------------------------------------------------- + + +// ----------------------------------------------------------------------- +/*N*/ bool SvxFmtBreakItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const +/*N*/ { +/*N*/ style::BreakType eBreak = style::BreakType_NONE; +/*N*/ switch ( (SvxBreak)GetValue() ) +/*N*/ { +/*N*/ case SVX_BREAK_COLUMN_BEFORE: eBreak = style::BreakType_COLUMN_BEFORE; break; +/*N*/ case SVX_BREAK_COLUMN_AFTER: eBreak = style::BreakType_COLUMN_AFTER ; break; +/*N*/ case SVX_BREAK_COLUMN_BOTH: eBreak = style::BreakType_COLUMN_BOTH ; break; +/*N*/ case SVX_BREAK_PAGE_BEFORE: eBreak = style::BreakType_PAGE_BEFORE ; break; +/*N*/ case SVX_BREAK_PAGE_AFTER: eBreak = style::BreakType_PAGE_AFTER ; break; +/*N*/ case SVX_BREAK_PAGE_BOTH: eBreak = style::BreakType_PAGE_BOTH ; break; +/*N*/ } +/*N*/ rVal <<= eBreak; +/*N*/ return sal_True; +/*N*/ } +// ----------------------------------------------------------------------- +/*N*/ bool SvxFmtBreakItem::PutValue( const uno::Any& rVal, BYTE nMemberId ) +/*N*/ { +/*N*/ style::BreakType nBreak; +/*N*/ +/*N*/ if(!(rVal >>= nBreak)) +/*N*/ { +/*N*/ sal_Int32 nValue; +/*?*/ if(!(rVal >>= nValue)) +/*?*/ return sal_False; +/*?*/ +/*?*/ nBreak = (style::BreakType) nValue; +/*N*/ } +/*N*/ +/*N*/ SvxBreak eBreak = SVX_BREAK_NONE; +/*N*/ switch( nBreak ) +/*N*/ { +/*N*/ case style::BreakType_COLUMN_BEFORE: eBreak = SVX_BREAK_COLUMN_BEFORE; break; +/*?*/ case style::BreakType_COLUMN_AFTER: eBreak = SVX_BREAK_COLUMN_AFTER; break; +/*?*/ case style::BreakType_COLUMN_BOTH: eBreak = SVX_BREAK_COLUMN_BOTH; break; +/*N*/ case style::BreakType_PAGE_BEFORE: eBreak = SVX_BREAK_PAGE_BEFORE; break; +/*?*/ case style::BreakType_PAGE_AFTER: eBreak = SVX_BREAK_PAGE_AFTER; break; +/*?*/ case style::BreakType_PAGE_BOTH: eBreak = SVX_BREAK_PAGE_BOTH; break; +/*N*/ } +/*N*/ SetValue((sal_uInt16) eBreak); +/*N*/ +/*N*/ return sal_True; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxFmtBreakItem::Clone( SfxItemPool* ) const +/*N*/ { +/*N*/ return new SvxFmtBreakItem( *this ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvStream& SvxFmtBreakItem::Store( SvStream& rStrm , sal_uInt16 nItemVersion ) const +/*N*/ { +/*N*/ rStrm << (sal_Int8)GetValue(); +/*N*/ if( FMTBREAK_NOAUTO > nItemVersion ) +/*N*/ rStrm << (sal_Int8)0x01; +/*N*/ return rStrm; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ sal_uInt16 SvxFmtBreakItem::GetVersion( sal_uInt16 nFFVer ) const +/*N*/ { +/*N*/ DBG_ASSERT( SOFFICE_FILEFORMAT_31==nFFVer || +/*N*/ SOFFICE_FILEFORMAT_40==nFFVer || +/*N*/ SOFFICE_FILEFORMAT_50==nFFVer, +/*N*/ "SvxFmtBreakItem: Gibt es ein neues Fileformat?" ); +/*N*/ return SOFFICE_FILEFORMAT_31==nFFVer || +/*N*/ SOFFICE_FILEFORMAT_40==nFFVer ? 0 : FMTBREAK_NOAUTO; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxFmtBreakItem::Create( SvStream& rStrm, sal_uInt16 nVersion ) const +/*N*/ { +/*N*/ sal_Int8 eBreak, bDummy; +/*N*/ rStrm >> eBreak; +/*N*/ if( FMTBREAK_NOAUTO > nVersion ) +/*N*/ rStrm >> bDummy; +/*N*/ return new SvxFmtBreakItem( (const SvxBreak)eBreak, Which() ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*?*/ sal_uInt16 SvxFmtBreakItem::GetValueCount() const +/*?*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); return 0;//STRIP001 return SVX_BREAK_END; // SVX_BREAK_PAGE_BOTH + 1 +/*?*/ } + +// class SvxFmtKeepItem ------------------------------------------------- + +/*N*/ SfxPoolItem* SvxFmtKeepItem::Clone( SfxItemPool* ) const +/*N*/ { +/*N*/ return new SvxFmtKeepItem( *this ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvStream& SvxFmtKeepItem::Store( SvStream& rStrm , sal_uInt16 nItemVersion ) const +/*N*/ { +/*N*/ rStrm << (sal_Int8)GetValue(); +/*N*/ return rStrm; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxFmtKeepItem::Create( SvStream& rStrm, sal_uInt16 ) const +/*N*/ { +/*N*/ sal_Int8 bIsKeep; +/*N*/ rStrm >> bIsKeep; +/*N*/ return new SvxFmtKeepItem( sal_Bool( bIsKeep != 0 ), Which() ); +/*N*/ } + +//------------------------------------------------------------------------ + + +// class SvxLineItem ------------------------------------------------------ + +/*?*/ SvxLineItem::SvxLineItem( const sal_uInt16 nId ) : +/*?*/ +/*?*/ SfxPoolItem ( nId ), +/*?*/ +/*?*/ pLine( NULL ) +/*?*/ { +/*?*/ } + +// ----------------------------------------------------------------------- + +/*?*/ int SvxLineItem::operator==( const SfxPoolItem& rAttr ) const +/*?*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); return 0;//STRIP001 DBG_ASSERT( SfxPoolItem::operator==(rAttr), "unequal types" ); +/*?*/ +/*?*/ } + +// ----------------------------------------------------------------------- + +/*?*/ SfxPoolItem* SvxLineItem::Clone( SfxItemPool* ) const +/*?*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); return NULL;//STRIP001 return new SvxLineItem( *this ); +/*?*/ } + + +// ----------------------------------------------------------------------- + +#ifdef _MSC_VER +#pragma optimize ( "", off ) +#endif + +// class SvxBrushItem ---------------------------------------------------- + +#define LOAD_GRAPHIC ((sal_uInt16)0x0001) +#define LOAD_LINK ((sal_uInt16)0x0002) +#define LOAD_FILTER ((sal_uInt16)0x0004) + +// class SvxBrushItem_Impl ----------------------------------------------- + +class SvxBrushItem_Impl +{ +public: + BfGraphicObject* pGraphicObject; + sal_Int8 nGraphicTransparency; //contains a percentage value which is + //copied to the GraphicObject when necessary +#ifndef SVX_LIGHT + SfxMediumRef xMedium; +#endif + Link aDoneLink; + + SvxBrushItem_Impl( BfGraphicObject* p ) : pGraphicObject( p ), nGraphicTransparency(0) {} +}; + +// class SvxBrushItemLink_Impl ------------------------------------------- + +class SvxBrushItemLink_Impl : public SfxBrushItemLink +{ + virtual Graphic GetGraphic( const String& rLink, const String& rFilter ); + virtual CreateSvxBrushTabPage GetBackgroundTabpageCreateFunc(); + virtual GetSvxBrushTabPageRanges GetBackgroundTabpageRanges(); +}; + +// ----------------------------------------------------------------------- + +/*?*/ Graphic SvxBrushItemLink_Impl::GetGraphic( const String& rLink, const String& rFilter) +/*?*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); Graphic aResult; return aResult;//STRIP001 Graphic aResult; +/*?*/ } + +// ----------------------------------------------------------------------- + +/*?*/ CreateSvxBrushTabPage SvxBrushItemLink_Impl::GetBackgroundTabpageCreateFunc() +/*?*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); return NULL;//STRIP001 #ifndef SVX_LIGHT +/*?*/ } + +// ----------------------------------------------------------------------- + +/*?*/ GetSvxBrushTabPageRanges SvxBrushItemLink_Impl::GetBackgroundTabpageRanges() +/*?*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); return NULL;//STRIP001 #ifndef SVX_LIGHT +/*?*/ } + +// ----------------------------------------------------------------------- + +/*N*/ void SvxBrushItem::InitSfxLink() +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvxBrushItem::SvxBrushItem( sal_uInt16 nWhich ) : +/*N*/ +/*N*/ SfxPoolItem( nWhich ), +/*N*/ +/*N*/ aColor ( COL_TRANSPARENT ), +/*N*/ pImpl ( new SvxBrushItem_Impl( 0 ) ), +/*N*/ pStrLink ( NULL ), +/*N*/ pStrFilter ( NULL ), +/*N*/ eGraphicPos ( GPOS_NONE ), +/*N*/ bLoadAgain ( sal_True ) +/*N*/ +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvxBrushItem::SvxBrushItem( const Color& rColor, sal_uInt16 nWhich) : +/*N*/ +/*N*/ SfxPoolItem( nWhich ), +/*N*/ +/*N*/ aColor ( rColor ), +/*N*/ pImpl ( new SvxBrushItem_Impl( 0 ) ), +/*N*/ pStrLink ( NULL ), +/*N*/ pStrFilter ( NULL ), +/*N*/ eGraphicPos ( GPOS_NONE ), +/*N*/ bLoadAgain ( sal_True ) +/*N*/ +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvxBrushItem::SvxBrushItem( const Graphic& rGraphic, SvxGraphicPosition ePos, +/*N*/ sal_uInt16 nWhich ) : +/*N*/ +/*N*/ SfxPoolItem( nWhich ), +/*N*/ +/*N*/ aColor ( COL_TRANSPARENT ), +/*N*/ pImpl ( new SvxBrushItem_Impl( new BfGraphicObject( rGraphic ) ) ), +/*N*/ pStrLink ( NULL ), +/*N*/ pStrFilter ( NULL ), +/*N*/ eGraphicPos ( ( GPOS_NONE != ePos ) ? ePos : GPOS_MM ), +/*N*/ bLoadAgain ( sal_True ) +/*N*/ +/*N*/ { +/*N*/ DBG_ASSERT( GPOS_NONE != ePos, "SvxBrushItem-Ctor with GPOS_NONE == ePos" ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvxBrushItem::SvxBrushItem( const BfGraphicObject& rGraphicObj, +/*N*/ SvxGraphicPosition ePos, sal_uInt16 nWhich ) : +/*N*/ +/*N*/ SfxPoolItem( nWhich ), +/*N*/ +/*N*/ aColor ( COL_TRANSPARENT ), +/*N*/ pImpl ( new SvxBrushItem_Impl( new BfGraphicObject( rGraphicObj ) ) ), +/*N*/ pStrLink ( NULL ), +/*N*/ pStrFilter ( NULL ), +/*N*/ eGraphicPos ( ( GPOS_NONE != ePos ) ? ePos : GPOS_MM ), +/*N*/ bLoadAgain ( sal_True ) +/*N*/ +/*N*/ { +/*N*/ DBG_ASSERT( GPOS_NONE != ePos, "SvxBrushItem-Ctor with GPOS_NONE == ePos" ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvxBrushItem::SvxBrushItem( +/*N*/ const String& rLink, const String& rFilter, +/*N*/ SvxGraphicPosition ePos, sal_uInt16 nWhich ) : +/*N*/ +/*N*/ SfxPoolItem( nWhich ), +/*N*/ +/*N*/ aColor ( COL_TRANSPARENT ), +/*N*/ pImpl ( new SvxBrushItem_Impl( NULL ) ), +/*N*/ pStrLink ( new String( rLink ) ), +/*N*/ pStrFilter ( new String( rFilter ) ), +/*N*/ eGraphicPos ( ( GPOS_NONE != ePos ) ? ePos : GPOS_MM ), +/*N*/ bLoadAgain ( sal_True ) +/*N*/ +/*N*/ { +/*N*/ DBG_ASSERT( GPOS_NONE != ePos, "SvxBrushItem-Ctor with GPOS_NONE == ePos" ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvxBrushItem::SvxBrushItem( SvStream& rStream, sal_uInt16 nVersion, +/*N*/ sal_uInt16 nWhich ) : +/*N*/ +/*N*/ SfxPoolItem( nWhich ), +/*N*/ +/*N*/ aColor ( COL_TRANSPARENT ), +/*N*/ pImpl ( new SvxBrushItem_Impl( NULL ) ), +/*N*/ pStrLink ( NULL ), +/*N*/ pStrFilter ( NULL ), +/*N*/ eGraphicPos ( GPOS_NONE ) +/*N*/ +/*N*/ { +/*N*/ sal_Bool bTrans; +/*N*/ Color aTempColor; +/*N*/ Color aTempFillColor; +/*N*/ sal_Int8 nStyle; +/*N*/ +/*N*/ rStream >> bTrans; +/*N*/ rStream >> aTempColor; +/*N*/ rStream >> aTempFillColor; +/*N*/ rStream >> nStyle; +/*N*/ +/*N*/ switch ( nStyle ) +/*N*/ { +/*N*/ case 8://BRUSH_25: +/*N*/ { +/*N*/ sal_uInt32 nRed = aTempColor.GetRed(); +/*N*/ sal_uInt32 nGreen = aTempColor.GetGreen(); +/*N*/ sal_uInt32 nBlue = aTempColor.GetBlue(); +/*N*/ nRed += (sal_uInt32)(aTempFillColor.GetRed())*2; +/*N*/ nGreen += (sal_uInt32)(aTempFillColor.GetGreen())*2; +/*N*/ nBlue += (sal_uInt32)(aTempFillColor.GetBlue())*2; +/*N*/ aColor = Color( (sal_Int8)(nRed/3), (sal_Int8)(nGreen/3), (sal_Int8)(nBlue/3) ); +/*N*/ } +/*N*/ break; +/*N*/ +/*N*/ case 9://BRUSH_50: +/*N*/ { +/*N*/ sal_uInt32 nRed = aTempColor.GetRed(); +/*N*/ sal_uInt32 nGreen = aTempColor.GetGreen(); +/*N*/ sal_uInt32 nBlue = aTempColor.GetBlue(); +/*N*/ nRed += (sal_uInt32)(aTempFillColor.GetRed()); +/*N*/ nGreen += (sal_uInt32)(aTempFillColor.GetGreen()); +/*N*/ nBlue += (sal_uInt32)(aTempFillColor.GetBlue()); +/*N*/ aColor = Color( (sal_Int8)(nRed/2), (sal_Int8)(nGreen/2), (sal_Int8)(nBlue/2) ); +/*N*/ } +/*N*/ break; +/*N*/ +/*N*/ case 10://BRUSH_75: +/*N*/ { +/*N*/ sal_uInt32 nRed = aTempColor.GetRed()*2; +/*N*/ sal_uInt32 nGreen = aTempColor.GetGreen()*2; +/*N*/ sal_uInt32 nBlue = aTempColor.GetBlue()*2; +/*N*/ nRed += (sal_uInt32)(aTempFillColor.GetRed()); +/*N*/ nGreen += (sal_uInt32)(aTempFillColor.GetGreen()); +/*N*/ nBlue += (sal_uInt32)(aTempFillColor.GetBlue()); +/*N*/ aColor = Color( (sal_Int8)(nRed/3), (sal_Int8)(nGreen/3), (sal_Int8)(nBlue/3) ); +/*N*/ } +/*N*/ break; +/*N*/ +/*N*/ case 0://BRUSH_NULL: +/*N*/ aColor = Color( COL_TRANSPARENT ); +/*N*/ break; +/*N*/ +/*N*/ default: +/*N*/ aColor = aTempColor; +/*N*/ } +/*N*/ +/*N*/ if ( nVersion >= BRUSH_GRAPHIC_VERSION ) +/*N*/ { +/*N*/ sal_uInt16 nDoLoad = 0; +/*N*/ sal_Int8 nPos; +/*N*/ +/*N*/ rStream >> nDoLoad; +/*N*/ +/*N*/ if ( nDoLoad & LOAD_GRAPHIC ) +/*N*/ { +/*N*/ Graphic aGraphic; +/*N*/ +/*N*/ rStream >> aGraphic; +/*N*/ pImpl->pGraphicObject = new BfGraphicObject( aGraphic ); +/*N*/ +/*N*/ if( SVSTREAM_FILEFORMAT_ERROR == rStream.GetError() ) +/*N*/ { +/*?*/ rStream.ResetError(); +/*?*/ rStream.SetError( ERRCODE_SVX_GRAPHIC_WRONG_FILEFORMAT| +/*?*/ ERRCODE_WARNING_MASK ); +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ if ( nDoLoad & LOAD_LINK ) +/*N*/ { +/*N*/ String aRel; +/*N*/ // UNICODE: rStream >> aRel; +/*N*/ rStream.ReadByteString(aRel); +/*N*/ +/*N*/ String aAbs = ::binfilter::StaticBaseUrl::RelToAbs( aRel ); +/*N*/ pStrLink = new String( aAbs ); +/*N*/ } +/*N*/ +/*N*/ if ( nDoLoad & LOAD_FILTER ) +/*N*/ { +/*N*/ pStrFilter = new String; +/*N*/ // UNICODE: rStream >> *pStrFilter; +/*N*/ rStream.ReadByteString(*pStrFilter); +/*N*/ } +/*N*/ +/*N*/ rStream >> nPos; +/*N*/ +/*N*/ eGraphicPos = (SvxGraphicPosition)nPos; +/*N*/ } +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvxBrushItem::SvxBrushItem( const SvxBrushItem& rItem ) : +/*N*/ +/*N*/ SfxPoolItem( rItem.Which() ), +/*N*/ +/*N*/ pImpl ( new SvxBrushItem_Impl( NULL ) ), +/*N*/ pStrLink ( NULL ), +/*N*/ pStrFilter ( NULL ), +/*N*/ eGraphicPos ( GPOS_NONE ), +/*N*/ bLoadAgain ( sal_True ) +/*N*/ +/*N*/ { +/*N*/ *this = rItem; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvxBrushItem::~SvxBrushItem() +/*N*/ { +/*N*/ #ifndef SVX_LIGHT +/*N*/ if( pImpl->xMedium.Is() ) +/*?*/ pImpl->xMedium->SetDoneLink( Link() ); +/*N*/ #endif +/*N*/ delete pImpl->pGraphicObject; +/*N*/ delete pImpl; +/*N*/ delete pStrLink; +/*N*/ delete pStrFilter; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ sal_uInt16 SvxBrushItem::GetVersion( sal_uInt16 nFileVersion ) const +/*N*/ { +/*N*/ return BRUSH_GRAPHIC_VERSION; +/*N*/ } + +// ----------------------------------------------------------------------- +/*?*/ inline sal_Int8 lcl_PercentToTransparency(long nPercent) +/*?*/ { +/*?*/ //0xff must not be returned! +/*?*/ return sal_Int8(nPercent ? (50 + 0xfe * nPercent) / 100 : 0); +/*?*/ } +/*?*/ inline sal_Int8 lcl_TransparencyToPercent(sal_Int32 nTrans) +/*?*/ { +/*?*/ return (nTrans * 100 + 127) / 254; +/*?*/ } + +/*N*/ bool SvxBrushItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const +/*N*/ { +/*N*/ sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); +/*N*/ nMemberId &= ~CONVERT_TWIPS; +/*N*/ switch( nMemberId) +/*N*/ { +/*N*/ case MID_BACK_COLOR: +/*N*/ rVal <<= (sal_Int32)( aColor.GetColor() ); +/*N*/ break; +/*N*/ case MID_BACK_COLOR_R_G_B: +/*N*/ rVal <<= (sal_Int32)( aColor.GetRGBColor() ); +/*N*/ break; +/*N*/ case MID_BACK_COLOR_TRANSPARENCY: +/*N*/ rVal <<= lcl_TransparencyToPercent(aColor.GetTransparency()); +/*N*/ break; +/*N*/ case MID_GRAPHIC_POSITION: +/*N*/ rVal <<= (style::GraphicLocation)(sal_Int16)eGraphicPos; +/*N*/ break; +/*N*/ +/*N*/ case MID_GRAPHIC: +/*N*/ DBG_ERRORFILE( "not implemented" ); +/*N*/ break; +/*N*/ +/*N*/ case MID_GRAPHIC_TRANSPARENT: +/*N*/ rVal = Bool2Any( aColor.GetTransparency() == 0xff ); +/*N*/ break; +/*N*/ +/*N*/ case MID_GRAPHIC_URL: +/*N*/ { +/*N*/ OUString sLink; +/*N*/ if ( pStrLink ) +/*N*/ sLink = *pStrLink; +/*N*/ else if( pImpl->pGraphicObject ) +/*N*/ { +/*N*/ OUString sPrefix(RTL_CONSTASCII_USTRINGPARAM(UNO_NAME_GRAPHOBJ_URLPREFIX)); +/*N*/ String sId( pImpl->pGraphicObject->GetUniqueID(), +/*N*/ RTL_TEXTENCODING_ASCII_US ); +/*N*/ sLink = sPrefix; +/*N*/ sLink += OUString(sId); +/*N*/ } +/*N*/ rVal <<= sLink; +/*N*/ } +/*N*/ break; +/*N*/ +/*N*/ case MID_GRAPHIC_FILTER: +/*N*/ { +/*N*/ OUString sFilter; +/*N*/ if ( pStrFilter ) +/*N*/ sFilter = *pStrFilter; +/*N*/ rVal <<= sFilter; +/*N*/ } +/*N*/ break; +/*N*/ case MID_GRAPHIC_TRANSPARENCY : +/*N*/ rVal <<= pImpl->nGraphicTransparency; +/*N*/ break; +/*N*/ } +/*N*/ +/*N*/ return sal_True; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ bool SvxBrushItem::PutValue( const uno::Any& rVal, BYTE nMemberId ) +/*N*/ { +/*N*/ sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); +/*N*/ nMemberId &= ~CONVERT_TWIPS; +/*N*/ switch( nMemberId) +/*N*/ { +/*N*/ case MID_BACK_COLOR: +/*N*/ case MID_BACK_COLOR_R_G_B: +/*N*/ { +/*N*/ sal_Int32 nCol; +/*N*/ if ( !( rVal >>= nCol ) ) +/*N*/ return sal_False; +/*N*/ if(MID_BACK_COLOR_R_G_B == nMemberId) +/*N*/ { +/*N*/ nCol = COLORDATA_RGB( nCol ); +/*N*/ nCol += aColor.GetColor() & 0xff000000; +/*N*/ } +/*N*/ aColor = Color( nCol ); +/*N*/ } +/*N*/ break; +/*N*/ case MID_BACK_COLOR_TRANSPARENCY: +/*N*/ { +/*N*/ sal_Int32 nTrans; +/*N*/ if ( !( rVal >>= nTrans ) || nTrans < 0 || nTrans > 100 ) +/*N*/ return sal_False; +/*N*/ aColor.SetTransparency(lcl_PercentToTransparency(nTrans)); +/*N*/ } +/*N*/ break; +/*N*/ +/*N*/ case MID_GRAPHIC_POSITION: +/*N*/ { +/*N*/ style::GraphicLocation eLocation; +/*N*/ if ( !( rVal>>=eLocation ) ) +/*N*/ { +/*N*/ sal_Int32 nValue; +/*?*/ if ( !( rVal >>= nValue ) ) +/*?*/ return sal_False; +/*?*/ eLocation = (style::GraphicLocation)nValue; +/*N*/ } +/*N*/ SetGraphicPos( (SvxGraphicPosition)(sal_uInt16)eLocation ); +/*N*/ } +/*N*/ break; +/*N*/ +/*N*/ case MID_GRAPHIC: +/*N*/ DBG_ERRORFILE( "not implemented" ); +/*N*/ break; +/*N*/ +/*N*/ case MID_GRAPHIC_TRANSPARENT: +/*N*/ aColor.SetTransparency( Any2Bool( rVal ) ? 0xff : 0 ); +/*N*/ break; +/*N*/ +/*N*/ case MID_GRAPHIC_URL: +/*N*/ { +/*N*/ if ( rVal.getValueType() == ::getCppuType( (OUString*)0 ) ) +/*N*/ { +/*N*/ OUString sLink; +/*N*/ rVal >>= sLink; +/*N*/ if( 0 == sLink.compareToAscii( UNO_NAME_GRAPHOBJ_URLPKGPREFIX, +/*N*/ sizeof(UNO_NAME_GRAPHOBJ_URLPKGPREFIX)-1 ) ) +/*N*/ { +/*N*/ DBG_ERROR( "package urls aren't implemented" ); +/*N*/ } +/*N*/ else if( 0 == sLink.compareToAscii( UNO_NAME_GRAPHOBJ_URLPREFIX, +/*N*/ sizeof(UNO_NAME_GRAPHOBJ_URLPREFIX)-1 ) ) +/*N*/ { +/*N*/ DELETEZ( pStrLink ); +/*N*/ String sTmp( sLink ); +/*N*/ ByteString sId( sTmp.Copy( +/*N*/ sizeof(UNO_NAME_GRAPHOBJ_URLPREFIX)-1), +/*N*/ RTL_TEXTENCODING_ASCII_US ); +/*N*/ BfGraphicObject *pOldGrfObj = pImpl->pGraphicObject; +/*N*/ pImpl->pGraphicObject = new BfGraphicObject( sId ); +/*N*/ ApplyGraphicTransparency_Impl(); +/*N*/ delete pOldGrfObj; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ SetGraphicLink(sLink); +/*N*/ } +/*N*/ if ( sLink.getLength() && eGraphicPos == GPOS_NONE ) +/*N*/ eGraphicPos = GPOS_MM; +/*N*/ else if( !sLink.getLength() ) +/*N*/ eGraphicPos = GPOS_NONE; +/*N*/ } +/*N*/ } +/*N*/ break; +/*N*/ +/*N*/ case MID_GRAPHIC_FILTER: +/*N*/ { +/*N*/ if( rVal.getValueType() == ::getCppuType( (OUString*)0 ) ) +/*N*/ { +/*N*/ OUString sLink; +/*N*/ rVal >>= sLink; +/*N*/ SetGraphicFilter( sLink ); +/*N*/ } +/*N*/ } +/*N*/ break; +/*N*/ case MID_GRAPHIC_TRANSPARENCY : +/*N*/ { +/*N*/ sal_Int32 nTmp; +/*N*/ rVal >>= nTmp; +/*N*/ if(nTmp >= 0 && nTmp <= 100) +/*N*/ { +/*N*/ pImpl->nGraphicTransparency = sal_Int8(nTmp); +/*N*/ if(pImpl->pGraphicObject) +/*N*/ ApplyGraphicTransparency_Impl(); +/*N*/ } +/*N*/ } +/*N*/ break; +/*N*/ } +/*N*/ +/*N*/ return sal_True; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvxBrushItem& SvxBrushItem::operator=( const SvxBrushItem& rItem ) +/*N*/ { +/*N*/ aColor = rItem.aColor; +/*N*/ eGraphicPos = rItem.eGraphicPos; +/*N*/ +/*N*/ DELETEZ( pImpl->pGraphicObject ); +/*N*/ DELETEZ( pStrLink ); +/*N*/ DELETEZ( pStrFilter ); +/*N*/ +/*N*/ if ( GPOS_NONE != eGraphicPos ) +/*N*/ { +/*N*/ if ( rItem.pStrLink ) +/*N*/ pStrLink = new String( *rItem.pStrLink ); +/*N*/ if ( rItem.pStrFilter ) +/*N*/ pStrFilter = new String( *rItem.pStrFilter ); +/*N*/ if ( rItem.pImpl->pGraphicObject ) +/*N*/ { +/*N*/ pImpl->pGraphicObject = new BfGraphicObject( *rItem.pImpl->pGraphicObject ); +/*N*/ } +/*N*/ } +/*N*/ pImpl->nGraphicTransparency = rItem.pImpl->nGraphicTransparency; +/*N*/ return *this; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ int SvxBrushItem::operator==( const SfxPoolItem& rAttr ) const +/*N*/ { +/*N*/ DBG_ASSERT( SfxPoolItem::operator==(rAttr), "unequal types" ); +/*N*/ +/*N*/ SvxBrushItem& rCmp = (SvxBrushItem&)rAttr; +/*N*/ sal_Bool bEqual = ( aColor == rCmp.aColor && eGraphicPos == rCmp.eGraphicPos && +/*N*/ pImpl->nGraphicTransparency == rCmp.pImpl->nGraphicTransparency); +/*N*/ +/*N*/ if ( bEqual ) +/*N*/ { +/*N*/ if ( GPOS_NONE != eGraphicPos ) +/*N*/ { +/*N*/ if ( !rCmp.pStrLink ) +/*N*/ bEqual = !pStrLink; +/*N*/ else +/*N*/ bEqual = pStrLink && ( *pStrLink == *rCmp.pStrLink ); +/*N*/ +/*N*/ if ( bEqual ) +/*N*/ { +/*N*/ if ( !rCmp.pStrFilter ) +/*N*/ bEqual = !pStrFilter; +/*N*/ else +/*N*/ bEqual = pStrFilter && ( *pStrFilter == *rCmp.pStrFilter ); +/*N*/ } +/*N*/ +/*N*/ if ( bEqual && !rCmp.pStrLink ) +/*N*/ { +/*N*/ if ( !rCmp.pImpl->pGraphicObject ) +/*?*/ bEqual = !pImpl->pGraphicObject; +/*N*/ else +/*N*/ bEqual = pImpl->pGraphicObject && +/*N*/ ( *pImpl->pGraphicObject == *rCmp.pImpl->pGraphicObject ); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ return bEqual; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxBrushItem::Clone( SfxItemPool* ) const +/*N*/ { +/*N*/ return new SvxBrushItem( *this ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxBrushItem::Create( SvStream& rStream, sal_uInt16 nVersion ) const +/*N*/ { +/*N*/ return new SvxBrushItem( rStream, nVersion, Which() ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvStream& SvxBrushItem::Store( SvStream& rStream , sal_uInt16 nItemVersion ) const +/*N*/ { +/*N*/ rStream << (sal_Bool)sal_False; +/*N*/ rStream << aColor; +/*N*/ rStream << aColor; +/*N*/ rStream << (sal_Int8)(aColor.GetTransparency() > 0 ? 0 : 1); //BRUSH_NULL : BRUSH_SOLID +/*N*/ +/*N*/ sal_uInt16 nDoLoad = 0; +/*N*/ +/*N*/ if ( pImpl->pGraphicObject && !pStrLink ) +/*N*/ nDoLoad |= LOAD_GRAPHIC; +/*N*/ if ( pStrLink ) +/*N*/ nDoLoad |= LOAD_LINK; +/*N*/ if ( pStrFilter ) +/*N*/ nDoLoad |= LOAD_FILTER; +/*N*/ rStream << nDoLoad; +/*N*/ +/*N*/ if ( pImpl->pGraphicObject && !pStrLink ) +/*N*/ rStream << pImpl->pGraphicObject->GetGraphic(); +/*N*/ if ( pStrLink ) +/*N*/ { +/*N*/ String aRel = ::binfilter::StaticBaseUrl::AbsToRel( *pStrLink ); +/*N*/ // UNICODE: rStream << aRel; +/*N*/ rStream.WriteByteString(aRel); +/*N*/ } +/*N*/ if ( pStrFilter ) +/*N*/ { +/*N*/ // UNICODE: rStream << *pStrFilter; +/*?*/ rStream.WriteByteString(*pStrFilter); +/*N*/ } +/*N*/ rStream << (sal_Int8)eGraphicPos; +/*N*/ return rStream; +/*N*/ } + +// ----------------------------------------------------------------------- +// const wegcasten, da const als logisches const zu verstehen ist +// wenn GetGraphic() gerufen wird, soll sich das Item darum kuemmern, +// eine gelinkte Grafik zu holen. + +GraphicFilter* GetGrfFilter(); + + +// ----------------------------------------------------------------------- + +/*N*/ const BfGraphicObject* SvxBrushItem::GetGraphicObject( SfxObjectShell* pSh ) const +/*N*/ { +/*N*/ #ifndef SVX_LIGHT +/*N*/ if ( bLoadAgain && pStrLink && !pImpl->pGraphicObject && !pImpl->xMedium.Is() ) +/*N*/ // wenn Grafik schon geladen, als Cache benutzen +/*N*/ { +/*?*/ if( pSh && pSh->IsAbortingImport() ) +/*?*/ { +/*?*/ SvxBrushItem* pThis = (SvxBrushItem*)this; +/*?*/ pThis->bLoadAgain = sal_False; +/*?*/ return 0; +/*?*/ } +/*?*/ //JP 29.6.2001: only with "valid" names - empty names now allowed +/*?*/ if( pStrLink->Len() ) +/*?*/ { +/*?*/ pImpl->xMedium = new SfxMedium( +/*?*/ *pStrLink, STREAM_STD_READ, sal_False ); +/*?*/ +/*?*/ pImpl->xMedium->SetTransferPriority( SFX_TFPRIO_VISIBLE_LOWRES_GRAPHIC ); +/*?*/ if( pImpl->xMedium->IsRemote() ) +/*?*/ { +/*?*/ if( pSh ) +/*?*/ pSh->RegisterTransfer( *pImpl->xMedium ); +/*?*/ else +/*?*/ DBG_WARNING( "SvxBrushItem::GetGraphic ohne DocShell" ); +/*?*/ } +/*?*/ +/*?*/ SfxMediumRef xRef( pImpl->xMedium ); +/*?*/ // Ref halten wg. synchr. DoneCallback +/*?*/ if( pImpl->aDoneLink.IsSet() ) +/*?*/ { +/*?*/ // Auf besonderen Wunsch des Writers wird der synchrone und der +/*?*/ // asynchrone Fall was die Benachrichtigung angeht unterschiedlich +/*?*/ // behandelt. Der Callback erfolgt nur bei asynchronem Eintreffen +/*?*/ // der Daten +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 /*?*/ +/*?*/ } +/*?*/ else +/*?*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 /*?*/ pImpl->xMedium->DownLoad( ); +/*?*/ } +/*N*/ } +/*N*/ } +/*N*/ #endif +/*N*/ return pImpl->pGraphicObject; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ const Graphic* SvxBrushItem::GetGraphic( SfxObjectShell* pSh ) const +/*N*/ { +/*N*/ const BfGraphicObject* pGrafObj = GetGraphicObject( pSh ); +/*N*/ return( pGrafObj ? &( pGrafObj->GetGraphic() ) : NULL ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ void SvxBrushItem::SetGraphicPos( SvxGraphicPosition eNew ) +/*N*/ { +/*N*/ eGraphicPos = eNew; +/*N*/ +/*N*/ if ( GPOS_NONE == eGraphicPos ) +/*N*/ { +/*N*/ DELETEZ( pImpl->pGraphicObject ); +/*N*/ DELETEZ( pStrLink ); +/*N*/ DELETEZ( pStrFilter ); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ if ( !pImpl->pGraphicObject && !pStrLink ) +/*N*/ { +/*N*/ pImpl->pGraphicObject = new BfGraphicObject; // dummy anlegen +/*N*/ } +/*N*/ } +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ void SvxBrushItem::SetGraphic( const Graphic& rNew ) +/*N*/ { +/*N*/ if ( !pStrLink ) +/*N*/ { +/*N*/ if ( pImpl->pGraphicObject ) +/*N*/ pImpl->pGraphicObject->SetGraphic( rNew ); +/*N*/ else +/*N*/ pImpl->pGraphicObject = new BfGraphicObject( rNew ); +/*N*/ +/*N*/ ApplyGraphicTransparency_Impl(); +/*N*/ +/*N*/ if ( GPOS_NONE == eGraphicPos ) +/*N*/ eGraphicPos = GPOS_MM; // None waere Brush, also Default: Mitte +/*N*/ } +/*N*/ else +/*N*/ DBG_ERROR( "SetGraphic() on linked graphic! :-/" ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ void SvxBrushItem::SetGraphicLink( const String& rNew ) +/*N*/ { +/*N*/ if ( !rNew.Len() ) +/*N*/ DELETEZ( pStrLink ); +/*N*/ else +/*N*/ { +/*N*/ if ( pStrLink ) +/*N*/ *pStrLink = rNew; +/*N*/ else +/*N*/ pStrLink = new String( rNew ); +/*N*/ +/*N*/ DELETEZ( pImpl->pGraphicObject ); +/*N*/ } +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ void SvxBrushItem::SetGraphicFilter( const String& rNew ) +/*N*/ { +/*N*/ if ( !rNew.Len() ) +/*N*/ DELETEZ( pStrFilter ); +/*N*/ else +/*N*/ { +/*?*/ if ( pStrFilter ) +/*?*/ *pStrFilter = rNew; +/*?*/ else +/*?*/ pStrFilter = new String( rNew ); +/*N*/ } +/*N*/ } + +#ifdef _MSC_VER +#pragma optimize ( "", on ) +#endif +/* -----------------------------16.08.2002 09:18------------------------------ + + ---------------------------------------------------------------------------*/ +/*N*/ void SvxBrushItem::ApplyGraphicTransparency_Impl() +/*N*/ { +/*N*/ DBG_ASSERT(pImpl->pGraphicObject, "no GraphicObject available" ); +/*N*/ if(pImpl->pGraphicObject) +/*N*/ { +/*N*/ BfGraphicAttr aAttr(pImpl->pGraphicObject->GetAttr()); +/*N*/ aAttr.SetTransparency(lcl_PercentToTransparency( +/*N*/ pImpl->nGraphicTransparency)); +/*N*/ pImpl->pGraphicObject->SetAttr(aAttr); +/*N*/ } +/*N*/ } +// class SvxFrameDirectionItem ---------------------------------------------- + +/*N*/ SvxFrameDirectionItem::SvxFrameDirectionItem( SvxFrameDirection nValue , +/*N*/ USHORT nWhich ) +/*N*/ : SfxUInt16Item( nWhich, nValue ) +/*N*/ { +/*N*/ } + +/*N*/ SvxFrameDirectionItem::~SvxFrameDirectionItem() +/*N*/ { +/*N*/ } + +/*N*/ int SvxFrameDirectionItem::operator==( const SfxPoolItem& rCmp ) const +/*N*/ { +/*N*/ DBG_ASSERT( SfxPoolItem::operator==(rCmp), "unequal types" ); +/*N*/ +/*N*/ return GetValue() == ((SvxFrameDirectionItem&)rCmp).GetValue(); +/*N*/ } + +/*N*/ SfxPoolItem* SvxFrameDirectionItem::Clone( SfxItemPool * ) const +/*N*/ { +/*N*/ return new SvxFrameDirectionItem( *this ); +/*N*/ } + +SfxPoolItem* SvxFrameDirectionItem::Create( SvStream & rStrm, USHORT /*nVer*/ ) const +{ + sal_uInt16 nValue; + rStrm >> nValue; + return new SvxFrameDirectionItem( (SvxFrameDirection)nValue, Which() ); +} + +/*N*/ SvStream& SvxFrameDirectionItem::Store( SvStream & rStrm, USHORT nIVer ) const +/*N*/ { +/*N*/ sal_uInt16 nValue = GetValue(); +/*N*/ rStrm << nValue; +/*N*/ return rStrm; +/*N*/ } + +/*N*/ USHORT SvxFrameDirectionItem::GetVersion( USHORT nFVer ) const +/*N*/ { +/*N*/ return SOFFICE_FILEFORMAT_50 > nFVer ? USHRT_MAX : 0; +/*N*/ } + + +/*N*/ bool SvxFrameDirectionItem::PutValue( const ::com::sun::star::uno::Any& rVal, +/*N*/ BYTE ) +/*N*/ { +/*N*/ sal_Int16 nVal; +/*N*/ sal_Bool bRet = ( rVal >>= nVal ); +/*N*/ if( bRet ) +/*N*/ { +/*N*/ // translate WritingDirection2 constants into SvxFrameDirection +/*N*/ switch( nVal ) +/*N*/ { +/*N*/ case text::WritingMode2::LR_TB: +/*N*/ SetValue( FRMDIR_HORI_LEFT_TOP ); +/*N*/ break; +/*N*/ case text::WritingMode2::RL_TB: +/*?*/ SetValue( FRMDIR_HORI_RIGHT_TOP ); +/*?*/ break; +/*?*/ case text::WritingMode2::TB_RL: +/*?*/ SetValue( FRMDIR_VERT_TOP_RIGHT ); +/*?*/ break; +/*?*/ case text::WritingMode2::TB_LR: +/*?*/ SetValue( FRMDIR_VERT_TOP_LEFT ); +/*?*/ break; +/*?*/ case text::WritingMode2::PAGE: +/*?*/ SetValue( FRMDIR_ENVIRONMENT ); +/*?*/ break; +/*?*/ default: +/*?*/ bRet = sal_False; +/*N*/ break; +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ return bRet; +/*N*/ } + +/*N*/ bool SvxFrameDirectionItem::QueryValue( ::com::sun::star::uno::Any& rVal, +/*N*/ BYTE ) const +/*N*/ { +/*N*/ // translate SvxFrameDirection into WritingDirection2 +/*N*/ sal_Int16 nVal; +/*N*/ sal_Bool bRet = sal_True; +/*N*/ switch( GetValue() ) +/*N*/ { +/*N*/ case FRMDIR_HORI_LEFT_TOP: +/*N*/ nVal = text::WritingMode2::LR_TB; +/*N*/ break; +/*?*/ case FRMDIR_HORI_RIGHT_TOP: +/*?*/ nVal = text::WritingMode2::RL_TB; +/*?*/ break; +/*?*/ case FRMDIR_VERT_TOP_RIGHT: +/*?*/ nVal = text::WritingMode2::TB_RL; +/*?*/ break; +/*?*/ case FRMDIR_VERT_TOP_LEFT: +/*?*/ nVal = text::WritingMode2::TB_LR; +/*?*/ break; +/*?*/ case FRMDIR_ENVIRONMENT: +/*?*/ nVal = text::WritingMode2::PAGE; +/*?*/ break; +/*?*/ default: +/*?*/ DBG_ERROR("Unknown SvxFrameDirection value!"); +/*?*/ bRet = sal_False; +/*?*/ break; +/*N*/ } +/*N*/ +/*N*/ // return value + error state +/*N*/ if( bRet ) +/*N*/ { +/*N*/ rVal <<= nVal; +/*N*/ } +/*N*/ return bRet; +/*N*/ } + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_svx/source/items/svx_grfitem.cxx b/binfilter/bf_svx/source/items/svx_grfitem.cxx new file mode 100644 index 000000000000..6401ecec5541 --- /dev/null +++ b/binfilter/bf_svx/source/items/svx_grfitem.cxx @@ -0,0 +1,175 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +#define ITEMID_GRF_CROP 0 + +#include <tools/stream.hxx> +#include <grfcrop.hxx> +#include <com/sun/star/text/GraphicCrop.hpp> +namespace binfilter { + +using namespace ::com::sun::star; + +#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)) +//TYPEINIT1_AUTOFACTORY( SvxGrfCrop, SfxPoolItem ) + +/****************************************************************************** + * Implementierung class SwCropGrf + ******************************************************************************/ + +/*N*/ SvxGrfCrop::SvxGrfCrop( USHORT nItemId ) +/*N*/ : SfxPoolItem( nItemId ), +/*N*/ nLeft( 0 ), nRight( 0 ), nTop( 0 ), nBottom( 0 ) +/*N*/ {} + +/*N*/ SvxGrfCrop::SvxGrfCrop( sal_Int32 nL, sal_Int32 nR, +/*N*/ sal_Int32 nT, sal_Int32 nB, USHORT nItemId ) +/*N*/ : SfxPoolItem( nItemId ), +/*N*/ nLeft( nL ), nRight( nR ), nTop( nT ), nBottom( nB ) +/*N*/ {} + +/*N*/ SvxGrfCrop::~SvxGrfCrop() +/*N*/ { +/*N*/ } + +/*N*/ int SvxGrfCrop::operator==( const SfxPoolItem& rAttr ) const +/*N*/ { +/*N*/ DBG_ASSERT( SfxPoolItem::operator==( rAttr ), "not equal attributes" ); +/*N*/ return nLeft == ((const SvxGrfCrop&)rAttr).GetLeft() && +/*N*/ nRight == ((const SvxGrfCrop&)rAttr).GetRight() && +/*N*/ nTop == ((const SvxGrfCrop&)rAttr).GetTop() && +/*N*/ nBottom == ((const SvxGrfCrop&)rAttr).GetBottom(); +/*N*/ } + +/* +SfxPoolItem* SvxGrfCrop::Clone( SfxItemPool* ) const +{ + return new SvxGrfCrop( *this ); +} +*/ + +/* +USHORT SvxGrfCrop::GetVersion( USHORT nFFVer ) const +{ + DBG_ASSERT( SOFFICE_FILEFORMAT_31==nFFVer || + SOFFICE_FILEFORMAT_40==nFFVer || + SOFFICE_FILEFORMAT_NOW==nFFVer, + "SvxGrfCrop: exist a new fileformat?" ); + return GRFCROP_VERSION_SWDEFAULT; +} +*/ + +/*N*/ SfxPoolItem* SvxGrfCrop::Create( SvStream& rStrm, USHORT nVersion ) const +/*N*/ { +/*N*/ INT32 top, left, right, bottom; +/*N*/ rStrm >> top >> left >> right >> bottom; +/*N*/ +/*N*/ if( GRFCROP_VERSION_SWDEFAULT == nVersion ) +/*N*/ top = -top, bottom = -bottom, left = -left, right = -right; +/*N*/ +/*N*/ SvxGrfCrop* pNew = (SvxGrfCrop*)Clone(); +/*N*/ pNew->SetLeft( left ); +/*N*/ pNew->SetRight( right ); +/*N*/ pNew->SetTop( top ); +/*N*/ pNew->SetBottom( bottom ); +/*N*/ return pNew; +/*N*/ } + + +/*N*/ SvStream& SvxGrfCrop::Store( SvStream& rStrm, USHORT nVersion ) const +/*N*/ { +/*N*/ INT32 left = GetLeft(), right = GetRight(), +/*N*/ top = GetTop(), bottom = GetBottom(); +/*N*/ if( GRFCROP_VERSION_SWDEFAULT == nVersion ) +/*N*/ top = -top, bottom = -bottom, left = -left, right = -right; +/*N*/ +/*N*/ rStrm << top << left << right << bottom; +/*N*/ +/*N*/ return rStrm; +/*N*/ } + + + +/*N*/ bool SvxGrfCrop::QueryValue( uno::Any& rVal, BYTE nMemberId ) const +/*N*/ { +/*N*/ sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); +/*N*/ nMemberId &= ~CONVERT_TWIPS; +/*N*/ text::GraphicCrop aRet; +/*N*/ aRet.Left = nLeft; +/*N*/ aRet.Right = nRight; +/*N*/ aRet.Top = nTop; +/*N*/ aRet.Bottom = nBottom; +/*N*/ +/*N*/ if( bConvert ) +/*N*/ { +/*N*/ aRet.Right = TWIP_TO_MM100(aRet.Right ); +/*N*/ aRet.Top = TWIP_TO_MM100(aRet.Top ); +/*N*/ aRet.Left = TWIP_TO_MM100(aRet.Left ); +/*N*/ aRet.Bottom = TWIP_TO_MM100(aRet.Bottom); +/*N*/ } +/*N*/ +/*N*/ +/*N*/ rVal <<= aRet; +/*N*/ return true; +/*N*/ } + +/*N*/ bool SvxGrfCrop::PutValue( const uno::Any& rVal, BYTE nMemberId ) +/*N*/ { +/*N*/ sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); +/*N*/ nMemberId &= ~CONVERT_TWIPS; +/*N*/ text::GraphicCrop aVal; +/*N*/ +/*N*/ if(!(rVal >>= aVal)) +/*N*/ return false; +/*N*/ if( bConvert ) +/*N*/ { +/*N*/ aVal.Right = MM100_TO_TWIP(aVal.Right ); +/*N*/ aVal.Top = MM100_TO_TWIP(aVal.Top ); +/*N*/ aVal.Left = MM100_TO_TWIP(aVal.Left ); +/*N*/ aVal.Bottom = MM100_TO_TWIP(aVal.Bottom); +/*N*/ } +/*N*/ +/*N*/ nLeft = aVal.Left ; +/*N*/ nRight = aVal.Right ; +/*N*/ nTop = aVal.Top ; +/*N*/ nBottom = aVal.Bottom; +/*N*/ return true; +/*N*/ } + + + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_svx/source/items/svx_hlnkitem.cxx b/binfilter/bf_svx/source/items/svx_hlnkitem.cxx new file mode 100644 index 000000000000..ff27a68d0c12 --- /dev/null +++ b/binfilter/bf_svx/source/items/svx_hlnkitem.cxx @@ -0,0 +1,104 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +// include --------------------------------------------------------------- +#ifdef _MSC_VER +#pragma hdrstop +#endif + +#define _SVX_HLNKITEM_CXX + +#include <svxids.hrc> +#include <bf_svtools/memberid.hrc> + +#include "hlnkitem.hxx" + +namespace binfilter { + +// ----------------------------------------------------------------------- + +/*N*/ TYPEINIT1_AUTOFACTORY(SvxHyperlinkItem, SfxPoolItem); + +// class SvxHyperlinkItem ------------------------------------------------ + +/*-------------------------------------------------------------------- + Beschreibung: + --------------------------------------------------------------------*/ + +#define HYPERLINKFF_MARKER 0x599401FE + + +/*-------------------------------------------------------------------- + Beschreibung: + --------------------------------------------------------------------*/ + + +/*-------------------------------------------------------------------- + Beschreibung: + --------------------------------------------------------------------*/ + + +/*-------------------------------------------------------------------- + Beschreibung: + --------------------------------------------------------------------*/ + + +/*-------------------------------------------------------------------- + Beschreibung: + --------------------------------------------------------------------*/ + +/*?*/ SfxPoolItem* SvxHyperlinkItem::Clone( SfxItemPool* ) const +/*?*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); return NULL;//STRIP001 return new SvxHyperlinkItem( *this ); +/*?*/ } + +/*-------------------------------------------------------------------- + Beschreibung: + --------------------------------------------------------------------*/ + +/*?*/ int SvxHyperlinkItem::operator==( const SfxPoolItem& rAttr ) const +/*?*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); return 0;//STRIP001 //STRIP001 DBG_ASSERT( SfxPoolItem::operator==(rAttr), "unterschiedliche Typen" ); +/*?*/ } + + +/*-------------------------------------------------------------------- + Beschreibung: + --------------------------------------------------------------------*/ + + +/*-------------------------------------------------------------------- + Beschreibung: + --------------------------------------------------------------------*/ + + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_svx/source/items/svx_numitem.cxx b/binfilter/bf_svx/source/items/svx_numitem.cxx new file mode 100644 index 000000000000..59918281b322 --- /dev/null +++ b/binfilter/bf_svx/source/items/svx_numitem.cxx @@ -0,0 +1,937 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif +#include <numitem.hxx> + +#define ITEMID_BRUSH SID_ATTR_BRUSH +#include <brshitem.hxx> +#include <vcl/font.hxx> +#include <svxids.hrc> +#include <numdef.hxx> +#include <vcl/graph.hxx> +#include <vcl/window.hxx> +#include <vcl/svapp.hxx> +#include <unolingu.hxx> +#include <com/sun/star/text/XNumberingFormatter.hpp> +#include <com/sun/star/text/XDefaultNumberingProvider.hpp> +#include <com/sun/star/style/NumberingType.hpp> +#include <com/sun/star/lang/XMultiServiceFactory.hpp> +#include <com/sun/star/beans/PropertyValue.hpp> +#include <comphelper/processfactory.hxx> + +#include "unonrule.hxx" +#include <legacysmgr/legacy_binfilters_smgr.hxx> //STRIP002 +namespace binfilter { + +#define MM100_TO_TWIP(MM100) ((MM100*72L+63L)/127L) + +#define DEF_WRITER_LSPACE 500 //Standardeinrueckung +#define DEF_DRAW_LSPACE 800 //Standardeinrueckung + +using namespace ::rtl; +using namespace ::com::sun::star; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::text; +using namespace ::com::sun::star::beans; +using namespace ::com::sun::star::style; + +sal_Int32 SvxNumberType::nRefCount = 0; +::com::sun::star::uno::Reference< ::com::sun::star::text::XNumberingFormatter> SvxNumberType::xFormatter = 0; +/* -----------------------------22.02.01 14:24-------------------------------- + + ---------------------------------------------------------------------------*/ +/*N*/ SvxNumberType::SvxNumberType(sal_Int16 nType) : +/*N*/ nNumType(nType), +/*N*/ bShowSymbol(sal_True) +/*N*/ { +/*N*/ if(!xFormatter.is()) +/*N*/ { +/*N*/ try +/*N*/ { +/*N*/ Reference< XMultiServiceFactory > xMSF = ::legacy_binfilters::getLegacyProcessServiceFactory(); +/*N*/ Reference < XInterface > xI = xMSF->createInstance( +/*N*/ ::rtl::OUString::createFromAscii( "com.sun.star.text.DefaultNumberingProvider" ) ); +/*N*/ Reference<XDefaultNumberingProvider> xRet(xI, UNO_QUERY); +/*N*/ DBG_ASSERT(xRet.is(), "service missing: \"com.sun.star.text.DefaultNumberingProvider\""); +/*N*/ xFormatter = Reference<XNumberingFormatter> (xRet, UNO_QUERY); +/*N*/ } +/*N*/ catch(Exception& ) +/*N*/ { +/*N*/ } +/*N*/ } +/*N*/ nRefCount++; +/*N*/ } +/* -----------------------------22.02.01 14:31-------------------------------- + + ---------------------------------------------------------------------------*/ +/*N*/ SvxNumberType::SvxNumberType(const SvxNumberType& rType) : +/*N*/ nNumType(rType.nNumType), +/*N*/ bShowSymbol(rType.bShowSymbol) +/*N*/ { +/*N*/ nRefCount++; +/*N*/ } +/* -----------------------------22.02.01 14:24-------------------------------- + + ---------------------------------------------------------------------------*/ +/*N*/ SvxNumberType::~SvxNumberType() +/*N*/ { +/*N*/ if(!--nRefCount) +/*N*/ xFormatter = 0; +/*N*/ } +/* -----------------------------22.02.01 11:09-------------------------------- + + ---------------------------------------------------------------------------*/ +/*N*/ String SvxNumberType::GetNumStr( ULONG nNo ) const +/*N*/ { +/*N*/ LanguageType eLang = Application::GetSettings().GetLanguage(); +/*N*/ Locale aLocale = SvxCreateLocale(eLang); +/*N*/ return GetNumStr( nNo, aLocale ); +/*N*/ } +/* -----------------28.10.98 15:56------------------- + * + * --------------------------------------------------*/ +/*N*/ String SvxNumberType::GetNumStr( ULONG nNo, const Locale& rLocale ) const +/*N*/ { +/*N*/ String aTmpStr; +/*N*/ if(!xFormatter.is()) +/*N*/ return aTmpStr; +/*N*/ +/*N*/ if(bShowSymbol) +/*N*/ { +/*N*/ switch(nNumType) +/*N*/ { +/*N*/ case NumberingType::CHAR_SPECIAL: +/*N*/ case NumberingType::BITMAP: +/*N*/ break; +/*N*/ default: +/*N*/ { +/*N*/ //#95525# '0' allowed for ARABIC numberings +/*N*/ if(NumberingType::ARABIC == nNumType && 0 == nNo ) +/*N*/ aTmpStr = '0'; +/*N*/ else +/*N*/ { +/*N*/ Sequence< PropertyValue > aProperties(2); +/*N*/ PropertyValue* pValues = aProperties.getArray(); +/*N*/ pValues[0].Name = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("NumberingType")); +/*N*/ pValues[0].Value <<= nNumType; +/*N*/ pValues[1].Name = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Value")); +/*N*/ pValues[1].Value <<= (sal_Int32)nNo; +/*N*/ +/*N*/ try +/*N*/ { +/*N*/ aTmpStr = xFormatter->makeNumberingString( aProperties, rLocale ); +/*N*/ } +/*N*/ catch(Exception&) +/*N*/ { +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ return aTmpStr; +/*N*/ } +/* -----------------27.10.98 10:33------------------- + * + * --------------------------------------------------*/ +/*N*/ SvxNumberFormat::SvxNumberFormat(sal_Int16 eType) : +/*N*/ SvxNumberType(eType), +/*N*/ eNumAdjust(SVX_ADJUST_LEFT), +/*N*/ nInclUpperLevels(0), +/*N*/ nStart(1), +/*N*/ cBullet(SVX_DEF_BULLET), +/*N*/ nFirstLineOffset(0), +/*N*/ nAbsLSpace(0), +/*N*/ nLSpace(0), +/*N*/ nCharTextDistance(0), +/*N*/ pGraphicBrush(0), +/*N*/ eVertOrient(SVX_VERT_NONE), +/*N*/ nBulletRelSize(100), +/*N*/ nBulletColor(COL_BLACK), +/*N*/ pBulletFont(0) +/*N*/ { +/*N*/ } +/* -----------------27.10.98 10:56------------------- + * + * --------------------------------------------------*/ +/*N*/ SvxNumberFormat::SvxNumberFormat(const SvxNumberFormat& rFormat) : +/*N*/ SvxNumberType(rFormat), +/*N*/ pGraphicBrush(0), +/*N*/ pBulletFont(0) +/*N*/ { +/*N*/ *this = rFormat; +/*N*/ } +/* -----------------27.10.98 10:56------------------- + * + * --------------------------------------------------*/ +/*N*/ SvxNumberFormat::~SvxNumberFormat() +/*N*/ { +/*N*/ delete pGraphicBrush; +/*N*/ delete pBulletFont; +/*N*/ } +/* -----------------08.12.98 11:14------------------- + * + * --------------------------------------------------*/ +/*N*/ SvxNumberFormat::SvxNumberFormat(SvStream &rStream) +/*N*/ { +/*N*/ USHORT nVersion; +/*N*/ rStream >> nVersion; +/*N*/ +/*N*/ USHORT nUSHORT; +/*N*/ rStream >> nUSHORT; +/*N*/ SetNumberingType((sal_Int16)nUSHORT); +/*N*/ rStream >> nUSHORT; +/*N*/ eNumAdjust = (SvxAdjust)nUSHORT; +/*N*/ rStream >> nUSHORT; +/*N*/ nInclUpperLevels = (BYTE)nUSHORT; +/*N*/ rStream >> nUSHORT; +/*N*/ nStart = nUSHORT; +/*N*/ rStream >> nUSHORT; +/*N*/ cBullet = nUSHORT; +/*N*/ +/*N*/ short nShort; +/*N*/ rStream >> nShort; +/*N*/ nFirstLineOffset = nShort; +/*N*/ rStream >> nShort; +/*N*/ nAbsLSpace = nShort; +/*N*/ rStream >> nShort; +/*N*/ nLSpace = nShort; +/*N*/ +/*N*/ rStream >> nShort; +/*N*/ nCharTextDistance = nShort; +/*N*/ rtl_TextEncoding eEnc = gsl_getSystemTextEncoding(); +/*N*/ rStream.ReadByteString(sPrefix, eEnc); +/*N*/ rStream.ReadByteString(sSuffix, eEnc); +/*N*/ rStream.ReadByteString(sCharStyleName, eEnc); +/*N*/ rStream >> nUSHORT; +/*N*/ if(nUSHORT) +/*N*/ { +/*?*/ SvxBrushItem aHelper; +/*?*/ pGraphicBrush = (SvxBrushItem*) aHelper.Create( rStream, BRUSH_GRAPHIC_VERSION ); +/*N*/ } +/*N*/ else +/*N*/ pGraphicBrush = 0; +/*N*/ +/*N*/ rStream >> nUSHORT; +/*N*/ eVertOrient = (SvxFrameVertOrient)nUSHORT; +/*N*/ +/*N*/ rStream >> nUSHORT; +/*N*/ if(nUSHORT) +/*N*/ { +/*N*/ pBulletFont = new Font; +/*N*/ rStream >> *pBulletFont; +/*N*/ if(!pBulletFont->GetCharSet()) +/*N*/ pBulletFont->SetCharSet(rStream.GetStreamCharSet()); +/*N*/ } +/*N*/ else +/*N*/ pBulletFont = 0; +/*N*/ rStream >> aGraphicSize; +/*N*/ +/*N*/ rStream >> nBulletColor; +/*N*/ rStream >> nUSHORT; +/*N*/ nBulletRelSize = nUSHORT; +/*N*/ rStream >> nUSHORT; +/*N*/ SetShowSymbol((BOOL)nUSHORT); +/*N*/ +/*N*/ if( nVersion < NUMITEM_VERSION_03 ) +/*N*/ cBullet = ByteString::ConvertToUnicode( cBullet, +/*N*/ (pBulletFont&&pBulletFont->GetCharSet()) ? pBulletFont->GetCharSet() +/*N*/ : RTL_TEXTENCODING_SYMBOL ); +/*N*/ if(pBulletFont) +/*N*/ { +/*N*/ BOOL bConvertBulletFont = rStream.GetVersion() <= SOFFICE_FILEFORMAT_50; +/*N*/ if(bConvertBulletFont) +/*N*/ { +/*N*/ +/*N*/ FontToSubsFontConverter pConverter = +/*N*/ CreateFontToSubsFontConverter(pBulletFont->GetName(), +/*N*/ FONTTOSUBSFONT_IMPORT|FONTTOSUBSFONT_ONLYOLDSOSYMBOLFONTS); +/*N*/ if(pConverter) +/*N*/ { +/*N*/ cBullet = ConvertFontToSubsFontChar(pConverter, cBullet); +/*N*/ String sFontName = GetFontToSubsFontName(pConverter); +/*N*/ pBulletFont->SetName(sFontName); +/*N*/ DestroyFontToSubsFontConverter(pConverter); +/*N*/ } +/*N*/ } +/*N*/ } +/*N*/ } +/* -----------------08.12.98 11:14------------------- + * + * --------------------------------------------------*/ +/*N*/ SvStream& SvxNumberFormat::Store(SvStream &rStream, FontToSubsFontConverter pConverter) +/*N*/ { +/*N*/ if(pConverter && pBulletFont) +/*N*/ { +/*N*/ cBullet = ConvertFontToSubsFontChar(pConverter, cBullet); +/*N*/ String sFontName = GetFontToSubsFontName(pConverter); +/*N*/ pBulletFont->SetName(sFontName); +/*N*/ } +/*N*/ +/*N*/ rStream << (USHORT)NUMITEM_VERSION_03; +/*N*/ +/*N*/ rStream << (USHORT)GetNumberingType(); +/*N*/ rStream << (USHORT)eNumAdjust; +/*N*/ rStream << (USHORT)nInclUpperLevels; +/*N*/ rStream << nStart; +/*N*/ rStream << (USHORT)cBullet; +/*N*/ +/*N*/ rStream << nFirstLineOffset; +/*N*/ rStream << nAbsLSpace; +/*N*/ rStream << nLSpace; +/*N*/ +/*N*/ rStream << nCharTextDistance; +/*N*/ rtl_TextEncoding eEnc = gsl_getSystemTextEncoding(); +/*N*/ rStream.WriteByteString(sPrefix, eEnc); +/*N*/ rStream.WriteByteString(sSuffix, eEnc); +/*N*/ rStream.WriteByteString(sCharStyleName, eEnc); +/*N*/ if(pGraphicBrush) +/*N*/ { +/*?*/ rStream << (USHORT)1; +/*?*/ +/*?*/ // #75113# in SD or SI force bullet itself to be stored, +/*?*/ // for that purpose throw away link when link and graphic +/*?*/ // are present, so Brush save is forced +/*?*/ if(pGraphicBrush->GetGraphicLink() && pGraphicBrush->GetGraphic()) +/*?*/ { +/*?*/ String aEmpty; +/*?*/ pGraphicBrush->SetGraphicLink(aEmpty); +/*?*/ } +/*?*/ +/*?*/ pGraphicBrush->Store(rStream, BRUSH_GRAPHIC_VERSION); +/*N*/ } +/*N*/ else +/*N*/ rStream << (USHORT)0; +/*N*/ +/*N*/ rStream << (USHORT)eVertOrient; +/*N*/ if(pBulletFont) +/*N*/ { +/*N*/ rStream << (USHORT)1; +/*N*/ rStream << *pBulletFont; +/*N*/ } +/*N*/ else +/*N*/ rStream << (USHORT)0; +/*N*/ rStream << aGraphicSize; +/*N*/ +/*N*/ Color nTempColor = nBulletColor; +/*N*/ if(COL_AUTO == nBulletColor.GetColor()) +/*N*/ nTempColor = COL_BLACK; +/*N*/ rStream << nTempColor; +/*N*/ rStream << nBulletRelSize; +/*N*/ rStream << (USHORT)IsShowSymbol(); +/*N*/ return rStream; +/*N*/ } +/* -----------------------------23.02.01 11:10-------------------------------- + + ---------------------------------------------------------------------------*/ +/*N*/ SvxNumberFormat& SvxNumberFormat::operator=( const SvxNumberFormat& rFormat ) +/*N*/ { +/*N*/ SetNumberingType(rFormat.GetNumberingType()); +/*N*/ eNumAdjust = rFormat.eNumAdjust ; +/*N*/ nInclUpperLevels = rFormat.nInclUpperLevels ; +/*N*/ nStart = rFormat.nStart ; +/*N*/ cBullet = rFormat.cBullet ; +/*N*/ nFirstLineOffset = rFormat.nFirstLineOffset; +/*N*/ nAbsLSpace = rFormat.nAbsLSpace ; +/*N*/ nLSpace = rFormat.nLSpace ; +/*N*/ nCharTextDistance = rFormat.nCharTextDistance ; +/*N*/ eVertOrient = rFormat.eVertOrient ; +/*N*/ sPrefix = rFormat.sPrefix ; +/*N*/ sSuffix = rFormat.sSuffix ; +/*N*/ aGraphicSize = rFormat.aGraphicSize ; +/*N*/ nBulletColor = rFormat.nBulletColor ; +/*N*/ nBulletRelSize = rFormat.nBulletRelSize; +/*N*/ SetShowSymbol(rFormat.IsShowSymbol()); +/*N*/ sCharStyleName = rFormat.sCharStyleName; +/*N*/ DELETEZ(pGraphicBrush); +/*N*/ if(rFormat.pGraphicBrush) +/*N*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 /*?*/ pGraphicBrush = new SvxBrushItem(*rFormat.pGraphicBrush); +/*N*/ } +/*N*/ DELETEZ(pBulletFont); +/*N*/ if(rFormat.pBulletFont) +/*N*/ pBulletFont = new Font(*rFormat.pBulletFont); +/*N*/ return *this; +/*N*/ } +/* -----------------27.10.98 10:56------------------- + * + * --------------------------------------------------*/ +/*N*/ BOOL SvxNumberFormat::operator==( const SvxNumberFormat& rFormat) const +/*N*/ { +/*N*/ if( GetNumberingType() != rFormat.GetNumberingType() || +/*N*/ eNumAdjust != rFormat.eNumAdjust || +/*N*/ nInclUpperLevels != rFormat.nInclUpperLevels || +/*N*/ nStart != rFormat.nStart || +/*N*/ cBullet != rFormat.cBullet || +/*N*/ nFirstLineOffset != rFormat.nFirstLineOffset || +/*N*/ nAbsLSpace != rFormat.nAbsLSpace || +/*N*/ nLSpace != rFormat.nLSpace || +/*N*/ nCharTextDistance != rFormat.nCharTextDistance || +/*N*/ eVertOrient != rFormat.eVertOrient || +/*N*/ sPrefix != rFormat.sPrefix || +/*N*/ sSuffix != rFormat.sSuffix || +/*N*/ aGraphicSize != rFormat.aGraphicSize || +/*N*/ nBulletColor != rFormat.nBulletColor || +/*N*/ nBulletRelSize != rFormat.nBulletRelSize || +/*N*/ IsShowSymbol() != rFormat.IsShowSymbol() || +/*N*/ sCharStyleName != rFormat.sCharStyleName +/*N*/ ) +/*N*/ return FALSE; +/*N*/ if(pGraphicBrush && !rFormat.pGraphicBrush || +/*N*/ !pGraphicBrush && rFormat.pGraphicBrush || +/*N*/ pGraphicBrush && *pGraphicBrush != *rFormat.pGraphicBrush ) +/*N*/ return FALSE; +/*N*/ if(pBulletFont && !rFormat.pBulletFont || +/*N*/ !pBulletFont && rFormat.pBulletFont || +/*N*/ pBulletFont && *pBulletFont != *rFormat.pBulletFont) +/*N*/ return FALSE; +/*N*/ return TRUE; +/*N*/ } +/* -----------------28.10.98 09:53------------------- + * + * --------------------------------------------------*/ +/*N*/ void SvxNumberFormat::SetGraphicBrush( const SvxBrushItem* pBrushItem, +/*N*/ const Size* pSize, const SvxFrameVertOrient* pOrient) +/*N*/ { +/*N*/ if(!pBrushItem) +/*N*/ { +/*N*/ delete pGraphicBrush; +/*N*/ pGraphicBrush = 0; +/*N*/ } +/*N*/ else if(!pGraphicBrush || pGraphicBrush && !(*pBrushItem == *pGraphicBrush)) +/*N*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 /*?*/ delete pGraphicBrush; +/*N*/ } +/*N*/ +/*N*/ if(pOrient) +/*N*/ eVertOrient = *pOrient; +/*N*/ else +/*?*/ eVertOrient = SVX_VERT_NONE; +/*N*/ if(pSize) +/*N*/ aGraphicSize = *pSize; +/*N*/ else +/*?*/ aGraphicSize.Width() = aGraphicSize.Height() = 0; +/*N*/ } +/* -----------------28.10.98 09:59------------------- + * + * --------------------------------------------------*/ +/* -----------------------------22.02.01 15:55-------------------------------- + + ---------------------------------------------------------------------------*/ +/* -----------------------------22.02.01 15:55-------------------------------- + + ---------------------------------------------------------------------------*/ +/*N*/ SvxFrameVertOrient SvxNumberFormat::GetVertOrient() const +/*N*/ { +/*N*/ return eVertOrient; +/*N*/ } +/* -----------------28.10.98 09:59------------------- + * + * --------------------------------------------------*/ +/*N*/ void SvxNumberFormat::SetBulletFont(const Font* pFont) +/*N*/ { +/*N*/ delete pBulletFont; +/*N*/ pBulletFont = pFont ? new Font(*pFont): 0; +/*N*/ } + +/* -----------------28.10.98 10:03------------------- + * + * --------------------------------------------------*/ +/* -----------------------------02.07.01 15:36-------------------------------- + + ---------------------------------------------------------------------------*/ + +/* -----------------28.10.98 10:38------------------- + * + * --------------------------------------------------*/ +/* -----------------28.10.98 15:57------------------- + * + * --------------------------------------------------*/ +/*N*/ String SvxNumberFormat::CreateRomanString( ULONG nNo, BOOL bUpper ) +/*N*/ { +/*N*/ nNo %= 4000; // mehr kann nicht dargestellt werden +/*N*/ // i, ii, iii, iv, v, vi, vii, vii, viii, ix +/*N*/ // (Dummy),1000,500,100,50,10,5,1 +/*N*/ const char *cRomanArr = bUpper +/*N*/ ? "MDCLXVI--" // +2 Dummy-Eintraege !! +/*N*/ : "mdclxvi--"; // +2 Dummy-Eintraege !! +/*N*/ +/*N*/ String sRet; +/*N*/ USHORT nMask = 1000; +/*N*/ while( nMask ) +/*N*/ { +/*N*/ BYTE nZahl = BYTE(nNo / nMask); +/*N*/ BYTE nDiff = 1; +/*N*/ nNo %= nMask; +/*N*/ +/*N*/ if( 5 < nZahl ) +/*N*/ { +/*N*/ if( nZahl < 9 ) +/*N*/ sRet += sal_Unicode(*(cRomanArr-1)); +/*N*/ ++nDiff; +/*N*/ nZahl -= 5; +/*N*/ } +/*N*/ switch( nZahl ) +/*N*/ { +/*N*/ case 3: { sRet += sal_Unicode(*cRomanArr); } +/*N*/ case 2: { sRet += sal_Unicode(*cRomanArr); } +/*N*/ case 1: { sRet += sal_Unicode(*cRomanArr); } +/*N*/ break; +/*N*/ +/*N*/ case 4: { +/*N*/ sRet += sal_Unicode(*cRomanArr); +/*N*/ sRet += sal_Unicode(*(cRomanArr-nDiff)); +/*N*/ } +/*N*/ break; +/*N*/ case 5: { sRet += sal_Unicode(*(cRomanArr-nDiff)); } +/*N*/ break; +/*N*/ } +/*N*/ +/*N*/ nMask /= 10; // zur naechsten Dekade +/*N*/ cRomanArr += 2; +/*N*/ } +/*N*/ return sRet; +/*N*/ } +#ifdef OLD_NUMBER_FORMATTING +/*?*/ void SvxNumberFormat::GetCharStr( ULONG nNo, String& rStr ) const +/*?*/ { +/*?*/ DBG_ASSERT( nNo, "0 ist eine ungueltige Nummer !!" ); +/*?*/ +/*?*/ const ULONG coDiff = 'Z' - 'A' +1; +/*?*/ char cAdd = (SVX_NUM_CHARS_UPPER_LETTER == eNumType ? 'A' : 'a') - 1; +/*?*/ ULONG nCalc; +/*?*/ +/*?*/ do { +/*?*/ nCalc = nNo % coDiff; +/*?*/ if( !nCalc ) +/*?*/ nCalc = coDiff; +/*?*/ rStr.Insert( sal_Unicode(cAdd + nCalc ), 0 ); +/*?*/ nNo -= nCalc; +/*?*/ if( nNo ) +/*?*/ nNo /= coDiff; +/*?*/ } while( nNo ); +/*?*/ } +/*?*/ +/*?*/ void SvxNumberFormat::GetCharStrN( ULONG nNo, String& rStr ) const +/*?*/ { +/*?*/ DBG_ASSERT( nNo, "0 ist eine ungueltige Nummer !!" ); +/*?*/ +/*?*/ const ULONG coDiff = 'Z' - 'A' +1; +/*?*/ char cChar = (char)(--nNo % coDiff); +/*?*/ if( SVX_NUM_CHARS_UPPER_LETTER_N == eNumType ) +/*?*/ cChar += 'A'; +/*?*/ else +/*?*/ cChar += 'a'; +/*?*/ +/*?*/ rStr.Fill( (USHORT)(nNo / coDiff) + 1, sal_Unicode(cChar) ); +/*?*/ } +#endif //OLD_NUMBER_FORMATTING +/* -----------------------------22.02.01 13:31-------------------------------- + + ---------------------------------------------------------------------------*/ +/*N*/ const String& SvxNumberFormat::GetCharFmtName()const +/*N*/ { +/*N*/ return sCharStyleName; +/*N*/ } +/* -----------------27.10.98 10:38------------------- + * + * --------------------------------------------------*/ +sal_Int32 SvxNumRule::nRefCount = 0; +static SvxNumberFormat* pStdNumFmt = 0; +static SvxNumberFormat* pStdOutlineNumFmt = 0; +/*N*/ SvxNumRule::SvxNumRule(ULONG nFeatures, USHORT nLevels, BOOL bCont, SvxNumRuleType eType) : +/*N*/ nLevelCount(nLevels), +/*N*/ nFeatureFlags(nFeatures), +/*N*/ bContinuousNumbering(bCont), +/*N*/ eNumberingType(eType) +/*N*/ { +/*N*/ ++nRefCount; +/*N*/ LanguageType eLang = Application::GetSettings().GetLanguage(); +/*N*/ aLocale = SvxCreateLocale(eLang); +/*N*/ for(USHORT i = 0; i < SVX_MAX_NUM; i++) +/*N*/ { +/*N*/ if(i < nLevels) +/*N*/ { +/*N*/ aFmts[i] = new SvxNumberFormat(SVX_NUM_CHARS_UPPER_LETTER); +/*N*/ //daran wird zwischen writer und draw unterschieden +/*N*/ if(nFeatures & NUM_CONTINUOUS) +/*N*/ { +/*N*/ aFmts[i]->SetLSpace( MM100_TO_TWIP(DEF_WRITER_LSPACE) ); +/*N*/ aFmts[i]->SetAbsLSpace( MM100_TO_TWIP(DEF_WRITER_LSPACE * (i+1)) ); +/*N*/ aFmts[i]->SetFirstLineOffset(MM100_TO_TWIP(-DEF_WRITER_LSPACE)); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ aFmts[i]->SetLSpace( DEF_DRAW_LSPACE ); +/*N*/ aFmts[i]->SetAbsLSpace( DEF_DRAW_LSPACE * (i) ); +/*N*/ } +/*N*/ } +/*N*/ else +/*N*/ aFmts[i] = 0; +/*N*/ aFmtsSet[i] = FALSE; +/*N*/ } +/*N*/ } +/* -----------------27.10.98 10:41------------------- + * + * --------------------------------------------------*/ +/*N*/ SvxNumRule::SvxNumRule(const SvxNumRule& rCopy) +/*N*/ { +/*N*/ ++nRefCount; +/*N*/ aLocale = rCopy.aLocale; +/*N*/ nLevelCount = rCopy.nLevelCount ; +/*N*/ nFeatureFlags = rCopy.nFeatureFlags ; +/*N*/ bContinuousNumbering = rCopy.bContinuousNumbering; +/*N*/ eNumberingType = rCopy.eNumberingType; +/*N*/ memset( aFmts, 0, sizeof( aFmts )); +/*N*/ for(USHORT i = 0; i < SVX_MAX_NUM; i++) +/*N*/ { +/*N*/ if(rCopy.aFmts[i]) +/*N*/ aFmts[i] = new SvxNumberFormat(*rCopy.aFmts[i]); +/*N*/ else +/*N*/ aFmts[i] = 0; +/*N*/ aFmtsSet[i] = rCopy.aFmtsSet[i]; +/*N*/ } +/*N*/ } +/* -----------------08.12.98 11:07------------------- + * + * --------------------------------------------------*/ +/*N*/ SvxNumRule::SvxNumRule(SvStream &rStream) +/*N*/ { +/*N*/ ++nRefCount; +/*N*/ LanguageType eLang = Application::GetSettings().GetLanguage(); +/*N*/ aLocale = SvxCreateLocale(eLang); +/*N*/ USHORT nVersion; +/*N*/ USHORT nTemp; +/*N*/ rStream >> nVersion; +/*N*/ rStream >> nLevelCount; +/*N*/ rStream >> nTemp; +/*N*/ nFeatureFlags = nTemp; +/*N*/ rStream >> nTemp; +/*N*/ bContinuousNumbering = (BOOL)nTemp; +/*N*/ rStream >> nTemp; +/*N*/ eNumberingType = (SvxNumRuleType)nTemp; +/*N*/ memset( aFmts, 0, sizeof( aFmts )); +/*N*/ +/*N*/ for(USHORT i = 0; i < SVX_MAX_NUM; i++) +/*N*/ { +/*N*/ USHORT nSet; +/*N*/ rStream >> nSet; +/*N*/ if(nSet) +/*N*/ aFmts[i] = new SvxNumberFormat(rStream); +/*N*/ else +/*N*/ aFmts[i] = 0; +/*N*/ aFmtsSet[i] = aFmts[i] ? TRUE : FALSE; +/*N*/ } +/*N*/ if(NUMITEM_VERSION_02 <= nVersion) +/*N*/ { +/*N*/ USHORT nShort; +/*N*/ rStream >> nShort; +/*N*/ nFeatureFlags = nShort; +/*N*/ } +/*N*/ } + +/* -----------------08.12.98 11:07------------------- + * + * --------------------------------------------------*/ +/*N*/ SvStream& SvxNumRule::Store(SvStream &rStream) +/*N*/ { +/*N*/ rStream<<(USHORT)NUMITEM_VERSION_03; +/*N*/ rStream<<nLevelCount; +/*N*/ //first save of nFeatureFlags for old versions +/*N*/ rStream<<(USHORT)nFeatureFlags; +/*N*/ rStream<<(USHORT)bContinuousNumbering; +/*N*/ rStream<<(USHORT)eNumberingType; +/*N*/ +/*N*/ FontToSubsFontConverter pConverter = 0; +/*N*/ BOOL bConvertBulletFont = rStream.GetVersion() <= SOFFICE_FILEFORMAT_50; +/*N*/ for(USHORT i = 0; i < SVX_MAX_NUM; i++) +/*N*/ { +/*N*/ if(aFmts[i]) +/*N*/ { +/*N*/ rStream << USHORT(1); +/*N*/ if(bConvertBulletFont && aFmts[i]->GetBulletFont()) +/*N*/ { +/*N*/ if(!pConverter) +/*N*/ pConverter = +/*N*/ CreateFontToSubsFontConverter(aFmts[i]->GetBulletFont()->GetName(), +/*N*/ FONTTOSUBSFONT_EXPORT|FONTTOSUBSFONT_ONLYOLDSOSYMBOLFONTS); +/*N*/ } +/*N*/ aFmts[i]->Store(rStream, pConverter); +/*N*/ } +/*N*/ else +/*N*/ rStream << USHORT(0); +/*N*/ } +/*N*/ //second save of nFeatureFlags for new versions +/*N*/ rStream<<(USHORT)nFeatureFlags; +/*N*/ if(pConverter) +/*N*/ DestroyFontToSubsFontConverter(pConverter); +/*N*/ +/*N*/ return rStream; +/*N*/ } + +/* -----------------27.10.98 10:41------------------- + * + * --------------------------------------------------*/ +/*N*/ SvxNumRule::~SvxNumRule() +/*N*/ { +/*N*/ for(USHORT i = 0; i < SVX_MAX_NUM; i++) +/*N*/ delete aFmts[i]; +/*N*/ if(!--nRefCount) +/*N*/ { +/*N*/ DELETEZ(pStdNumFmt); +/*N*/ DELETEZ(pStdOutlineNumFmt); +/*N*/ } +/*N*/ } +/* -----------------29.10.98 16:07------------------- + * + * --------------------------------------------------*/ +/* -----------------27.10.98 10:41------------------- + * + * --------------------------------------------------*/ +/*N*/ int SvxNumRule::operator==( const SvxNumRule& rCopy) const +/*N*/ { +/*N*/ if(nLevelCount != rCopy.nLevelCount || +/*N*/ nFeatureFlags != rCopy.nFeatureFlags || +/*N*/ bContinuousNumbering != rCopy.bContinuousNumbering || +/*N*/ eNumberingType != rCopy.eNumberingType) +/*N*/ return FALSE; +/*N*/ for(USHORT i = 0; i < nLevelCount; i++) +/*N*/ { +/*N*/ if( aFmtsSet[i] != rCopy.aFmtsSet[i] || +/*N*/ !aFmts[i] && rCopy.aFmts[i] || +/*N*/ aFmts[i] && !rCopy.aFmts[i] || +/*N*/ aFmts[i] && *aFmts[i] != *rCopy.aFmts[i] ) +/*N*/ return FALSE; +/*N*/ } +/*N*/ return TRUE; +/*N*/ } +/* -----------------27.10.98 10:41------------------- + * + * --------------------------------------------------*/ +/*N*/ const SvxNumberFormat* SvxNumRule::Get(USHORT nLevel)const +/*N*/ { +/*N*/ DBG_ASSERT(nLevel < SVX_MAX_NUM, "falsches Level" ); +/*N*/ return aFmtsSet[nLevel] ? aFmts[nLevel] : 0; +/*N*/ } +/* -----------------02.11.98 09:10------------------- + * + * --------------------------------------------------*/ +/*N*/ const SvxNumberFormat& SvxNumRule::GetLevel(USHORT nLevel)const +/*N*/ { +/*N*/ if(!pStdNumFmt) +/*N*/ { +/*N*/ pStdNumFmt = new SvxNumberFormat(SVX_NUM_ARABIC); +/*N*/ pStdOutlineNumFmt = new SvxNumberFormat(SVX_NUM_NUMBER_NONE); +/*N*/ } +/*N*/ +/*N*/ DBG_ASSERT(nLevel < SVX_MAX_NUM, "falsches Level" ); +/*N*/ return aFmts[nLevel] ? +/*N*/ *aFmts[nLevel] : eNumberingType == SVX_RULETYPE_NUMBERING ? +/*N*/ *pStdNumFmt : *pStdOutlineNumFmt; +/*N*/ } + +/* -----------------29.10.98 09:08------------------- + * + * --------------------------------------------------*/ +/*N*/ void SvxNumRule::SetLevel( USHORT i, const SvxNumberFormat& rNumFmt, BOOL bIsValid ) +/*N*/ { +/*N*/ if( !aFmtsSet[i] || !(rNumFmt == *Get( i )) ) +/*N*/ { +/*N*/ delete aFmts[ i ]; +/*N*/ aFmts[ i ] = new SvxNumberFormat( rNumFmt ); +/*N*/ aFmtsSet[i] = bIsValid; +/*N*/ // bInvalidRuleFlag = TRUE; +/*N*/ } +/*N*/ } +/* -----------------30.10.98 12:44------------------- + * + * --------------------------------------------------*/ +/* -----------------28.10.98 15:38------------------- + * + * --------------------------------------------------*/ +/* -----------------18.08.99 10:18------------------- + Description: changes linked to embedded bitmaps + --------------------------------------------------*/ +/*N*/ BOOL SvxNumRule::UnLinkGraphics() +/*N*/ { +/*N*/ BOOL bRet = FALSE; +/*N*/ for(USHORT i = 0; i < GetLevelCount(); i++) +/*N*/ { +/*N*/ SvxNumberFormat aFmt(GetLevel(i)); +/*N*/ const SvxBrushItem* pBrush = aFmt.GetBrush(); +/*N*/ const String* pLinkStr; +/*N*/ const Graphic* pGraphic; +/*N*/ if(SVX_NUM_BITMAP == aFmt.GetNumberingType()) +/*N*/ { +/*N*/ if(pBrush && +/*N*/ 0 != (pLinkStr = pBrush->GetGraphicLink()) && +/*N*/ pLinkStr->Len() && +/*N*/ 0 !=(pGraphic = pBrush->GetGraphic())) +/*N*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 /*?*/ SvxBrushItem aTempItem(*pBrush); +/*N*/ } +/*N*/ } +/*N*/ else if((SVX_NUM_BITMAP|LINK_TOKEN) == aFmt.GetNumberingType()) +/*N*/ aFmt.SetNumberingType(SVX_NUM_BITMAP); +/*N*/ SetLevel(i, aFmt); +/*N*/ } +/*N*/ return bRet; +/*N*/ } + +/* -----------------27.10.98 10:41------------------- + * + * --------------------------------------------------*/ +/*N*/ SvxNumBulletItem::SvxNumBulletItem(SvxNumRule& rRule) : +/*N*/ SfxPoolItem(SID_ATTR_NUMBERING_RULE), +/*N*/ pNumRule(new SvxNumRule(rRule)) +/*N*/ { +/*N*/ } + +/*-----------------23.11.98 10:36------------------- + MT: Das sind ja sehr sinnige Kommentare... +--------------------------------------------------*/ +/*N*/ SvxNumBulletItem::SvxNumBulletItem(SvxNumRule& rRule, USHORT nWhich ) : +/*N*/ SfxPoolItem(nWhich), +/*N*/ pNumRule(new SvxNumRule(rRule)) +/*N*/ { +/*N*/ } + +/* -----------------27.10.98 10:41------------------- + * + * --------------------------------------------------*/ +/*N*/ SvxNumBulletItem::SvxNumBulletItem(const SvxNumBulletItem& rCopy) : +/*N*/ SfxPoolItem(rCopy.Which()) +/*N*/ { +/*N*/ pNumRule = new SvxNumRule(*rCopy.pNumRule); +/*N*/ } +/* -----------------27.10.98 10:41------------------- + * + * --------------------------------------------------*/ +/*N*/ SvxNumBulletItem::~SvxNumBulletItem() +/*N*/ { +/*N*/ delete pNumRule; +/*N*/ } + +/* -----------------27.10.98 10:41------------------- + * + * --------------------------------------------------*/ +/*N*/ int SvxNumBulletItem::operator==( const SfxPoolItem& rCopy) const +/*N*/ { +/*N*/ return *pNumRule == *((SvxNumBulletItem&)rCopy).pNumRule; +/*N*/ } +/* -----------------27.10.98 10:41------------------- + * + * --------------------------------------------------*/ +/*N*/ SfxPoolItem* SvxNumBulletItem::Clone( SfxItemPool *pPool ) const +/*N*/ { +/*N*/ return new SvxNumBulletItem(*this); +/*N*/ } +/* -----------------08.12.98 10:43------------------- + * + * --------------------------------------------------*/ +/*N*/ SfxPoolItem* SvxNumBulletItem::Create(SvStream &rStream, USHORT) const +/*N*/ { +/*N*/ SvxNumRule aRule(rStream); +/*N*/ return new SvxNumBulletItem(aRule, Which() ); +/*N*/ } +/* -----------------08.12.98 10:43------------------- + * + * --------------------------------------------------*/ +/*N*/ SvStream& SvxNumBulletItem::Store(SvStream &rStream, USHORT nItemVersion )const +/*N*/ { +/*N*/ pNumRule->Store(rStream); +/*N*/ return rStream; +/*N*/ } +/* -----------------08.12.98 10:43------------------- + * + * --------------------------------------------------*/ +/*N*/ USHORT SvxNumBulletItem::GetVersion( USHORT nFileVersion ) const +/*N*/ { +/*N*/ return NUMITEM_VERSION_03; +/*N*/ } + +/* -----------------08.12.98 10:43------------------- + * + * --------------------------------------------------*/ + + +/*N*/ bool SvxNumBulletItem::PutValue( const ::com::sun::star::uno::Any& rVal, BYTE nMemberId ) +/*N*/ { +/*N*/ uno::Reference< container::XIndexReplace > xRule; +/*N*/ if( rVal >>= xRule ) +/*N*/ { +/*N*/ try +/*N*/ { +/*N*/ SvxNumRule* pNewRule = new SvxNumRule( SvxGetNumRule( xRule ) ); +/*N*/ if( pNewRule->GetLevelCount() != pNumRule->GetLevelCount() || +/*N*/ pNewRule->GetNumRuleType() != pNumRule->GetNumRuleType() ) +/*N*/ { +/*N*/ SvxNumRule* pConverted = SvxConvertNumRule( pNewRule, pNumRule->GetLevelCount(), pNumRule->GetNumRuleType() ); +/*N*/ delete pNewRule; +/*N*/ pNewRule = pConverted; +/*N*/ } +/*N*/ delete pNumRule; +/*N*/ pNumRule = pNewRule; +/*N*/ return sal_True; +/*N*/ } +/*N*/ catch(lang::IllegalArgumentException&) +/*N*/ { +/*N*/ } +/*N*/ } +/*N*/ return sal_False; +/*N*/ } + +/* -----------------08.12.98 10:43------------------- + * + * --------------------------------------------------*/ +/*N*/ SvxNumRule* SvxConvertNumRule( const SvxNumRule* pRule, USHORT nLevels, SvxNumRuleType eType ) +/*N*/ { +/*N*/ const USHORT nSrcLevels = pRule->GetLevelCount(); +/*N*/ SvxNumRule* pNewRule = new SvxNumRule( pRule->GetFeatureFlags(), nLevels, pRule->IsContinuousNumbering(), eType ); +/*N*/ +/*N*/ // move all levels one level up if the destination is a presentation numbering and the source is not +/*N*/ const sal_Bool bConvertUp = pRule->GetNumRuleType() != SVX_RULETYPE_PRESENTATION_NUMBERING && +/*N*/ eType == SVX_RULETYPE_PRESENTATION_NUMBERING; +/*N*/ +/*N*/ // move all levels one level down if the source is a presentation numbering and the destination is not +/*N*/ const sal_Bool bConvertDown = pRule->GetNumRuleType() == SVX_RULETYPE_PRESENTATION_NUMBERING && +/*N*/ eType != SVX_RULETYPE_PRESENTATION_NUMBERING; +/*N*/ +/*N*/ USHORT nSrcLevel = bConvertDown ? 1 : 0; +/*N*/ USHORT nDstLevel = bConvertUp ? 1 : 0; +/*N*/ for( ; (nDstLevel < nLevels) && (nSrcLevel < nSrcLevels); nSrcLevel++, nDstLevel++ ) +/*N*/ pNewRule->SetLevel( nDstLevel, pRule->GetLevel( nSrcLevel ) ); +/*N*/ +/*N*/ return pNewRule; +/*N*/ } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_svx/source/items/svx_pageitem.cxx b/binfilter/bf_svx/source/items/svx_pageitem.cxx new file mode 100644 index 000000000000..45c630eb64fa --- /dev/null +++ b/binfilter/bf_svx/source/items/svx_pageitem.cxx @@ -0,0 +1,278 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +// include --------------------------------------------------------------- + +#include <tools/stream.hxx> +#ifdef _MSC_VER +#pragma hdrstop +#endif + +// Erstmal definieren, damit die Klassendeklarionen angezogen werden. +#define ITEMID_PAGE 0 +#define ITEMID_SETITEM 0 + +#include <bf_svtools/poolitem.hxx> + +#include "pageitem.hxx" +#include "itemtype.hxx" +#include <unomid.hxx> + +#include <com/sun/star/style/PageStyleLayout.hpp> + +#include <bf_svtools/itemset.hxx> +namespace binfilter { + +using namespace ::rtl; +using namespace ::com::sun::star; + +// STATIC DATA ----------------------------------------------------------- + +/*N*/ TYPEINIT1_AUTOFACTORY( SvxPageItem, SfxPoolItem ); + +/*-------------------------------------------------------------------- + Beschreibung: Konstruktor + --------------------------------------------------------------------*/ + +/*N*/ SvxPageItem::SvxPageItem( const USHORT nId ) : SfxPoolItem( nId ), +/*N*/ +/*N*/ eNumType ( SVX_ARABIC ), +/*N*/ bLandscape ( sal_False ), +/*N*/ eUse ( SVX_PAGE_ALL ) +/*N*/ { +/*N*/ } + +/*-------------------------------------------------------------------- + Beschreibung: Copy-Konstruktor + --------------------------------------------------------------------*/ + +/*N*/ SvxPageItem::SvxPageItem( const SvxPageItem& rItem ) +/*N*/ : SfxPoolItem( rItem ) +/*N*/ { +/*N*/ eNumType = rItem.eNumType; +/*N*/ bLandscape = rItem.bLandscape; +/*N*/ eUse = rItem.eUse; +/*N*/ } + +/*-------------------------------------------------------------------- + Beschreibung: Clonen + --------------------------------------------------------------------*/ + +/*N*/ SfxPoolItem* SvxPageItem::Clone( SfxItemPool *pPool ) const +/*N*/ { +/*N*/ return new SvxPageItem( *this ); +/*N*/ } + +/*-------------------------------------------------------------------- + Beschreibung: Abfrage auf Gleichheit + --------------------------------------------------------------------*/ + +/*N*/ int SvxPageItem::operator==( const SfxPoolItem& rAttr ) const +/*N*/ { +/*N*/ DBG_ASSERT( SfxPoolItem::operator==(rAttr), "unequal types" ); +/*N*/ const SvxPageItem& rItem = (SvxPageItem&)rAttr; +/*N*/ return ( eNumType == rItem.eNumType && +/*N*/ bLandscape == rItem.bLandscape && +/*N*/ eUse == rItem.eUse ); +/*N*/ } + +/*?*/ inline XubString GetUsageText( const USHORT eU ) +/*?*/ { +/*?*/ if ( eU & SVX_PAGE_LEFT ) +/*?*/ return SVX_RESSTR(RID_SVXITEMS_PAGE_USAGE_LEFT); +/*?*/ if ( eU & SVX_PAGE_RIGHT ) +/*?*/ return SVX_RESSTR(RID_SVXITEMS_PAGE_USAGE_RIGHT); +/*?*/ if ( eU & SVX_PAGE_ALL ) +/*?*/ return SVX_RESSTR(RID_SVXITEMS_PAGE_USAGE_ALL); +/*?*/ if ( eU & SVX_PAGE_MIRROR ) +/*?*/ return SVX_RESSTR(RID_SVXITEMS_PAGE_USAGE_MIRROR); +/*?*/ return String(); +/*?*/ } + +//------------------------------------------------------------------------ + + +//------------------------------------------------------------------------ +/*N*/ bool SvxPageItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const +/*N*/ { +/*N*/ sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); +/*N*/ nMemberId &= ~CONVERT_TWIPS; +/*N*/ switch( nMemberId ) +/*N*/ { +/*N*/ case MID_PAGE_NUMTYPE: +/*N*/ { +/*N*/ //! die Konstanten sind nicht mehr in den IDLs ?!? +/*N*/ rVal <<= (sal_Int16)( eNumType ); +/*N*/ } +/*N*/ break; +/*N*/ case MID_PAGE_ORIENTATION: +/*N*/ //Landscape= sal_True +/*N*/ rVal = Bool2Any(bLandscape); +/*N*/ break; +/*N*/ case MID_PAGE_LAYOUT : +/*N*/ { +/*N*/ style::PageStyleLayout eRet; +/*N*/ switch(eUse & 0x0f) +/*N*/ { +/*N*/ case SVX_PAGE_LEFT : eRet = style::PageStyleLayout_LEFT; break; +/*N*/ case SVX_PAGE_RIGHT : eRet = style::PageStyleLayout_RIGHT; break; +/*N*/ case SVX_PAGE_ALL : eRet = style::PageStyleLayout_ALL; break; +/*N*/ case SVX_PAGE_MIRROR: eRet = style::PageStyleLayout_MIRRORED; break; +/*N*/ default: +/*N*/ DBG_ERROR("was fuer ein Layout ist das?"); +/*N*/ return sal_False; +/*N*/ } +/*N*/ rVal <<= eRet; +/*N*/ } +/*N*/ break; +/*N*/ } +/*N*/ +/*N*/ return sal_True; +/*N*/ } +//------------------------------------------------------------------------ +/*N*/ bool SvxPageItem::PutValue( const uno::Any& rVal, BYTE nMemberId ) +/*N*/ { +/*N*/ switch( nMemberId ) +/*N*/ { +/*N*/ case MID_PAGE_NUMTYPE: +/*N*/ { +/*N*/ sal_Int32 nValue; +/*N*/ if(!(rVal >>= nValue)) +/*N*/ return sal_False; +/*N*/ +/*N*/ eNumType = (SvxNumType)nValue; +/*N*/ } +/*N*/ break; +/*N*/ case MID_PAGE_ORIENTATION: +/*N*/ bLandscape = Any2Bool(rVal); +/*N*/ break; +/*N*/ case MID_PAGE_LAYOUT : +/*N*/ { +/*N*/ style::PageStyleLayout eLayout; +/*N*/ if(!(rVal >>= eLayout)) +/*N*/ { +/*N*/ sal_Int32 nValue; +/*?*/ if(!(rVal >>= nValue)) +/*?*/ return sal_False; +/*?*/ eLayout = (style::PageStyleLayout)nValue; +/*N*/ } +/*N*/ eUse &= 0xfff0; +/*N*/ switch( eLayout ) +/*N*/ { +/*N*/ case style::PageStyleLayout_LEFT : eUse |= SVX_PAGE_LEFT ; break; +/*N*/ case style::PageStyleLayout_RIGHT : eUse |= SVX_PAGE_RIGHT; break; +/*?*/ case style::PageStyleLayout_ALL : eUse |= SVX_PAGE_ALL ; break; +/*N*/ case style::PageStyleLayout_MIRRORED: eUse |= SVX_PAGE_MIRROR;break; +/*N*/ } +/*N*/ } +/*N*/ break; +/*N*/ } +/*N*/ return sal_True; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ SfxPoolItem* SvxPageItem::Create( SvStream& rStream, USHORT ) const +/*N*/ { +/*N*/ XubString sStr; +/*N*/ BYTE eType; +/*N*/ sal_Bool bLand; +/*N*/ USHORT nUse; +/*N*/ +/*N*/ // UNICODE: rStream >> sStr; +/*N*/ rStream.ReadByteString( sStr ); +/*N*/ +/*N*/ rStream >> eType; +/*N*/ rStream >> bLand; +/*N*/ rStream >> nUse; +/*N*/ +/*N*/ SvxPageItem* pPage = new SvxPageItem( Which() ); +/*N*/ pPage->SetDescName( sStr ); +/*N*/ pPage->SetNumType( (SvxNumType)eType ); +/*N*/ pPage->SetLandscape( bLand ); +/*N*/ pPage->SetPageUsage( nUse ); +/*N*/ return pPage; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ SvStream& SvxPageItem::Store( SvStream &rStrm, USHORT nItemVersion ) const +/*N*/ { +/*N*/ // UNICODE: rStrm << aDescName; +/*N*/ rStrm.WriteByteString(aDescName); +/*N*/ +/*N*/ rStrm << (BYTE)eNumType << bLandscape << eUse; +/*N*/ return rStrm; +/*N*/ } + +/*-------------------------------------------------------------------- + Beschreibung: HeaderFooterSet + --------------------------------------------------------------------*/ + +/*N*/ SvxSetItem::SvxSetItem( const USHORT nId, const SfxItemSet& rSet ) : +/*N*/ +/*N*/ SfxSetItem( nId, rSet ) +/*N*/ { +/*N*/ } + +/*N*/ SvxSetItem::SvxSetItem( const SvxSetItem& rItem ) : +/*N*/ +/*N*/ SfxSetItem( rItem ) +/*N*/ { +/*N*/ } + + +/*N*/ SfxPoolItem* SvxSetItem::Clone( SfxItemPool *pPool ) const +/*N*/ { +/*N*/ return new SvxSetItem(*this); +/*N*/ } + +//------------------------------------------------------------------------ + + +/*N*/ SfxPoolItem* SvxSetItem::Create(SvStream &rStrm, USHORT nVersion) const +/*N*/ { +/*N*/ SfxItemSet* pSet = new SfxItemSet( *GetItemSet().GetPool(), +/*N*/ GetItemSet().GetRanges() ); +/*N*/ +/*N*/ pSet->Load( rStrm ); +/*N*/ +/*N*/ return new SvxSetItem( Which(), *pSet ); +/*N*/ } + +/*N*/ SvStream& SvxSetItem::Store(SvStream &rStrm, USHORT nItemVersion) const +/*N*/ { +/*N*/ GetItemSet().Store( rStrm, nItemVersion ); +/*N*/ +/*N*/ return rStrm; +/*N*/ } + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_svx/source/items/svx_paperinf.cxx b/binfilter/bf_svx/source/items/svx_paperinf.cxx new file mode 100644 index 000000000000..bf0e181a4a33 --- /dev/null +++ b/binfilter/bf_svx/source/items/svx_paperinf.cxx @@ -0,0 +1,179 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +// include --------------------------------------------------------------- + +#include <limits.h> + +#include <sal/macros.h> +#include "dialogs.hrc" +#include "paperinf.hxx" +namespace binfilter { + +#define SVX_PAPER_OFFSET 3 // Anfang: enum Paper A3 - SvxPaper A0; Diff=3 + +// STATIC DATA ----------------------------------------------------------- + +static Size __FAR_DATA aDinTab[] = +{ + Size(lA0Width,lA0Height), // A0 + Size(lA1Width,lA1Height), // A1 + Size(lA2Width,lA2Height), // A2 + Size(lA3Width,lA3Height), // A3 + Size(lA4Width,lA4Height), // A4 + Size(lA5Width,lA5Height), // A5 + Size(lB4Width, lB4Height), // B4 + Size(lB5Width,lB5Height), // B5 + Size(lLetterWidth,lLetterHeight), // LETTER + Size(lLegalWidth,lLegalHeight), // LEGAL + Size(lTabloidWidth,lTabloidHeight), // TABLOID + Size(0, 0), // USER + Size(lB6Width, lB6Height), // B6 + Size(lC4Width, lC4Height), // C4 + Size(lC5Width, lC5Height), // C5 + Size(lC6Width, lC6Height), // C6 + Size(lC65Width, lC65Height), // C65 + Size(lDLWidth, lDLHeight), // DL + Size(lDiaWidth,lDiaHeight ), // DIA + Size(lScreenWidth, lScreenHeight), // SCREEN + Size(lAWidth, lAHeight), // A + Size(lBWidth, lBHeight), // B + Size(lCWidth, lCHeight), // C + Size(lDWidth, lDHeight), // D + Size(lEWidth, lEHeight), // E + Size(lExeWidth, lExeHeight), // Executive + Size(lLegal2Width, lLegal2Height), // Legal2 + Size(lMonarchWidth, lMonarchHeight),// Monarch + Size(lCom675Width, lCom675Height), // COM-6 3/4 + Size(lCom9Width, lCom9Height), // COM-9 + Size(lCom10Width, lCom10Height), // COM-10 + Size(lCom11Width, lCom11Height), // COM-11 + Size(lCom12Width, lCom12Height), // COM-12 + Size(lKai16Width, lKai16Height), // 16 kai + Size(lKai32Width, lKai32Height), // 32 kai + Size(lKai32BigWidth, lKai32BigHeight), // 32 kai gross + Size(lJISB4Width, lJISB4Height), // B4 (JIS) + Size(lJISB5Width, lJISB5Height), // B5 (JIS) + Size(lJISB6Width, lJISB6Height) // B6 (JIS) +}; + +static const int nTabSize = SAL_N_ELEMENTS(aDinTab); + +// ----------------------------------------------------------------------- + +/*N*/ long TwipsTo100thMM( long nIn ) +/*N*/ { +/*N*/ long nRet = OutputDevice::LogicToLogic( nIn, MAP_TWIP, MAP_100TH_MM ); +/*N*/ long nTmp = nRet % 10; +/*N*/ +/*N*/ if ( nTmp ) +/*N*/ nRet += 10 - nTmp; +/*N*/ return nRet; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ Size ConvertTo100thMM( Size& rSize ) +/*N*/ { +/*N*/ // Convert form TWIPS to 100TH_MM +/*N*/ long nW = TwipsTo100thMM( rSize.Width() ); +/*N*/ long nH = TwipsTo100thMM( rSize.Height() ); +/*N*/ +/*N*/ rSize.Width() = nW; +/*N*/ rSize.Height() = nH; +/*N*/ return rSize; +/*N*/ } + +/*-------------------------------------------------------------------- + Beschreibung: Ist der Printer gueltig + --------------------------------------------------------------------*/ + +/*?*/ inline BOOL IsValidPrinter( const Printer* pPtr ) +/*?*/ { +/*?*/ return pPtr->GetName().Len() ? TRUE : FALSE; +/*?*/ } + +/*------------------------------------------------------------------------ + Beschreibung: Konvertierung eines SV-Defines fuer Papiergroesse in + Twips. + Funktioniert logischerweise nicht fuer User Groessen + (ASSERT). +------------------------------------------------------------------------*/ + +/*N*/ Size SvxPaperInfo::GetPaperSize( SvxPaper ePaper, MapUnit eUnit ) +/*N*/ { +/*N*/ DBG_ASSERT( ePaper < nTabSize, "Tabelle der Papiergroessen ueberindiziert" ); +/*N*/ DBG_ASSERT( eUnit == MAP_TWIP || eUnit == MAP_100TH_MM, "this MapUnit not supported" ); +/*N*/ Size aSize = aDinTab[ePaper]; // in Twips +/*N*/ +/*N*/ if ( eUnit == MAP_100TH_MM ) +/*N*/ ConvertTo100thMM( aSize ); +/*N*/ return aSize; +/*N*/ } + +/*------------------------------------------------------------------------ + Beschreibung: Papiergroesse der Druckers liefern, aligned auf + die eigenen Groessen. + Falls kein Printer im System eingestellt ist, + wird DIN A4 Portrait als Defaultpapiergroesse geliefert. +------------------------------------------------------------------------*/ + +/*N*/ Size SvxPaperInfo::GetPaperSize( const Printer* pPrinter ) +/*N*/ { +/*N*/ if ( !IsValidPrinter(pPrinter) ) +/*?*/ return GetPaperSize( SVX_PAPER_A4 ); +/*N*/ const SvxPaper ePaper = (SvxPaper)(pPrinter->GetPaper() + SVX_PAPER_OFFSET); +/*N*/ +/*N*/ if ( ePaper == SVX_PAPER_USER ) +/*N*/ { +/*N*/ // Orientation nicht beruecksichtigen, da durch SV bereits +/*N*/ // die richtigen Masze eingestellt worden sind. +/*N*/ Size aPaperSize = pPrinter->GetPaperSize(); +/*N*/ const Size aInvalidSize; +/*N*/ +/*N*/ if ( aPaperSize == aInvalidSize ) +/*?*/ return GetPaperSize(SVX_PAPER_A4); +/*N*/ MapMode aMap1 = pPrinter->GetMapMode(); +/*N*/ MapMode aMap2; +/*N*/ +/*N*/ if ( aMap1 == aMap2 ) +/*N*/ aPaperSize = +/*N*/ pPrinter->PixelToLogic( aPaperSize, MapMode( MAP_TWIP ) ); +/*N*/ return aPaperSize; +/*N*/ } +/*N*/ +/*N*/ const Orientation eOrient = pPrinter->GetOrientation(); +/*N*/ Size aSize( GetPaperSize( ePaper ) ); +/*N*/ // bei Landscape die Seiten tauschen, ist bei SV schon geschehen +/*N*/ if ( eOrient == ORIENTATION_LANDSCAPE ) +/*?*/ Swap( aSize ); +/*N*/ return aSize; +/*N*/ } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_svx/source/items/svx_paraitem.cxx b/binfilter/bf_svx/source/items/svx_paraitem.cxx new file mode 100644 index 000000000000..0baea01ff9c5 --- /dev/null +++ b/binfilter/bf_svx/source/items/svx_paraitem.cxx @@ -0,0 +1,1244 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +// include --------------------------------------------------------------- + +#include <com/sun/star/style/TabStop.hpp> +#include <com/sun/star/style/LineSpacing.hpp> +#include <com/sun/star/style/LineSpacingMode.hpp> +#include <com/sun/star/uno/Sequence.hxx> +#include <comphelper/processfactory.hxx> +#include <bf_svtools/syslocale.hxx> + +#include <comphelper/types.hxx> + +using namespace ::rtl; +using namespace ::com::sun::star; + +#define ITEMID_TABSTOP 0 +#define ITEMID_LINESPACING 0 +#define ITEMID_ADJUST 0 +#define ITEMID_ORPHANS 0 +#define ITEMID_WIDOWS 0 +#define ITEMID_PAGEMODEL 0 +#define ITEMID_FMTSPLIT 0 +#define ITEMID_HYPHENZONE 0 +#define ITEMID_SCRIPTSPACE 0 +#define ITEMID_HANGINGPUNCTUATION 0 +#define ITEMID_FORBIDDENRULE 0 +#define ITEMID_PARAVERTALIGN 0 +#define ITEMID_PARAGRID 0 + +#include <tools/rtti.hxx> +#include "bf_basic/sbx.hxx" +#define GLOBALOVERFLOW3 + +#define _SVX_PARAITEM_CXX + +#include <bf_svtools/itempool.hxx> + +#include <bf_svtools/memberid.hrc> +#include "svxitems.hrc" + +#include "lspcitem.hxx" +#include "adjitem.hxx" +#include "orphitem.hxx" +#include "widwitem.hxx" +#include "tstpitem.hxx" +#include "pmdlitem.hxx" +#include "spltitem.hxx" +#include "hyznitem.hxx" +#include "scriptspaceitem.hxx" +#include "hngpnctitem.hxx" +#include "forbiddenruleitem.hxx" +#include "paravertalignitem.hxx" +#include "pgrditem.hxx" + + +#include "rtl/ustring.hxx" + +#include <unomid.hxx> + +#include "itemtype.hxx" +#include "dialmgr.hxx" +#include "paperinf.hxx" + +#include <vcl/svapp.hxx> + +#include <algorithm> +namespace binfilter { + +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 ----------------------------------------------------------- + + +// ----------------------------------------------------------------------- + + +/*N*/ TYPEINIT1_AUTOFACTORY(SvxLineSpacingItem, SfxPoolItem ); +/*N*/ TYPEINIT1_AUTOFACTORY(SvxAdjustItem, SfxPoolItem); +/*N*/ TYPEINIT1_AUTOFACTORY(SvxWidowsItem, SfxByteItem); +/*N*/ TYPEINIT1_AUTOFACTORY(SvxOrphansItem, SfxByteItem); +/*N*/ TYPEINIT1_AUTOFACTORY(SvxHyphenZoneItem, SfxPoolItem); +/*N*/ TYPEINIT1_AUTOFACTORY(SvxTabStopItem, SfxPoolItem); +/*N*/ TYPEINIT1_AUTOFACTORY(SvxFmtSplitItem, SfxBoolItem); +/*N*/ TYPEINIT1_AUTOFACTORY(SvxPageModelItem, SfxStringItem); +/*N*/ TYPEINIT1_AUTOFACTORY(SvxScriptSpaceItem, SfxBoolItem); +/*N*/ TYPEINIT1_AUTOFACTORY(SvxHangingPunctuationItem, SfxBoolItem); +/*N*/ TYPEINIT1_AUTOFACTORY(SvxForbiddenRuleItem, SfxBoolItem); +/*N*/ TYPEINIT1_AUTOFACTORY(SvxParaVertAlignItem, SfxUInt16Item); +/*N*/ TYPEINIT1_AUTOFACTORY(SvxParaGridItem, SfxBoolItem); + +/*N*/ SV_IMPL_VARARR_SORT( SvxTabStopArr, SvxTabStop ) + +// ----------------------------------------------------------------------- + +/*N*/ SvxLineSpacingItem::SvxLineSpacingItem( sal_uInt16 nHeight, const sal_uInt16 nId ) +/*N*/ : SfxEnumItemInterface( nId ) +/*N*/ { +/*N*/ nPropLineSpace = 100; +/*N*/ nInterLineSpace = 0; +/*N*/ nLineHeight = nHeight; +/*N*/ eLineSpace = SVX_LINE_SPACE_AUTO; +/*N*/ eInterLineSpace = SVX_INTER_LINE_SPACE_OFF; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ int SvxLineSpacingItem::operator==( const SfxPoolItem& rAttr ) const +/*N*/ { +/*N*/ DBG_ASSERT( SfxPoolItem::operator==(rAttr), "unequal types" ); +/*N*/ +/*N*/ const SvxLineSpacingItem& rLineSpace = (const SvxLineSpacingItem&)rAttr; +/*N*/ return ( +/*N*/ // Gleiche Linespacing Rule? +/*N*/ (eLineSpace == rLineSpace.eLineSpace) +/*N*/ // Bei maximalem und minimalem Linespacing muss das Mass +/*N*/ // uebereinstimmen. +/*N*/ && (eLineSpace == SVX_LINE_SPACE_AUTO || +/*N*/ nLineHeight == rLineSpace.nLineHeight) +/*N*/ // Gleiche Interlinespacing Rule? +/*N*/ && ( eInterLineSpace == rLineSpace.eInterLineSpace ) +/*N*/ // Entweder proportional oder draufaddieren eingestellt. +/*N*/ && (( eInterLineSpace == SVX_INTER_LINE_SPACE_OFF) +/*N*/ || (eInterLineSpace == SVX_INTER_LINE_SPACE_PROP +/*N*/ && nPropLineSpace == rLineSpace.nPropLineSpace) +/*N*/ || (eInterLineSpace == SVX_INTER_LINE_SPACE_FIX +/*N*/ && (nInterLineSpace == rLineSpace.nInterLineSpace)))) ? +/*N*/ 1 : 0; +/*N*/ } + +/*-----------------18.03.98 16:32------------------- + os: wer weiss noch, wieso das LineSpacingItem so + kompliziert ist? Fuer UNO koennen wir das nicht + gebrauchen. Da gibt es nur zwei Werte: + - ein sal_uInt16 fuer den Modus + - ein sal_uInt32 fuer alle Werte (Abstand, Hoehe, rel. Angaben) + +--------------------------------------------------*/ +/*N*/ bool SvxLineSpacingItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const +/*N*/ { +/*N*/ sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); +/*N*/ nMemberId &= ~CONVERT_TWIPS; +/*N*/ +/*N*/ style::LineSpacing aLSp; +/*N*/ switch( eLineSpace ) +/*N*/ { +/*N*/ case SVX_LINE_SPACE_AUTO: +/*N*/ if(eInterLineSpace == SVX_INTER_LINE_SPACE_FIX) +/*N*/ { +/*?*/ aLSp.Mode = style::LineSpacingMode::LEADING; +/*?*/ aLSp.Height = nInterLineSpace; +/*N*/ } +/*N*/ else if(eInterLineSpace == SVX_INTER_LINE_SPACE_OFF) +/*N*/ { +/*N*/ aLSp.Mode = style::LineSpacingMode::PROP; +/*N*/ aLSp.Height = 100; +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ aLSp.Mode = style::LineSpacingMode::PROP; +/*N*/ aLSp.Height = nPropLineSpace; +/*N*/ } +/*N*/ break; +/*N*/ case SVX_LINE_SPACE_FIX : +/*N*/ case SVX_LINE_SPACE_MIN : +/*N*/ aLSp.Mode = eLineSpace == SVX_LINE_SPACE_FIX ? style::LineSpacingMode::FIX : style::LineSpacingMode::MINIMUM; +/*N*/ aLSp.Height = ( bConvert ? (short)TWIP_TO_MM100(nLineHeight) : nLineHeight ); +/*N*/ break; +/*N*/ } +/*N*/ +/*N*/ switch ( nMemberId ) +/*N*/ { +/*?*/ case 0 : rVal <<= aLSp; break; +/*?*/ case MID_LINESPACE : rVal <<= aLSp.Mode; break; +/*?*/ case MID_HEIGHT : rVal <<= aLSp.Height; break; +/*?*/ default: DBG_ERROR("Wrong MemberId!"); break; +/*N*/ } +/*N*/ +/*N*/ return sal_True; +/*N*/ } +/*-----------------18.03.98 16:32------------------- + +--------------------------------------------------*/ +/*N*/ bool SvxLineSpacingItem::PutValue( const uno::Any& rVal, BYTE nMemberId ) +/*N*/ { +/*N*/ sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); +/*N*/ nMemberId &= ~CONVERT_TWIPS; +/*N*/ +/*N*/ // fill with current data +/*N*/ style::LineSpacing aLSp; +/*N*/ uno::Any aAny; +/*N*/ sal_Bool bRet = QueryValue( aAny, bConvert ? CONVERT_TWIPS : 0 ) && ( aAny >>= aLSp ); +/*N*/ +/*N*/ // get new data +/*N*/ switch ( nMemberId ) +/*N*/ { +/*N*/ case 0 : bRet = (rVal >>= aLSp); break; +/*?*/ case MID_LINESPACE : bRet = (rVal >>= aLSp.Mode); break; +/*?*/ case MID_HEIGHT : bRet = (rVal >>= aLSp.Height); break; +/*N*/ default: DBG_ERROR("Wrong MemberId!"); break; +/*N*/ } +/*N*/ +/*N*/ if( bRet ) +/*N*/ { +/*N*/ nLineHeight = aLSp.Height; +/*N*/ switch( aLSp.Mode ) +/*N*/ { +/*N*/ case style::LineSpacingMode::LEADING: +/*N*/ { +/*?*/ eInterLineSpace = SVX_INTER_LINE_SPACE_FIX; +/*?*/ eLineSpace = SVX_LINE_SPACE_AUTO; +/*?*/ nInterLineSpace = aLSp.Height; +/*N*/ } +/*N*/ break; +/*N*/ case style::LineSpacingMode::PROP: +/*N*/ { +/*N*/ eLineSpace = SVX_LINE_SPACE_AUTO; +/*N*/ nPropLineSpace = (sal_Int8)std::min(aLSp.Height, (short)0xFF); +/*N*/ if(100 == aLSp.Height) +/*N*/ eInterLineSpace = SVX_INTER_LINE_SPACE_OFF; +/*N*/ else +/*N*/ eInterLineSpace = SVX_INTER_LINE_SPACE_PROP; +/*N*/ } +/*N*/ break; +/*N*/ case style::LineSpacingMode::FIX: +/*N*/ case style::LineSpacingMode::MINIMUM: +/*N*/ { +/*N*/ eInterLineSpace = SVX_INTER_LINE_SPACE_OFF; +/*N*/ eLineSpace = aLSp.Mode == style::LineSpacingMode::FIX ? SVX_LINE_SPACE_FIX : SVX_LINE_SPACE_MIN; +/*N*/ nLineHeight = aLSp.Height; +/*N*/ if(bConvert) +/*N*/ nLineHeight = (USHORT)MM100_TO_TWIP(nLineHeight); +/*N*/ } +/*N*/ break; +/*N*/ } +/*N*/ } +/*N*/ +/*N*/ return bRet; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxLineSpacingItem::Clone( SfxItemPool * ) const +/*N*/ { +/*N*/ return new SvxLineSpacingItem( *this ); +/*N*/ } + +//------------------------------------------------------------------------ + + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxLineSpacingItem::Create(SvStream& rStrm, sal_uInt16) const +/*N*/ { +/*N*/ sal_Int8 nPropSpace; +/*N*/ short nInterSpace; +/*N*/ sal_uInt16 nHeight; +/*N*/ sal_Int8 nRule, nInterRule; +/*N*/ +/*N*/ rStrm >> nPropSpace +/*N*/ >> nInterSpace +/*N*/ >> nHeight +/*N*/ >> nRule +/*N*/ >> nInterRule; +/*N*/ +/*N*/ SvxLineSpacingItem* pAttr = new SvxLineSpacingItem( nHeight, Which() ); +/*N*/ pAttr->SetInterLineSpace( nInterSpace ); +/*N*/ pAttr->SetPropLineSpace( nPropSpace ); +/*N*/ pAttr->GetLineSpaceRule() = (SvxLineSpace)nRule; +/*N*/ pAttr->GetInterLineSpaceRule() = (SvxInterLineSpace)nInterRule; +/*N*/ return pAttr; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvStream& SvxLineSpacingItem::Store( SvStream& rStrm, sal_uInt16 nItemVersion ) const +/*N*/ { +/*N*/ rStrm << (sal_Int8) GetPropLineSpace() +/*N*/ << (short) GetInterLineSpace() +/*N*/ << (sal_uInt16) GetLineHeight() +/*N*/ << (sal_Int8) GetLineSpaceRule() +/*N*/ << (sal_Int8) GetInterLineSpaceRule(); +/*N*/ return rStrm; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*?*/ sal_uInt16 SvxLineSpacingItem::GetValueCount() const +/*?*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); return SVX_LINESPACE_END;//STRIP001 /*?*/ return SVX_LINESPACE_END; // SVX_LINESPACE_TWO_LINES + 1 +/*?*/ } + +// ----------------------------------------------------------------------- + +/*?*/ XubString SvxLineSpacingItem::GetValueTextByPos( sal_uInt16 nPos ) const +/*?*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); XubString aText;//STRIP001 //STRIP001 //! Strings demnaechst aus Resource laden +/*?*/ return aText; +/*?*/ } + +// ----------------------------------------------------------------------- + +/*?*/ sal_uInt16 SvxLineSpacingItem::GetEnumValue() const +/*?*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); return 0;//STRIP001 //STRIP001 sal_uInt16 nVal; +/*?*/ } + +// ----------------------------------------------------------------------- + +/*?*/ void SvxLineSpacingItem::SetEnumValue( sal_uInt16 nVal ) +/*?*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 //STRIP001 switch ( nVal ) +/*?*/ } + +// class SvxAdjustItem --------------------------------------------------- + +/*N*/ SvxAdjustItem::SvxAdjustItem(const SvxAdjust eAdjst, const sal_uInt16 nId ) +/*N*/ : SfxEnumItemInterface( nId ), +/*N*/ bOneBlock( sal_False ), bLastCenter( sal_False ), bLastBlock( sal_False ) +/*N*/ { +/*N*/ SetAdjust( eAdjst ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ int SvxAdjustItem::operator==( const SfxPoolItem& rAttr ) const +/*N*/ { +/*N*/ DBG_ASSERT( SfxPoolItem::operator==(rAttr), "unequal types" ); +/*N*/ +/*N*/ return( ( GetAdjust() == ((SvxAdjustItem&)rAttr).GetAdjust() && +/*N*/ bOneBlock == ((SvxAdjustItem&)rAttr).bOneBlock && +/*N*/ bLastCenter == ((SvxAdjustItem&)rAttr).bLastCenter && +/*N*/ bLastBlock == ((SvxAdjustItem&)rAttr).bLastBlock ) +/*N*/ ? 1 : 0 ); +/*N*/ } + +/*-----------------18.03.98 16:15------------------- + +--------------------------------------------------*/ +/*N*/ bool SvxAdjustItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const +/*N*/ { +/*N*/ sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); +/*N*/ nMemberId &= ~CONVERT_TWIPS; +/*N*/ switch( nMemberId ) +/*N*/ { +/*N*/ case MID_PARA_ADJUST : rVal <<= (sal_Int16)GetAdjust(); break; +/*N*/ case MID_LAST_LINE_ADJUST : rVal <<= (sal_Int16)GetLastBlock(); break; +/*N*/ case MID_EXPAND_SINGLE : +/*N*/ { +/*N*/ sal_Bool bValue = bOneBlock; +/*N*/ rVal.setValue( &bValue, ::getCppuBooleanType() ); +/*N*/ break; +/*N*/ } +/*N*/ } +/*N*/ return sal_True; +/*N*/ } +/*-----------------18.03.98 16:15------------------- + +--------------------------------------------------*/ + +/*N*/ bool SvxAdjustItem::PutValue( const uno::Any& rVal, BYTE nMemberId ) +/*N*/ { +/*N*/ sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); +/*N*/ nMemberId &= ~CONVERT_TWIPS; +/*N*/ switch( nMemberId ) +/*N*/ { +/*N*/ case MID_PARA_ADJUST : +/*N*/ case MID_LAST_LINE_ADJUST : +/*N*/ { +/*N*/ sal_Int32 eVal = - 1; +/*N*/ try +/*N*/ { +/*N*/ eVal = ::comphelper::getEnumAsINT32(rVal); +/*N*/ } +/*N*/ catch(...) {} +/*N*/ if(eVal >= 0 && eVal <= 4) +/*N*/ { +/*N*/ if(MID_LAST_LINE_ADJUST == nMemberId && +/*N*/ eVal != SVX_ADJUST_LEFT && +/*N*/ eVal != SVX_ADJUST_BLOCK && +/*N*/ eVal != SVX_ADJUST_CENTER) +/*N*/ return FALSE; +/*N*/ if(eVal < (sal_uInt16)SVX_ADJUST_END) +/*N*/ nMemberId == MID_PARA_ADJUST ? +/*N*/ SetAdjust((SvxAdjust)eVal) : +/*N*/ SetLastBlock((SvxAdjust)eVal); +/*N*/ } +/*N*/ } +/*N*/ break; +/*N*/ case MID_EXPAND_SINGLE : +/*N*/ bOneBlock = Any2Bool(rVal); +/*N*/ break; +/*N*/ } +/*N*/ return sal_True; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxAdjustItem::Clone( SfxItemPool * ) const +/*N*/ { +/*N*/ return new SvxAdjustItem( *this ); +/*N*/ } + +//------------------------------------------------------------------------ + + +// ----------------------------------------------------------------------- + +/*?*/ sal_uInt16 SvxAdjustItem::GetValueCount() const +/*?*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); return 0;//STRIP001 return SVX_ADJUST_END; // SVX_ADJUST_BLOCKLINE + 1 +/*?*/ } + +// ----------------------------------------------------------------------- + + +// ----------------------------------------------------------------------- + +/*?*/ sal_uInt16 SvxAdjustItem::GetEnumValue() const +/*?*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); return 0;//STRIP001 return GetAdjust(); +/*?*/ } + +// ----------------------------------------------------------------------- + +/*N*/ void SvxAdjustItem::SetEnumValue( sal_uInt16 nVal ) +/*N*/ {DBG_BF_ASSERT(0, "STRIP"); //STRIP001 +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ sal_uInt16 SvxAdjustItem::GetVersion( sal_uInt16 nFileVersion ) const +/*N*/ { +/*N*/ return (nFileVersion == SOFFICE_FILEFORMAT_31) +/*N*/ ? 0 : ADJUST_LASTBLOCK_VERSION; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxAdjustItem::Create(SvStream& rStrm, sal_uInt16 nVersion) const +/*N*/ { +/*N*/ char eAdjustment; +/*N*/ rStrm >> eAdjustment; +/*N*/ SvxAdjustItem *pRet = new SvxAdjustItem( (SvxAdjust)eAdjustment, Which() ); +/*N*/ if( nVersion >= ADJUST_LASTBLOCK_VERSION ) +/*N*/ { +/*N*/ sal_Int8 nFlags; +/*N*/ rStrm >> nFlags; +/*N*/ pRet->bOneBlock = 0 != (nFlags & 0x0001); +/*N*/ pRet->bLastCenter = 0 != (nFlags & 0x0002); +/*N*/ pRet->bLastBlock = 0 != (nFlags & 0x0004); +/*N*/ } +/*N*/ return pRet; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvStream& SvxAdjustItem::Store( SvStream& rStrm, sal_uInt16 nItemVersion ) const +/*N*/ { +/*N*/ rStrm << (char)GetAdjust(); +/*N*/ if ( nItemVersion >= ADJUST_LASTBLOCK_VERSION ) +/*N*/ { +/*N*/ sal_Int8 nFlags = 0; +/*N*/ if ( bOneBlock ) +/*N*/ nFlags |= 0x0001; +/*N*/ if ( bLastCenter ) +/*N*/ nFlags |= 0x0002; +/*N*/ if ( bLastBlock ) +/*N*/ nFlags |= 0x0004; +/*N*/ rStrm << (sal_Int8) nFlags; +/*N*/ } +/*N*/ return rStrm; +/*N*/ } + +// class SvxWidowsItem --------------------------------------------------- + +/*N*/ SvxWidowsItem::SvxWidowsItem(const BYTE nL, const USHORT nId ) : +/*N*/ SfxByteItem( nId, nL ) +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxWidowsItem::Clone( SfxItemPool * ) const +/*N*/ { +/*N*/ return new SvxWidowsItem( *this ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxWidowsItem::Create(SvStream& rStrm, sal_uInt16) const +/*N*/ { +/*N*/ sal_Int8 nLines; +/*N*/ rStrm >> nLines; +/*N*/ return new SvxWidowsItem( nLines, Which() ); +/*N*/ } + +// ----------------------------------------------------------------------- + + +//------------------------------------------------------------------------ + + +// class SvxOrphansItem -------------------------------------------------- + +/*N*/ SvxOrphansItem::SvxOrphansItem(const BYTE nL, const USHORT nId ) : +/*N*/ SfxByteItem( nId, nL ) +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxOrphansItem::Clone( SfxItemPool * ) const +/*N*/ { +/*N*/ return new SvxOrphansItem( *this ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxOrphansItem::Create(SvStream& rStrm, sal_uInt16) const +/*N*/ { +/*N*/ sal_Int8 nLines; +/*N*/ rStrm >> nLines; +/*N*/ return new SvxOrphansItem( nLines, Which() ); +/*N*/ } + +// ----------------------------------------------------------------------- + + +//------------------------------------------------------------------------ + + +// class SvxHyphenZoneItem ----------------------------------------------- + +/*N*/ SvxHyphenZoneItem::SvxHyphenZoneItem( const sal_Bool bHyph, const sal_uInt16 nId ) : +/*N*/ SfxPoolItem( nId ) +/*N*/ { +/*N*/ bHyphen = bHyph; +/*N*/ bPageEnd = sal_True; +/*N*/ nMinLead = nMinTrail = 0; +/*N*/ nMaxHyphens = 255; +/*N*/ } + +// ----------------------------------------------------------------------- +/*N*/ bool SvxHyphenZoneItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const +/*N*/ { +/*N*/ sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); +/*N*/ nMemberId &= ~CONVERT_TWIPS; +/*N*/ switch(nMemberId) +/*N*/ { +/*N*/ case MID_IS_HYPHEN: +/*N*/ rVal = Bool2Any(bHyphen); +/*N*/ break; +/*N*/ case MID_HYPHEN_MIN_LEAD: +/*N*/ rVal <<= (sal_Int16)nMinLead; +/*N*/ break; +/*N*/ case MID_HYPHEN_MIN_TRAIL: +/*N*/ rVal <<= (sal_Int16)nMinTrail; +/*N*/ break; +/*N*/ case MID_HYPHEN_MAX_HYPHENS: +/*N*/ rVal <<= (sal_Int16)nMaxHyphens; +/*N*/ break; +/*N*/ } +/*N*/ return sal_True; +/*N*/ } +// ----------------------------------------------------------------------- +/*N*/ bool SvxHyphenZoneItem::PutValue( const uno::Any& rVal, BYTE nMemberId ) +/*N*/ { +/*N*/ sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); +/*N*/ nMemberId &= ~CONVERT_TWIPS; +/*N*/ sal_Int16 nNewVal = 0; +/*N*/ +/*N*/ if( nMemberId != MID_IS_HYPHEN ) +/*N*/ if(!(rVal >>= nNewVal)) +/*N*/ return sal_False; +/*N*/ +/*N*/ switch(nMemberId) +/*N*/ { +/*N*/ case MID_IS_HYPHEN: +/*N*/ bHyphen = Any2Bool(rVal); +/*N*/ break; +/*N*/ case MID_HYPHEN_MIN_LEAD: +/*N*/ nMinLead = (BYTE)nNewVal; +/*N*/ break; +/*N*/ case MID_HYPHEN_MIN_TRAIL: +/*N*/ nMinTrail = (BYTE)nNewVal; +/*N*/ break; +/*N*/ case MID_HYPHEN_MAX_HYPHENS: +/*N*/ nMaxHyphens = (BYTE)nNewVal; +/*N*/ break; +/*N*/ } +/*N*/ return sal_True; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ int SvxHyphenZoneItem::operator==( const SfxPoolItem& rAttr ) const +/*N*/ { +/*N*/ DBG_ASSERT( SfxPoolItem::operator==(rAttr), "unequal types" ); +/*N*/ +/*N*/ return ( (((SvxHyphenZoneItem&)rAttr).bHyphen == bHyphen) +/*N*/ && (((SvxHyphenZoneItem&)rAttr).bPageEnd == bPageEnd) +/*N*/ && (((SvxHyphenZoneItem&)rAttr).nMinLead == nMinLead) +/*N*/ && (((SvxHyphenZoneItem&)rAttr).nMinTrail == nMinTrail) +/*N*/ && (((SvxHyphenZoneItem&)rAttr).nMaxHyphens == nMaxHyphens) ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxHyphenZoneItem::Clone( SfxItemPool * ) const +/*N*/ { +/*N*/ return new SvxHyphenZoneItem( *this ); +/*N*/ } + +//------------------------------------------------------------------------ + + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxHyphenZoneItem::Create(SvStream& rStrm, sal_uInt16) const +/*N*/ { +/*N*/ sal_Int8 bHyphen, bHyphenPageEnd; +/*N*/ sal_Int8 nMinLead, nMinTrail, nMaxHyphens; +/*N*/ rStrm >> bHyphen >> bHyphenPageEnd >> nMinLead >> nMinTrail >> nMaxHyphens; +/*N*/ SvxHyphenZoneItem* pAttr = new SvxHyphenZoneItem( sal_False, Which() ); +/*N*/ pAttr->SetHyphen( sal_Bool( bHyphen != 0 ) ); +/*N*/ pAttr->SetPageEnd( sal_Bool( bHyphenPageEnd != 0 ) ); +/*N*/ pAttr->GetMinLead() = nMinLead; +/*N*/ pAttr->GetMinTrail() = nMinTrail; +/*N*/ pAttr->GetMaxHyphens() = nMaxHyphens; +/*N*/ return pAttr; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvStream& SvxHyphenZoneItem::Store( SvStream& rStrm, sal_uInt16 nItemVersion ) const +/*N*/ { +/*N*/ rStrm << (sal_Int8) IsHyphen() +/*N*/ << (sal_Int8) IsPageEnd() +/*N*/ << (sal_Int8) GetMinLead() +/*N*/ << (sal_Int8) GetMinTrail() +/*N*/ << (sal_Int8) GetMaxHyphens(); +/*N*/ return rStrm; +/*N*/ } + +// class SvxTabStop ------------------------------------------------------ + +/*N*/ SvxTabStop::SvxTabStop() +/*N*/ { +/*N*/ nTabPos = 0; +/*N*/ eAdjustment = SVX_TAB_ADJUST_LEFT; +/*N*/ cDecimal = SvtSysLocale().GetLocaleData().getNumDecimalSep().GetChar(0); +/*N*/ cFill = cDfltFillChar; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvxTabStop::SvxTabStop( const long nPos, const SvxTabAdjust eAdjst, +/*N*/ const sal_Unicode cDec, const sal_Unicode cFil ) +/*N*/ { +/*N*/ nTabPos = nPos; +/*N*/ eAdjustment = eAdjst; +/*N*/ cDecimal = ( cDfltDecimalChar == cDec ) ? SvtSysLocale().GetLocaleData().getNumDecimalSep().GetChar(0) : cDec; +/*N*/ cFill = cFil; +/*N*/ } + +// ----------------------------------------------------------------------- + + +// class SvxTabStopItem -------------------------------------------------- + +/*N*/ SvxTabStopItem::SvxTabStopItem( sal_uInt16 nWhich ) : +/*N*/ SfxPoolItem( nWhich ), +/*N*/ SvxTabStopArr( sal_Int8(SVX_TAB_DEFCOUNT) ) +/*N*/ { +/*N*/ const sal_uInt16 nTabs = SVX_TAB_DEFCOUNT, nDist = SVX_TAB_DEFDIST; +/*N*/ const SvxTabAdjust eAdjst= SVX_TAB_ADJUST_DEFAULT; +/*N*/ +/*N*/ for (sal_uInt16 i = 0; i < nTabs; ++i) +/*N*/ { +/*N*/ SvxTabStop * pTab = new SvxTabStop( (i + 1) * nDist, eAdjst ); +/*N*/ SvxTabStopArr::Insert( pTab, 1 ); +/*N*/ } +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvxTabStopItem::SvxTabStopItem( const sal_uInt16 nTabs, +/*N*/ const sal_uInt16 nDist, +/*N*/ const SvxTabAdjust eAdjst, +/*N*/ sal_uInt16 nWhich ) : +/*N*/ SfxPoolItem( nWhich ), +/*N*/ SvxTabStopArr( sal_Int8(nTabs) ) +/*N*/ { +/*N*/ for ( sal_uInt16 i = 0; i < nTabs; ++i ) +/*N*/ { +/*N*/ SvxTabStop * pTab = new SvxTabStop( (i + 1) * nDist, eAdjst ); +/*N*/ SvxTabStopArr::Insert( pTab, 1 ); +/*N*/ } +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvxTabStopItem::SvxTabStopItem( const SvxTabStopItem& rTSI ) : +/*N*/ SfxPoolItem( rTSI.Which() ), +/*N*/ SvxTabStopArr( (sal_Int8)rTSI.Count() ) +/*N*/ { +/*N*/ SvxTabStopArr::Insert( &rTSI ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ sal_uInt16 SvxTabStopItem::GetPos( const SvxTabStop& rTab ) const +/*N*/ { +/*N*/ sal_uInt16 nFound; +/*N*/ return Seek_Entry( rTab, &nFound ) ? nFound : SVX_TAB_NOTFOUND; +/*N*/ } + +// ----------------------------------------------------------------------- + + +// ----------------------------------------------------------------------- + + + +/* + enum ::com::sun::star::style::TabAlign +{ + TABALIGN_LEFT, + TABALIGN_CENTER, + TABALIGN_RIGHT, + TABALIGN_DECIMAL +}; + +struct ::com::sun::star::style::TabStop +{ + long Position; + ::com::sun::star::style::TabAlign ::com::sun::star::drawing::Alignment; + unsigned short DecimalChar; + unsigned short FillChar; +}; +typedef sequence ::com::sun::star::style::TabStop> TabSTopSequence; + + */ +/*-----------------19.03.98 08:50------------------- + +--------------------------------------------------*/ + +/*N*/ bool SvxTabStopItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const +/*N*/ { +/*N*/ sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); +/*N*/ nMemberId &= ~CONVERT_TWIPS; +/*N*/ switch ( nMemberId ) +/*N*/ { +/*N*/ case MID_TABSTOPS: +/*N*/ { +/*N*/ sal_uInt16 nCount = Count(); +/*N*/ uno::Sequence< style::TabStop> aSeq(nCount); +/*N*/ style::TabStop* pArr = aSeq.getArray(); +/*N*/ for(sal_uInt16 i = 0; i < nCount; i++) +/*N*/ { +/*N*/ const SvxTabStop& rTab = *(GetStart() + i); +/*N*/ pArr[i].Position = bConvert ? TWIP_TO_MM100(rTab.GetTabPos()) : rTab.GetTabPos(); +/*N*/ switch(rTab.GetAdjustment()) +/*N*/ { +/*N*/ case SVX_TAB_ADJUST_LEFT : pArr[i].Alignment = style::TabAlign_LEFT; break; +/*N*/ case SVX_TAB_ADJUST_RIGHT : pArr[i].Alignment = style::TabAlign_RIGHT; break; +/*N*/ case SVX_TAB_ADJUST_DECIMAL: pArr[i].Alignment = style::TabAlign_DECIMAL; break; +/*N*/ case SVX_TAB_ADJUST_CENTER : pArr[i].Alignment = style::TabAlign_CENTER; break; +/*N*/ default: //SVX_TAB_ADJUST_DEFAULT +/*N*/ pArr[i].Alignment = style::TabAlign_DEFAULT; +/*N*/ +/*N*/ } +/*N*/ pArr[i].DecimalChar = rTab.GetDecimal(); +/*N*/ pArr[i].FillChar = rTab.GetFill(); +/*N*/ } +/*N*/ rVal <<= aSeq; +/*N*/ break; +/*N*/ } +/*N*/ case MID_STD_TAB: +/*N*/ { +/*N*/ const SvxTabStop &rTab = *(GetStart()); +/*N*/ rVal <<= bConvert ? TWIP_TO_MM100(rTab.GetTabPos()) : rTab.GetTabPos(); +/*N*/ break; +/*N*/ } +/*N*/ } +/*N*/ return sal_True; +/*N*/ } +/*-----------------19.03.98 08:50------------------- + +--------------------------------------------------*/ + +/*N*/ bool SvxTabStopItem::PutValue( const uno::Any& rVal, BYTE nMemberId ) +/*N*/ { +/*N*/ sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); +/*N*/ nMemberId &= ~CONVERT_TWIPS; +/*N*/ switch ( nMemberId ) +/*N*/ { +/*N*/ case MID_TABSTOPS: +/*N*/ { +/*N*/ uno::Sequence< style::TabStop> aSeq; +/*N*/ if(!(rVal >>= aSeq)) +/*N*/ { +/*?*/ uno::Sequence < uno::Sequence < uno::Any > > aAnySeq; +/*?*/ if (!(rVal >>= aAnySeq)) +/*?*/ return sal_False; +/*?*/ sal_Int32 nLength = aAnySeq.getLength(); +/*?*/ aSeq.realloc( nLength ); +/*?*/ for ( sal_Int32 n=0; n<nLength; n++ ) +/*?*/ { +/*?*/ uno::Sequence < uno::Any >& rAnySeq = aAnySeq[n]; +/*?*/ if ( rAnySeq.getLength() == 4 ) +/*?*/ { +/*?*/ if (!(rAnySeq[0] >>= aSeq[n].Position)) return sal_False; +/*?*/ if (!(rAnySeq[1] >>= aSeq[n].Alignment)) +/*?*/ { +/*?*/ sal_Int32 nVal; +/*?*/ if (rAnySeq[1] >>= nVal) +/*?*/ aSeq[n].Alignment = (::com::sun::star::style::TabAlign) nVal; +/*?*/ else +/*?*/ return sal_False; +/*?*/ } +/*?*/ if (!(rAnySeq[2] >>= aSeq[n].DecimalChar)) +/*?*/ { +/*?*/ ::rtl::OUString aVal; +/*?*/ if ( (rAnySeq[2] >>= aVal) && aVal.getLength() == 1 ) +/*?*/ aSeq[n].DecimalChar = aVal.toChar(); +/*?*/ else +/*?*/ return sal_False; +/*?*/ } +/*?*/ if (!(rAnySeq[3] >>= aSeq[n].FillChar)) +/*?*/ { +/*?*/ ::rtl::OUString aVal; +/*?*/ if ( (rAnySeq[3] >>= aVal) && aVal.getLength() == 1 ) +/*?*/ aSeq[n].FillChar = aVal.toChar(); +/*?*/ else +/*?*/ return sal_False; +/*?*/ } +/*?*/ } +/*?*/ else +/*?*/ return sal_False; +/*?*/ } +/*N*/ } +/*N*/ +/*N*/ SvxTabStopArr::Remove( 0, Count() ); +/*N*/ const style::TabStop* pArr = aSeq.getConstArray(); +/*N*/ const sal_uInt16 nCount = (sal_uInt16)aSeq.getLength(); +/*N*/ for(sal_uInt16 i = 0; i < nCount ; i++) +/*N*/ { +/*N*/ SvxTabAdjust eAdjust = SVX_TAB_ADJUST_DEFAULT; +/*N*/ switch(pArr[i].Alignment) +/*N*/ { +/*N*/ case style::TabAlign_LEFT : eAdjust = SVX_TAB_ADJUST_LEFT; break; +/*N*/ case style::TabAlign_CENTER : eAdjust = SVX_TAB_ADJUST_CENTER; break; +/*N*/ case style::TabAlign_RIGHT : eAdjust = SVX_TAB_ADJUST_RIGHT; break; +/*N*/ case style::TabAlign_DECIMAL: eAdjust = SVX_TAB_ADJUST_DECIMAL; break; +/*N*/ } +/*N*/ sal_Unicode cFill = pArr[i].FillChar; +/*N*/ sal_Unicode cDecimal = pArr[i].DecimalChar; +/*N*/ SvxTabStop aTab( bConvert ? MM100_TO_TWIP(pArr[i].Position) : pArr[i].Position, +/*N*/ eAdjust, +/*N*/ cDecimal, +/*N*/ cFill ); +/*N*/ Insert(aTab); +/*N*/ } +/*N*/ break; +/*N*/ } +/*N*/ case MID_STD_TAB: +/*N*/ { +/*N*/ sal_Int32 nNewPos; +/*N*/ if (!(rVal >>= nNewPos) ) +/*N*/ return sal_False; +/*N*/ const SvxTabStop& rTab = *(GetStart()); +/*N*/ SvxTabStop aNewTab ( bConvert ? MM100_TO_TWIP ( nNewPos ) : nNewPos, +/*N*/ rTab.GetAdjustment(), rTab.GetDecimal(), rTab.GetFill() ); +/*N*/ Remove ( 0 ); +/*N*/ Insert( aNewTab ); +/*N*/ break; +/*N*/ } +/*N*/ } +/*N*/ return sal_True; +/*N*/ } +// ----------------------------------------------------------------------- + +/*N*/ int SvxTabStopItem::operator==( const SfxPoolItem& rAttr ) const +/*N*/ { +/*N*/ DBG_ASSERT( SfxPoolItem::operator==(rAttr), "unequal types" ); +/*N*/ +/*N*/ const SvxTabStopItem& rTSI = (SvxTabStopItem&)rAttr; +/*N*/ +/*N*/ if ( Count() != rTSI.Count() ) +/*N*/ return 0; +/*N*/ +/*N*/ for ( sal_uInt16 i = 0; i < Count(); ++i ) +/*N*/ if( !(*this)[i].IsEqual( rTSI[i] ) ) +/*N*/ return 0; +/*N*/ return 1; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxTabStopItem::Clone( SfxItemPool * ) const +/*N*/ { +/*N*/ return new SvxTabStopItem( *this ); +/*N*/ } + +//------------------------------------------------------------------------ + + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxTabStopItem::Create( SvStream& rStrm, sal_uInt16 ) const +/*N*/ { +/*N*/ sal_Int8 nTabs; +/*N*/ rStrm >> nTabs; +/*N*/ SvxTabStopItem* pAttr = +/*N*/ new SvxTabStopItem( 0, 0, SVX_TAB_ADJUST_DEFAULT, Which() ); +/*N*/ +/*N*/ for ( sal_Int8 i = 0; i < nTabs; i++ ) +/*N*/ { +/*N*/ long nPos; +/*N*/ sal_Int8 eAdjust; +/*N*/ unsigned char cDecimal, cFill; +/*N*/ rStrm >> nPos >> eAdjust >> cDecimal >> cFill; +/*N*/ if( !i || SVX_TAB_ADJUST_DEFAULT != eAdjust ) +/*N*/ pAttr->Insert( SvxTabStop +/*N*/ ( nPos, (SvxTabAdjust)eAdjust, sal_Unicode(cDecimal), sal_Unicode(cFill) ) ); +/*N*/ } +/*N*/ return pAttr; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvStream& SvxTabStopItem::Store( SvStream& rStrm, sal_uInt16 nItemVersion ) const +/*N*/ { +/*N*/ //MA 05. Sep. 96: Default-Tabs werden nur noch fuer das default-Attr +/*N*/ //expandiert. Fuer vollstaendige Rueckwaertskompatibilitaet (<=304) +/*N*/ //muessten alle Tabs expandiert werden, dass blaeht aber das File u.U. +/*N*/ //enorm auf. +/*N*/ //Alles nur SWG! +/*N*/ +/*N*/ const SfxItemPool *pPool = SfxItemPool::GetStoringPool(); +/*N*/ const FASTBOOL bStoreDefTabs = pPool +/*N*/ && pPool->GetName().EqualsAscii("SWG") +/*N*/ && binfilter::IsDefaultItem( this ); +/*N*/ +/*N*/ const short nTabs = Count(); +/*N*/ sal_uInt16 nCount = 0, nDefDist; +/*N*/ long nNew; +/*N*/ +/*N*/ if( bStoreDefTabs ) +/*N*/ { +/*N*/ const SvxTabStopItem& rDefTab = (const SvxTabStopItem &) +/*N*/ pPool->GetDefaultItem( pPool->GetWhich( SID_ATTR_TABSTOP, sal_False ) ); +/*N*/ nDefDist = sal_uInt16( rDefTab.GetStart()->GetTabPos() ); +/*N*/ const long nPos = nTabs > 0 ? (*this)[nTabs-1].GetTabPos() : 0; +/*N*/ nCount = (sal_uInt16)(nPos / nDefDist); +/*N*/ nNew = (nCount + 1) * nDefDist; +/*N*/ +/*N*/ if( nNew <= nPos + 50 ) +/*N*/ nNew += nDefDist; +/*N*/ +/*N*/ nCount = nNew < lA3Width ? ( lA3Width - nNew ) / nDefDist + 1 : 0; +/*N*/ } +/*N*/ +/*N*/ rStrm << (sal_Int8) ( nTabs + nCount ); +/*N*/ for ( short i = 0; i < nTabs; i++ ) +/*N*/ { +/*N*/ const SvxTabStop& rTab = (*this)[ i ]; +/*N*/ rStrm << (long) rTab.GetTabPos() +/*N*/ << (sal_Int8) rTab.GetAdjustment() +/*N*/ << (unsigned char) rTab.GetDecimal() +/*N*/ << (unsigned char) rTab.GetFill(); +/*N*/ } +/*N*/ +/*N*/ if ( bStoreDefTabs ) +/*N*/ for( ; nCount; --nCount ) +/*N*/ { +/*N*/ SvxTabStop aSwTabStop(nNew, SVX_TAB_ADJUST_DEFAULT); +/*N*/ rStrm << (long) aSwTabStop.GetTabPos() +/*N*/ << (sal_Int8) aSwTabStop.GetAdjustment() +/*N*/ << (unsigned char) aSwTabStop.GetDecimal() +/*N*/ << (unsigned char) aSwTabStop.GetFill(); +/*N*/ nNew += nDefDist; +/*N*/ } +/*N*/ +/*N*/ return rStrm; +/*N*/ } + +// ----------------------------------------------------------------------- +/*N*/ sal_Bool SvxTabStopItem::Insert( const SvxTabStop& rTab ) +/*N*/ { +/*N*/ sal_uInt16 nTabPos = GetPos(rTab); +/*N*/ if(SVX_TAB_NOTFOUND != nTabPos ) +/*?*/ Remove(nTabPos); +/*N*/ return SvxTabStopArr::Insert( rTab ); +/*N*/ } +// ----------------------------------------------------------------------- + + + +// class SvxFmtSplitItem ------------------------------------------------- +/*N*/ SvxFmtSplitItem::~SvxFmtSplitItem() +/*N*/ { +/*N*/ } +// ----------------------------------------------------------------------- +/*N*/ SfxPoolItem* SvxFmtSplitItem::Clone( SfxItemPool * ) const +/*N*/ { +/*N*/ return new SvxFmtSplitItem( *this ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvStream& SvxFmtSplitItem::Store( SvStream& rStrm, sal_uInt16 nItemVersion ) const +/*N*/ { +/*N*/ rStrm << (sal_Int8)GetValue(); +/*N*/ return rStrm; +/*N*/ } + +// ----------------------------------------------------------------------- +/*N*/ +/*N*/ SfxPoolItem* SvxFmtSplitItem::Create( SvStream& rStrm, sal_uInt16 ) const +/*N*/ { +/*N*/ sal_Int8 bIsSplit; +/*N*/ rStrm >> bIsSplit; +/*N*/ return new SvxFmtSplitItem( sal_Bool( bIsSplit != 0 ), Which() ); +/*N*/ } + +//------------------------------------------------------------------------ + + +// -------------------------------------------------------------------- + + +//------------------------------------------------------------------------ + + + + +//------------------------------------------------------------------------ + +/*N*/ SvxScriptSpaceItem::SvxScriptSpaceItem( sal_Bool bOn, const sal_uInt16 nId ) +/*N*/ : SfxBoolItem( nId, bOn ) +/*N*/ { +/*N*/ } + +/*N*/ SfxPoolItem* SvxScriptSpaceItem::Clone( SfxItemPool *pPool ) const +/*N*/ { +/*N*/ return new SvxScriptSpaceItem( GetValue(), Which() ); +/*N*/ } + +/*N*/ SfxPoolItem* SvxScriptSpaceItem::Create(SvStream & rStrm, USHORT) const +/*N*/ { +/*N*/ sal_Bool bFlag; +/*N*/ rStrm >> bFlag; +/*N*/ return new SvxScriptSpaceItem( bFlag, Which() ); +/*N*/ } + +/*N*/ USHORT SvxScriptSpaceItem::GetVersion( USHORT nFFVer ) const +/*N*/ { +/*N*/ DBG_ASSERT( SOFFICE_FILEFORMAT_31==nFFVer || +/*N*/ SOFFICE_FILEFORMAT_40==nFFVer || +/*N*/ SOFFICE_FILEFORMAT_50==nFFVer, +/*N*/ "SvxTwoLinesItem: Gibt es ein neues Fileformat?" ); +/*N*/ +/*N*/ return SOFFICE_FILEFORMAT_50 > nFFVer ? USHRT_MAX : 0; +/*N*/ } + + +//------------------------------------------------------------------------ + +/*N*/ SvxHangingPunctuationItem::SvxHangingPunctuationItem( +/*N*/ sal_Bool bOn, const sal_uInt16 nId ) +/*N*/ : SfxBoolItem( nId, bOn ) +/*N*/ { +/*N*/ } + +/*N*/ SfxPoolItem* SvxHangingPunctuationItem::Clone( SfxItemPool *pPool ) const +/*N*/ { +/*N*/ return new SvxHangingPunctuationItem( GetValue(), Which() ); +/*N*/ } + +/*N*/ SfxPoolItem* SvxHangingPunctuationItem::Create(SvStream & rStrm, USHORT) const +/*N*/ { +/*N*/ sal_Bool nValue; +/*N*/ rStrm >> nValue; +/*N*/ return new SvxHangingPunctuationItem( nValue, Which() ); +/*N*/ } + +/*N*/ USHORT SvxHangingPunctuationItem::GetVersion( USHORT nFFVer ) const +/*N*/ { +/*N*/ DBG_ASSERT( SOFFICE_FILEFORMAT_31==nFFVer || +/*N*/ SOFFICE_FILEFORMAT_40==nFFVer || +/*N*/ SOFFICE_FILEFORMAT_50==nFFVer, +/*N*/ "SvxHangingPunctuationItem: Gibt es ein neues Fileformat?" ); +/*N*/ +/*N*/ return SOFFICE_FILEFORMAT_50 > nFFVer ? USHRT_MAX : 0; +/*N*/ } + +//------------------------------------------------------------------------ + +/*N*/ SvxForbiddenRuleItem::SvxForbiddenRuleItem( +/*N*/ sal_Bool bOn, const sal_uInt16 nId ) +/*N*/ : SfxBoolItem( nId, bOn ) +/*N*/ { +/*N*/ } +/* -----------------------------29.11.00 11:23-------------------------------- + + ---------------------------------------------------------------------------*/ +/*N*/ SfxPoolItem* SvxForbiddenRuleItem::Clone( SfxItemPool *pPool ) const +/*N*/ { +/*N*/ return new SvxForbiddenRuleItem( GetValue(), Which() ); +/*N*/ } +/* -----------------------------29.11.00 11:23-------------------------------- + + ---------------------------------------------------------------------------*/ +/*N*/ SfxPoolItem* SvxForbiddenRuleItem::Create(SvStream & rStrm, USHORT) const +/*N*/ { +/*N*/ sal_Bool nValue; +/*N*/ rStrm >> nValue; +/*N*/ return new SvxForbiddenRuleItem( nValue, Which() ); +/*N*/ } +/* -----------------------------29.11.00 11:23-------------------------------- + + ---------------------------------------------------------------------------*/ +/*N*/ USHORT SvxForbiddenRuleItem::GetVersion( USHORT nFFVer ) const +/*N*/ { +/*N*/ DBG_ASSERT( SOFFICE_FILEFORMAT_31==nFFVer || +/*N*/ SOFFICE_FILEFORMAT_40==nFFVer || +/*N*/ SOFFICE_FILEFORMAT_50==nFFVer, +/*N*/ "SvxForbiddenRuleItem: Gibt es ein neues Fileformat?" ); +/*N*/ +/*N*/ return SOFFICE_FILEFORMAT_50 > nFFVer ? USHRT_MAX : 0; +/*N*/ } +/* -----------------------------29.11.00 11:23-------------------------------- + + ---------------------------------------------------------------------------*/ + +/************************************************************************* +|* class SvxParaVertAlignItem +*************************************************************************/ + +/*N*/ SvxParaVertAlignItem::SvxParaVertAlignItem( sal_uInt16 nValue, +/*N*/ const sal_uInt16 nW ) +/*N*/ : SfxUInt16Item( nW, nValue ) +/*N*/ { +/*N*/ } + + + + +/*N*/ USHORT SvxParaVertAlignItem::GetVersion( USHORT nFFVer ) const +/*N*/ { +/*N*/ return SOFFICE_FILEFORMAT_50 > nFFVer ? USHRT_MAX : 0; +/*N*/ } + + + + + + +/*N*/ SvxParaGridItem::SvxParaGridItem( sal_Bool bOn, const sal_uInt16 nId ) +/*N*/ : SfxBoolItem( nId, bOn ) +/*N*/ { +/*N*/ } + +/*N*/ SfxPoolItem* SvxParaGridItem::Clone( SfxItemPool *pPool ) const +/*N*/ {DBG_BF_ASSERT(0, "STRIP"); return NULL;//STRIP001 +/*N*/ } + +/*N*/ SfxPoolItem* SvxParaGridItem::Create(SvStream & rStrm, USHORT) const +/*N*/ {DBG_BF_ASSERT(0, "STRIP"); return NULL;//STRIP001 +/*N*/ } + +/*N*/ USHORT SvxParaGridItem::GetVersion( USHORT nFFVer ) const +/*N*/ { +/*N*/ DBG_ASSERT( SOFFICE_FILEFORMAT_31==nFFVer || +/*N*/ SOFFICE_FILEFORMAT_40==nFFVer || +/*N*/ SOFFICE_FILEFORMAT_50==nFFVer, +/*N*/ "SvxParaGridItem: Gibt es ein neues Fileformat?" ); +/*N*/ +/*N*/ return SOFFICE_FILEFORMAT_50 > nFFVer ? USHRT_MAX : 0; +/*N*/ } + +/*N*/ SfxItemPresentation SvxParaGridItem::GetPresentation( +/*N*/ SfxItemPresentation ePres, +/*N*/ SfxMapUnit eCoreMetric, SfxMapUnit ePresMetric, +/*N*/ String &rText, const ::IntlWrapper* pIntl ) const +/*N*/ { +/*?*/ switch( ePres ) +/*?*/ { +/*?*/ case SFX_ITEM_PRESENTATION_NONE: +/*?*/ rText.Erase(); +/*?*/ break; +/*?*/ case SFX_ITEM_PRESENTATION_NAMELESS: +/*?*/ case SFX_ITEM_PRESENTATION_COMPLETE: +/*?*/ { +/*?*/ rText = GetValue() ? +/*?*/ SVX_RESSTR( RID_SVXITEMS_PARASNAPTOGRID_ON ) : +/*?*/ SVX_RESSTR( RID_SVXITEMS_PARASNAPTOGRID_OFF ); +/*?*/ +/*?*/ return ePres; +/*?*/ } +/*?*/ break; +/*?*/ } +/*?*/ return SFX_ITEM_PRESENTATION_NONE; +/*N*/ } + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_svx/source/items/svx_postattr.cxx b/binfilter/bf_svx/source/items/svx_postattr.cxx new file mode 100644 index 000000000000..ea61ba54dbe5 --- /dev/null +++ b/binfilter/bf_svx/source/items/svx_postattr.cxx @@ -0,0 +1,90 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +// include --------------------------------------------------------------- + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +#define _SVX_POSTATTR_CXX +#define ITEMID_AUTHOR 0 +#define ITEMID_DATE 0 +#define ITEMID_TEXT 0 + +#include <bf_svtools/stritem.hxx> + +#include "postattr.hxx" +namespace binfilter { + +// ----------------------------------------------------------------------- + +/*N*/ TYPEINIT1_AUTOFACTORY(SvxPostItAuthorItem, SfxStringItem); +/*N*/ TYPEINIT1_AUTOFACTORY(SvxPostItDateItem, SfxStringItem); +/*N*/ TYPEINIT1_AUTOFACTORY(SvxPostItTextItem, SfxStringItem); + +// class SvxPostItAuthorItem --------------------------------------------- + + +// ----------------------------------------------------------------------- + + +//------------------------------------------------------------------------ + + +// ----------------------------------------------------------------------- + + +// class SvxPostItDateItem ----------------------------------------------- + + +// ----------------------------------------------------------------------- + + +//------------------------------------------------------------------------ + + +// ----------------------------------------------------------------------- + + +// class SvxPostItTextItem ----------------------------------------------- + + +// ----------------------------------------------------------------------- + + +//------------------------------------------------------------------------ + + +// ----------------------------------------------------------------------- + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_svx/source/items/svx_rotmodit.cxx b/binfilter/bf_svx/source/items/svx_rotmodit.cxx new file mode 100644 index 000000000000..223044642da6 --- /dev/null +++ b/binfilter/bf_svx/source/items/svx_rotmodit.cxx @@ -0,0 +1,132 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#include <tools/stream.hxx> +#ifdef _MSC_VER +#pragma hdrstop +#endif + +#include <com/sun/star/table/CellVertJustify.hpp> + +#include "rotmodit.hxx" +namespace binfilter { + +using namespace ::rtl; +using namespace ::com::sun::star; + +// STATIC DATA ----------------------------------------------------------- + +/*N*/ TYPEINIT1_AUTOFACTORY(SvxRotateModeItem, SfxEnumItem); + + +//----------------------------------------------------------------------- +// SvxRotateModeItem - Ausrichtung bei gedrehtem Text +//----------------------------------------------------------------------- + +/*N*/ SvxRotateModeItem::SvxRotateModeItem( SvxRotateMode eMode, USHORT nWhich ) +/*N*/ : SfxEnumItem( nWhich, eMode ) +/*N*/ { +/*N*/ } + +/*N*/ SvxRotateModeItem::SvxRotateModeItem( const SvxRotateModeItem& rItem ) +/*N*/ : SfxEnumItem( rItem ) +/*N*/ { +/*N*/ } + +/*N*/ __EXPORT SvxRotateModeItem::~SvxRotateModeItem() +/*N*/ { +/*N*/ } + +/*N*/ SfxPoolItem* __EXPORT SvxRotateModeItem::Create( SvStream& rStream, USHORT ) const +/*N*/ { +/*N*/ USHORT nVal; +/*N*/ rStream >> nVal; +/*N*/ return new SvxRotateModeItem( (SvxRotateMode) nVal,Which() ); +/*N*/ } + + + +/*?*/ USHORT __EXPORT SvxRotateModeItem::GetValueCount() const +/*?*/ { +/*?*/ return 4; // STANDARD, TOP, CENTER, BOTTOM +/*?*/ } + +/*N*/ SfxPoolItem* __EXPORT SvxRotateModeItem::Clone( SfxItemPool* ) const +/*N*/ { +/*N*/ return new SvxRotateModeItem( *this ); +/*N*/ } + +/*N*/ USHORT __EXPORT SvxRotateModeItem::GetVersion( USHORT nFileVersion ) const +/*N*/ { +/*N*/ return 0; +/*N*/ } + +// QueryValue/PutValue: Der ::com::sun::star::table::CellVertJustify enum wird mitbenutzt... + +/*N*/ bool SvxRotateModeItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const +/*N*/ { +/*N*/ table::CellVertJustify eUno = table::CellVertJustify_STANDARD; +/*N*/ switch ( (SvxRotateMode)GetValue() ) +/*N*/ { +/*N*/ case SVX_ROTATE_MODE_STANDARD: eUno = table::CellVertJustify_STANDARD; break; +/*N*/ case SVX_ROTATE_MODE_TOP: eUno = table::CellVertJustify_TOP; break; +/*N*/ case SVX_ROTATE_MODE_CENTER: eUno = table::CellVertJustify_CENTER; break; +/*N*/ case SVX_ROTATE_MODE_BOTTOM: eUno = table::CellVertJustify_BOTTOM; break; +/*N*/ } +/*N*/ rVal <<= eUno; +/*N*/ return sal_True; +/*N*/ } + +/*N*/ bool SvxRotateModeItem::PutValue( const uno::Any& rVal, BYTE nMemberId ) +/*N*/ { +/*N*/ table::CellVertJustify eUno; +/*N*/ if(!(rVal >>= eUno)) +/*N*/ { +/*N*/ sal_Int32 nValue; +/*?*/ if(!(rVal >>= nValue)) +/*?*/ return sal_False; +/*?*/ eUno = (table::CellVertJustify)nValue; +/*N*/ } +/*N*/ +/*N*/ SvxRotateMode eSvx = SVX_ROTATE_MODE_STANDARD; +/*N*/ switch (eUno) +/*N*/ { +/*N*/ case table::CellVertJustify_STANDARD: eSvx = SVX_ROTATE_MODE_STANDARD; break; +/*?*/ case table::CellVertJustify_TOP: eSvx = SVX_ROTATE_MODE_TOP; break; +/*?*/ case table::CellVertJustify_CENTER: eSvx = SVX_ROTATE_MODE_CENTER; break; +/*N*/ case table::CellVertJustify_BOTTOM: eSvx = SVX_ROTATE_MODE_BOTTOM; break; +/*N*/ } +/*N*/ SetValue( eSvx ); +/*N*/ return sal_True; +/*N*/ } + + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_svx/source/items/svx_svxerr.cxx b/binfilter/bf_svx/source/items/svx_svxerr.cxx new file mode 100644 index 000000000000..e8f745ef8ebb --- /dev/null +++ b/binfilter/bf_svx/source/items/svx_svxerr.cxx @@ -0,0 +1,52 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +// include --------------------------------------------------------------- + +#include <tools/shl.hxx> +#ifdef _MSC_VER +#pragma hdrstop +#endif + +#include "svxerr.hxx" +#include "dialmgr.hxx" + +#include "dialogs.hrc" +namespace binfilter { + +/*N*/ SvxErrorHandler::SvxErrorHandler() : +/*N*/ +/*N*/ SfxErrorHandler( +/*N*/ RID_SVXERRCODE, ERRCODE_AREA_SVX, ERRCODE_AREA_SVX_END, &DIALOG_MGR() ) +/*N*/ { +/*N*/ } + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_svx/source/items/svx_svxerr.src b/binfilter/bf_svx/source/items/svx_svxerr.src new file mode 100644 index 000000000000..f3ba72956426 --- /dev/null +++ b/binfilter/bf_svx/source/items/svx_svxerr.src @@ -0,0 +1,246 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ +#define NO_LOCALIZE_EXPORT + // include --------------------------------------------------------------- +#define __RSC + +#ifndef _ERRCODE_HXX +#include <tools/errcode.hxx> +#endif + +#include "svxerr.hxx" +#include "dialogs.hrc" + // pragma ---------------------------------------------------------------- + + // Error-Context --------------------------------------------------------- +Resource RID_SVXERRCTX +{ +}; + // Error-Code ------------------------------------------------------------ +Resource RID_SVXERRCODE +{ + String ERRCODE_SVX_GRAPHIC_WRONG_FILEFORMAT&ERRCODE_RES_MASK + { + Text [ de ] = "Eine unverknüpfte Grafik konnte nicht geladen werden" ; + Text [ en-US ] = "An unlinked graphic could not be loaded"; + Text[ pt ] = "Foi impossÃvel carregar uma imagem não ligada."; + Text[ ru ] = "Ðевозможно загрузить неÑвÑзанные графичеÑкие объекты"; + Text[ el ] = "Δεν ήταν δυνατόν να φοÏτωθεί κάποιο γÏαφικό χωÏίς σÏνδεση"; + Text[ nl ] = "Niet-gekoppelde afbeelding kan niet worden geladen"; + Text[ fr ] = "Une image (non liée) n'a pas pu être chargée."; + Text[ es ] = "No se pudo cargar una imagen no vinculada"; + Text[ fi ] = "Linkittämätöntä kuvaa ei voitu ladata"; + Text[ ca ] = "No s'ha pogut carregar la imatge no enllaçada"; + Text[ it ] = "Non è stato possibile caricare un'immagine non collegata"; + Text[ sk ] = "Nie je možné naÄÃtaÅ¥ nepripojený obrázok"; + Text[ da ] = "Det var ikke muligt at indlæse en ikke-kædet grafik"; + Text[ sv ] = "Ett grafikobjekt utan länk kunde inte laddas"; + Text[ pl ] = "Nie można zaÅ‚adować niepoÅ‚Ä…czonej grafiki"; + Text[ pt-BR ] = "Não foi possÃvel carregar uma figura não vinculada."; + Text[ th ] = "ไม่สามารถโหลดà¸à¸£à¸²à¸Ÿà¸´à¸„ที่ไม่เชื่à¸à¸¡à¹‚ยงได้"; + Text[ ja ] = "リンクã•ã‚Œã¦ã„ãªã„図ã¯èªã¿è¾¼ã¿ã§ãã¾ã›ã‚“"; + Text[ ko ] = "ì—°ê²°ë˜ì§€ ì•Šì€ ê·¸ëž˜í”½ì€ ë¡œë“œí•˜ì§€ 못했습니다."; + Text[ zh-CN ] = "æ— æ³•è£…å…¥ä¸€ä¸ªå°šæœªé“¾æŽ¥çš„å›¾å½¢"; + Text[ zh-TW ] = "無法載入一個尚未連çµçš„圖形"; + Text[ tr ] = "BaÄŸlantı oluÅŸturulmamış bir grafik yüklenemedi"; + Text[ hi-IN ] = "लिंक हटाया हà¥à¤† सà¥à¤šà¤¿à¤¤à¥à¤° को लोड नहीं कर सकते है"; + Text[ ar ] = "تعذر تØميل Ø¥Øدى الصور الغير مرتبطة"; + Text[ he ] = "â€®×œ× × ×™×ª×Ÿ לטעון ×¢×¦× ×’×¨×¤×™ שקישורו × ×•×ª×§â€¬"; + }; + String (ERRCODE_SVX_FORMS_NOIOSERVICES | ERRCODE_CLASS_READ) & ERRCODE_RES_MASK + { + Text [ de ] = "Die Formular-Schicht wurden nicht geladen, da notwendige IO-Services (stardiv.uno.io.*) nicht instantiiert werden konnten"; + Text [ en-US ] = "The form layer wasn't loaded as the required IO-services (stardiv.uno.io.*) could not be instantiated"; + Text [ x-comment ] = " "; + Text[ pt ] = "ImpossÃvel carregar a camada do formulário: foi impossÃvel instanciar os serviços IO (stardiv.uno.io.*) necessários"; + Text[ ru ] = "Ðе загружен Ñлой формы, так как не удалоÑÑŒ Ñоздать ÑкземплÑÑ€ Ñлужбы IO (stardiv.uno.io.*)."; + Text[ el ] = "Δεν φοÏτώθηκε η στÏώση της φόÏμας, επειδή δεν ήταν δυνατόν να γίνει ενημÎÏωση κάποιων απαιτουμÎνων υπηÏεσιών εισόδου - εξόδου (stardiv.uno.io.*)."; + Text[ nl ] = "Formulierniveau kan niet worden geladen omdat noodzakelijke io--services (stardiv.uno.io.*) niet kunnen worden geïnitieerd."; + Text[ fr ] = "La couche de formulaire n'a pas été chargée : impossible d'instancier les services IO (stardiv.uno.io.*) requis."; + Text[ es ] = "No se cargó la capa de formulario porque no se pudieron instanciar servicios IO necesarios (stardiv.uno.io.*)"; + Text[ fi ] = "Lomakekerrosta ei ladattu, koska vaadittujen IO-palveluiden (stardiv.uno.io.*) käyttö ei onnistunut"; + Text[ ca ] = "La capa del formulari no estava carregada quan no s'han pogut instanciar els serveis IO (stardiv.uno.io.*) necessaris"; + Text[ it ] = "Lo strato del formulario non è stato caricato poichè stato possibile creare i servizi IO (strdiv.uno.io.*) necessari."; + Text[ sk ] = "Vrstva formulára nebola naÄÃtaná, pretože nie je možné vytvoriÅ¥ požadované IO služby (stardiv.uno.io.*)."; + Text[ da ] = "Formularlaget blev ikke indlæst, fordi det ikke var muligt at instantiere den krævede IO-service (stardiv.uno.io.*)."; + Text[ sv ] = "Formulärskiktet laddades inte eftersom nödvändig IO-service (stardiv.uno.io.*) inte kunde instantieras."; + Text[ pl ] = "Warstwa formularza nie zostaÅ‚a zaÅ‚adowana, ponieważ nie można utworzyć instancji wymaganych usÅ‚ug we-wy (stardiv.uno.io.*)"; + Text[ pt-BR ] = "Não foi possÃvel carregar a camada do formulário pois não foi possÃvel instanciar os serviços IO (stardiv.uno.io.*) necessários."; + Text[ th ] = "ไม่ได้โหลดระดับขà¸à¸‡à¹à¸šà¸šà¸Ÿà¸à¸£à¹Œà¸¡à¹€à¸›à¹‡à¸™ IO-services (stardiv.uno.io.*) à¸à¸¢à¹ˆà¸²à¸‡à¸—ี่ต้à¸à¸‡à¸à¸²à¸£à¹„ม่สามารถถูà¸à¹à¸ªà¸”งให้เห็นตัวà¸à¸¢à¹ˆà¸²à¸‡"; + Text[ ja ] = "IOサービス(stardiv.uno.io.*)ãŒã‚¤ãƒ³ã‚¹ãƒˆãƒ¼ãƒ«ã§ããªã‹ã£ãŸãŸã‚ã€ãƒ•ã‚©ãƒ¼ãƒ 層ã¯èªã¿è¾¼ã¾ã‚Œã¾ã›ã‚“ã§ã—ãŸã€‚"; + Text[ ko ] = "필요한 IO 서비스(stardiv.uno.io.*)ì˜ ì¸ìŠ¤í„´ìŠ¤ë¥¼ ìƒì„±í•˜ì§€ 못했으므로 ì–‘ì‹ ê³„ì¸µì´ ë¡œë“œë˜ì§€ 않았습니다."; + Text[ zh-CN ] = "å› ä¸ºæ— æ³•å®‰è£…éœ€è¦çš„ IO æœåŠ¡(stardiv.uno.io.*)，所以ä¸èƒ½è£…入表å•åˆ†å±‚ä¿¡æ¯"; + Text[ zh-TW ] = "å› ç‚ºæ²’æœ‰å®‰è£å¿…è¦çš„ IO æœå‹™(stardiv.uno.io.*)而無法載入表單層次。"; + Text[ tr ] = "Gerekli IO hizmetleri (stardiv.uno.io.*) baÅŸlatılamadığı için, form düzeyi yüklenemedi."; + Text[ hi-IN ] = "आवशà¥à¤¯à¤• IO-सेवों (stardiv.uno.io.*) को पà¥à¤°à¤¾à¤°à¤‚ठनहीं करने के कारण फ़ॉरà¥à¤® का परत को लोड नहीं कर सकते है "; + Text[ ar ] = "لم يتم تØميل طبقة الاستمارة، إذ تعذر إنشاء خدمات IO اللازمة (stardiv.uno.io.*)"; + Text[ he ] = "â€®×œ× × ×™×ª×Ÿ להפעיל ×ת שירתי הקלט\\פלט ×”× ×“×¨×©×™× (stardiv.uno.io.*) ולכן רובד ×”×˜×¤×¡×™× ×œ× × ×˜×¢×Ÿ.‬"; + }; + String (ERRCODE_SVX_FORMS_NOIOSERVICES | ERRCODE_CLASS_WRITE) & ERRCODE_RES_MASK + { + Text [ de ] = "Die Formular-Schicht wurden nicht geschrieben, da notwendige IO-Services (stardiv.uno.io.*) nicht instantiiert werden konnten"; + Text [ en-US ] = "The form layer wasn't written as the required IO services (stardiv.uno.io.*) could not be instantiated"; + Text[ pt ] = "ImpossÃvel escrever a camada do formulário: foi impossÃvel instanciar os serviços IO (stardiv.uno.io.*) necessários."; + Text[ ru ] = "Ðе запиÑан Ñлой формы, так как не удалоÑÑŒ Ñоздать ÑкземплÑÑ€ Ñлужбы IO (stardiv.uno.io.*)."; + Text[ el ] = "Δεν φοÏτώθηκε η στÏώση της φόÏμας, επειδή δεν ήταν δυνατόν να γίνει ενημÎÏωση κάποιων απαιτουμÎνων υπηÏεσιών εισόδου - εξόδου (stardiv.uno.io.*)."; + Text[ nl ] = "Formulierniveau is niet geschreven omdat noodzakelijke io-services (stardiv.uno.io.*) niet kunnen worden geïnitieerd."; + Text[ fr ] = "La couche de formulaire n'a pas été écrite : impossible d'instancier les services IO (stardiv.uno.io.*) requis."; + Text[ es ] = "No se pudo escribir la capa de formulario porque no se pudieron instanciar servicios IO necesarios (stardiv.uno.io.*)"; + Text[ fi ] = "Lomakekerrosta ei kirjoitettu, koska vaadittujen IO-palveluiden (stardiv.uno.io.*) käyttö ei onnistunut"; + Text[ ca ] = "La capa del formulari no estava escrita quan no s'han pogut instanciar els serveis IO (stardiv.uno.io.*) necessaris"; + Text[ it ] = "Lo strato del formulario non è stato scritto perché non non è stato possibile creare i servizi IO (stardiv.uno.io.*) necessari."; + Text[ sk ] = "Vrstva formulára nebola zapÃsaná, pretože nie je možné vytvoriÅ¥ požadované IO služby (stardiv.uno.io.*)."; + Text[ da ] = "Formularlaget blev ikke skrevet, fordi det ikke var muligt at instantiere den krævede IO-service (stardiv.uno.io.*)."; + Text[ sv ] = "Formulärskiktet skrevs inte eftersom nödvändig IO-service (stardiv.uno.io.*) inte kunde instantieras"; + Text[ pl ] = "Warstwa formularza nie zostaÅ‚a zapisana, ponieważ nie można utworzyć instancji wymaganych usÅ‚ug we-wy (stardiv.uno.io.*)"; + Text[ pt-BR ] = "Não foi possÃvel gravar a camada do formulário pois não foi possÃvel instanciar os serviços IO (stardiv.uno.io.*) necessários."; + Text[ th ] = "ไม่สามารถเขียนระดับขà¸à¸‡à¹à¸šà¸šà¸Ÿà¸à¸£à¹Œà¸¡à¹€à¸›à¹‡à¸™ IO services (stardiv.uno.io.*) à¸à¸¢à¹ˆà¸²à¸‡à¸—ี่ต้à¸à¸‡à¸à¸²à¸£à¹„ม่สามารถถูà¸à¹à¸ªà¸”งให้เห็นตัวà¸à¸¢à¹ˆà¸²à¸‡"; + Text[ ja ] = "IOサービス(stardiv.uno.io.*)ãŒã‚¤ãƒ³ã‚¹ãƒˆãƒ¼ãƒ«ã§ããªã‹ã£ãŸãŸã‚ã€ãƒ•ã‚©ãƒ¼ãƒ 層ã¯æ›¸ãã“ã‚ã¾ã›ã‚“ã§ã—ãŸã€‚"; + Text[ ko ] = "필요한 IO 서비스(stardiv.uno.io.*)ì˜ ì¸ìŠ¤í„´ìŠ¤ë¥¼ ìƒì„±í•˜ì§€ 못했으므로 ì–‘ì‹ ê³„ì¸µì´ ìž‘ì„±ë˜ì§€ 않았습니다."; + Text[ zh-CN ] = "å› ä¸ºæ— æ³•å®‰è£…éœ€è¦çš„ IO æœåŠ¡(stardiv.uno.io.*)，所以ä¸èƒ½å†™å…¥è¡¨å•åˆ†å±‚ä¿¡æ¯"; + Text[ zh-TW ] = "å› ç‚ºæ²’æœ‰å®‰è£å¿…è¦çš„ IO æœå‹™(stardiv.uno.io.*)而無法寫入表單層次。"; + Text[ tr ] = "Gerekli IO hizmetleri (stardiv.uno.io.*) baÅŸlatılamadığı için, form düzeyi yazılamadı."; + Text[ hi-IN ] = "आवशà¥à¤¯à¤• IO-सवों (stardiv.uno.io.*) को पà¥à¤°à¤¾à¤°à¤‚ठनहीं करने के कारण फ़ॉरà¥à¤® का परत को लिख नहीं सकते है"; + Text[ ar ] = "لم يتم كتابة طبقة الاستمارة، إذ تعذر إنشاء خدمات IO اللازمة (stardiv.uno.io.*)"; + Text[ he ] = "â€®×œ× × ×™×ª×Ÿ להפעיל ×ת שירתי הקלט\\פלט ×”× ×“×¨×©×™× (stardiv.uno.io.*) ולכן רובד ×”×˜×¤×¡×™× ×œ× × ×›×ª×‘.‬"; + }; + String (ERRCODE_SVX_FORMS_READWRITEFAILED | ERRCODE_CLASS_READ) & ERRCODE_RES_MASK + { + Text [ de ] = "Beim Lesen der Formular-Controls trat ein Fehler auf. Die Formular-Schicht wurde nicht geladen"; + Text [ en-US ] = "An error occurred while reading the form controls. The form layer has not been loaded"; + Text[ pt ] = "Ocorreu um erro na leitura dos controlos do formulário. Foi impossÃvel carregar a camada do formulário."; + Text[ ru ] = "Ошибка Ñ‡Ñ‚ÐµÐ½Ð¸Ñ Ñлементов ÑƒÐ¿Ñ€Ð°Ð²Ð»ÐµÐ½Ð¸Ñ Ñ„Ð¾Ñ€Ð¼Ñ‹. Ðе загружен Ñлой формы"; + Text[ el ] = "Κατά την ανάγνωση των στοιχείων ελÎγχου της φόÏμας παÏουσιάστηκε Îνα σφάλμα. Η στÏώση της φόÏμας δεν φοÏτώθηκε."; + Text[ nl ] = "Fout bij lezen van formulier-controls. Formulierniveau is niet geladen."; + Text[ fr ] = "Une erreur est survenue lors de la lecture des contrôles de formulaire. La couche de formulaire n'a pas été chargée."; + Text[ es ] = "Ha ocurrido un error al leer los controles de formulario. No se cargó la capa de formulario."; + Text[ fi ] = "Lomakkeen ohjausobjekteja luettaessa ilmeni virhe. Lomakekerrosta ei ole ladattu"; + Text[ ca ] = "Hi ha hagut un error en llegir els controls del formulari. No s'ha pogut carregar la capa del formulari"; + Text[ it ] = "Si è verificato un errore nella lettura del formulario Controls. Lo strato del formulario non è stato caricato"; + Text[ sk ] = "Nastala chyba pri naÄÃtavanà formulárových prvkov. Vrstva formulára nebola naÄÃtaná."; + Text[ da ] = "Der opstod en fejl under læsning af formular-kontrolelementerne. Formularlaget blev ikke indlæst."; + Text[ sv ] = "Det uppstod ett fel vid läsning av formulär-controls. Formulärskiktet laddades inte"; + Text[ pl ] = "WystÄ…piÅ‚ bÅ‚Ä…d podczas odczytu formantów formularza. Warstwa formularza nie zostaÅ‚a zaÅ‚adowana"; + Text[ pt-BR ] = "Ocorreu um erro na leitura dos controles do formulário. Não foi possÃvel carregar a camada do formulário."; + Text[ th ] = "เà¸à¸´à¸”ความผิดพลาดขณะà¸à¹ˆà¸²à¸™à¸•à¸±à¸§à¸„วบคุมà¹à¸šà¸šà¸Ÿà¸à¸£à¹Œà¸¡ ระดับขà¸à¸‡à¹à¸šà¸šà¸Ÿà¸à¸£à¹Œà¸¡à¸¢à¸±à¸‡à¹„ม่ได้ถูà¸à¹‚หลด"; + Text[ ja ] = "フォーム層ã®èªã¿å–ã‚Šä¸ã«ã‚¨ãƒ©ãƒ¼ç™ºç”Ÿã€‚ã“ã®ãƒ•ã‚©ãƒ¼ãƒ 層ã¯èªã¿è¾¼ã¾ã‚Œã¦ã„ã¾ã›ã‚“。"; + Text[ ko ] = "ì–‘ì‹ ì»¨íŠ¸ë¡¤ì„ ì½ì„ ë•Œ 오류가 ë°œìƒí–ˆìŠµë‹ˆë‹¤. ì–‘ì‹ ê³„ì¸µì´ ë¡œë“œë˜ì§€ 않았습니다."; + Text[ zh-CN ] = "在读å–表å•æŽ§åˆ¶åŒºæ—¶å‘ç”Ÿä¸€ä¸ªé”™è¯¯ã€‚æ— æ³•è£…å…¥è¡¨å•åˆ†å±‚ä¿¡æ¯ã€‚"; + Text[ zh-TW ] = "在讀å–è¡¨å–®æŽ§åˆ¶é …æ™‚ç™¼ç”ŸéŒ¯èª¤ã€‚ç„¡æ³•è¼‰å…¥è¡¨å–®å±¤æ¬¡ã€‚"; + Text[ tr ] = "Form komut öğeleri okunurken bir hata oluÅŸtu. Form düzeyi yüklenemedi."; + Text[ hi-IN ] = "फ़ॉरà¥à¤® नियंतà¥à¤°à¤£à¥‹à¤‚ को पढ़ने के समय गलती घटित हà¥à¤† । फ़ॉरà¥à¤® का परत को लोड़ नहीं कर सकते है"; + Text[ ar ] = "Øدث خطأ أثناء قراءة عناصر تØكم الاستمارة. لم يتم تØميل طبقة الاستمارة"; + Text[ he ] = "‮×רעה שגי××” בעת קרי×ת פקדי ×”×˜×¤×¡×™× ×•×œ×›×Ÿ רובד ×”×˜×¤×¡×™× ×œ× × ×˜×¢×Ÿ.‬"; + }; + String (ERRCODE_SVX_FORMS_READWRITEFAILED | ERRCODE_CLASS_WRITE) & ERRCODE_RES_MASK + { + Text [ de ] = "Beim Schreiben der Formular-Controls trat ein Fehler auf. Die Formular-Schicht wurde nicht gespeichert"; + Text [ en-US ] = "An error occurred while writing the form controls. The form layer has not been saved"; + Text[ pt ] = "Ocorreu um erro ao escrever os controlos do formulário. Foi impossÃvel guardar a camada do formulário."; + Text[ ru ] = "Ошибка запиÑи Ñлементов ÑƒÐ¿Ñ€Ð°Ð²Ð»ÐµÐ½Ð¸Ñ Ñ„Ð¾Ñ€Ð¼Ñ‹. Ðе Ñохранен Ñлой формы"; + Text[ el ] = "Κατά την εγγÏαφή των στοιχείων ελÎγχου της φόÏμας παÏουσιάστηκε Îνα σφάλμα. Η στÏώση της φόÏμας δεν φοÏτώθηκε."; + Text[ nl ] = "Fout bij schrijven van formulier-controls. Formulierniveau is niet opgeslagen."; + Text[ fr ] = "Une erreur est survenue lors de l'écriture des contrôles de formulaire. La couche de formulaire n'a pas été enregistrée."; + Text[ es ] = "Ha ocurrido un error al escribir los controles de formulario. No se guardó la capa de formulario."; + Text[ fi ] = "Lomakkeen ohjausobjekteja kirjoitettaessa ilmeni virhe. Lomakekerrosta ei ole tallennettu"; + Text[ ca ] = "Hi ha hagut un error en llegir els controls del formulari. No s'ha pogut desar la capa del formulari"; + Text[ it ] = "Si è verificato un errore durante la compilazione del formulario controls. Lo strato del formulario non è stato salvato."; + Text[ sk ] = "Nastala chyba pri zapisovanà formulárových prvkov. Vrstva formulára nebola uložená."; + Text[ da ] = "Der opstod en fejl under skrivning af formular-kontrolelementerne. Formularlaget blev ikke gemt."; + Text[ sv ] = "Det uppstod ett fel vid skrivning av formulär-controls. Formulärskiktet sparades inte"; + Text[ pl ] = "WystÄ…piÅ‚ bÅ‚Ä…d podczas zapisu formantów formularza. Warstwa formularza nie zostaÅ‚a zapisana"; + Text[ pt-BR ] = "Ocorreu um erro ao gravar os controles do formulário. Não foi possÃvel salvar a camada do formulário."; + Text[ th ] = "เà¸à¸´à¸”ความผิดพลาดขณะเขียนตัวควบคุมà¹à¸šà¸šà¸Ÿà¸à¸£à¹Œà¸¡ ระดับขà¸à¸‡à¹à¸šà¸šà¸Ÿà¸à¸£à¹Œà¸¡à¸¢à¸±à¸‡à¹„ม่ได้ถูà¸à¸šà¸±à¸™à¸—ึà¸"; + Text[ ja ] = "フォーム層ã®æ›¸ãè¾¼ã¿ä¸ã«ã‚¨ãƒ©ãƒ¼ç™ºç”Ÿã€‚フォーム層ã¯ä¿å˜ã•ã‚Œã¦ã„ã¾ã›ã‚“。"; + Text[ ko ] = "ì–‘ì‹ ì»¨íŠ¸ë¡¤ì„ ê¸°ë¡í• ë•Œ 오류가 ë°œìƒí–ˆìŠµë‹ˆë‹¤. ì–‘ì‹ ê³„ì¸µì´ ì €ìž¥ë˜ì§€ 않았습니다."; + Text[ zh-CN ] = "在写入表å•æŽ§åˆ¶åŒºæ—¶å‘ç”Ÿä¸€ä¸ªé”™è¯¯ã€‚æ— æ³•å˜ç›˜è¡¨å•åˆ†å±‚ä¿¡æ¯ã€‚"; + Text[ zh-TW ] = "åœ¨å¯«å…¥è¡¨å–®æŽ§åˆ¶é …æ™‚ç™¼ç”Ÿä¸€å€‹éŒ¯èª¤ã€‚æ²’æœ‰å„²å˜è¡¨å–®å±¤æ¬¡ã€‚"; + Text[ tr ] = "Form komut öğeleri yazılırken bir hata oluÅŸtu. Form düzeyi kaydedilemedi."; + Text[ hi-IN ] = "फ़ॉरà¥à¤® नियंतà¥à¤°à¤£à¥‹à¤‚ को लिखने के समय गलती घटित हà¥à¤† । फ़ॉरà¥à¤® का परत को संचित नहीं कर सकते है"; + Text[ ar ] = "Øدث خطأ أثناء كتابة عناصر تØكم الاستمارة. لم يتم ØÙظ طبقة الاستمارة"; + Text[ he ] = "‮×רעה שגי××” בעת כתיבת פקדי ×”×˜×¤×¡×™× ×•×œ×›×Ÿ רובד ×”×˜×¤×¡×™× ×œ× × ×©×ž×¨.‬"; + }; + String (ERRCODE_SVX_BULLETITEM_NOBULLET | ERRCODE_CLASS_READ) & ERRCODE_RES_MASK + { + Text [ de ] = "Beim Lesen eines Bullets trat ein Fehler auf. Es konnten nicht alle Bullets geladen werden"; + Text [ en-US ] = "An error occurred while reading one of the bullets. Not all of the bullets were loaded."; + Text[ pt ] = "Surgiu um erro durante a leitura de uma marca. Foi impossÃvel carregá-las todas."; + Text[ ru ] = "Ошибка Ñ‡Ñ‚ÐµÐ½Ð¸Ñ Ð¼Ð°Ñ€ÐºÐµÑ€Ð°. Ðе удаетÑÑ Ð·Ð°Ð³Ñ€ÑƒÐ·Ð¸Ñ‚ÑŒ вÑе маркеры."; + Text[ el ] = "ΠαÏουσιάστηκε σφάλμα κατά την ανάγνωση μιας από τις κουκίδες. Δεν φοÏτώθηκαν όλες οι κουκίδες."; + Text[ nl ] = "Fout bij laden van opsommingsteken. Niet alle tekens kunnen worden geladen."; + Text[ fr ] = "Une erreur s'est produite pendant la lecture d'une puce. Certaines puces n'ont pas pu être chargées."; + Text[ es ] = "Ha ocurrido un error al leer una viñeta. No se pudieron cargar todas las viñetas."; + Text[ fi ] = "Luettelomerkkiä luettaessa on ilmennyt virhe. Kaikkia luettelomerkkejä ei ladattu."; + Text[ ca ] = "Hi ha hagut un error en llegir un pic. No s'han pogut carregar tots el pics."; + Text[ it ] = "Durante la lettura di un bullet si è verificato un errore. Non è stato possibile caricare tutti i bullet."; + Text[ sk ] = "Nastala chyba pri naÄÃtavanà jednej z odrážok. Nie vÅ¡etky odrážky boli naÄÃtané."; + Text[ da ] = "Der opstod en fejl ved læsning af et punkttegn. Det var ikke muligt at indlæse alle punkttegn."; + Text[ sv ] = "Det uppstod ett fel vid läsning av en punkt. Det gick inte att ladda alla punkter"; + Text[ pl ] = "WystÄ…piÅ‚ bÅ‚Ä…d podczas odczytu wypunktowania. Nie można zaÅ‚adować wszystkich wypunktowaÅ„."; + Text[ pt-BR ] = "Ocorreu um erro durante a leitura de uma das marcas. Não foi possÃvel carregar todas elas."; + Text[ th ] = "เà¸à¸´à¸”ความผิดพลาดขณะà¸à¹ˆà¸²à¸™à¸«à¸™à¸¶à¹ˆà¸‡à¹ƒà¸™à¸ªà¸±à¸à¸¥à¸±à¸à¸©à¸“์à¹à¸ªà¸”งหัวข้à¸à¸¢à¹ˆà¸à¸¢ ไม่ทั้งหมดขà¸à¸‡à¸ªà¸±à¸à¸¥à¸±à¸à¸©à¸“์à¹à¸ªà¸”งหัวข้à¸à¸¢à¹ˆà¸à¸¢à¸–ูà¸à¹‚หลด"; + Text[ ja ] = "箇æ¡æ›¸ãã‚’èªã¿è¾¼ã‚€ã¨ãã«ã‚¨ãƒ©ãƒ¼ãŒç™ºç”Ÿã—ã¾ã—ãŸã€‚ã™ã¹ã¦ã®ç®‡æ¡æ›¸ãã¯èªã¿è¾¼ã‚ã¾ã›ã‚“ã§ã—ãŸã€‚"; + Text[ ko ] = "글머리 기호를 ì½ëŠ” 중 오류가 ë°œìƒí–ˆìŠµë‹ˆë‹¤. 글머리 기호를 ëª¨ë‘ ë¡œë“œí•˜ì§€ 못했습니다."; + Text[ zh-CN ] = "在读å–一个项目符å·æ—¶å‘ç”Ÿé”™è¯¯ã€‚æ— æ³•è£…å…¥å…¨éƒ¨çš„é¡¹ç›®ç¬¦å·ã€‚"; + Text[ zh-TW ] = "在讀å–ä¸€å€‹é …ç›®ç¬¦è™Ÿæ™‚ç™¼ç”ŸéŒ¯èª¤ã€‚ç„¡æ³•è¼‰å…¥æ‰€æœ‰çš„é …ç›®ç¬¦è™Ÿã€‚"; + Text[ tr ] = "Madde iÅŸaretleri okunurken hata oluÅŸtu. Bu nedenle tüm madde iÅŸaretleri yüklenemedi."; + Text[ hi-IN ] = "किसी à¤à¤• बà¥à¤²à¥à¤²à¥‡à¤Ÿà¥à¤¸ को पढ़ने के समय गलती घटित हà¥à¤† । सब बà¥à¤²à¥à¤²à¥‡à¤Ÿà¥‹à¤‚ को लोड़ नहीं कर सकते है ।"; + Text[ ar ] = "Øدث خطأ أثناء قراءة Ø¥Øدى علامات التعداد. تعذر تØميل كل علامات التعداد."; + Text[ he ] = "‮×רעה שגי××” בעת קרי×ת ×חד ×ž× ×§×•×“×•×ª הכותרה (bullets). ×œ× ×›×œ ×”× ×§×•×“×•×ª × ×˜×¢× ×•.‬"; + }; + + + String ERRCODE_SVX_VBASIC_STORAGE_EXIST & ERRCODE_RES_MASK + { + Text [ de ] = "Der im Dokument enthaltene originale VBA Basic Code wird nicht gespeichert." ; + Text [ en-US ] = "The original VBA Basic Code contained in the document will not be saved."; + Text[ pt ] = "O código VBA original contido no documento não será guardado."; + Text[ ru ] = "СодержащийÑÑ Ð² документе иÑходный код VBA Basic Ñохранен не будет."; + Text[ el ] = "Δεν θα γίνει αποθήκευση του Î±Ï…Î¸ÎµÎ½Ï„Î¹ÎºÎ¿Ï VBA basic code που πεÏιÎχεται στο ÎγγÏαφο."; + Text[ nl ] = "De originele VBA Basic-code in dit document wordt niet opgeslagen."; + Text[ fr ] = "Le code VBA basic d'origine contenu dans le document ne sera pas enregistré."; + Text[ es ] = "No se guardará el Basic Code VBA incluido en el documento."; + Text[ fi ] = "Asiakirjan alkuperäistä VBA-peruskoodia ei tallenneta."; + Text[ ca ] = "No es desarà el Basic Code VBA inclós en el document."; + Text[ it ] = "Non è possibile salvare il codice VBA Basic contenuto nel documeto."; + Text[ sk ] = "Kód VBA Basic pôvodne obsiahnutý v dokumente nebude uložený."; + Text[ da ] = "Den originale VBA Basic Code, som er indeholdt i dokumentet, gemmes ikke."; + Text[ sv ] = "Original-VBA-Basic-koden som finns i dokumentet sparas inte."; + Text[ pl ] = "Zawarty w dokumencie oryginalny kod VBA nie zostanie zapisany."; + Text[ pt-BR ] = "O código BASIC VBA original contido no documento não será salvo."; + Text[ th ] = "มีต้นฉบับ VBA Basic Code ในเà¸à¸à¸ªà¸²à¸£à¸—ี่จะไม่ถูà¸à¸šà¸±à¸™à¸—ึà¸"; + Text[ ja ] = "ドã‚ュメントã«å«ã¾ã‚Œã¦ã„るオリジナル㮠VBA Basic Code ã¯ä¿å˜ã•ã‚Œã¾ã›ã‚“。"; + Text[ ko ] = "ë¬¸ì„œì— í¬í•¨ë˜ì–´ 있는 ì›ëž˜ VBA Basic Code는 ì €ìž¥ë˜ì§€ 않습니다."; + Text[ zh-CN ] = "ä¸ä¼šå˜ç›˜æ–‡æ¡£ä¸å«æœ‰çš„æºVBA Basic Code。"; + Text[ zh-TW ] = "文件å«æœ‰çš„æº VBA basic 碼ä¸æœƒè¢«å„²å˜ã€‚"; + Text[ tr ] = "Belgede bulunan ilk VBA basic kodu kaydedilmeyecek."; + Text[ hi-IN ] = "लेखपतà¥à¤° का यथारà¥à¤¥ VBA Basic Code को संचित नहीं कर सकते है ।"; + Text[ ar ] = "لن يتم ØÙظ الـ VBA Basic Codeالأصلي الموجود ÙÙŠ المستند."; + Text[ he ] = "‮קוד הבייסיק ×” VBA המקורי שבמסמך ×œ× ×™×©×ž×¨.‬"; + }; +}; + // ********************************************************************** EOF diff --git a/binfilter/bf_svx/source/items/svx_svxfont.cxx b/binfilter/bf_svx/source/items/svx_svxfont.cxx new file mode 100644 index 000000000000..dd9e4796edea --- /dev/null +++ b/binfilter/bf_svx/source/items/svx_svxfont.cxx @@ -0,0 +1,429 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +// include ---------------------------------------------------------------- + +#include <vcl/print.hxx> +#include <unotools/charclass.hxx> +#include <unolingu.hxx> +#ifdef _MSC_VER +#pragma hdrstop +#endif + +#define ITEMID_ESCAPEMENT 0 + +#define _SVX_SVXFONT_CXX + +#include "svxfont.hxx" +namespace binfilter { + +// Minimum: Prozentwert fuers kernen +#define MINKERNPERCENT 5 + +// prop. Groesse der Kleinbuchstaben bei Kapitaelchen +#define KAPITAELCHENPROP 80 + +#ifndef REDUCEDSVXFONT + const sal_Unicode CH_BLANK = sal_Unicode(' '); // ' ' Leerzeichen + static sal_Char __READONLY_DATA sDoubleSpace[] = " "; +#endif + +/************************************************************************* + * class SvxFont + *************************************************************************/ + +/*N*/ SvxFont::SvxFont() +/*N*/ { +/*N*/ nKern = nEsc = 0; +/*N*/ nPropr = 100; +/*N*/ eCaseMap = SVX_CASEMAP_NOT_MAPPED; +/*N*/ eLang = LANGUAGE_SYSTEM; +/*N*/ } + +/*N*/ SvxFont::SvxFont( const Font &rFont ) +/*N*/ : Font( rFont ) +/*N*/ { +/*N*/ nKern = nEsc = 0; +/*N*/ nPropr = 100; +/*N*/ eCaseMap = SVX_CASEMAP_NOT_MAPPED; +/*N*/ eLang = LANGUAGE_SYSTEM; +/*N*/ } + +/************************************************************************* + * class SvxFont: Copy-Ctor + *************************************************************************/ + +/*N*/ SvxFont::SvxFont( const SvxFont &rFont ) +/*N*/ : Font( rFont ) +/*N*/ { +/*N*/ nKern = rFont.GetFixKerning(); +/*N*/ nEsc = rFont.GetEscapement(); +/*N*/ nPropr = rFont.GetPropr(); +/*N*/ eCaseMap = rFont.GetCaseMap(); +/*N*/ eLang = rFont.GetLanguage(); +/*N*/ } + +/************************************************************************* + * static SvxFont::DrawArrow + *************************************************************************/ + + +/************************************************************************* + * SvxFont::CalcCaseMap + *************************************************************************/ + +/*N*/ XubString SvxFont::CalcCaseMap( const XubString &rTxt ) const +/*N*/ { +/*N*/ if( !IsCaseMap() || !rTxt.Len() ) return rTxt; +/*N*/ XubString aTxt( rTxt ); +/*N*/ // Ich muss mir noch die Sprache besorgen +/*N*/ const LanguageType eLng = LANGUAGE_DONTKNOW == eLang +/*N*/ ? LANGUAGE_SYSTEM : eLang; +/*N*/ +/*N*/ CharClass aCharClass( SvxCreateLocale( eLng ) ); +/*N*/ +/*N*/ switch( eCaseMap ) +/*N*/ { +/*N*/ case SVX_CASEMAP_KAPITAELCHEN: +/*N*/ case SVX_CASEMAP_VERSALIEN: +/*N*/ { +/*N*/ aCharClass.toUpper( aTxt ); +/*N*/ break; +/*N*/ } +/*N*/ +/*N*/ case SVX_CASEMAP_GEMEINE: +/*N*/ { +/*?*/ aCharClass.toLower( aTxt ); +/*?*/ break; +/*?*/ } +/*?*/ case SVX_CASEMAP_TITEL: +/*?*/ { +/*?*/ // Jeder Wortbeginn wird gross geschrieben, +/*?*/ // der Rest des Wortes wird unbesehen uebernommen. +/*?*/ // Bug: wenn das Attribut mitten im Wort beginnt. +/*?*/ BOOL bBlank = TRUE; +/*?*/ +/*?*/ for( UINT32 i = 0; i < aTxt.Len(); ++i ) +/*?*/ { +/*?*/ if( sal_Unicode(' ') == aTxt.GetChar(i) || sal_Unicode('\t') == aTxt.GetChar(i) ) +/*?*/ bBlank = TRUE; +/*?*/ else +/*?*/ { +/*?*/ if( bBlank ) +/*?*/ { +/*?*/ String aTemp( aTxt.GetChar( i ) ); +/*?*/ aCharClass.toUpper( aTemp ); +/*?*/ aTxt.Replace( i, 1, aTemp ); +/*?*/ } +/*?*/ bBlank = FALSE; +/*?*/ } +/*?*/ } +/*?*/ break; +/*?*/ } +/*?*/ default: +/*?*/ { +/*?*/ DBG_ASSERT(!this, "SvxFont::CaseMapTxt: unknown casemap"); +/*N*/ break; +/*N*/ } +/*N*/ } +/*N*/ return aTxt; +/*N*/ } + +/************************************************************************* + * Hier beginnen die Methoden, die im Writer nicht benutzt werden koennen, + * deshalb kann man diesen Bereich durch setzen von REDUCEDSVXFONT ausklammern. + *************************************************************************/ +#ifndef REDUCEDSVXFONT + +/************************************************************************* + * class SvxDoCapitals + * die virtuelle Methode Do wird von SvxFont::DoOnCapitals abwechselnd mit + * den "Gross-" und "Kleinbuchstaben"-Teilen aufgerufen. + * Die Ableitungen von SvxDoCapitals erfuellen diese Methode mit Leben. + *************************************************************************/ + +class SvxDoCapitals +{ +protected: + OutputDevice *pOut; + const XubString &rTxt; + const xub_StrLen nIdx; + const xub_StrLen nLen; + +public: + SvxDoCapitals( OutputDevice *pOut, const XubString &rTxt, + const xub_StrLen nIdx, const xub_StrLen nLen ) + : pOut(pOut), rTxt(rTxt), nIdx(nIdx), nLen(nLen) + { } + + + inline OutputDevice *GetOut() { return pOut; } + inline const XubString &GetTxt() const { return rTxt; } + xub_StrLen GetIdx() const { return nIdx; } + xub_StrLen GetLen() const { return nLen; } +}; + + + + +/************************************************************************* + * SvxFont::DoOnCapitals() const + * zerlegt den String in Gross- und Kleinbuchstaben und ruft jeweils die + * Methode SvxDoCapitals::Do( ) auf. + *************************************************************************/ + + +/************************************************************************** + * SvxFont::SetPhysFont() + *************************************************************************/ + +/*N*/ void SvxFont::SetPhysFont( OutputDevice *pOut ) const +/*N*/ { +/*N*/ const Font& rCurrentFont = pOut->GetFont(); +/*N*/ if ( nPropr == 100 ) +/*N*/ { +/*N*/ if ( !rCurrentFont.IsSameInstance( *this ) ) +/*N*/ pOut->SetFont( *this ); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ Font aNewFont( *this ); +/*N*/ Size aSize( aNewFont.GetSize() ); +/*N*/ aNewFont.SetSize( Size( aSize.Width() * nPropr / 100L, +/*N*/ aSize.Height() * nPropr / 100L ) ); +/*N*/ if ( !rCurrentFont.IsSameInstance( aNewFont ) ) +/*N*/ pOut->SetFont( aNewFont ); +/*N*/ } +/*N*/ } + +/************************************************************************* + * SvxFont::ChgPhysFont() + *************************************************************************/ + + +/************************************************************************* + * SvxFont::GetPhysTxtSize() + *************************************************************************/ + + +/*N*/ Size SvxFont::GetPhysTxtSize( const OutputDevice *pOut, const XubString &rTxt ) +/*N*/ { +/*N*/ if ( !IsCaseMap() && !IsKern() ) +/*N*/ return Size( pOut->GetTextWidth( rTxt ), pOut->GetTextHeight() ); +/*N*/ +/*?*/ Size aTxtSize; +/*?*/ aTxtSize.setHeight( pOut->GetTextHeight() ); +/*?*/ if ( !IsCaseMap() ) +/*?*/ aTxtSize.setWidth( pOut->GetTextWidth( rTxt ) ); +/*?*/ else +/*?*/ aTxtSize.setWidth( pOut->GetTextWidth( CalcCaseMap( rTxt ) ) ); +/*?*/ +/*?*/ if( IsKern() && ( rTxt.Len() > 1 ) ) +/*?*/ aTxtSize.Width() += ( ( rTxt.Len()-1 ) * long( nKern ) ); +/*?*/ +/*?*/ return aTxtSize; +/*N*/ } + +/*N*/ Size SvxFont::QuickGetTextSize( const OutputDevice *pOut, const XubString &rTxt, +/*N*/ const USHORT nIdx, const USHORT nLen, sal_Int32* pDXArray ) const +/*N*/ { +/*N*/ if ( !IsCaseMap() && !IsKern() ) +/*N*/ return Size( pOut->GetTextArray( rTxt, pDXArray, nIdx, nLen ), +/*N*/ pOut->GetTextHeight() ); +/*N*/ +/*N*/ Size aTxtSize; +/*N*/ aTxtSize.setHeight( pOut->GetTextHeight() ); +/*N*/ if ( !IsCaseMap() ) +/*N*/ aTxtSize.setWidth( pOut->GetTextArray( rTxt, pDXArray, nIdx, nLen ) ); +/*N*/ else +/*?*/ aTxtSize.setWidth( pOut->GetTextArray( CalcCaseMap( rTxt ), +/*?*/ pDXArray, nIdx, nLen ) ); +/*N*/ +/*N*/ if( IsKern() && ( nLen > 1 ) ) +/*N*/ { +/*N*/ aTxtSize.Width() += ( ( nLen-1 ) * long( nKern ) ); +/*N*/ +/*N*/ if ( pDXArray ) +/*N*/ { +/*N*/ for ( xub_StrLen i = 0; i < nLen; i++ ) +/*N*/ pDXArray[i] += ( (i+1) * long( nKern ) ); +/*N*/ // Der letzte ist um ein nKern zu gross: +/*N*/ pDXArray[nLen-1] -= nKern; +/*N*/ } +/*N*/ } +/*N*/ return aTxtSize; +/*N*/ } + +/************************************************************************* + * SvxFont::GetTxtSize() + *************************************************************************/ + + +/************************************************************************* + * SvxFont::DrawText() + *************************************************************************/ + + +/*N*/ void SvxFont::QuickDrawText( OutputDevice *pOut, +/*N*/ const Point &rPos, const XubString &rTxt, +/*N*/ const xub_StrLen nIdx, const xub_StrLen nLen, const sal_Int32* pDXArray ) const +/*N*/ { +/*N*/ // Font muss ins OutputDevice selektiert sein... +/*N*/ if ( !IsCaseMap() && !IsCapital() && !IsKern() && !IsEsc() ) +/*N*/ { +/*N*/ pOut->DrawTextArray( rPos, rTxt, pDXArray, nIdx, nLen ); +/*N*/ return; +/*N*/ } +/*N*/ +/*?*/ Point aPos( rPos ); +/*?*/ +/*?*/ if ( nEsc ) +/*?*/ { +/*?*/ long nDiff = GetSize().Height(); +/*?*/ nDiff *= nEsc; +/*?*/ nDiff /= 100; +/*?*/ +/*?*/ if ( !IsVertical() ) +/*?*/ aPos.Y() -= nDiff; +/*?*/ else +/*?*/ aPos.X() += nDiff; +/*?*/ } +/*?*/ +/*?*/ if( IsCapital() ) +/*?*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 /*?*/ DBG_ASSERT( !pDXArray, "DrawCapital nicht fuer TextArray!" ); +/*?*/ } +/*?*/ else +/*?*/ { +/*?*/ if ( IsKern() && !pDXArray ) +/*?*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 /*?*/ Size aSize = GetPhysTxtSize( pOut, rTxt, nIdx, nLen ); +/*?*/ } +/*?*/ else +/*?*/ { +/*?*/ if ( !IsCaseMap() ) +/*?*/ pOut->DrawTextArray( aPos, rTxt, pDXArray, nIdx, nLen ); +/*?*/ else +/*?*/ pOut->DrawTextArray( aPos, CalcCaseMap( rTxt ), pDXArray, nIdx, nLen ); +/*?*/ } +/*?*/ } +/*N*/ } + +// ----------------------------------------------------------------------- + + +// ----------------------------------------------------------------------- + +/*N*/ SvxFont& SvxFont::operator=( const Font& rFont ) +/*N*/ { +/*N*/ Font::operator=( rFont ); +/*N*/ return *this; +/*N*/ } + +/*N*/ SvxFont& SvxFont::operator=( const SvxFont& rFont ) +/*N*/ { +/*N*/ Font::operator=( rFont ); +/*N*/ eLang = rFont.eLang; +/*N*/ eCaseMap = rFont.eCaseMap; +/*N*/ nEsc = rFont.nEsc; +/*N*/ nPropr = rFont.nPropr; +/*N*/ nKern = rFont.nKern; +/*N*/ return *this; +/*N*/ } + + +/************************************************************************* + * class SvxDoGetCapitalSize + * wird von SvxFont::GetCapitalSize() zur Berechnung der TxtSize bei + * eingestellten Kapitaelchen benutzt. + *************************************************************************/ + +class SvxDoGetCapitalSize : public SvxDoCapitals +{ +protected: + SvxFont* pFont; + Size aTxtSize; + short nKern; +public: + SvxDoGetCapitalSize( SvxFont *pFnt, const OutputDevice *pOut, + const XubString &rTxt, const xub_StrLen nIdx, + const xub_StrLen nLen, const short nKrn ) + : SvxDoCapitals( (OutputDevice*)pOut, rTxt, nIdx, nLen ), + pFont( pFnt ), + nKern( nKrn ) + { } + + + inline const Size &GetSize() const { return aTxtSize; }; +}; + + +/************************************************************************* + * SvxFont::GetCapitalSize() + * berechnet TxtSize, wenn Kapitaelchen eingestellt sind. + *************************************************************************/ + + +/************************************************************************* + * class SvxDoDrawCapital + * wird von SvxFont::DrawCapital zur Ausgabe von Kapitaelchen benutzt. + *************************************************************************/ + +class SvxDoDrawCapital : public SvxDoCapitals +{ +protected: + SvxFont *pFont; + Point aPos; + Point aSpacePos; + short nKern; +public: + SvxDoDrawCapital( SvxFont *pFnt, OutputDevice *pOut, const XubString &rTxt, + const xub_StrLen nIdx, const xub_StrLen nLen, + const Point &rPos, const short nKrn ) + : SvxDoCapitals( pOut, rTxt, nIdx, nLen ), + pFont( pFnt ), + aPos( rPos ), + aSpacePos( rPos ), + nKern( nKrn ) + { } +}; + + + + +/************************************************************************* + * SvxFont::DrawCapital() gibt Kapitaelchen aus. + *************************************************************************/ + + +#endif // !REDUCEDSVXFONT + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_svx/source/items/svx_svxitems.src b/binfilter/bf_svx/source/items/svx_svxitems.src new file mode 100644 index 000000000000..4e59ac678fd0 --- /dev/null +++ b/binfilter/bf_svx/source/items/svx_svxitems.src @@ -0,0 +1,501 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ +#define NO_LOCALIZE_EXPORT + // include ------------------------------------------------------------------ +#include "svxitems.hrc" + // pragma ------------------------------------------------------------------- + + // Value-Strings ------------------------------------------------------------ +String RID_SVXITEMS_TRUE +{ + Text [ de ] = "Wahr" ; + Text [ en-US ] = "True" ; + Text [ x-comment ] = " "; + Text[ pt ] = "Verdadeiro"; + Text[ ru ] = "ИСТИÐÐ"; + Text[ el ] = "Αληθής"; + Text[ nl ] = "Waar"; + Text[ fr ] = "Vrai"; + Text[ es ] = "Verdadero"; + Text[ fi ] = "Tosi"; + Text[ ca ] = "Cert"; + Text[ it ] = "Vero"; + Text[ sk ] = "Pravda"; + Text[ da ] = "Sand"; + Text[ sv ] = "Sant"; + Text[ pl ] = "Prawda"; + Text[ pt-BR ] = "Verdadeiro"; + Text[ th ] = "จริง"; + Text[ ja ] = "真(TRUE)"; + Text[ ko ] = "TRUE"; + Text[ zh-CN ] = "真"; + Text[ zh-TW ] = "真"; + Text[ tr ] = "DoÄŸru"; + Text[ hi-IN ] = "सतà¥à¤¯"; + Text[ ar ] = "Øقيقي"; + Text[ he ] = "‮×מת‬"; +}; +String RID_SVXITEMS_FALSE +{ + Text [ de ] = "Falsch" ; + Text [ en-US ] = "False" ; + Text [ x-comment ] = " "; + Text[ pt ] = "Falso"; + Text[ ru ] = "ЛОЖЬ"; + Text[ el ] = "Λάθος"; + Text[ nl ] = "Fout"; + Text[ fr ] = "Faux"; + Text[ es ] = "Falso"; + Text[ fi ] = "Epätosi"; + Text[ ca ] = "Fals"; + Text[ it ] = "Falso"; + Text[ sk ] = "Nepravda"; + Text[ da ] = "Falsk"; + Text[ sv ] = "Falsk"; + Text[ pl ] = "FAÅSZ"; + Text[ pt-BR ] = "Falso"; + Text[ th ] = "เท็จ"; + Text[ ja ] = "å½(FALSE)"; + Text[ ko ] = "FALSE"; + Text[ zh-CN ] = "错误"; + Text[ zh-TW ] = "錯誤"; + Text[ tr ] = "Yanlış"; + Text[ hi-IN ] = "असतà¥à¤¯"; + Text[ ar ] = "خطأ"; + Text[ he ] = "‮שקר‬"; +}; + // Extras ------------------------------------------------------------------- + // SvxSearchItem ------------------------------------------------------------ + // Kommando + + // Vorlagen + + // Zellen-Typ + + // Applikation + + // enum SvxBreak ------------------------------------------------------------ + + // enum SvxShadowLocation --------------------------------------------------- + + // enum BrushStyle ---------------------------------------------------------- + + // enum ColorName ----------------------------------------------------------- + + // enum FontWeight ------------------------------------------------------- + + // enum FontUnderline ---------------------------------------------------- + // enum FontStrikeout ---------------------------------------------------- + // enum CASEMAP ---------------------------------------------------------- + // enum ESCAPEMENT ------------------------------------------------------- + // enum SvxAdjust ----------------------------------------------------------- + // DB-Server-Connect -------------------------------------------------------- + // enum SvxTabAdjust -------------------------------------------------------- + // Typ-Namen der SlotIds ---------------------------------------------------- + // GetValueText von BoolItems + +String RID_SVXITEMS_PAGE_USAGE_LEFT +{ + Text [ de ] = "Links" ; + Text [ en-US ] = "Left" ; + Text [ x-comment ] = " "; + Text[ pt ] = "Esquerda"; + Text[ ru ] = "Слева"; + Text[ el ] = "ΑÏιστεÏά"; + Text[ nl ] = "Links"; + Text[ fr ] = "Gauche"; + Text[ es ] = "Izquierda"; + Text[ fi ] = "Vasen"; + Text[ ca ] = "Esquerra"; + Text[ it ] = "Sinistra"; + Text[ sk ] = "Vľavo"; + Text[ da ] = "Venstre"; + Text[ sv ] = "Vänster"; + Text[ pl ] = "Z lewej"; + Text[ pt-BR ] = "Esquerda"; + Text[ th ] = "ซ้าย"; + Text[ ja ] = "å·¦"; + Text[ ko ] = "왼쪽"; + Text[ zh-CN ] = "å‘å·¦"; + Text[ zh-TW ] = "å‘å·¦"; + Text[ tr ] = "Sol"; + Text[ hi-IN ] = "बायाà¤"; + Text[ ar ] = "يسار"; + Text[ he ] = "‮שמ×ל‬"; +}; +String RID_SVXITEMS_PAGE_USAGE_RIGHT +{ + Text [ de ] = "Rechts" ; + Text [ en-US ] = "Right" ; + Text [ x-comment ] = " "; + Text[ pt ] = "Direita"; + Text[ ru ] = "Справа"; + Text[ el ] = "Δεξιά"; + Text[ nl ] = "Rechts"; + Text[ fr ] = "Droite"; + Text[ es ] = "Derecha"; + Text[ fi ] = "Oikea"; + Text[ ca ] = "Dreta"; + Text[ it ] = "Destra"; + Text[ sk ] = "Vpravo"; + Text[ da ] = "Højre"; + Text[ sv ] = "Höger"; + Text[ pl ] = "Z prawej"; + Text[ pt-BR ] = "Direita"; + Text[ th ] = "ขวา"; + Text[ ja ] = "å³"; + Text[ ko ] = "오른쪽"; + Text[ zh-CN ] = "å‘å³"; + Text[ zh-TW ] = "å‘å³"; + Text[ tr ] = "SaÄŸ"; + Text[ hi-IN ] = "दाहिना"; + Text[ ar ] = "يمين"; + Text[ he ] = "‮ימין‬"; +}; +String RID_SVXITEMS_PAGE_USAGE_ALL +{ + Text [ de ] = "Alle" ; + Text [ en-US ] = "All" ; + Text [ x-comment ] = " "; + Text[ pt ] = "Tudo"; + Text[ ru ] = "Ð’Ñе"; + Text[ el ] = "Όλα"; + Text[ nl ] = "Alle"; + Text[ fr ] = "Toutes les pages"; + Text[ es ] = "Todo"; + Text[ fi ] = "Kaikki"; + Text[ ca ] = "Tot"; + Text[ it ] = "Tutto"; + Text[ sk ] = "VÅ¡etko"; + Text[ da ] = "Alle"; + Text[ sv ] = "Alla"; + Text[ pl ] = "Wszystko"; + Text[ pt-BR ] = "Tudo"; + Text[ th ] = "ทั้งหมด"; + Text[ ja ] = "ã™ã¹ã¦"; + Text[ ko ] = "모ë‘"; + Text[ zh-CN ] = "全部"; + Text[ zh-TW ] = "全部"; + Text[ tr ] = "Tümü"; + Text[ hi-IN ] = "सब"; + Text[ ar ] = "الكل"; + Text[ he ] = "‮הכל‬"; +}; +String RID_SVXITEMS_PAGE_USAGE_MIRROR +{ + Text [ de ] = "Gespiegelt" ; + Text [ en-US ] = "Mirrored" ; + Text [ x-comment ] = " "; + Text[ pt ] = "Invertido"; + Text[ ru ] = "Отраженные"; + Text[ el ] = "Με κατοπτÏισμό"; + Text[ nl ] = "Gespiegeld"; + Text[ fr ] = "Pages en vis-à -vis"; + Text[ es ] = "Reflejado"; + Text[ fi ] = "Peilattu"; + Text[ ca ] = "Replicat"; + Text[ it ] = "Rispecchiato"; + Text[ sk ] = "Zrkadlené"; + Text[ da ] = "Spejlvendt"; + Text[ sv ] = "Spegelvänt"; + Text[ pl ] = "Odbicie lustrzane"; + Text[ pt-BR ] = "Refletido"; + Text[ th ] = "ส่à¸à¸‡"; + Text[ ja ] = "å·¦å³å¯¾ç§°"; + Text[ ko ] = "대ì¹"; + Text[ zh-CN ] = "翻转的"; + Text[ zh-TW ] = "翻轉的"; + Text[ tr ] = "Yansıma"; + Text[ hi-IN ] = "दरà¥à¤ªà¤£ किया हà¥à¤†"; + Text[ ar ] = "منعكس"; + Text[ he ] = "‮משוכפל‬"; +}; + + + + +String RID_SVXITEMS_TWOLINES_OFF +{ + Text [ de ] = "Doppelzeilig aus"; + Text [ en-US ] = "Double-lined off"; + Text[ pt ] = "Desactivar linhas duplas"; + Text[ ru ] = "Выкл. двухÑтрочный"; + Text[ el ] = "ΔίγÏαμμη γÏαφή απενεÏγοποιημÎνη"; + Text[ nl ] = "Tweeregelig uit"; + Text[ fr ] = "'Deux lignes en une' désactivé"; + Text[ es ] = "Desactivar lÃneas dobles"; + Text[ fi ] = "Kaksoisviiva poissa käytöstä"; + Text[ ca ] = "Desactiva lÃnies dobles"; + Text[ it ] = "Disattiva 'A due righe'"; + Text[ sk ] = "Dvojité riadky vypnuté"; + Text[ da ] = "Dobbelt fra"; + Text[ sv ] = "Dubbla rader av"; + Text[ pl ] = "Podwójne wiersze wyÅ‚Ä…czone"; + Text[ pt-BR ] = "Linhas duplas desativadas"; + Text[ th ] = "ขีดเส้นปิดคู่"; + Text[ ja ] = "2行使ㄠオフ"; + Text[ ko ] = "ë‘줄 í•´ì œ"; + Text[ zh-CN ] = "ä¸ä½¿ç”¨åŒè¡Œ"; + Text[ zh-TW ] = "ä¸ä½¿ç”¨é›™è¡Œ"; + Text[ tr ] = "Çift Çizgili Kapalı"; + Text[ hi-IN ] = "दà¥à¤µà¤¿à¤—à¥à¤£à¤¿à¤¤ रेखा बंद"; + Text[ ar ] = "Two lines off"; + Text[ he ] = "‮ריווח כפול בין שורות מכובה‬"; +}; +String RID_SVXITEMS_TWOLINES +{ + Text [ de ] = "Doppelzeilig"; + Text [ en-US ] = "Double-lined"; + Text[ pt ] = "Linhas duplas"; + Text[ ru ] = "ДвухÑтрочный"; + Text[ el ] = "ΔίγÏαμμη γÏαφή"; + Text[ nl ] = "Tweeregelig"; + Text[ fr ] = "Deux lignes en une"; + Text[ es ] = "LÃneas dobles"; + Text[ fi ] = "Kaksoisviiva"; + Text[ ca ] = "Dues lÃnies"; + Text[ it ] = "A due righe"; + Text[ sk ] = "Dvojité riadky"; + Text[ da ] = "Dobbelt"; + Text[ sv ] = "Dubbla rader"; + Text[ pl ] = "Podwójne wiersze"; + Text[ pt-BR ] = "Linhas duplas"; + Text[ th ] = "ขีดเส้นคู่"; + Text[ ja ] = "2行使ã„"; + Text[ ko ] = "ë‘줄"; + Text[ zh-CN ] = "åŒè¡Œ"; + Text[ zh-TW ] = "雙行"; + Text[ tr ] = "Çift Çizgili"; + Text[ hi-IN ] = "दà¥à¤µà¤¿à¤—à¥à¤£à¤¿à¤¤ रेखा"; + Text[ ar ] = "سطرين"; + Text[ he ] = "‮ריווח כפול בין שורות מופעל‬"; +}; + + + +String RID_SVXITEMS_CHARROTATE_OFF +{ + Text [ de ] = "keine gedrehten Zeichen"; + Text [ en-US ] = "No rotated characters"; + Text[ pt ] = "Sem rotação de caracteres"; + Text[ ru ] = "Без перевернутых Ñимволов"; + Text[ el ] = "ΧωÏίς πεÏιστÏοφή χαÏακτήÏων"; + Text[ nl ] = "geen gedraaide tekens"; + Text[ fr ] = "Sans rotation des caractères"; + Text[ es ] = "Sin rotación de caracteres"; + Text[ fi ] = "Ei kierrettyjä merkkejä"; + Text[ ca ] = "Sense carà cters canviats"; + Text[ it ] = "Senza rotazione carattere"; + Text[ sk ] = "Bez otoÄených znakov"; + Text[ da ] = "ingen roterede tegn"; + Text[ sv ] = "Inga roterade tecken"; + Text[ pl ] = "bez obróconych znaków"; + Text[ pt-BR ] = "Caracteres sem rotação"; + Text[ th ] = "ตัวà¸à¸±à¸à¸‚ระที่ไม่หมุน"; + Text[ ja ] = "æ–‡å—を回転ã—ãªã„"; + Text[ ko ] = "íšŒì „ëœ ë¬¸ìž ì•„ë‹˜"; + Text[ zh-CN ] = "å—符ä¸æ—‹è½¬"; + Text[ zh-TW ] = "å—å…ƒä¸æ—‹è½‰"; + Text[ tr ] = "Döndürülmüş karakterler yok"; + Text[ hi-IN ] = "घà¥à¤®à¤¾à¤¯à¤¾ हà¥à¤† अकà¥à¤·à¤°à¥‡à¤‚ नहीं"; + Text[ ar ] = "بدون استدارة Ø£ØرÙ"; + Text[ he ] = "â€®×œ×œ× ×ª×•×™× ×ž×¡×•×‘×‘×™×‬"; +}; +String RID_SVXITEMS_CHARROTATE +{ + Text [ de ] = "Zeichen um $(ARG1)° gedreht"; + Text [ en-US ] = "Character rotated by $(ARG1)°"; + Text[ pt ] = "Rotação de caracteres: $(ARG1)°"; + Text[ ru ] = "Повернуть Ñимволы на $(ARG1)°"; + Text[ el ] = "ΠεÏιστÏοφή χαÏακτήÏων από $(ARG1)°"; + Text[ nl ] = "teken $(ARG1)° gedraaid"; + Text[ fr ] = "Rotation des caractères : $(ARG1)°"; + Text[ es ] = "Carácter rodado en $(ARG1)°"; + Text[ fi ] = "Merkkiä kierretty $(ARG1)°"; + Text[ ca ] = "Carà cter rodat en $(ARG1)°"; + Text[ it ] = "Carattere rotato di $(ARG1)°"; + Text[ sk ] = "Znak otoÄený o $(ARG1)°"; + Text[ da ] = "Tegn roteret med $(ARG1)°"; + Text[ sv ] = "Tecken roterat med $(ARG1)°"; + Text[ pl ] = "Znaki obrócone o $(ARG1)°"; + Text[ pt-BR ] = "Caracter girado em $(ARG1)?"; + Text[ th ] = "ตัวà¸à¸±à¸à¸‚ระหมุนโดย $(ARG1)à¸"; + Text[ ja ] = "æ–‡å—ã‚’ $(ARG1)ー 回転"; + Text[ ko ] = "$(ARG1)?íšŒì „ëœ ë¬¸ìž"; + Text[ zh-CN ] = "å—符旋转 $(ARG1)"; + Text[ zh-TW ] = "å—元旋轉 $(ARG1)°"; + Text[ tr ] = "Karakter $(ARG1)° çevrildi"; + Text[ hi-IN ] = "अकà¥à¤·à¤° को $(ARG1)° से घà¥à¤®à¤¾à¤¯à¤¾"; + Text[ ar ] = "استدارة الأØر٠بمقدار $(ARG1)°"; + Text[ he ] = "‮תו מסובב ב $(ARG1)°‬"; +}; +String RID_SVXITEMS_CHARROTATE_FITLINE +{ + Text [ de ] = " an Zeile anpassen"; + Text [ en-US ] = "Fit to line"; + Text[ pt ] = "Ajustar à linha"; + Text[ ru ] = "СоглаÑовать Ñо Ñтрокой"; + Text[ el ] = "Î ÏοσαÏμογή στη γÏαμμή"; + Text[ nl ] = "aanpassen aan regel"; + Text[ fr ] = " Adapter à la ligne"; + Text[ es ] = "Ajustar a la lÃnea"; + Text[ fi ] = "Sovita riville"; + Text[ ca ] = "ajustar a fila"; + Text[ it ] = "Adatta alla riga"; + Text[ sk ] = "PrispôsobiÅ¥ riadku"; + Text[ da ] = " tilpas til linje"; + Text[ sv ] = " Anpassa till rad"; + Text[ pl ] = "Dopasuj do wiersza"; + Text[ pt-BR ] = " Ajustar à linha"; + Text[ th ] = "จัดพà¸à¸”ีบรรทัด"; + Text[ ja ] = "è¡Œã«åˆã‚ã›ã‚‹"; + Text[ ko ] = "ì¤„ì— ë§žì¶¤"; + Text[ zh-CN ] = "和行对é½"; + Text[ zh-TW ] = "和行å°é½Š"; + Text[ tr ] = "Satıra uydur"; + Text[ hi-IN ] = "रेखा केलिठयोगà¥à¤¯"; + Text[ ar ] = "ملاءمة للسطر"; + Text[ he ] = "‮הת×מה לשורה‬"; +}; + +String RID_SVXITEMS_RELIEF_NONE +{ + Text [ de ] = "Kein Relief" ; + Text [ en-US ] = "No relief"; + Text[ pt ] = "Sem relevo"; + Text[ ru ] = "Без рельефа"; + Text[ el ] = "ΧωÏίς ανάγλυφο"; + Text[ nl ] = "Geen reliëf"; + Text[ fr ] = "Sans relief"; + Text[ es ] = "Sin relieve"; + Text[ fi ] = "Ei korkokuvaa"; + Text[ ca ] = "Sense relleu"; + Text[ it ] = "Senza rilievo"; + Text[ sk ] = "Bez reliéfu"; + Text[ da ] = "Intet relief"; + Text[ sv ] = "Ingen relief"; + Text[ pl ] = "Bez reliefu"; + Text[ pt-BR ] = "Sem relevo"; + Text[ th ] = "ไม่นูน"; + Text[ ja ] = "æµ®ã出ã—ãªã—"; + Text[ ko ] = "ì–‘ê° ì—†ìŒ"; + Text[ zh-CN ] = "æ— æµ®é›•æ•ˆæžœ"; + Text[ zh-TW ] = "無浮雕效果"; + Text[ tr ] = "Rölyef yok"; + Text[ hi-IN ] = "सहायता नहीं"; + Text[ ar ] = "بدون نقش"; + Text[ he ] = "â€®×œ×œ× ×”×‘×œ×˜×”â€¬"; +}; +String RID_SVXITEMS_RELIEF_ENGRAVED +{ + Text [ de ] = "Gravur"; + Text [ en-US ] = "Engraved"; + Text[ pt ] = "Gravado"; + Text[ ru ] = "Гравировка"; + Text[ el ] = "ΧαÏαγμÎνο"; + Text[ nl ] = "Gravure"; + Text[ fr ] = "Empreinte"; + Text[ es ] = "Grabado"; + Text[ fi ] = "Kaiverrettu"; + Text[ ca ] = "Gravat"; + Text[ it ] = "Incisione"; + Text[ sk ] = "Rytina"; + Text[ da ] = "Indgraveret"; + Text[ sv ] = "Gravyr"; + Text[ pl ] = "Grawerowane"; + Text[ pt-BR ] = "Entalhado"; + Text[ th ] = "รà¸à¸¢à¸ˆà¸²à¸£à¸¶à¸"; + Text[ ja ] = "æµ®ã彫り"; + Text[ ko ] = "오목 효과"; + Text[ zh-CN ] = "雕刻"; + Text[ zh-TW ] = "雕刻"; + Text[ tr ] = "Kazınmış"; + Text[ hi-IN ] = "खोदा हà¥à¤†"; + Text[ ar ] = "ØÙر"; + Text[ he ] = "‮חרוט‬"; +}; + + +String RID_SVXITEMS_PARASNAPTOGRID_ON +{ + Text [ de ] = "Absatz wird am Textraster gefangen (wenn aktiviert)"; + Text [ en-US ] = "Paragraph snaps to text grid (if active)"; + Text[ pt ] = "paragraph snap to grid"; + Text[ ru ] = "Параграф привÑзан к Ñетке текÑта (еÑли активно)"; + Text[ el ] = "Î Ïοσκόλληση παÏαγÏάφου στο πλÎγμα κειμÎνου (αν είναι ενεÏγοποιημÎνο)"; + Text[ nl ] = "Alinea wordt aan tekstraster gevangen (indien geactiveerd)"; + Text[ fr ] = "Capture du paragraphe à la grille du texte (si activée)"; + Text[ es ] = "Utilizar la cuadrÃcula en el párrafo (si ésta está activada) "; + Text[ fi ] = "Kappaleen kohdistus tekstiruudukkoon (jos käytössä)"; + Text[ ca ] = "Paragraph snaps to text grid (if active)"; + Text[ it ] = "Cattura il paragrafo alla griglia di testo (se attivata)"; + Text[ sk ] = "Odstavec zachytávaÅ¥ na textový mriežku (ak aktÃvna)"; + Text[ da ] = "Afstanden mÃ¥les ved tekstgitteret (ved aktivering)"; + Text[ sv ] = "Stycke fästs mot textraster (om det är aktiverat)"; + Text[ pl ] = "Akapity sÄ… przyciÄ…gane do siatki tekstu (jeÅ›li aktywna)"; + Text[ pt-BR ] = "O parágrafo se encaixa na grade do texto (se ativada)"; + Text[ th ] = "Paragraph snaps to text grid (if active)"; + Text[ ja ] = "段è½ã‚’æ–‡å—罫線ã§ä½ç½®åˆã‚ã›(オンã®ã¨ã)"; + Text[ ko ] = "단ë½ì„ í…스트 그리드로 맞춤(활성시)"; + Text[ zh-CN ] = "段è½å’Œç¨¿çº¸æ ¼çº¿å¯¹é½(如使用稿纸)"; + Text[ zh-TW ] = "段è½å’Œç¨¿ç´™æ ¼ç·šå°é½Š (如使用稿紙)"; + Text[ tr ] = "Paragraph snaps to text grid (if active)"; + Text[ hi-IN ] = "Paragraph snaps to text grid (if active)"; + Text[ ar ] = "paragraph snap to grid"; + Text[ he ] = "‮פסקה מתמקמת על קודקוד רשת (במידה והרשת מופעלת)‬"; +}; + +String RID_SVXITEMS_PARASNAPTOGRID_OFF +{ + Text [ de ] = "Absatz wird nicht am Textraster gefangen"; + Text [ en-US ] = "Paragraph does not snap to text grid"; + Text[ pt ] = "paragraph does not snap to grid"; + Text[ ru ] = "Параграф не привÑзан к Ñетке текÑта"; + Text[ el ] = "ΧωÏίς Ï€Ïοσκόλληση παÏαγÏάφου στο πλÎγμα κειμÎνου"; + Text[ nl ] = "Alinea wordt niet aan tekstraster gevangen"; + Text[ fr ] = "Pas de capture du paragraphe à la grille du texte"; + Text[ es ] = "No utilizar la cuadrÃcula en el párrafo"; + Text[ fi ] = "Kappale ei kohdistu tekstiruudukkoon"; + Text[ ca ] = "Paragraph does not snap to text grid"; + Text[ it ] = "Non cattura il paragrafo alla griglia di testo"; + Text[ sk ] = "Odstavec nezachytávaÅ¥ na textový mriežku"; + Text[ da ] = "Afstanden mÃ¥les ikke ved tekstgitteret"; + Text[ sv ] = "Stycke fästs inte mot textraster"; + Text[ pl ] = "Akapit nie jest przyciÄ…gany do siatki tekstu"; + Text[ pt-BR ] = "O parágrafo não se encaixa na grade do texto"; + Text[ th ] = "Paragraph does not snap to text grid"; + Text[ ja ] = "段è½ã‚’æ–‡å—罫線ã§ä½ç½®åˆã‚ã›ã—ãªã„"; + Text[ ko ] = "단ë½ì„ í…스트 그리드로 맞추지 ì•ŠìŒ"; + Text[ zh-CN ] = "段è½ä¸å’Œç¨¿çº¸æ ¼çº¿å¯¹é½"; + Text[ zh-TW ] = "段è½ä¸å’Œç¨¿ç´™æ ¼ç·šå°é½Š"; + Text[ tr ] = "Paragraph does not snap to text grid"; + Text[ hi-IN ] = "Paragraph does not snap to text grid"; + Text[ ar ] = "paragraph does not snap to grid"; + Text[ he ] = "â€®×ž×™×§×•× ×¤×¡×§×” חופשי (××£ ×× ×”×¨×©×ª מופעלת)‬"; +}; + + // ********************************************************************** EOF diff --git a/binfilter/bf_svx/source/items/svx_textitem.cxx b/binfilter/bf_svx/source/items/svx_textitem.cxx new file mode 100644 index 000000000000..173b14727fc9 --- /dev/null +++ b/binfilter/bf_svx/source/items/svx_textitem.cxx @@ -0,0 +1,2621 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#include <tools/stream.hxx> +#include <toolkit/unohlp.hxx> +#include <math.h> +#include <rtl/math.hxx> + +#include <eeitem.hxx> + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +#define ITEMID_FONTLIST 0 +#define ITEMID_FONT 0 +#define ITEMID_POSTURE 0 +#define ITEMID_WEIGHT 0 +#define ITEMID_FONTHEIGHT 0 +#define ITEMID_UNDERLINE 0 +#define ITEMID_CROSSEDOUT 0 +#define ITEMID_SHADOWED 0 +#define ITEMID_AUTOKERN 0 +#define ITEMID_WORDLINEMODE 0 +#define ITEMID_CONTOUR 0 +#define ITEMID_PROPSIZE 0 +#define ITEMID_COLOR 0 +#define ITEMID_CHARSETCOLOR 0 +#define ITEMID_KERNING 0 +#define ITEMID_CASEMAP 0 +#define ITEMID_ESCAPEMENT 0 +#define ITEMID_LANGUAGE 0 +#define ITEMID_NOLINEBREAK 0 +#define ITEMID_NOHYPHENHERE 0 +#define ITEMID_BLINK 0 +#define ITEMID_EMPHASISMARK 0 +#define ITEMID_TWOLINES 0 +#define ITEMID_CHARROTATE 0 +#define ITEMID_CHARSCALE_W 0 +#define ITEMID_CHARRELIEF 0 + + +#define GLOBALOVERFLOW3 + + +#include <bf_svtools/memberid.hrc> +#include "svxids.hrc" +#include "svxitems.hrc" + +#include "rtl/ustring.hxx" +#include <i18npool/mslangid.hxx> +#include <bf_svtools/itemset.hxx> +#include <bf_svtools/itempool.hxx> + +#include <com/sun/star/style/CaseMap.hpp> +#include <com/sun/star/awt/XFont.hpp> +#include <com/sun/star/text/FontEmphasis.hpp> +#include <com/sun/star/i18n/ScriptType.hpp> + + + +#include "flstitem.hxx" +#include "fontitem.hxx" +#include "postitem.hxx" +#include "wghtitem.hxx" +#include "fhgtitem.hxx" +#include "fwdtitem.hxx" +#include "udlnitem.hxx" +#include "crsditem.hxx" +#include "shdditem.hxx" +#include "akrnitem.hxx" +#include "wrlmitem.hxx" +#include "cntritem.hxx" +#include "prszitem.hxx" +#include "cscoitem.hxx" +#include "kernitem.hxx" +#include "cmapitem.hxx" +#include "escpitem.hxx" +#include "langitem.hxx" +#include "nlbkitem.hxx" +#include "nhypitem.hxx" +#include "blnkitem.hxx" +#include "emphitem.hxx" +#include "twolinesitem.hxx" +#include "scripttypeitem.hxx" +#include "charrotateitem.hxx" +#include "charscaleitem.hxx" +#include "charreliefitem.hxx" +#include "itemtype.hxx" +#include "dlgutil.hxx" + +// #90477# +#include <tools/tenccvt.hxx> +namespace binfilter { + +#define STORE_UNICODE_MAGIC_MARKER 0xFE331188 + +using namespace ::rtl; +using namespace ::com::sun::star; +using namespace ::com::sun::star::text; + +// 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)) + +BOOL SvxFontItem::bEnableStoreUnicodeNames = FALSE; + +// STATIC DATA ----------------------------------------------------------- + +// ----------------------------------------------------------------------- + +/*N*/ TYPEINIT1(SvxFontListItem, SfxPoolItem); +/*N*/ TYPEINIT1_AUTOFACTORY(SvxFontItem, SfxPoolItem); +/*N*/ TYPEINIT1_AUTOFACTORY(SvxPostureItem, SfxEnumItem); +/*N*/ TYPEINIT1_AUTOFACTORY(SvxWeightItem, SfxEnumItem); +/*N*/ TYPEINIT1_AUTOFACTORY(SvxFontHeightItem, SfxPoolItem); +/*N*/ TYPEINIT1_AUTOFACTORY(SvxUnderlineItem, SfxEnumItem); +/*N*/ TYPEINIT1_AUTOFACTORY(SvxCrossedOutItem, SfxEnumItem); +/*N*/ TYPEINIT1_AUTOFACTORY(SvxShadowedItem, SfxBoolItem); +/*N*/ TYPEINIT1_AUTOFACTORY(SvxAutoKernItem, SfxBoolItem); +/*N*/ TYPEINIT1_AUTOFACTORY(SvxWordLineModeItem, SfxBoolItem); +/*N*/ TYPEINIT1_AUTOFACTORY(SvxContourItem, SfxBoolItem); +/*N*/ TYPEINIT1_AUTOFACTORY(SvxPropSizeItem, SfxUInt16Item); +/*N*/ TYPEINIT1_AUTOFACTORY(SvxColorItem, SfxPoolItem); +/*N*/ TYPEINIT1_AUTOFACTORY(SvxCharSetColorItem, SvxColorItem); +/*N*/ TYPEINIT1_AUTOFACTORY(SvxKerningItem, SfxInt16Item); +/*N*/ TYPEINIT1_AUTOFACTORY(SvxCaseMapItem, SfxEnumItem); +/*N*/ TYPEINIT1_AUTOFACTORY(SvxEscapementItem, SfxPoolItem); +/*N*/ TYPEINIT1_AUTOFACTORY(SvxLanguageItem, SfxEnumItem); +/*N*/ TYPEINIT1_AUTOFACTORY(SvxNoLinebreakItem, SfxBoolItem); +/*N*/ TYPEINIT1_AUTOFACTORY(SvxNoHyphenItem, SfxBoolItem); +/*N*/ TYPEINIT1_AUTOFACTORY(SvxBlinkItem, SfxBoolItem); +/*N*/ TYPEINIT1_AUTOFACTORY(SvxEmphasisMarkItem, SfxUInt16Item); +/*N*/ TYPEINIT1_AUTOFACTORY(SvxTwoLinesItem, SfxPoolItem); +/*N*/ TYPEINIT1_AUTOFACTORY(SvxCharRotateItem, SfxUInt16Item); +/*N*/ TYPEINIT1_AUTOFACTORY(SvxCharScaleWidthItem, SfxUInt16Item); +/*N*/ TYPEINIT1_AUTOFACTORY(SvxCharReliefItem, SfxEnumItem); + + +/*N*/ TYPEINIT1(SvxScriptSetItem, SfxSetItem ); + + +// class SvxFontListItem ------------------------------------------------- + +/*N*/ SvxFontListItem::SvxFontListItem( const FontList* pFontLst, +/*N*/ const USHORT nId ) : +/*N*/ SfxPoolItem( nId ), +/*N*/ pFontList( pFontLst ) +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvxFontListItem::SvxFontListItem( const SvxFontListItem& rItem ) : +/*N*/ +/*N*/ SfxPoolItem( rItem ), +/*N*/ pFontList( rItem.GetFontList() ) +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxFontListItem::Clone( SfxItemPool* ) const +/*N*/ { +/*N*/ return new SvxFontListItem( *this ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*?*/ int SvxFontListItem::operator==( const SfxPoolItem& rAttr ) const +/*?*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); return 0;//STRIP001 DBG_ASSERT( SfxPoolItem::operator==(rAttr), "unequal types" ); +/*?*/ } + +//------------------------------------------------------------------------ + + +// class SvxFontItem ----------------------------------------------------- + +/*N*/ SvxFontItem::SvxFontItem( const USHORT nId ) : +/*N*/ SfxPoolItem( nId ) +/*N*/ { +/*N*/ eFamily = FAMILY_SWISS; +/*N*/ ePitch = PITCH_VARIABLE; +/*N*/ eTextEncoding = RTL_TEXTENCODING_DONTKNOW; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvxFontItem::SvxFontItem( const FontFamily eFam, const XubString& aName, +/*N*/ const XubString& aStName, const FontPitch eFontPitch, +/*N*/ const rtl_TextEncoding eFontTextEncoding, const USHORT nId ) : +/*N*/ +/*N*/ SfxPoolItem( nId ), +/*N*/ +/*N*/ aFamilyName(aName), +/*N*/ aStyleName(aStName) +/*N*/ { +/*N*/ eFamily = eFam; +/*N*/ ePitch = eFontPitch; +/*N*/ eTextEncoding = eFontTextEncoding; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ bool SvxFontItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const +/*N*/ { +/*N*/ sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); +/*N*/ nMemberId &= ~CONVERT_TWIPS; +/*N*/ switch(nMemberId) +/*N*/ { +/*N*/ case MID_FONT_FAMILY_NAME : +/*N*/ rVal <<= OUString(aFamilyName.GetBuffer()); +/*N*/ break; +/*N*/ case MID_FONT_STYLE_NAME: +/*N*/ rVal <<= OUString(aStyleName.GetBuffer()); +/*N*/ break; +/*N*/ case MID_FONT_FAMILY : rVal <<= (sal_Int16)(eFamily); break; +/*N*/ case MID_FONT_CHAR_SET : rVal <<= (sal_Int16)(eTextEncoding); break; +/*N*/ case MID_FONT_PITCH : rVal <<= (sal_Int16)(ePitch); break; +/*N*/ } +/*N*/ return sal_True; +/*N*/ } +// ----------------------------------------------------------------------- +/*N*/ bool SvxFontItem::PutValue( const uno::Any& rVal, BYTE nMemberId) +/*N*/ { +/*N*/ sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); +/*N*/ nMemberId &= ~CONVERT_TWIPS; +/*N*/ switch(nMemberId) +/*N*/ { +/*N*/ case MID_FONT_FAMILY_NAME : +/*N*/ { +/*N*/ OUString aStr; +/*N*/ if(!(rVal >>= aStr)) +/*N*/ return sal_False; +/*N*/ aFamilyName = aStr.getStr(); +/*N*/ } +/*N*/ break; +/*N*/ case MID_FONT_STYLE_NAME: +/*N*/ { +/*N*/ OUString aStr; +/*N*/ if(!(rVal >>= aStr)) +/*N*/ return sal_False; +/*N*/ aStyleName = aStr.getStr(); +/*N*/ } +/*N*/ break; +/*N*/ case MID_FONT_FAMILY : +/*N*/ { +/*N*/ sal_Int16 nFamily; +/*N*/ if(!(rVal >>= nFamily)) +/*N*/ return sal_False; +/*N*/ eFamily = (FontFamily)nFamily; +/*N*/ } +/*N*/ break; +/*N*/ case MID_FONT_CHAR_SET : +/*N*/ { +/*N*/ sal_Int16 nSet; +/*N*/ if(!(rVal >>= nSet)) +/*N*/ return sal_False; +/*N*/ eTextEncoding = (rtl_TextEncoding)nSet; +/*N*/ } +/*N*/ break; +/*N*/ case MID_FONT_PITCH : +/*N*/ { +/*N*/ sal_Int16 nPitch; +/*N*/ if(!(rVal >>= nPitch)) +/*N*/ return sal_False; +/*N*/ ePitch = (FontPitch)nPitch; +/*N*/ } +/*N*/ break; +/*N*/ } +/*N*/ return sal_True; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ int SvxFontItem::operator==( const SfxPoolItem& rAttr ) const +/*N*/ { +/*N*/ DBG_ASSERT( SfxPoolItem::operator==(rAttr), "unequal types" ); +/*N*/ +/*N*/ const SvxFontItem& rItem = (const SvxFontItem&)rAttr; +/*N*/ +/*N*/ int bRet = ( eFamily == rItem.eFamily && +/*N*/ aFamilyName == rItem.aFamilyName && +/*N*/ aStyleName == rItem.aStyleName ); +/*N*/ +/*N*/ if ( bRet ) +/*N*/ { +/*N*/ if ( ePitch != rItem.ePitch || eTextEncoding != rItem.eTextEncoding ) +/*N*/ { +/*N*/ bRet = sal_False; +/*N*/ DBG_WARNING( "FontItem::operator==(): nur Pitch oder rtl_TextEncoding unterschiedlich" ); +/*N*/ } +/*N*/ } +/*N*/ return bRet; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxFontItem::Clone( SfxItemPool * ) const +/*N*/ { +/*N*/ return new SvxFontItem( *this ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvStream& SvxFontItem::Store( SvStream& rStrm , USHORT nItemVersion ) const +/*N*/ { +/*N*/ BOOL bToBats = +/*N*/ GetFamilyName().EqualsAscii( "StarSymbol", 0, sizeof("StarSymbol")-1 ) || +/*N*/ GetFamilyName().EqualsAscii( "OpenSymbol", 0, sizeof("OpenSymbol")-1 ); +/*N*/ +/*N*/ // #90477# rStrm << (BYTE) GetFamily() +/*N*/ // << (BYTE) GetPitch() +/*N*/ // << (BYTE)(bToBats ? RTL_TEXTENCODING_SYMBOL : GetStoreCharSet( GetCharSet(), (USHORT)rStrm.GetVersion() ) ); +/*N*/ rStrm << (BYTE) GetFamily() << (BYTE) GetPitch() +/*N*/ << (BYTE)(bToBats ? RTL_TEXTENCODING_SYMBOL : GetSOStoreTextEncoding(GetCharSet(), (sal_uInt16)rStrm.GetVersion())); +/*N*/ +/*N*/ String aStoreFamilyName( GetFamilyName() ); +/*N*/ if( bToBats ) +/*N*/ aStoreFamilyName = String( "StarBats", sizeof("StarBats")-1, RTL_TEXTENCODING_ASCII_US ); +/*N*/ rStrm.WriteByteString(aStoreFamilyName); +/*N*/ rStrm.WriteByteString(GetStyleName()); +/*N*/ +/*N*/ // #96441# Kach for EditEngine, only set while creating clipboard stream. +/*N*/ if ( bEnableStoreUnicodeNames ) +/*N*/ { +/*N*/ sal_uInt32 nMagic = STORE_UNICODE_MAGIC_MARKER; +/*N*/ rStrm << nMagic; +/*N*/ rStrm.WriteByteString( aStoreFamilyName, RTL_TEXTENCODING_UNICODE ); +/*N*/ rStrm.WriteByteString( GetStyleName(), RTL_TEXTENCODING_UNICODE ); +/*N*/ } +/*N*/ +/*N*/ return rStrm; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxFontItem::Create(SvStream& rStrm, USHORT) const +/*N*/ { +/*N*/ BYTE eFamily, eFontPitch, eFontTextEncoding; +/*N*/ String aName, aStyle; +/*N*/ rStrm >> eFamily; +/*N*/ rStrm >> eFontPitch; +/*N*/ rStrm >> eFontTextEncoding; +/*N*/ +/*N*/ // UNICODE: rStrm >> aName; +/*N*/ rStrm.ReadByteString(aName); +/*N*/ +/*N*/ // UNICODE: rStrm >> aStyle; +/*N*/ rStrm.ReadByteString(aStyle); +/*N*/ +/*N*/ // Task 91008/90471: set the "correct" textencoding +/*N*/ eFontTextEncoding = (BYTE)GetSOLoadTextEncoding( eFontTextEncoding, (USHORT)rStrm.GetVersion() ); +/*N*/ +/*N*/ // irgendwann wandelte sich der StarBats vom ANSI- zum SYMBOL-Font +/*N*/ if ( RTL_TEXTENCODING_SYMBOL != eFontTextEncoding && aName.EqualsAscii("StarBats") ) +/*N*/ eFontTextEncoding = RTL_TEXTENCODING_SYMBOL; +/*N*/ +/*N*/ // Check if we have stored unicode +/*N*/ ULONG nStreamPos = rStrm.Tell(); +/*N*/ sal_uInt32 nMagic = STORE_UNICODE_MAGIC_MARKER; +/*N*/ rStrm >> nMagic; +/*N*/ if ( nMagic == STORE_UNICODE_MAGIC_MARKER ) +/*N*/ { +/*N*/ rStrm.ReadByteString( aName, RTL_TEXTENCODING_UNICODE ); +/*N*/ rStrm.ReadByteString( aStyle, RTL_TEXTENCODING_UNICODE ); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ rStrm.Seek( nStreamPos ); +/*N*/ } +/*N*/ +/*N*/ +/*N*/ +/*N*/ return new SvxFontItem( (FontFamily)eFamily, aName, aStyle, +/*N*/ (FontPitch)eFontPitch, (rtl_TextEncoding)eFontTextEncoding, Which() ); +/*N*/ } + +//------------------------------------------------------------------------ + + +// class SvxPostureItem -------------------------------------------------- + +/*N*/ SvxPostureItem::SvxPostureItem( const FontItalic ePosture, const USHORT nId ) : +/*N*/ SfxEnumItem( nId, ePosture ) +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxPostureItem::Clone( SfxItemPool * ) const +/*N*/ { +/*N*/ return new SvxPostureItem( *this ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*?*/ USHORT SvxPostureItem::GetValueCount() const +/*?*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); return 0;//STRIP001 /*?*/ return ITALIC_NORMAL + 1; // auch ITALIC_NONE geh"ort dazu +/*?*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvStream& SvxPostureItem::Store( SvStream& rStrm , USHORT nItemVersion ) const +/*N*/ { +/*N*/ rStrm << (BYTE)GetValue(); +/*N*/ return rStrm; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxPostureItem::Create(SvStream& rStrm, USHORT) const +/*N*/ { +/*N*/ BYTE nPosture; +/*N*/ rStrm >> nPosture; +/*N*/ return new SvxPostureItem( (const FontItalic)nPosture, Which() ); +/*N*/ } + +//------------------------------------------------------------------------ + + +// ----------------------------------------------------------------------- + + + +/*-----------------13.03.98 14:28------------------- + +--------------------------------------------------*/ +/*N*/ bool SvxPostureItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const +/*N*/ { +/*N*/ sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); +/*N*/ nMemberId &= ~CONVERT_TWIPS; +/*N*/ switch( nMemberId ) +/*N*/ { +/*N*/ case MID_ITALIC: +/*?*/ rVal = Bool2Any(GetBoolValue()); +/*N*/ break; +/*N*/ case MID_POSTURE: +/*N*/ rVal <<= (awt::FontSlant)GetValue(); // Werte von awt::FontSlant und FontItalic sind gleich +/*N*/ break; +/*N*/ } +/*N*/ return sal_True; +/*N*/ } +/*-----------------13.03.98 14:28------------------- + +--------------------------------------------------*/ +/*N*/ bool SvxPostureItem::PutValue( const uno::Any& rVal, BYTE nMemberId ) +/*N*/ { +/*N*/ sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); +/*N*/ nMemberId &= ~CONVERT_TWIPS; +/*N*/ switch( nMemberId ) +/*N*/ { +/*N*/ case MID_ITALIC: +/*?*/ SetBoolValue(Any2Bool(rVal)); +/*N*/ break; +/*N*/ case MID_POSTURE: +/*N*/ { +/*?*/ awt::FontSlant eSlant; +/*?*/ if(!(rVal >>= eSlant)) +/*?*/ { +/*?*/ sal_Int32 nValue; +/*?*/ if(!(rVal >>= nValue)) +/*?*/ return sal_False; +/*?*/ +/*?*/ eSlant = (awt::FontSlant)nValue; +/*N*/ } +/*N*/ SetValue((USHORT)eSlant); +/*N*/ } +/*N*/ } +/*N*/ return sal_True; +/*N*/ } +// ----------------------------------------------------------------------- + +/*N*/ int SvxPostureItem::HasBoolValue() const +/*N*/ { +/*N*/ return sal_True; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ sal_Bool SvxPostureItem::GetBoolValue() const +/*N*/ { +/*N*/ return ( (FontItalic)GetValue() >= ITALIC_OBLIQUE ); +/*N*/ } + +// ----------------------------------------------------------------------- + + +// class SvxWeightItem --------------------------------------------------- + +/*N*/ SvxWeightItem::SvxWeightItem( const FontWeight eWght, const USHORT nId ) : +/*N*/ SfxEnumItem( nId, eWght ) +/*N*/ { +/*N*/ } + + + +// ----------------------------------------------------------------------- + +/*N*/ int SvxWeightItem::HasBoolValue() const +/*N*/ { +/*N*/ return sal_True; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ sal_Bool SvxWeightItem::GetBoolValue() const +/*N*/ { +/*N*/ return (FontWeight)GetValue() >= WEIGHT_BOLD; +/*N*/ } + +// ----------------------------------------------------------------------- + + +// ----------------------------------------------------------------------- + +/*?*/ USHORT SvxWeightItem::GetValueCount() const +/*?*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); return 0;//STRIP001 return WEIGHT_BLACK; // WEIGHT_DONTKNOW geh"ort nicht dazu +/*?*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxWeightItem::Clone( SfxItemPool * ) const +/*N*/ { +/*N*/ return new SvxWeightItem( *this ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvStream& SvxWeightItem::Store( SvStream& rStrm , USHORT nItemVersion ) const +/*N*/ { +/*N*/ rStrm << (BYTE)GetValue(); +/*N*/ return rStrm; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxWeightItem::Create(SvStream& rStrm, USHORT) const +/*N*/ { +/*N*/ BYTE nWeight; +/*N*/ rStrm >> nWeight; +/*N*/ return new SvxWeightItem( (FontWeight)nWeight, Which() ); +/*N*/ } + +//------------------------------------------------------------------------ + + +// ----------------------------------------------------------------------- + + +/*-----------------13.03.98 14:18------------------- + +--------------------------------------------------*/ +/*N*/ bool SvxWeightItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const +/*N*/ { +/*N*/ sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); +/*N*/ nMemberId &= ~CONVERT_TWIPS; +/*N*/ switch( nMemberId ) +/*N*/ { +/*N*/ case MID_BOLD : +/*?*/ rVal = Bool2Any(GetBoolValue()); +/*N*/ break; +/*N*/ case MID_WEIGHT: +/*N*/ { +/*N*/ rVal <<= (float)( VCLUnoHelper::ConvertFontWeight( (FontWeight)GetValue() ) ); +/*N*/ } +/*N*/ break; +/*N*/ } +/*N*/ return sal_True; +/*N*/ } +/*-----------------13.03.98 14:18------------------- + +--------------------------------------------------*/ +/*N*/ bool SvxWeightItem::PutValue( const uno::Any& rVal, BYTE nMemberId ) +/*N*/ { +/*N*/ sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); +/*N*/ nMemberId &= ~CONVERT_TWIPS; +/*N*/ switch( nMemberId ) +/*N*/ { +/*N*/ case MID_BOLD : +/*?*/ SetBoolValue(Any2Bool(rVal)); +/*N*/ break; +/*N*/ case MID_WEIGHT: +/*N*/ { +/*N*/ double fValue; +/*N*/ if(!(rVal >>= fValue)) +/*N*/ { +/*?*/ sal_Int32 nValue; +/*?*/ if(!(rVal >>= nValue)) +/*?*/ return sal_False; +/*?*/ fValue = (float)nValue; +/*N*/ } +/*N*/ SetValue( VCLUnoHelper::ConvertFontWeight((float)fValue) ); +/*N*/ } +/*N*/ break; +/*N*/ } +/*N*/ return sal_True; +/*N*/ } + +// class SvxFontHeightItem ----------------------------------------------- + +/*N*/ SvxFontHeightItem::SvxFontHeightItem( const ULONG nSz, +/*N*/ const USHORT nPrp, +/*N*/ const USHORT nId ) : +/*N*/ SfxPoolItem( nId ) +/*N*/ { +/*N*/ SetHeight( nSz,nPrp ); // mit den Prozenten rechnen +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxFontHeightItem::Clone( SfxItemPool * ) const +/*N*/ { +/*N*/ return new SvxFontHeightItem( *this ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvStream& SvxFontHeightItem::Store( SvStream& rStrm , USHORT nItemVersion ) const +/*N*/ { +/*N*/ rStrm << (USHORT)GetHeight(); +/*N*/ +/*N*/ if( FONTHEIGHT_UNIT_VERSION <= nItemVersion ) +/*N*/ rStrm << GetProp() << (USHORT)GetPropUnit(); +/*N*/ else +/*N*/ { +/*N*/ // JP 30.06.98: beim Export in alte Versionen geht die relative +/*N*/ // Angabe verloren, wenn es keine Prozentuale ist +/*N*/ USHORT nProp = GetProp(); +/*N*/ if( SFX_MAPUNIT_RELATIVE != GetPropUnit() ) +/*N*/ nProp = 100; +/*N*/ rStrm << nProp; +/*N*/ } +/*N*/ return rStrm; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxFontHeightItem::Create( SvStream& rStrm, +/*N*/ USHORT nVersion ) const +/*N*/ { +/*N*/ USHORT nsize, nprop = 0, nPropUnit = SFX_MAPUNIT_RELATIVE; +/*N*/ +/*N*/ rStrm >> nsize; +/*N*/ +/*N*/ if( FONTHEIGHT_16_VERSION <= nVersion ) +/*N*/ rStrm >> nprop; +/*N*/ else +/*N*/ { +/*?*/ BYTE nP; +/*?*/ rStrm >> nP; +/*?*/ nprop = (USHORT)nP; +/*N*/ } +/*N*/ +/*N*/ if( FONTHEIGHT_UNIT_VERSION <= nVersion ) +/*N*/ rStrm >> nPropUnit; +/*N*/ +/*N*/ SvxFontHeightItem* pItem = new SvxFontHeightItem( nsize, 100, Which() ); +/*N*/ pItem->SetProp( nprop, (SfxMapUnit)nPropUnit ); +/*N*/ return pItem; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ int SvxFontHeightItem::operator==( const SfxPoolItem& rItem ) const +/*N*/ { +/*N*/ DBG_ASSERT( SfxPoolItem::operator==( rItem ), "unequal type" ); +/*N*/ return GetHeight() == ((SvxFontHeightItem&)rItem).GetHeight() && +/*N*/ GetProp() == ((SvxFontHeightItem&)rItem).GetProp() && +/*N*/ GetPropUnit() == ((SvxFontHeightItem&)rItem).GetPropUnit(); +/*N*/ } + +/*-----------------13.03.98 14:53------------------- + +--------------------------------------------------*/ +/*N*/ bool SvxFontHeightItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const +/*N*/ { +/*N*/ // In StarOne sind im uno::Any immer 1/100mm. Ueber die MemberId wird +/*N*/ // gesteuert, ob der Wert im Item 1/100mm oder Twips sind. +/*N*/ +/*N*/ sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); +/*N*/ nMemberId &= ~CONVERT_TWIPS; +/*N*/ switch( nMemberId ) +/*N*/ { +/*N*/ case MID_FONTHEIGHT: +/*N*/ { +/*N*/ // Point (also Twips) sind gefragt, +/*N*/ // also umrechnen, wenn CONVERT_TWIPS nicht gesetzt ist +/*N*/ if( bConvert ) +/*N*/ { +/*N*/ long nTwips = bConvert ? nHeight : MM100_TO_TWIP(nHeight); +/*N*/ rVal <<= (float)( nTwips / 20.0 ); +/*N*/ } +/*N*/ else +/*N*/ { +/*N*/ double fPoints = MM100_TO_TWIP((long)nHeight) / 20.0; +/*N*/ float fRoundPoints = +/*N*/ static_cast<float>(::rtl::math::round(fPoints, 1)); +/*N*/ rVal <<= fRoundPoints; +/*N*/ } +/*N*/ } +/*N*/ break; +/*N*/ case MID_FONTHEIGHT_PROP: +/*N*/ rVal <<= (sal_Int16)(SFX_MAPUNIT_RELATIVE == ePropUnit ? nProp : 100); +/*N*/ break; +/*N*/ case MID_FONTHEIGHT_DIFF: +/*N*/ { +/*N*/ float fRet = (float)(short)nProp; +/*N*/ switch( ePropUnit ) +/*N*/ { +/*N*/ case SFX_MAPUNIT_RELATIVE: +/*N*/ fRet = 0.; +/*N*/ break; +/*N*/ case SFX_MAPUNIT_100TH_MM: +/*?*/ fRet = MM100_TO_TWIP(fRet); +/*?*/ fRet /= 20.; +/*?*/ break; +/*?*/ case SFX_MAPUNIT_POINT: +/*?*/ +/*?*/ break; +/*?*/ case SFX_MAPUNIT_TWIP: +/*?*/ fRet /= 20.; +/*N*/ break; +/*N*/ } +/*N*/ rVal <<= fRet; +/*N*/ } +/*N*/ break; +/*N*/ } +/*N*/ return sal_True; +/*N*/ } +/* -----------------01.07.98 13:43------------------- + * Relative Abweichung aus der Hoehe herausrechnen + * --------------------------------------------------*/ +/*N*/ sal_uInt32 lcl_GetRealHeight_Impl(sal_uInt32 nHeight, sal_uInt16 nProp, SfxMapUnit eProp, sal_Bool bCoreInTwip) +/*N*/ { +/*N*/ sal_uInt32 nRet = nHeight; +/*N*/ short nDiff = 0; +/*N*/ switch( eProp ) +/*N*/ { +/*N*/ case SFX_MAPUNIT_RELATIVE: +/*N*/ nRet *= 100; +/*N*/ nRet /= nProp; +/*N*/ break; +/*N*/ case SFX_MAPUNIT_POINT: +/*N*/ { +/*?*/ short nTemp = (short)nProp; +/*?*/ nDiff = nTemp * 20; +/*?*/ if(!bCoreInTwip) +/*?*/ nDiff = (short)TWIP_TO_MM100((long)(nDiff)); +/*?*/ } +/*?*/ break; +/*?*/ case SFX_MAPUNIT_100TH_MM: +/*?*/ //dann ist die Core doch wohl auch in 1/100 mm +/*?*/ nDiff = (short)nProp; +/*?*/ break; +/*?*/ case SFX_MAPUNIT_TWIP: +/*?*/ // hier doch sicher TWIP +/*?*/ nDiff = ((short)nProp); +/*N*/ break; +/*N*/ } +/*N*/ nRet -= nDiff; +/*N*/ +/*N*/ return nRet; +/*N*/ } + +/*-----------------13.03.98 14:53------------------- + +--------------------------------------------------*/ +/*N*/ bool SvxFontHeightItem::PutValue( const uno::Any& rVal, BYTE nMemberId ) +/*N*/ { +/*N*/ sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); +/*N*/ nMemberId &= ~CONVERT_TWIPS; +/*N*/ switch( nMemberId ) +/*N*/ { +/*N*/ case MID_FONTHEIGHT: +/*N*/ { +/*N*/ ePropUnit = SFX_MAPUNIT_RELATIVE; +/*N*/ nProp = 100; +/*N*/ double fPoint; +/*N*/ if(!(rVal >>= fPoint)) +/*N*/ { +/*N*/ sal_Int32 nValue; +/*?*/ if(!(rVal >>= nValue)) +/*?*/ return sal_False; +/*?*/ fPoint = (float)nValue; +/*N*/ } +/*N*/ if(fPoint < 0. || fPoint > 10000.) +/*N*/ return sal_False; +/*N*/ +/*N*/ nHeight = (long)( fPoint * 20.0 + 0.5 ); // Twips +/*N*/ if (!bConvert) +/*N*/ nHeight = TWIP_TO_MM100(nHeight); // umrechnen, wenn das Item 1/100mm enthaelt +/*N*/ } +/*N*/ break; +/*N*/ case MID_FONTHEIGHT_PROP: +/*N*/ { +/*N*/ sal_Int16 nNew; +/*N*/ if(!(rVal >>= nNew)) +/*N*/ return sal_True; +/*N*/ +/*N*/ nHeight = lcl_GetRealHeight_Impl(nHeight, nProp, ePropUnit, bConvert); +/*N*/ +/*N*/ nHeight *= nNew; +/*N*/ nHeight /= 100; +/*N*/ nProp = nNew; +/*N*/ ePropUnit = SFX_MAPUNIT_RELATIVE; +/*N*/ } +/*N*/ break; +/*N*/ case MID_FONTHEIGHT_DIFF: +/*N*/ { +/*?*/ nHeight = lcl_GetRealHeight_Impl(nHeight, nProp, ePropUnit, bConvert); +/*?*/ float fValue; +/*?*/ if(!(rVal >>= fValue)) +/*?*/ { +/*?*/ sal_Int32 nValue; +/*?*/ if(!(rVal >>= nValue)) +/*?*/ return sal_False; +/*?*/ fValue = (float)nValue; +/*?*/ } +/*?*/ sal_Int16 nCoreDiffValue = (sal_Int16)(fValue * 20.); +/*?*/ nHeight += bConvert ? nCoreDiffValue : TWIP_TO_MM100(nCoreDiffValue); +/*?*/ nProp = (sal_uInt16)((sal_Int16)fValue); +/*?*/ ePropUnit = SFX_MAPUNIT_POINT; +/*N*/ } +/*N*/ break; +/*N*/ } +/*N*/ return sal_True; +/*N*/ } + +//------------------------------------------------------------------------ + + +// ----------------------------------------------------------------------- + +/*N*/ USHORT SvxFontHeightItem::GetVersion(USHORT nFileVersion) const +/*N*/ { +/*N*/ return (nFileVersion <= SOFFICE_FILEFORMAT_40) +/*N*/ ? FONTHEIGHT_16_VERSION +/*N*/ : FONTHEIGHT_UNIT_VERSION; +/*N*/ } + +// ----------------------------------------------------------------------- + + +// ----------------------------------------------------------------------- + + +/*N*/ void SvxFontHeightItem::SetHeight( sal_uInt32 nNewHeight, const USHORT nNewProp, +/*N*/ SfxMapUnit eUnit ) +/*N*/ { +/*N*/ DBG_ASSERT( GetRefCount() == 0, "SetValue() with pooled item" ); +/*N*/ +/*N*/ #ifndef SVX_LIGHT +/*N*/ if( SFX_MAPUNIT_RELATIVE != eUnit ) +nHeight = nNewHeight + ::binfilter::ItemToControl( (short)nNewProp, eUnit,//STRIP008 /*N*/ nHeight = nNewHeight + ::ItemToControl( (short)nNewProp, eUnit, +/*N*/ SFX_FUNIT_TWIP ); +/*N*/ else +/*N*/ #endif // !SVX_LIGHT +/*N*/ if( 100 != nNewProp ) +/*N*/ nHeight = sal_uInt32(( nNewHeight * nNewProp ) / 100 ); +/*N*/ else +/*N*/ nHeight = nNewHeight; +/*N*/ +/*N*/ nProp = nNewProp; +/*N*/ ePropUnit = eUnit; +/*N*/ } + +// class SvxUnderlineItem ------------------------------------------------ + +/*N*/ SvxUnderlineItem::SvxUnderlineItem( const FontUnderline eSt, const USHORT nId ) +/*N*/ : SfxEnumItem( nId, eSt ), mColor( COL_TRANSPARENT ) +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ int SvxUnderlineItem::HasBoolValue() const +/*N*/ { +/*N*/ return sal_True; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ sal_Bool SvxUnderlineItem::GetBoolValue() const +/*N*/ { +/*N*/ return (FontUnderline)GetValue() != UNDERLINE_NONE; +/*N*/ } + +// ----------------------------------------------------------------------- + + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxUnderlineItem::Clone( SfxItemPool * ) const +/*N*/ { +/*N*/ SvxUnderlineItem* pNew = new SvxUnderlineItem( *this ); +/*N*/ pNew->SetColor( GetColor() ); +/*N*/ return pNew; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ USHORT SvxUnderlineItem::GetValueCount() const +/*N*/ { +/*N*/ return UNDERLINE_DOTTED + 1; // auch UNDERLINE_NONE geh"ort dazu +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvStream& SvxUnderlineItem::Store( SvStream& rStrm , USHORT nItemVersion ) const +/*N*/ { +/*N*/ rStrm << (BYTE)GetValue(); +/*N*/ return rStrm; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxUnderlineItem::Create(SvStream& rStrm, USHORT) const +/*N*/ { +/*N*/ BYTE nState; +/*N*/ rStrm >> nState; +/*N*/ return new SvxUnderlineItem( (FontUnderline)nState, Which() ); +/*N*/ } + +//------------------------------------------------------------------------ + + +// ----------------------------------------------------------------------- + + +/*-----------------13.03.98 16:25------------------- + +--------------------------------------------------*/ +/*N*/ bool SvxUnderlineItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const +/*N*/ { +/*N*/ sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); +/*N*/ nMemberId &= ~CONVERT_TWIPS; +/*N*/ switch(nMemberId) +/*N*/ { +/*N*/ case MID_UNDERLINED: +/*?*/ rVal = Bool2Any(GetBoolValue()); +/*?*/ break; +/*N*/ case MID_UNDERLINE: +/*N*/ rVal <<= (sal_Int16)(GetValue()); +/*N*/ break; +/*N*/ case MID_UL_COLOR: +/*N*/ rVal <<= (sal_Int32)( mColor.GetColor() ); +/*N*/ break; +/*N*/ case MID_UL_HASCOLOR: +/*N*/ rVal = Bool2Any( !mColor.GetTransparency() ); +/*N*/ break; +/*N*/ } +/*N*/ return sal_True; +/*N*/ +/*N*/ } +/*-----------------13.03.98 16:28------------------- + +--------------------------------------------------*/ +/*N*/ bool SvxUnderlineItem::PutValue( const uno::Any& rVal, BYTE nMemberId ) +/*N*/ { +/*N*/ sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); +/*N*/ nMemberId &= ~CONVERT_TWIPS; +/*N*/ sal_Bool bRet = sal_True; +/*N*/ switch(nMemberId) +/*N*/ { +/*N*/ case MID_UNDERLINED: +/*?*/ SetBoolValue(Any2Bool(rVal)); +/*N*/ break; +/*N*/ case MID_UNDERLINE: +/*N*/ { +/*N*/ sal_Int32 nValue; +/*N*/ if(!(rVal >>= nValue)) +/*N*/ bRet = sal_False; +/*N*/ else +/*N*/ SetValue((sal_Int16)nValue); +/*N*/ } +/*N*/ break; +/*N*/ case MID_UL_COLOR: +/*N*/ { +/*?*/ sal_Int32 nCol; +/*?*/ if( !( rVal >>= nCol ) ) +/*?*/ bRet = sal_False; +/*?*/ else +/*?*/ { +/*?*/ // Keep transparence, because it contains the information +/*?*/ // whether the font color or the stored color should be used +/*?*/ sal_uInt8 nTrans = mColor.GetTransparency(); +/*?*/ mColor = Color( nCol ); +/*?*/ mColor.SetTransparency( nTrans ); +/*?*/ } +/*N*/ } +/*N*/ break; +/*N*/ case MID_UL_HASCOLOR: +/*N*/ mColor.SetTransparency( Any2Bool( rVal ) ? 0 : 0xff ); +/*N*/ break; +/*N*/ } +/*N*/ return bRet; +/*N*/ } + +/*N*/ int SvxUnderlineItem::operator==( const SfxPoolItem& rItem ) const +/*N*/ { +/*N*/ DBG_ASSERT( SfxPoolItem::operator==( rItem ), "unequal type" ); +/*N*/ return SfxEnumItem::operator==( rItem ) && +/*N*/ GetColor() == ((SvxUnderlineItem&)rItem).GetColor(); +/*N*/ } + +// class SvxCrossedOutItem ----------------------------------------------- + +/*N*/ SvxCrossedOutItem::SvxCrossedOutItem( const FontStrikeout eSt, const USHORT nId ) +/*N*/ : SfxEnumItem( nId, eSt ) +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- + + +// ----------------------------------------------------------------------- + + +// ----------------------------------------------------------------------- + + +// ----------------------------------------------------------------------- + +/*N*/ USHORT SvxCrossedOutItem::GetValueCount() const +/*N*/ { +/*N*/ return STRIKEOUT_DOUBLE + 1; // auch STRIKEOUT_NONE geh"ort dazu +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxCrossedOutItem::Clone( SfxItemPool * ) const +/*N*/ { +/*N*/ return new SvxCrossedOutItem( *this ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvStream& SvxCrossedOutItem::Store( SvStream& rStrm , USHORT nItemVersion ) const +/*N*/ { +/*N*/ rStrm << (BYTE)GetValue(); +/*N*/ return rStrm; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxCrossedOutItem::Create(SvStream& rStrm, USHORT) const +/*N*/ { +/*N*/ BYTE eCross; +/*N*/ rStrm >> eCross; +/*N*/ return new SvxCrossedOutItem( (FontStrikeout)eCross, Which() ); +/*N*/ } + +//------------------------------------------------------------------------ + + +// ----------------------------------------------------------------------- + + +/*-----------------13.03.98 16:28------------------- + +--------------------------------------------------*/ +/*N*/ bool SvxCrossedOutItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const +/*N*/ { +/*N*/ sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); +/*N*/ nMemberId &= ~CONVERT_TWIPS; +/*N*/ switch(nMemberId) +/*N*/ { +/*N*/ case MID_CROSSED_OUT: +/*?*/ rVal = Bool2Any(GetBoolValue()); +/*N*/ break; +/*N*/ case MID_CROSS_OUT: +/*N*/ rVal <<= (sal_Int16)(GetValue()); +/*N*/ break; +/*N*/ } +/*N*/ return sal_True; +/*N*/ } +/*-----------------13.03.98 16:29------------------- + +--------------------------------------------------*/ +/*N*/ bool SvxCrossedOutItem::PutValue( const uno::Any& rVal, BYTE nMemberId ) +/*N*/ { +/*N*/ sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); +/*N*/ nMemberId &= ~CONVERT_TWIPS; +/*N*/ switch(nMemberId) +/*N*/ { +/*N*/ case MID_CROSSED_OUT: +/*?*/ SetBoolValue(Any2Bool(rVal)); +/*N*/ break; +/*N*/ case MID_CROSS_OUT: +/*N*/ { +/*N*/ sal_Int32 nValue; +/*N*/ if(!(rVal >>= nValue)) +/*N*/ return sal_False; +/*N*/ SetValue((sal_Int16)nValue); +/*N*/ } +/*N*/ break; +/*N*/ } +/*N*/ return sal_True; +/*N*/ } +// class SvxShadowedItem ------------------------------------------------- + +/*N*/ SvxShadowedItem::SvxShadowedItem( const sal_Bool bShadowed, const USHORT nId ) : +/*N*/ SfxBoolItem( nId, bShadowed ) +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxShadowedItem::Clone( SfxItemPool * ) const +/*N*/ { +/*N*/ return new SvxShadowedItem( *this ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvStream& SvxShadowedItem::Store( SvStream& rStrm , USHORT nItemVersion ) const +/*N*/ { +/*N*/ rStrm << (BYTE) GetValue(); +/*N*/ return rStrm; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxShadowedItem::Create(SvStream& rStrm, USHORT) const +/*N*/ { +/*N*/ BYTE nState; +/*N*/ rStrm >> nState; +/*N*/ return new SvxShadowedItem( nState, Which() ); +/*N*/ } + +//------------------------------------------------------------------------ + + +// class SvxAutoKernItem ------------------------------------------------- + +/*N*/ SvxAutoKernItem::SvxAutoKernItem( const sal_Bool bAutoKern, const USHORT nId ) : +/*N*/ SfxBoolItem( nId, bAutoKern ) +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxAutoKernItem::Clone( SfxItemPool * ) const +/*N*/ { +/*N*/ return new SvxAutoKernItem( *this ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvStream& SvxAutoKernItem::Store( SvStream& rStrm , USHORT nItemVersion ) const +/*N*/ { +/*N*/ rStrm << (BYTE) GetValue(); +/*N*/ return rStrm; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxAutoKernItem::Create(SvStream& rStrm, USHORT) const +/*N*/ { +/*N*/ BYTE nState; +/*N*/ rStrm >> nState; +/*N*/ return new SvxAutoKernItem( nState, Which() ); +/*N*/ } + +//------------------------------------------------------------------------ + + +// class SvxWordLineModeItem --------------------------------------------- + +/*N*/ SvxWordLineModeItem::SvxWordLineModeItem( const sal_Bool bWordLineMode, +/*N*/ const USHORT nId ) : +/*N*/ SfxBoolItem( nId, bWordLineMode ) +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxWordLineModeItem::Clone( SfxItemPool * ) const +/*N*/ { +/*N*/ return new SvxWordLineModeItem( *this ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvStream& SvxWordLineModeItem::Store( SvStream& rStrm , USHORT nItemVersion ) const +/*N*/ { +/*N*/ rStrm << (sal_Bool) GetValue(); +/*N*/ return rStrm; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxWordLineModeItem::Create(SvStream& rStrm, USHORT) const +/*N*/ { +/*N*/ sal_Bool bValue; +/*N*/ rStrm >> bValue; +/*N*/ return new SvxWordLineModeItem( bValue, Which() ); +/*N*/ } + +//------------------------------------------------------------------------ + + +// class SvxContourItem -------------------------------------------------- + +/*N*/ SvxContourItem::SvxContourItem( const sal_Bool bContoured, const USHORT nId ) : +/*N*/ SfxBoolItem( nId, bContoured ) +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxContourItem::Clone( SfxItemPool * ) const +/*N*/ { +/*N*/ return new SvxContourItem( *this ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvStream& SvxContourItem::Store( SvStream& rStrm , USHORT nItemVersion ) const +/*N*/ { +/*N*/ rStrm << (sal_Bool) GetValue(); +/*N*/ return rStrm; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxContourItem::Create(SvStream& rStrm, USHORT) const +/*N*/ { +/*N*/ sal_Bool bValue; +/*N*/ rStrm >> bValue; +/*N*/ return new SvxContourItem( bValue, Which() ); +/*N*/ } + +//------------------------------------------------------------------------ + + +// class SvxPropSizeItem ------------------------------------------------- + +/*N*/ SvxPropSizeItem::SvxPropSizeItem( const USHORT nPercent, const USHORT nId ) : +/*N*/ SfxUInt16Item( nId, nPercent ) +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxPropSizeItem::Clone( SfxItemPool * ) const +/*N*/ { +/*N*/ return new SvxPropSizeItem( *this ); +/*N*/ } + +// ----------------------------------------------------------------------- + + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxPropSizeItem::Create(SvStream& rStrm, USHORT) const +/*N*/ { +/*N*/ USHORT nSize; +/*N*/ rStrm >> nSize; +/*N*/ return new SvxPropSizeItem( nSize, Which() ); +/*N*/ } + +//------------------------------------------------------------------------ + + +// class SvxColorItem ---------------------------------------------------- + +/*N*/ SvxColorItem::SvxColorItem( const USHORT nId ) : +/*N*/ SfxPoolItem( nId ), +/*N*/ mColor( COL_BLACK ) +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvxColorItem::SvxColorItem( const Color& rCol, const USHORT nId ) : +/*N*/ SfxPoolItem( nId ), +/*N*/ mColor( rCol ) +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvxColorItem::SvxColorItem( SvStream &rStrm, const USHORT nId ) : +/*N*/ SfxPoolItem( nId ) +/*N*/ { +/*N*/ Color aColor; +/*N*/ rStrm >> aColor; +/*N*/ mColor = aColor; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvxColorItem::SvxColorItem( const SvxColorItem &rCopy ) : +/*N*/ SfxPoolItem( rCopy ), +/*N*/ mColor( rCopy.mColor ) +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvxColorItem::~SvxColorItem() +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- +/*N*/ USHORT SvxColorItem::GetVersion( USHORT nFFVer ) const +/*N*/ { +/*N*/ DBG_ASSERT( SOFFICE_FILEFORMAT_31==nFFVer || +/*N*/ SOFFICE_FILEFORMAT_40==nFFVer || +/*N*/ SOFFICE_FILEFORMAT_50==nFFVer, +/*N*/ "SvxColorItem: Gibt es ein neues Fileformat?" ); +/*N*/ return SOFFICE_FILEFORMAT_50 >= nFFVer ? VERSION_USEAUTOCOLOR : 0; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ int SvxColorItem::operator==( const SfxPoolItem& rAttr ) const +/*N*/ { +/*N*/ DBG_ASSERT( SfxPoolItem::operator==(rAttr), "unequal types" ); +/*N*/ +/*N*/ return mColor == ( (const SvxColorItem&)rAttr ).mColor; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ bool SvxColorItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const +/*N*/ { +/*N*/ rVal <<= (sal_Int32)(mColor.GetColor()); +/*N*/ return sal_True; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ bool SvxColorItem::PutValue( const uno::Any& rVal, BYTE nMemberId ) +/*N*/ { +/*N*/ sal_Int32 nColor; +/*N*/ if(!(rVal >>= nColor)) +/*N*/ return sal_False; +/*N*/ +/*N*/ mColor.SetColor( nColor ); +/*N*/ return sal_True; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxColorItem::Clone( SfxItemPool * ) const +/*N*/ { +/*N*/ return new SvxColorItem( *this ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvStream& SvxColorItem::Store( SvStream& rStrm , USHORT nItemVersion ) const +/*N*/ { +/*N*/ if( VERSION_USEAUTOCOLOR == nItemVersion && +/*N*/ COL_AUTO == mColor.GetColor() ) +/*N*/ rStrm << Color( COL_BLACK ); +/*N*/ else +/*N*/ rStrm << mColor; +/*N*/ return rStrm; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxColorItem::Create(SvStream& rStrm, USHORT nVer ) const +/*N*/ { +/*N*/ return new SvxColorItem( rStrm, Which() ); +/*N*/ } + +//------------------------------------------------------------------------ + + +// ----------------------------------------------------------------------- + +/*N*/ void SvxColorItem::SetValue( const Color& rNewCol ) +/*N*/ { +/*N*/ mColor = rNewCol; +/*N*/ } + +// class SvxCharSetColorItem --------------------------------------------- + +/*N*/ SvxCharSetColorItem::SvxCharSetColorItem( const USHORT nId ) : +/*N*/ SvxColorItem( nId ), +/*N*/ +/*N*/ eFrom( RTL_TEXTENCODING_DONTKNOW ) +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvxCharSetColorItem::SvxCharSetColorItem( const Color& rCol, +/*N*/ const rtl_TextEncoding eFrom, +/*N*/ const USHORT nId ) : +/*N*/ SvxColorItem( rCol, nId ), +/*N*/ +/*N*/ eFrom( eFrom ) +/*N*/ { +/*N*/ } + + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxCharSetColorItem::Clone( SfxItemPool * ) const +/*N*/ { +/*N*/ return new SvxCharSetColorItem( *this ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvStream& SvxCharSetColorItem::Store( SvStream& rStrm , USHORT nItemVersion ) const +/*N*/ { +/*N*/ // #90477# rStrm << (BYTE) GetStoreCharSet( GetCharSet(), (USHORT)rStrm.GetVersion() ) +/*N*/ // << GetValue(); +/*N*/ rStrm << (BYTE)GetSOStoreTextEncoding(GetCharSet(), (sal_uInt16)rStrm.GetVersion()) +/*N*/ << GetValue(); +/*N*/ return rStrm; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxCharSetColorItem::Create(SvStream& rStrm, USHORT) const +/*N*/ { +/*N*/ BYTE cSet; +/*N*/ Color aColor; +/*N*/ rStrm >> cSet >> aColor; +/*N*/ return new SvxCharSetColorItem( aColor, (rtl_TextEncoding)cSet, Which() ); +/*N*/ } + +//------------------------------------------------------------------------ + + +// class SvxKerningItem -------------------------------------------------- + +/*N*/ SvxKerningItem::SvxKerningItem( const short nKern, const USHORT nId ) : +/*N*/ SfxInt16Item( nId, nKern ) +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxKerningItem::Clone( SfxItemPool * ) const +/*N*/ { +/*N*/ return new SvxKerningItem( *this ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvStream& SvxKerningItem::Store( SvStream& rStrm , USHORT nItemVersion ) const +/*N*/ { +/*N*/ rStrm << (short) GetValue(); +/*N*/ return rStrm; +/*N*/ } + +// ----------------------------------------------------------------------- + + +// ----------------------------------------------------------------------- + + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxKerningItem::Create(SvStream& rStrm, USHORT) const +/*N*/ { +/*N*/ short nValue; +/*N*/ rStrm >> nValue; +/*N*/ return new SvxKerningItem( nValue, Which() ); +/*N*/ } + +//------------------------------------------------------------------------ + +/* -----------------------------19.02.01 12:21-------------------------------- + + ---------------------------------------------------------------------------*/ +/*N*/ bool SvxKerningItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const +/*N*/ { +/*N*/ sal_Int16 nVal = GetValue(); +/*N*/ if(nMemberId & CONVERT_TWIPS) +/*N*/ nVal = (sal_Int16)TWIP_TO_MM100(nVal); +/*N*/ rVal <<= nVal; +/*N*/ return sal_True; +/*N*/ } +// ----------------------------------------------------------------------- +/*N*/ bool SvxKerningItem::PutValue( const uno::Any& rVal, BYTE nMemberId) +/*N*/ { +/*N*/ sal_Int16 nVal; +/*N*/ if(!(rVal >>= nVal)) +/*N*/ return sal_False; +/*N*/ if(nMemberId & CONVERT_TWIPS) +/*N*/ nVal = (sal_Int16)MM100_TO_TWIP(nVal); +/*N*/ SetValue(nVal); +/*N*/ return sal_True; +/*N*/ } + +// class SvxCaseMapItem -------------------------------------------------- + +/*N*/ SvxCaseMapItem::SvxCaseMapItem( const SvxCaseMap eMap, const USHORT nId ) : +/*N*/ SfxEnumItem( nId, eMap ) +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- + +/*?*/ USHORT SvxCaseMapItem::GetValueCount() const +/*?*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); return 0;//STRIP001 return SVX_CASEMAP_END; // SVX_CASEMAP_KAPITAELCHEN + 1 +/*?*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxCaseMapItem::Clone( SfxItemPool * ) const +/*N*/ { +/*N*/ return new SvxCaseMapItem( *this ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvStream& SvxCaseMapItem::Store( SvStream& rStrm , USHORT nItemVersion ) const +/*N*/ { +/*N*/ rStrm << (BYTE) GetValue(); +/*N*/ return rStrm; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxCaseMapItem::Create(SvStream& rStrm, USHORT) const +/*N*/ { +/*N*/ BYTE cMap; +/*N*/ rStrm >> cMap; +/*N*/ return new SvxCaseMapItem( (const SvxCaseMap)cMap, Which() ); +/*N*/ } + +//------------------------------------------------------------------------ + + +// ----------------------------------------------------------------------- + + +/*-----------------13.03.98 16:29------------------- + +--------------------------------------------------*/ +/*N*/ bool SvxCaseMapItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const +/*N*/ { +/*N*/ sal_Int16 nRet = style::CaseMap::NONE; +/*N*/ switch( GetValue() ) +/*N*/ { +/*N*/ // case SVX_CASEMAP_NOT_MAPPED : nRet = style::CaseMap::NONE ; break; +/*N*/ case SVX_CASEMAP_VERSALIEN : nRet = style::CaseMap::UPPERCASE; break; +/*?*/ case SVX_CASEMAP_GEMEINE : nRet = style::CaseMap::LOWERCASE; break; +/*N*/ case SVX_CASEMAP_TITEL : nRet = style::CaseMap::TITLE ; break; +/*N*/ case SVX_CASEMAP_KAPITAELCHEN: nRet = style::CaseMap::SMALLCAPS; break; +/*N*/ } +/*N*/ rVal <<= (sal_Int16)(nRet); +/*N*/ return sal_True; +/*N*/ } +/*-----------------13.03.98 16:29------------------- + +--------------------------------------------------*/ +/*N*/ bool SvxCaseMapItem::PutValue( const uno::Any& rVal, BYTE nMemberId ) +/*N*/ { +/*N*/ sal_uInt16 nVal; +/*N*/ if(!(rVal >>= nVal)) +/*N*/ return sal_False; +/*N*/ +/*N*/ switch( nVal ) +/*N*/ { +/*N*/ case style::CaseMap::NONE : nVal = SVX_CASEMAP_NOT_MAPPED ; break; +/*N*/ case style::CaseMap::UPPERCASE: nVal = SVX_CASEMAP_VERSALIEN ; break; +/*?*/ case style::CaseMap::LOWERCASE: nVal = SVX_CASEMAP_GEMEINE ; break; +/*N*/ case style::CaseMap::TITLE : nVal = SVX_CASEMAP_TITEL ; break; +/*N*/ case style::CaseMap::SMALLCAPS: nVal = SVX_CASEMAP_KAPITAELCHEN; break; +/*N*/ } +/*N*/ SetValue(nVal); +/*N*/ return sal_True; +/*N*/ } + +// class SvxEscapementItem ----------------------------------------------- + +/*N*/ SvxEscapementItem::SvxEscapementItem( const USHORT nId ) : +/*N*/ SfxEnumItemInterface( nId ), +/*N*/ +/*N*/ nEsc ( 0 ), +/*N*/ nProp ( 100 ) +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- + + +// ----------------------------------------------------------------------- + +/*N*/ SvxEscapementItem::SvxEscapementItem( const short nEsc, +/*N*/ const BYTE nProp, +/*N*/ const USHORT nId ) : +/*N*/ SfxEnumItemInterface( nId ), +/*N*/ nEsc ( nEsc ), +/*N*/ nProp ( nProp ) +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ int SvxEscapementItem::operator==( const SfxPoolItem& rAttr ) const +/*N*/ { +/*N*/ DBG_ASSERT( SfxPoolItem::operator==(rAttr), "unequal types" ); +/*N*/ +/*N*/ return( nEsc == ((SvxEscapementItem&)rAttr).nEsc && +/*N*/ nProp == ((SvxEscapementItem&)rAttr).nProp ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxEscapementItem::Clone( SfxItemPool * ) const +/*N*/ { +/*N*/ return new SvxEscapementItem( *this ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvStream& SvxEscapementItem::Store( SvStream& rStrm , USHORT nItemVersion ) const +/*N*/ { +/*N*/ short nEsc = GetEsc(); +/*N*/ if( SOFFICE_FILEFORMAT_31 == rStrm.GetVersion() ) +/*N*/ { +/*N*/ if( DFLT_ESC_AUTO_SUPER == nEsc ) +/*N*/ nEsc = DFLT_ESC_SUPER; +/*N*/ else if( DFLT_ESC_AUTO_SUB == nEsc ) +/*N*/ nEsc = DFLT_ESC_SUB; +/*N*/ } +/*N*/ rStrm << (BYTE) GetProp() +/*N*/ << (short) nEsc; +/*N*/ return rStrm; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxEscapementItem::Create(SvStream& rStrm, USHORT) const +/*N*/ { +/*N*/ BYTE nProp; +/*N*/ short nEsc; +/*N*/ rStrm >> nProp >> nEsc; +/*N*/ return new SvxEscapementItem( nEsc, nProp, Which() ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*?*/ USHORT SvxEscapementItem::GetValueCount() const +/*?*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); return 0;//STRIP001 return SVX_ESCAPEMENT_END; // SVX_ESCAPEMENT_SUBSCRIPT + 1 +/*?*/ } + +//------------------------------------------------------------------------ + + +// ----------------------------------------------------------------------- + + +// ----------------------------------------------------------------------- + +/*?*/ USHORT SvxEscapementItem::GetEnumValue() const +/*?*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); return 0;//STRIP001 //STRIP001 if ( nEsc < 0 ) +/*?*/ } + +// ----------------------------------------------------------------------- + +/*?*/ void SvxEscapementItem::SetEnumValue( USHORT nVal ) +/*?*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); //STRIP001 SetEscapement( (const SvxEscapement)nVal ); +/*?*/ } + +/*-----------------13.03.98 17:05------------------- + +--------------------------------------------------*/ +/*N*/ bool SvxEscapementItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const +/*N*/ { +/*N*/ sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); +/*N*/ nMemberId &= ~CONVERT_TWIPS; +/*N*/ switch(nMemberId) +/*N*/ { +/*N*/ case MID_ESC: +/*N*/ rVal <<= (sal_Int16)(nEsc); +/*N*/ break; +/*N*/ case MID_ESC_HEIGHT: +/*N*/ rVal <<= (sal_Int8)(nProp); +/*N*/ break; +/*N*/ case MID_AUTO_ESC: +/*?*/ rVal = Bool2Any(DFLT_ESC_AUTO_SUB == nEsc || DFLT_ESC_AUTO_SUPER == nEsc); +/*N*/ break; +/*N*/ } +/*N*/ return sal_True; +/*N*/ } +/*-----------------13.03.98 17:05------------------- + +--------------------------------------------------*/ +/*N*/ bool SvxEscapementItem::PutValue( const uno::Any& rVal, BYTE nMemberId ) +/*N*/ { +/*N*/ sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); +/*N*/ nMemberId &= ~CONVERT_TWIPS; +/*N*/ switch(nMemberId) +/*N*/ { +/*N*/ case MID_ESC: +/*N*/ { +/*N*/ sal_Int16 nVal; +/*N*/ if( (rVal >>= nVal) && (Abs(nVal) <= 101)) +/*N*/ nEsc = nVal; +/*N*/ else +/*N*/ return sal_False; +/*N*/ } +/*N*/ break; +/*N*/ case MID_ESC_HEIGHT: +/*N*/ { +/*N*/ sal_Int8 nVal; +/*N*/ if( (rVal >>= nVal) && (nVal <= 100)) +/*N*/ nProp = nVal; +/*N*/ else +/*N*/ return sal_False; +/*N*/ } +/*N*/ break; +/*N*/ case MID_AUTO_ESC: +/*N*/ { +/*?*/ BOOL bVal = Any2Bool(rVal); +/*?*/ if(bVal) +/*?*/ { +/*?*/ if(nEsc < 0) +/*?*/ nEsc = DFLT_ESC_AUTO_SUB; +/*?*/ else +/*?*/ nEsc = DFLT_ESC_AUTO_SUPER; +/*?*/ } +/*?*/ else +/*?*/ if(DFLT_ESC_AUTO_SUPER == nEsc ) +/*?*/ --nEsc; +/*?*/ else if(DFLT_ESC_AUTO_SUB == nEsc) +/*?*/ ++nEsc; +/*N*/ } +/*N*/ break; +/*N*/ } +/*N*/ return sal_True; +/*N*/ } + +// class SvxLanguageItem ------------------------------------------------- + +/*N*/ SvxLanguageItem::SvxLanguageItem( const LanguageType eLang, const USHORT nId ) +/*N*/ : SfxEnumItem( nId , eLang ) +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- + +/*?*/ USHORT SvxLanguageItem::GetValueCount() const +/*?*/ { +/*?*/ DBG_BF_ASSERT(0, "STRIP"); return 0;//STRIP001 return LANGUAGE_COUNT; // aus tlintl.hxx +/*?*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxLanguageItem::Clone( SfxItemPool * ) const +/*N*/ { +/*N*/ return new SvxLanguageItem( *this ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvStream& SvxLanguageItem::Store( SvStream& rStrm , USHORT nItemVersion ) const +/*N*/ { +/*N*/ rStrm << (USHORT) GetValue(); +/*N*/ return rStrm; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxLanguageItem::Create(SvStream& rStrm, USHORT) const +/*N*/ { +/*N*/ USHORT nValue; +/*N*/ rStrm >> nValue; +/*N*/ return new SvxLanguageItem( (LanguageType)nValue, Which() ); +/*N*/ } + +//------------------------------------------------------------------------ + + +/*-----------------14.03.98 14:13------------------- + +--------------------------------------------------*/ +/*N*/ bool SvxLanguageItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const +/*N*/ { +/*N*/ sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); +/*N*/ nMemberId &= ~CONVERT_TWIPS; +/*N*/ switch(nMemberId) +/*N*/ { +/*N*/ case MID_LANG_INT: // for basic conversions! +/*?*/ rVal <<= (sal_Int16)(GetValue()); +/*N*/ break; +/*N*/ case MID_LANG_LOCALE: +/*N*/ lang::Locale aRet( MsLangId::convertLanguageToLocale( GetValue() )); +/*N*/ rVal <<= aRet; +/*N*/ break; +/*N*/ } +/*N*/ return sal_True; +/*N*/ } +/*-----------------14.03.98 14:13------------------- + +--------------------------------------------------*/ +/*N*/ bool SvxLanguageItem::PutValue( const uno::Any& rVal, BYTE nMemberId ) +/*N*/ { +/*N*/ sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); +/*N*/ nMemberId &= ~CONVERT_TWIPS; +/*N*/ switch(nMemberId) +/*N*/ { +/*N*/ case MID_LANG_INT: // for basic conversions! +/*N*/ { +/*?*/ sal_Int32 nValue; +/*?*/ if(!(rVal >>= nValue)) +/*?*/ return sal_False; +/*?*/ +/*?*/ SetValue((sal_Int16)nValue); +/*N*/ } +/*N*/ break; +/*N*/ case MID_LANG_LOCALE: +/*N*/ { +/*N*/ lang::Locale aLocale; +/*N*/ if(!(rVal >>= aLocale)) +/*N*/ return sal_False; +/*N*/ +/*N*/ if (aLocale.Language.getLength() || aLocale.Country.getLength()) +/*N*/ SetValue(MsLangId::convertIsoNamesToLanguage( aLocale.Language, aLocale.Country )); +/*N*/ else +/*N*/ SetValue(LANGUAGE_NONE); +/*N*/ } +/*N*/ break; +/*N*/ } +/*N*/ return sal_True; +/*N*/ } + +// class SvxNoLinebreakItem ---------------------------------------------- +/*N*/ SvxNoLinebreakItem::SvxNoLinebreakItem( const sal_Bool bBreak, const USHORT nId ) : +/*N*/ SfxBoolItem( nId, bBreak ) +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- + + +// ----------------------------------------------------------------------- + + +// ----------------------------------------------------------------------- + + +//------------------------------------------------------------------------ + + +// class SvxNoHyphenItem ------------------------------------------------- + +/*N*/ SvxNoHyphenItem::SvxNoHyphenItem( const sal_Bool bHyphen, const USHORT nId ) : +/*N*/ SfxBoolItem( nId , bHyphen ) +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- + + +// ----------------------------------------------------------------------- + + +// ----------------------------------------------------------------------- + + +//------------------------------------------------------------------------ + + +/* + * Dummy-Item fuer ToolBox-Controls: + * + */ + +// ----------------------------------------------------------------------- +// class SvxLineColorItem (== SvxColorItem) +// ----------------------------------------------------------------------- + + +// ----------------------------------------------------------------------- + + +// ----------------------------------------------------------------------- + + +// ----------------------------------------------------------------------- + + +// ----------------------------------------------------------------------- + + +//------------------------------------------------------------------------ + + +// class SvxBlinkItem ------------------------------------------------- + + +/*N*/ SvxBlinkItem::SvxBlinkItem( const sal_Bool bBlink, const USHORT nId ) : +/*N*/ SfxBoolItem( nId, bBlink ) +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxBlinkItem::Clone( SfxItemPool * ) const +/*N*/ { +/*N*/ return new SvxBlinkItem( *this ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvStream& SvxBlinkItem::Store( SvStream& rStrm , USHORT nItemVersion ) const +/*N*/ { +/*N*/ rStrm << (BYTE) GetValue(); +/*N*/ return rStrm; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxBlinkItem::Create(SvStream& rStrm, USHORT) const +/*N*/ { +/*N*/ BYTE nState; +/*N*/ rStrm >> nState; +/*N*/ return new SvxBlinkItem( nState, Which() ); +/*N*/ } + +// ----------------------------------------------------------------------- + + +// class SvxEmphaisMarkItem --------------------------------------------------- + +/*N*/ SvxEmphasisMarkItem::SvxEmphasisMarkItem( const FontEmphasisMark nValue, +/*N*/ const USHORT nId ) +/*N*/ : SfxUInt16Item( nId, nValue ) +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxEmphasisMarkItem::Clone( SfxItemPool * ) const +/*N*/ { +/*N*/ return new SvxEmphasisMarkItem( *this ); +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvStream& SvxEmphasisMarkItem::Store( SvStream& rStrm, +/*N*/ USHORT nItemVersion ) const +/*N*/ { +/*N*/ rStrm << (sal_uInt16)GetValue(); +/*N*/ return rStrm; +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxEmphasisMarkItem::Create( SvStream& rStrm, USHORT ) const +/*N*/ { +/*N*/ sal_uInt16 nValue; +/*N*/ rStrm >> nValue; +/*N*/ return new SvxEmphasisMarkItem( (FontEmphasisMark)nValue, Which() ); +/*N*/ } + +//------------------------------------------------------------------------ + + +// ----------------------------------------------------------------------- + +/*N*/ bool SvxEmphasisMarkItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const +/*N*/ { +/*N*/ sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); +/*N*/ nMemberId &= ~CONVERT_TWIPS; +/*N*/ switch( nMemberId ) +/*N*/ { +/*N*/ case MID_EMPHASIS: +/*N*/ { +/*N*/ sal_Int16 nValue = GetValue(); +/*N*/ sal_Int16 nRet = 0; +/*N*/ switch(nValue & EMPHASISMARK_STYLE) +/*N*/ { +/*N*/ case EMPHASISMARK_NONE : nRet = FontEmphasis::NONE; break; +/*?*/ case EMPHASISMARK_DOT : nRet = FontEmphasis::DOT_ABOVE; break; +/*?*/ case EMPHASISMARK_CIRCLE : nRet = FontEmphasis::CIRCLE_ABOVE; break; +/*?*/ case EMPHASISMARK_DISC : nRet = FontEmphasis::DISK_ABOVE; break; +/*?*/ case EMPHASISMARK_ACCENT : nRet = FontEmphasis::ACCENT_ABOVE; break; +/*N*/ } +/*N*/ if(nRet && nValue & EMPHASISMARK_POS_BELOW) +/*N*/ nRet += 10; +/*N*/ rVal <<= nRet; +/*N*/ } +/*N*/ break; +/*N*/ } +/*N*/ return sal_True; +/*N*/ } + +/*N*/ bool SvxEmphasisMarkItem::PutValue( const uno::Any& rVal, BYTE nMemberId ) +/*N*/ { +/*N*/ sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); +/*N*/ nMemberId &= ~CONVERT_TWIPS; +/*N*/ sal_Bool bRet = sal_True; +/*N*/ switch( nMemberId ) +/*N*/ { +/*N*/ case MID_EMPHASIS: +/*N*/ { +/*N*/ sal_Int32 nValue = -1; +/*N*/ rVal >>= nValue; +/*N*/ switch(nValue) +/*N*/ { +/*N*/ case FontEmphasis::NONE : nValue = EMPHASISMARK_NONE; break; +/*?*/ case FontEmphasis::DOT_ABOVE : nValue = EMPHASISMARK_DOT|EMPHASISMARK_POS_ABOVE; break; +/*?*/ case FontEmphasis::CIRCLE_ABOVE: nValue = EMPHASISMARK_CIRCLE|EMPHASISMARK_POS_ABOVE; break; +/*?*/ case FontEmphasis::DISK_ABOVE : nValue = EMPHASISMARK_DISC|EMPHASISMARK_POS_ABOVE; break; +/*?*/ case FontEmphasis::ACCENT_ABOVE: nValue = EMPHASISMARK_ACCENT|EMPHASISMARK_POS_ABOVE; break; +/*?*/ case FontEmphasis::DOT_BELOW : nValue = EMPHASISMARK_DOT|EMPHASISMARK_POS_BELOW; break; +/*?*/ case FontEmphasis::CIRCLE_BELOW: nValue = EMPHASISMARK_CIRCLE|EMPHASISMARK_POS_BELOW; break; +/*?*/ case FontEmphasis::DISK_BELOW : nValue = EMPHASISMARK_DISC|EMPHASISMARK_POS_BELOW; break; +/*?*/ case FontEmphasis::ACCENT_BELOW: nValue = EMPHASISMARK_ACCENT|EMPHASISMARK_POS_BELOW; break; +/*?*/ default: return sal_False; +/*N*/ } +/*N*/ SetValue( (sal_Int16)nValue ); +/*N*/ } +/*N*/ break; +/*N*/ } +/*N*/ return bRet; +/*N*/ } + +/*N*/ USHORT SvxEmphasisMarkItem::GetVersion( USHORT nFFVer ) const +/*N*/ { +/*N*/ DBG_ASSERT( SOFFICE_FILEFORMAT_31==nFFVer || +/*N*/ SOFFICE_FILEFORMAT_40==nFFVer || +/*N*/ SOFFICE_FILEFORMAT_50==nFFVer, +/*N*/ "SvxEmphasisMarkItem: Gibt es ein neues Fileformat?" ); +/*N*/ +/*N*/ return SOFFICE_FILEFORMAT_50 > nFFVer ? USHRT_MAX : 0; +/*N*/ } + + +/************************************************************************* +|* class SvxTwoLinesItem +*************************************************************************/ + +/*N*/ SvxTwoLinesItem::SvxTwoLinesItem( sal_Bool bFlag, sal_Unicode nStartBracket, +/*N*/ sal_Unicode nEndBracket, sal_uInt16 nW ) +/*N*/ : SfxPoolItem( nW ), +/*N*/ bOn( bFlag ), cStartBracket( nStartBracket ), cEndBracket( nEndBracket ) +/*N*/ { +/*N*/ } + +/*NBFF*/ SvxTwoLinesItem::SvxTwoLinesItem( const SvxTwoLinesItem& rAttr ) +/*NBFF*/ : SfxPoolItem( rAttr.Which() ), +/*NBFF*/ bOn( rAttr.bOn ), cStartBracket( rAttr.cStartBracket ), +/*NBFF*/ cEndBracket( rAttr.cEndBracket ) +/*NBFF*/ { +/*NBFF*/ } + +/*N*/ SvxTwoLinesItem::~SvxTwoLinesItem() +/*N*/ { +/*N*/ } + +/*?*/ int SvxTwoLinesItem::operator==( const SfxPoolItem& rAttr ) const +/*?*/ { +/*NFFF*/ DBG_ASSERT( SfxPoolItem::operator==( rAttr ), "not equal attribute types" ); +/*NBFF*/ return bOn == ((SvxTwoLinesItem&)rAttr).bOn && +/*NBFF*/ cStartBracket == ((SvxTwoLinesItem&)rAttr).cStartBracket && +/*NBFF*/ cEndBracket == ((SvxTwoLinesItem&)rAttr).cEndBracket; +/*?*/ } + +/*?*/ SfxPoolItem* SvxTwoLinesItem::Clone( SfxItemPool* ) const +/*?*/ { +/*NBFF*/ return new SvxTwoLinesItem( *this ); +/*?*/ } + +/*NBFF*/ bool SvxTwoLinesItem::QueryValue( ::com::sun::star::uno::Any& rVal, +/*NBFF*/ BYTE nMemberId ) const +/*NBFF*/ { +/*NBFF*/ sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); +/*NBFF*/ nMemberId &= ~CONVERT_TWIPS; +/*NBFF*/ sal_Bool bRet = sal_True; +/*NBFF*/ switch( nMemberId ) +/*NBFF*/ { +/*NBFF*/ case MID_TWOLINES: +/*NBFF*/ rVal = Bool2Any( bOn ); +/*NBFF*/ break; +/*NBFF*/ case MID_START_BRACKET: +/*NBFF*/ { +/*NBFF*/ OUString s; +/*NBFF*/ if( cStartBracket ) +/*NBFF*/ s = OUString( cStartBracket ); +/*NBFF*/ rVal <<= s; +/*NBFF*/ } +/*NBFF*/ break; +/*NBFF*/ case MID_END_BRACKET: +/*NBFF*/ { +/*NBFF*/ OUString s; +/*NBFF*/ if( cEndBracket ) +/*NBFF*/ s = OUString( cEndBracket ); +/*NBFF*/ rVal <<= s; +/*NBFF*/ } +/*NBFF*/ break; +/*NBFF*/ default: +/*NBFF*/ bRet = sal_False; +/*NBFF*/ break; +/*NBFF*/ } +/*NBFF*/ return bRet; +/*NBFF*/ } + +/*NBFF*/ bool SvxTwoLinesItem::PutValue( const ::com::sun::star::uno::Any& rVal, +/*NBFF*/ BYTE nMemberId ) +/*NBFF*/ { +/*NBFF*/ sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); +/*NBFF*/ nMemberId &= ~CONVERT_TWIPS; +/*NBFF*/ sal_Bool bRet = sal_False; +/*NBFF*/ OUString s; +/*NBFF*/ switch( nMemberId ) +/*NBFF*/ { +/*NBFF*/ case MID_TWOLINES: +/*NBFF*/ bOn = Any2Bool( rVal ); +/*NBFF*/ bRet = sal_True; +/*NBFF*/ break; +/*NBFF*/ case MID_START_BRACKET: +/*NBFF*/ if( rVal >>= s ) +/*NBFF*/ { +/*NBFF*/ cStartBracket = s.getLength() ? s[ 0 ] : 0; +/*NBFF*/ bRet = sal_True; +/*NBFF*/ } +/*NBFF*/ break; +/*NBFF*/ case MID_END_BRACKET: +/*NBFF*/ if( rVal >>= s ) +/*NBFF*/ { +/*NBFF*/ cEndBracket = s.getLength() ? s[ 0 ] : 0; +/*NBFF*/ bRet = sal_True; +/*NBFF*/ } +/*NBFF*/ break; +/*NBFF*/ } +/*NBFF*/ return bRet; +/*NBFF*/ } + +/*NBFF*/ SfxItemPresentation SvxTwoLinesItem::GetPresentation( SfxItemPresentation ePres, +/*NBFF*/ SfxMapUnit eCoreMetric, SfxMapUnit ePresMetric, +/*NBFF*/ String &rText, const ::IntlWrapper* pIntl ) const +/*NBFF*/ { +/*NBFF*/ switch( ePres ) +/*NBFF*/ { +/*NBFF*/ case SFX_ITEM_PRESENTATION_NONE: +/*NBFF*/ rText.Erase(); +/*NBFF*/ break; +/*NBFF*/ case SFX_ITEM_PRESENTATION_NAMELESS: +/*NBFF*/ case SFX_ITEM_PRESENTATION_COMPLETE: +/*NBFF*/ { +/*NBFF*/ if( !GetValue() ) +/*NBFF*/ rText = SVX_RESSTR( RID_SVXITEMS_TWOLINES_OFF ); +/*NBFF*/ else +/*NBFF*/ { +/*NBFF*/ rText = SVX_RESSTR( RID_SVXITEMS_TWOLINES ); +/*NBFF*/ if( GetStartBracket() ) +/*NBFF*/ rText.Insert( GetStartBracket(), 0 ); +/*NBFF*/ if( GetEndBracket() ) +/*NBFF*/ rText += GetEndBracket(); +/*NBFF*/ } +/*NBFF*/ return ePres; +/*NBFF*/ } +/*NBFF*/ break; +/*NBFF*/ } +/*NBFF*/ return SFX_ITEM_PRESENTATION_NONE; +/*NBFF*/ } + + +/*NBFF*/ SfxPoolItem* SvxTwoLinesItem::Create( SvStream & rStrm, USHORT nVer) const +/*NBFF*/ { +/*NBFF*/ sal_Bool bOn; +/*NBFF*/ sal_Unicode cStart, cEnd; +/*NBFF*/ rStrm >> bOn >> cStart >> cEnd; +/*NBFF*/ return new SvxTwoLinesItem( bOn, cStart, cEnd, Which() ); +/*NBFF*/ } + +/*NBFF*/ SvStream& SvxTwoLinesItem::Store(SvStream & rStrm, USHORT nIVer) const +/*NBFF*/ { +/*NBFF*/ rStrm << GetValue() << GetStartBracket() << GetEndBracket(); +/*NBFF*/ return rStrm; +/*NBFF*/ } + +/*N*/ USHORT SvxTwoLinesItem::GetVersion( USHORT nFFVer ) const +/*N*/ { +/*N*/ DBG_ASSERT( SOFFICE_FILEFORMAT_31==nFFVer || +/*N*/ SOFFICE_FILEFORMAT_40==nFFVer || +/*N*/ SOFFICE_FILEFORMAT_50==nFFVer, +/*N*/ "SvxTwoLinesItem: Gibt es ein neues Fileformat?" ); +/*N*/ +/*N*/ return SOFFICE_FILEFORMAT_50 > nFFVer ? USHRT_MAX : 0; +/*N*/ } + + +/************************************************************************* +|* class SvxCharRotateItem +*************************************************************************/ + +/*N*/ SvxCharRotateItem::SvxCharRotateItem( sal_uInt16 nValue, +/*N*/ sal_Bool bFitIntoLine, +/*N*/ const sal_uInt16 nW ) +/*N*/ : SfxUInt16Item( nW, nValue ), bFitToLine( bFitIntoLine ) +/*N*/ { +/*N*/ } + +/*NBFF*/ SfxPoolItem* SvxCharRotateItem::Clone( SfxItemPool* ) const +/*NBFF*/ { +/*NBFF*/ return new SvxCharRotateItem( GetValue(), IsFitToLine(), Which() ); +/*NBFF*/ } + +/*NBFF*/ SfxPoolItem* SvxCharRotateItem::Create( SvStream& rStrm, USHORT ) const +/*NBFF*/ { +/*NBFF*/ sal_uInt16 nVal; +/*NBFF*/ sal_Bool b; +/*NBFF*/ rStrm >> nVal >> b; +/*NBFF*/ return new SvxCharRotateItem( nVal, b, Which() ); +/*NBFF*/ } + +/*NBFF*/ SvStream& SvxCharRotateItem::Store( SvStream & rStrm, USHORT ) const +/*NBFF*/ { +/*NBFF*/ sal_Bool bFlag = IsFitToLine(); +/*NBFF*/ rStrm << GetValue() << bFlag; +/*NBFF*/ return rStrm; +/*NBFF*/ } + +/*N*/ USHORT SvxCharRotateItem::GetVersion( USHORT nFFVer ) const +/*N*/ { +/*N*/ return SOFFICE_FILEFORMAT_50 > nFFVer ? USHRT_MAX : 0; +/*N*/ } + +/*NBFF*/ SfxItemPresentation SvxCharRotateItem::GetPresentation( +/*NBFF*/ SfxItemPresentation ePres, +/*NBFF*/ SfxMapUnit eCoreMetric, SfxMapUnit ePresMetric, +/*NBFF*/ String &rText, const ::IntlWrapper* ) const +/*NBFF*/ { +/*NBFF*/ switch( ePres ) +/*NBFF*/ { +/*NBFF*/ case SFX_ITEM_PRESENTATION_NONE: +/*NBFF*/ rText.Erase(); +/*NBFF*/ break; +/*NBFF*/ case SFX_ITEM_PRESENTATION_NAMELESS: +/*NBFF*/ case SFX_ITEM_PRESENTATION_COMPLETE: +/*NBFF*/ { +/*NBFF*/ if( !GetValue() ) +/*NBFF*/ rText = SVX_RESSTR( RID_SVXITEMS_CHARROTATE_OFF ); +/*NBFF*/ else +/*NBFF*/ { +/*NBFF*/ rText = SVX_RESSTR( RID_SVXITEMS_CHARROTATE ); +/*NBFF*/ rText.SearchAndReplaceAscii( "$(ARG1)", +/*NBFF*/ String::CreateFromInt32( GetValue() / 10 )); +/*NBFF*/ if( IsFitToLine() ) +/*NBFF*/ rText += SVX_RESSTR( RID_SVXITEMS_CHARROTATE_FITLINE ); +/*NBFF*/ } +/*NBFF*/ return ePres; +/*NBFF*/ } +/*NBFF*/ break; +/*NBFF*/ } +/*NBFF*/ return SFX_ITEM_PRESENTATION_NONE; +/*NBFF*/ } + +/*NBFF*/ bool SvxCharRotateItem::QueryValue( ::com::sun::star::uno::Any& rVal, +/*NBFF*/ BYTE nMemberId ) const +/*NBFF*/ { +/*NBFF*/ sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); +/*NBFF*/ nMemberId &= ~CONVERT_TWIPS; +/*NBFF*/ sal_Bool bRet = sal_True; +/*NBFF*/ switch( nMemberId ) +/*NBFF*/ { +/*NBFF*/ case MID_ROTATE: +/*NBFF*/ rVal <<= (sal_Int16)GetValue(); +/*NBFF*/ break; +/*NBFF*/ case MID_FITTOLINE: +/*NBFF*/ rVal = Bool2Any( IsFitToLine() ); +/*NBFF*/ break; +/*NBFF*/ default: +/*NBFF*/ bRet = sal_False; +/*NBFF*/ break; +/*NBFF*/ } +/*NBFF*/ return bRet; +/*NBFF*/ } + +/*NBFF*/ bool SvxCharRotateItem::PutValue( const ::com::sun::star::uno::Any& rVal, +/*NBFF*/ BYTE nMemberId ) +/*NBFF*/ { +/*NBFF*/ sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); +/*NBFF*/ nMemberId &= ~CONVERT_TWIPS; +/*NBFF*/ sal_Bool bRet = sal_True; +/*NBFF*/ sal_Int16 nVal; +/*NBFF*/ switch( nMemberId ) +/*NBFF*/ { +/*NBFF*/ case MID_ROTATE: +/*NBFF*/ rVal >>= nVal; +/*NBFF*/ if(!nVal || 900 == nVal || 2700 == nVal) +/*NBFF*/ SetValue( (USHORT)nVal ); +/*NBFF*/ else +/*NBFF*/ bRet = sal_False; +/*NBFF*/ break; +/*NBFF*/ +/*NBFF*/ case MID_FITTOLINE: +/*NBFF*/ SetFitToLine( Any2Bool( rVal ) ); +/*NBFF*/ break; +/*NBFF*/ default: +/*NBFF*/ bRet = sal_False; +/*NBFF*/ } +/*NBFF*/ return bRet; +/*NBFF*/ } + +/*NBFF*/ int SvxCharRotateItem::operator==( const SfxPoolItem& rItem ) const +/*NBFF*/ { +/*NBFF*/ DBG_ASSERT( SfxPoolItem::operator==( rItem ), "unequal type" ); +/*NBFF*/ return SfxUInt16Item::operator==( rItem ) && +/*NBFF*/ IsFitToLine() == ((const SvxCharRotateItem&)rItem).IsFitToLine(); +/*NBFF*/ } + + +/************************************************************************* +|* class SvxCharScaleItem +*************************************************************************/ + +/*N*/ SvxCharScaleWidthItem::SvxCharScaleWidthItem( sal_uInt16 nValue, +/*N*/ const sal_uInt16 nW ) +/*N*/ : SfxUInt16Item( nW, nValue ) +/*N*/ { +/*N*/ } + +/*N*/ SfxPoolItem* SvxCharScaleWidthItem::Clone( SfxItemPool* ) const +/*N*/ { +/*N*/ return new SvxCharScaleWidthItem( GetValue(), Which() ); +/*N*/ } + +/*N*/ SfxPoolItem* SvxCharScaleWidthItem::Create( SvStream& rStrm, USHORT ) const +/*N*/ { +/*N*/ sal_uInt16 nVal; +/*N*/ rStrm >> nVal; +/*N*/ SvxCharScaleWidthItem* pItem = new SvxCharScaleWidthItem( nVal, Which() ); +/*N*/ +/*N*/ if ( Which() == EE_CHAR_FONTWIDTH ) +/*N*/ { +/*N*/ // #87271#: Was a SvxFontWidthItem in 5.2 +/*N*/ // USHORT nFixWidth, USHORT nPropWidth. +/*N*/ // nFixWidth has never been used... +/*N*/ rStrm >> nVal; +/*N*/ USHORT nTest; +/*N*/ rStrm >> nTest; +/*N*/ if ( nTest == 0x1234 ) +/*N*/ pItem->SetValue( nVal ); +/*N*/ else +/*N*/ rStrm.SeekRel( -2*(long)sizeof(sal_uInt16) ); +/*N*/ } +/*N*/ +/*N*/ return pItem; +/*N*/ } + +/*N*/ SvStream& SvxCharScaleWidthItem::Store( SvStream& rStream, USHORT nVer ) const +/*N*/ { +/*N*/ SvStream& rRet = SfxUInt16Item::Store( rStream, nVer ); +/*N*/ if ( Which() == EE_CHAR_FONTWIDTH ) +/*N*/ { +/*N*/ // see comment in Create().... +/*N*/ rRet.SeekRel( -1*(long)sizeof(USHORT) ); +/*N*/ rRet << (USHORT)0; +/*N*/ rRet << GetValue(); +/*N*/ // Really ugly, but not a problem for reading the doc in 5.2 +/*N*/ rRet << (USHORT)0x1234; +/*N*/ } +/*N*/ return rRet; +/*N*/ } + + +/*N*/ USHORT SvxCharScaleWidthItem::GetVersion( USHORT nFFVer ) const +/*N*/ { +/*N*/ return SOFFICE_FILEFORMAT_50 > nFFVer ? USHRT_MAX : 0; +/*N*/ } + + +/*N*/ bool SvxCharScaleWidthItem::PutValue( const uno::Any& rVal, BYTE nMemberId ) +/*N*/ { +/*N*/ // SfxUInt16Item::QueryValue returns sal_Int32 in Any now... (srx642w) +/*N*/ // where we still want this to be a sal_Int16 +/*N*/ sal_Int16 nValue; +/*N*/ if (rVal >>= nValue) +/*N*/ { +/*N*/ SetValue( (UINT16) nValue ); +/*N*/ return TRUE; +/*N*/ } +/*N*/ +/*N*/ DBG_ERROR( "SvxCharScaleWidthItem::PutValue - Wrong type!" ); +/*N*/ return FALSE; +/*N*/ } + +/*N*/ bool SvxCharScaleWidthItem::QueryValue( uno::Any& rVal, BYTE nMemberId ) const +/*N*/ { +/*N*/ // SfxUInt16Item::QueryValue returns sal_Int32 in Any now... (srx642w) +/*N*/ // where we still want this to be a sal_Int16 +/*N*/ rVal <<= (sal_Int16)GetValue(); +/*N*/ return TRUE; +/*N*/ } + +/************************************************************************* +|* class SvxCharReliefItem +*************************************************************************/ + +/*N*/ SvxCharReliefItem::SvxCharReliefItem( FontRelief eValue, +/*N*/ const sal_uInt16 nId ) +/*N*/ : SfxEnumItem( nId, eValue ) +/*N*/ { +/*N*/ } + +/*N*/ SfxPoolItem* SvxCharReliefItem::Clone( SfxItemPool *pPool ) const +/*N*/ { +/*N*/ return new SvxCharReliefItem( *this ); +/*N*/ } + +/*N*/ SfxPoolItem* SvxCharReliefItem::Create(SvStream & rStrm, USHORT) const +/*N*/ { +/*N*/ sal_uInt16 nVal; +/*N*/ rStrm >> nVal; +/*N*/ return new SvxCharReliefItem( (FontRelief)nVal, Which() ); +/*N*/ } + +/*N*/ SvStream& SvxCharReliefItem::Store(SvStream & rStrm, USHORT nIVer) const +/*N*/ { +/*N*/ sal_uInt16 nVal = GetValue(); +/*N*/ rStrm << nVal; +/*N*/ return rStrm; +/*N*/ } + +/*N*/ USHORT SvxCharReliefItem::GetVersion( USHORT nFFVer ) const +/*N*/ { +/*N*/ return SOFFICE_FILEFORMAT_50 > nFFVer ? USHRT_MAX : 0; +/*N*/ } + +/*N*/ String SvxCharReliefItem::GetValueTextByPos( USHORT nPos ) const +/*N*/ { +/*N*/ DBG_ASSERT( RID_SVXITEMS_RELIEF_ENGRAVED - RID_SVXITEMS_RELIEF_NONE, +/*N*/ "enum overflow" ); +/*N*/ return String( SVX_RES( RID_SVXITEMS_RELIEF_BEGIN + nPos )); +/*N*/ } + +/*N*/ USHORT SvxCharReliefItem::GetValueCount() const +/*N*/ { +/*N*/ return RID_SVXITEMS_RELIEF_ENGRAVED - RID_SVXITEMS_RELIEF_NONE; +/*N*/ } + +/*N*/ SfxItemPresentation SvxCharReliefItem::GetPresentation +/*N*/ ( +/*N*/ SfxItemPresentation ePres, +/*N*/ SfxMapUnit eCoreUnit, +/*N*/ SfxMapUnit ePresUnit, +/*N*/ XubString& rText, const ::IntlWrapper *pIntl +/*N*/ ) const +/*N*/ { +/*?*/ SfxItemPresentation eRet = ePres; +/*?*/ switch( ePres ) +/*?*/ { +/*?*/ case SFX_ITEM_PRESENTATION_NONE: +/*?*/ rText.Erase(); +/*?*/ break; +/*?*/ +/*?*/ case SFX_ITEM_PRESENTATION_NAMELESS: +/*?*/ case SFX_ITEM_PRESENTATION_COMPLETE: +/*?*/ rText = GetValueTextByPos( GetValue() ); +/*?*/ break; +/*?*/ +/*?*/ default: +/*?*/ eRet = SFX_ITEM_PRESENTATION_NONE; +/*?*/ } +/*?*/ return eRet; +/*N*/ } + +/*N*/ bool SvxCharReliefItem::PutValue( const ::com::sun::star::uno::Any& rVal, +/*N*/ BYTE nMemberId ) +/*N*/ { +/*N*/ sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); +/*N*/ nMemberId &= ~CONVERT_TWIPS; +/*N*/ sal_Bool bRet = sal_True; +/*N*/ switch( nMemberId ) +/*N*/ { +/*N*/ case MID_RELIEF: +/*N*/ { +/*N*/ sal_Int16 nVal = -1; +/*N*/ rVal >>= nVal; +/*N*/ if(nVal >= 0 && nVal <= RELIEF_ENGRAVED) +/*N*/ SetValue( (FontRelief)nVal ); +/*N*/ else +/*N*/ bRet = sal_False; +/*N*/ } +/*N*/ break; +/*N*/ default: +/*N*/ bRet = sal_False; +/*N*/ break; +/*N*/ } +/*N*/ return bRet; +/*N*/ } + +/*N*/ bool SvxCharReliefItem::QueryValue( ::com::sun::star::uno::Any& rVal, +/*N*/ BYTE nMemberId ) const +/*N*/ { +/*N*/ sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); +/*N*/ nMemberId &= ~CONVERT_TWIPS; +/*N*/ sal_Bool bRet = sal_True; +/*N*/ switch( nMemberId ) +/*N*/ { +/*N*/ case MID_RELIEF: +/*N*/ rVal <<= (sal_Int16)GetValue(); +/*N*/ break; +/*N*/ default: +/*N*/ bRet = sal_False; +/*N*/ break; +/*N*/ } +/*N*/ return bRet; +/*N*/ } + +/************************************************************************* +|* class SvxScriptTypeItemItem +*************************************************************************/ + + +/************************************************************************* +|* class SvxScriptSetItem +*************************************************************************/ + +/*N*/ SfxPoolItem* SvxScriptSetItem::Clone( SfxItemPool *pPool ) const +/*N*/ {DBG_BF_ASSERT(0, "STRIP"); return NULL;//STRIP001 +/*N*/ } + +/*N*/ SfxPoolItem* SvxScriptSetItem::Create( SvStream &, USHORT ) const +/*N*/ { +/*N*/ return 0; +/*N*/ } + +/*N*/ void GetDefaultFonts( SvxFontItem& rLatin, SvxFontItem& rAsian, SvxFontItem& rComplex ) +/*N*/ { +/*N*/ const USHORT nItemCnt = 3; +/*N*/ +/*N*/ static struct +/*N*/ { +/*N*/ USHORT nFontType; +/*N*/ USHORT nLanguage; +/*N*/ } +/*N*/ aOutTypeArr[ nItemCnt ] = +/*N*/ { +/*N*/ { DEFAULTFONT_LATIN_TEXT, LANGUAGE_ENGLISH_US }, +/*N*/ { DEFAULTFONT_CJK_TEXT, LANGUAGE_ENGLISH_US }, +/*N*/ { DEFAULTFONT_CTL_TEXT, LANGUAGE_ARABIC_SAUDI_ARABIA } +/*N*/ }; +/*N*/ +/*N*/ SvxFontItem* aItemArr[ nItemCnt ] = { &rLatin, &rAsian, &rComplex }; +/*N*/ +/*N*/ for ( USHORT n = 0; n < nItemCnt; ++n ) +/*N*/ { +/*N*/ Font aFont( OutputDevice::GetDefaultFont( aOutTypeArr[ n ].nFontType, +/*N*/ aOutTypeArr[ n ].nLanguage, +/*N*/ DEFAULTFONT_FLAGS_ONLYONE, 0 ) ); +/*N*/ SvxFontItem* pItem = aItemArr[ n ]; +/*N*/ pItem->GetFamily() = aFont.GetFamily(); +/*N*/ pItem->GetFamilyName() = aFont.GetName(); +/*N*/ pItem->GetStyleName().Erase(); +/*N*/ pItem->GetPitch() = aFont.GetPitch(); +/*N*/ pItem->GetCharSet() = aFont.GetCharSet(); +/*N*/ } +/*N*/ } + + +/*N*/ USHORT GetI18NScriptTypeOfLanguage( USHORT nLang ) +/*N*/ { +/*N*/ return GetI18NScriptType( SvtLanguageOptions::GetScriptTypeOfLanguage( nLang ) ); +/*N*/ } + +/*N*/ USHORT GetItemScriptType( short nI18NType ) +/*N*/ { +/*N*/ switch ( nI18NType ) +/*N*/ { +/*N*/ case i18n::ScriptType::LATIN: return SCRIPTTYPE_LATIN; +/*?*/ case i18n::ScriptType::ASIAN: return SCRIPTTYPE_ASIAN; +/*?*/ case i18n::ScriptType::COMPLEX: return SCRIPTTYPE_COMPLEX; +/*N*/ } +/*N*/ return 0; +/*N*/ } + +/*N*/ short GetI18NScriptType( USHORT nItemType ) +/*N*/ { +/*N*/ switch ( nItemType ) +/*N*/ { +/*N*/ case SCRIPTTYPE_LATIN: return i18n::ScriptType::LATIN; +/*?*/ case SCRIPTTYPE_ASIAN: return i18n::ScriptType::ASIAN; +/*?*/ case SCRIPTTYPE_COMPLEX: return i18n::ScriptType::COMPLEX; +/*N*/ } +/*N*/ return 0; +/*N*/ } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_svx/source/items/svx_writingmodeitem.cxx b/binfilter/bf_svx/source/items/svx_writingmodeitem.cxx new file mode 100644 index 000000000000..c42f9dba7526 --- /dev/null +++ b/binfilter/bf_svx/source/items/svx_writingmodeitem.cxx @@ -0,0 +1,91 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +// include --------------------------------------------------------------- + + +#include <bf_svx/xdef.hxx> + +#include "writingmodeitem.hxx" + + +#include "svxitems.hrc" +namespace binfilter { + +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::text; + +// class SvxWritingModeItem ------------------------------------------------- + +/*N*/ TYPEINIT1_AUTOFACTORY(SvxWritingModeItem, SfxUInt16Item); + +/*N*/ SvxWritingModeItem::SvxWritingModeItem( WritingMode eValue, USHORT nWhich ) +/*N*/ : SfxUInt16Item( nWhich, (sal_uInt16)eValue ) +/*N*/ { +/*N*/ } + +/*N*/ SvxWritingModeItem::~SvxWritingModeItem() +/*N*/ { +/*N*/ } + +/*N*/ int SvxWritingModeItem::operator==( const SfxPoolItem& rCmp ) const +/*N*/ { +/*N*/ DBG_ASSERT( SfxPoolItem::operator==(rCmp), "unequal types" ); +/*N*/ +/*N*/ return GetValue() == ((SvxWritingModeItem&)rCmp).GetValue(); +/*N*/ } + +/*N*/ SfxPoolItem* SvxWritingModeItem::Clone( SfxItemPool * ) const +/*N*/ { +/*N*/ return new SvxWritingModeItem( *this ); +/*N*/ } + + + +/*N*/ USHORT SvxWritingModeItem::GetVersion( USHORT nFVer ) const +/*N*/ { +/*N*/ return USHRT_MAX; +/*N*/ } + + + +/*N*/ bool SvxWritingModeItem::QueryValue( ::com::sun::star::uno::Any& rVal, +/*N*/ BYTE ) const +/*N*/ { +/*N*/ rVal <<= (WritingMode)GetValue(); +/*N*/ return true; +/*N*/ } + +/*N*/ SvxWritingModeItem& SvxWritingModeItem::operator=( const SvxWritingModeItem& rItem ) +/*N*/ { +/*N*/ SetValue( rItem.GetValue() ); +/*N*/ return *this; +/*N*/ } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_svx/source/items/svx_xmlcnitm.cxx b/binfilter/bf_svx/source/items/svx_xmlcnitm.cxx new file mode 100644 index 000000000000..17cdb6493815 --- /dev/null +++ b/binfilter/bf_svx/source/items/svx_xmlcnitm.cxx @@ -0,0 +1,236 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#include <com/sun/star/xml/AttributeData.hpp> +#include <com/sun/star/lang/XUnoTunnel.hpp> + +#include <bf_xmloff/xmlcnimp.hxx> +#include <bf_xmloff/unoatrcn.hxx> +#include "xmlcnitm.hxx" +namespace binfilter { + +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::container; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star::xml; + +using rtl::OUString; + +// ------------------------------------------------------------------------ + +/*N*/ TYPEINIT1(SvXMLAttrContainerItem, SfxPoolItem); + +/*N*/ SvXMLAttrContainerItem::SvXMLAttrContainerItem( USHORT nWhich ) : +/*N*/ SfxPoolItem( nWhich ) +/*N*/ { +/*N*/ pImpl = new SvXMLAttrContainerData; +/*N*/ } + +/*N*/ SvXMLAttrContainerItem::SvXMLAttrContainerItem( +/*N*/ const SvXMLAttrContainerItem& rItem ) : +/*N*/ SfxPoolItem( rItem ) +/*N*/ { +/*N*/ pImpl = new SvXMLAttrContainerData( *rItem.pImpl ); +/*N*/ } + +/*N*/ SvXMLAttrContainerItem::~SvXMLAttrContainerItem() +/*N*/ { +/*N*/ delete pImpl; +/*N*/ } + +/*N*/ int SvXMLAttrContainerItem::operator==( const SfxPoolItem& rItem ) const +/*N*/ { +/*N*/ DBG_ASSERT( rItem.ISA(SvXMLAttrContainerItem), +/*N*/ "SvXMLAttrContainerItem::operator ==(): Bad type"); +/*N*/ return *pImpl == *((const SvXMLAttrContainerItem&)rItem).pImpl; +/*N*/ } + + + +/*N*/ USHORT SvXMLAttrContainerItem::GetVersion( USHORT nFileFormatVersion ) const +/*N*/ { +/*N*/ // This item should never be stored +/*N*/ return USHRT_MAX; +/*N*/ } + +/*N*/ bool SvXMLAttrContainerItem::QueryValue( ::com::sun::star::uno::Any& rVal, BYTE nMemberId ) const +/*N*/ { +/*N*/ Reference<XNameContainer> xContainer = +/*N*/ new SvUnoAttributeContainer( new SvXMLAttrContainerData( *pImpl ) ); +/*N*/ +/*N*/ rVal.setValue( &xContainer, ::getCppuType((Reference<XNameContainer>*)0) ); +/*N*/ return true; +/*N*/ } +/*N*/ bool SvXMLAttrContainerItem::PutValue( const ::com::sun::star::uno::Any& rVal, BYTE nMemberId ) +/*NBFF*/{ +/*NBFF*/ Reference<XInterface> xRef; +/*NBFF*/ SvUnoAttributeContainer* pContainer = NULL; +/*NBFF*/ +/*NBFF*/ if( rVal.getValue() != NULL && rVal.getValueType().getTypeClass() == TypeClass_INTERFACE ) +/*NBFF*/ { +/*NBFF*/ xRef = *(Reference<XInterface>*)rVal.getValue(); +/*NBFF*/ Reference<XUnoTunnel> xTunnel(xRef, UNO_QUERY); +/*NBFF*/ if( xTunnel.is() ) +/*NBFF*/ pContainer = (SvUnoAttributeContainer*)xTunnel->getSomething(SvUnoAttributeContainer::getUnoTunnelId()); +/*NBFF*/ } +/*NBFF*/ +/*NBFF*/ if( pContainer ) +/*NBFF*/ { +/*NBFF*/ delete pImpl; +/*NBFF*/ pImpl = new SvXMLAttrContainerData( * pContainer->GetContainerImpl() ); +/*NBFF*/ } +/*NBFF*/ else +/*NBFF*/ { +/*NBFF*/ SvXMLAttrContainerData* pNewImpl = new SvXMLAttrContainerData; +/*NBFF*/ +/*NBFF*/ try +/*NBFF*/ { +/*NBFF*/ Reference<XNameContainer> xContainer( xRef, UNO_QUERY ); +/*NBFF*/ if( !xContainer.is() ) +/*NBFF*/ return false; +/*NBFF*/ +/*NBFF*/ const Sequence< OUString > aNameSequence( xContainer->getElementNames() ); +/*NBFF*/ const OUString* pNames = aNameSequence.getConstArray(); +/*NBFF*/ const INT32 nCount = aNameSequence.getLength(); +/*NBFF*/ Any aAny; +/*NBFF*/ AttributeData* pData; +/*NBFF*/ +/*NBFF*/ INT32 nAttr; for( nAttr = 0; nAttr < nCount; nAttr++ ) +/*NBFF*/ { +/*NBFF*/ const OUString aName( *pNames++ ); +/*NBFF*/ +/*NBFF*/ aAny = xContainer->getByName( aName ); +/*NBFF*/ if( aAny.getValue() == NULL || aAny.getValueType() != ::getCppuType((AttributeData*)0) ) +/*NBFF*/ return false; +/*NBFF*/ +/*NBFF*/ pData = (AttributeData*)aAny.getValue(); +/*NBFF*/ USHORT pos = aName.indexOf( sal_Unicode(':') ); +/*NBFF*/ if( pos != -1 ) +/*NBFF*/ { +/*NBFF*/ const OUString aPrefix( aName.copy( 0, pos )); +/*NBFF*/ const OUString aLName( aName.copy( pos+1 )); +/*NBFF*/ +/*NBFF*/ if( pData->Namespace.getLength() == 0 ) +/*NBFF*/ { +/*NBFF*/ if( !pNewImpl->AddAttr( aPrefix, aLName, pData->Value ) ) +/*NBFF*/ break; +/*NBFF*/ } +/*NBFF*/ else +/*NBFF*/ { +/*NBFF*/ if( !pNewImpl->AddAttr( aPrefix, pData->Namespace, aLName, pData->Value ) ) +/*NBFF*/ break; +/*NBFF*/ } +/*NBFF*/ } +/*NBFF*/ else +/*NBFF*/ { +/*NBFF*/ if( !pNewImpl->AddAttr( aName, pData->Value ) ) +/*NBFF*/ break; +/*NBFF*/ } +/*NBFF*/ } +/*NBFF*/ +/*NBFF*/ if( nAttr == nCount ) +/*NBFF*/ { +/*NBFF*/ delete pImpl; +/*NBFF*/ pImpl = pNewImpl; +/*NBFF*/ return false; +/*NBFF*/ } +/*NBFF*/ else +/*NBFF*/ { +/*NBFF*/ delete pNewImpl; +/*NBFF*/ } +/*NBFF*/ } +/*NBFF*/ catch(...) +/*NBFF*/ { +/*NBFF*/ delete pNewImpl; +/*NBFF*/ return false; +/*NBFF*/ } +/*NBFF*/ } +/*NBFF*/ return true; +/*N*/ } + + +/*N*/ BOOL SvXMLAttrContainerItem::AddAttr( const OUString& rLName, +/*N*/ const OUString& rValue ) +/*N*/ { +/*N*/ return pImpl->AddAttr( rLName, rValue ); +/*N*/ } + +/*N*/ BOOL SvXMLAttrContainerItem::AddAttr( const OUString& rPrefix, +/*N*/ const OUString& rNamespace, const OUString& rLName, +/*N*/ const OUString& rValue ) +/*N*/ { +/*N*/ return pImpl->AddAttr( rPrefix, rNamespace, rLName, rValue ); +/*N*/ } + +/*N*/ USHORT SvXMLAttrContainerItem::GetAttrCount() const +/*N*/ { +/*N*/ return (USHORT)pImpl->GetAttrCount(); +/*N*/ } + +/*N*/ OUString SvXMLAttrContainerItem::GetAttrNamespace( USHORT i ) const +/*N*/ { +/*N*/ return pImpl->GetAttrNamespace( i ); +/*N*/ } + +/*N*/ OUString SvXMLAttrContainerItem::GetAttrPrefix( USHORT i ) const +/*N*/ { +/*N*/ return pImpl->GetAttrPrefix( i ); +/*N*/ } + +/*N*/ const OUString& SvXMLAttrContainerItem::GetAttrLName( USHORT i ) const +/*N*/ { +/*N*/ return pImpl->GetAttrLName( i ); +/*N*/ } + +/*N*/ const OUString& SvXMLAttrContainerItem::GetAttrValue( USHORT i ) const +/*N*/ { +/*N*/ return pImpl->GetAttrValue( i ); +/*N*/ } + + +/*N*/ USHORT SvXMLAttrContainerItem::GetFirstNamespaceIndex() const +/*N*/ {DBG_BF_ASSERT(0, "STRIP"); return 0;//STRIP001 +/*N*/ } + +/*N*/ USHORT SvXMLAttrContainerItem::GetNextNamespaceIndex( USHORT nIdx ) const +/*N*/ {DBG_BF_ASSERT(0, "STRIP"); return 0;//STRIP001 +/*N*/ } + +/*N*/ const OUString& SvXMLAttrContainerItem::GetNamespace( USHORT i ) const +/*N*/ {DBG_BF_ASSERT(0, "STRIP"); return OUString::createFromAscii (""); //STRIP001 +/*N*/ } + +/*N*/ const OUString& SvXMLAttrContainerItem::GetPrefix( USHORT i ) const +/*N*/ { +/*N*/ DBG_BF_ASSERT(0, "STRIP"); return ::rtl::OUString::createFromAscii ("");//STRIP001 /*N*/ return pImpl->GetPrefix( i ); +/*N*/ } + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/binfilter/bf_svx/source/items/svx_zoomitem.cxx b/binfilter/bf_svx/source/items/svx_zoomitem.cxx new file mode 100644 index 000000000000..a1b89b551aa1 --- /dev/null +++ b/binfilter/bf_svx/source/items/svx_zoomitem.cxx @@ -0,0 +1,98 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifdef _MSC_VER +#pragma hdrstop +#endif + +#include "zoomitem.hxx" +namespace binfilter { + +// ----------------------------------------------------------------------- + +/*N*/ TYPEINIT1_AUTOFACTORY(SvxZoomItem,SfxUInt16Item); + +// ----------------------------------------------------------------------- + +/*N*/ SvxZoomItem::SvxZoomItem +/*N*/ ( +/*N*/ SvxZoomType eZoomType, +/*N*/ sal_uInt16 nVal, +/*N*/ sal_uInt16 nWhich +/*N*/ ) +/*N*/ : SfxUInt16Item( nWhich, nVal ), +/*N*/ nValueSet( SVX_ZOOM_ENABLE_ALL ), +/*N*/ eType( eZoomType ) +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvxZoomItem::SvxZoomItem( const SvxZoomItem& rOrig ) +/*N*/ : SfxUInt16Item( rOrig.Which(), rOrig.GetValue() ), +/*N*/ nValueSet( rOrig.GetValueSet() ), +/*N*/ eType( rOrig.GetType() ) +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SvxZoomItem::~SvxZoomItem() +/*N*/ { +/*N*/ } + +// ----------------------------------------------------------------------- + +/*N*/ SfxPoolItem* SvxZoomItem::Clone( SfxItemPool *pPool ) const +/*N*/ { +/*N*/ return new SvxZoomItem( *this ); +/*N*/ } + +// ----------------------------------------------------------------------- + + +// ----------------------------------------------------------------------- + + +// ----------------------------------------------------------------------- + +/*N*/ int SvxZoomItem::operator==( const SfxPoolItem& rAttr ) const +/*N*/ { +/*N*/ DBG_ASSERT( SfxPoolItem::operator==(rAttr), "unequal types" ); +/*N*/ +/*N*/ SvxZoomItem& rItem = (SvxZoomItem&)rAttr; +/*N*/ +/*N*/ return ( GetValue() == rItem.GetValue() && +/*N*/ nValueSet == rItem.GetValueSet() && +/*N*/ eType == rItem.GetType() ); +/*N*/ } + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |