/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed
* with this work for additional information regarding copyright
* ownership. The ASF licenses this file to you under the Apache
* License, Version 2.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of
* the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/
#include <editeng/legacyitem.hxx>
#include <unotools/fontdefs.hxx>
#include <tools/tenccvt.hxx>
#include <tools/stream.hxx>
#include <comphelper/fileformat.h>
#include <vcl/graph.hxx>
#include <vcl/GraphicObject.hxx>
#include <vcl/TypeSerializer.hxx>
#include <osl/diagnose.h>
#include <tools/urlobj.hxx>
#include <editeng/fontitem.hxx>
#include <editeng/fhgtitem.hxx>
#include <editeng/wghtitem.hxx>
#include <editeng/postitem.hxx>
#include <editeng/udlnitem.hxx>
#include <editeng/crossedoutitem.hxx>
#include <editeng/colritem.hxx>
#include <editeng/boxitem.hxx>
#include <editeng/borderline.hxx>
#include <editeng/lineitem.hxx>
#include <editeng/brushitem.hxx>
#include <editeng/editerr.hxx>
#include <editeng/adjustitem.hxx>
#include <editeng/justifyitem.hxx>
#include <editeng/frmdiritem.hxx>
#include <editeng/formatbreakitem.hxx>
#include <editeng/keepitem.hxx>
#include <editeng/shaditem.hxx>
#include <tools/GenericTypeSerializer.hxx>
void Create_legacy_direct_set(SvxFontHeightItem& rItem, sal_uInt32 nH, sal_uInt16 nP, MapUnit eP)
{
rItem.legacy_direct_set(nH, nP, eP);
}
namespace legacy
{
namespace SvxFont
{
sal_uInt16 GetVersion(sal_uInt16)
{
return 0;
}
void Create(SvxFontItem& rItem, SvStream& rStrm, sal_uInt16)
{
sal_uInt8 _eFamily, eFontPitch, eFontTextEncoding;
OUString aName, aStyle;
rStrm.ReadUChar( _eFamily );
rStrm.ReadUChar( eFontPitch );
rStrm.ReadUChar( eFontTextEncoding );
// UNICODE: rStrm >> aName;
aName = rStrm.ReadUniOrByteString(rStrm.GetStreamCharSet());
// UNICODE: rStrm >> aStyle;
aStyle = rStrm.ReadUniOrByteString(rStrm.GetStreamCharSet());
// Set the "correct" textencoding
eFontTextEncoding = static_cast<sal_uInt8>(GetSOLoadTextEncoding( eFontTextEncoding ));
// at some point, the StarBats changes from ANSI font to SYMBOL font
if ( RTL_TEXTENCODING_SYMBOL != eFontTextEncoding && aName == "StarBats" )
eFontTextEncoding = RTL_TEXTENCODING_SYMBOL;
// Check if we have stored unicode
sal_uInt64 const nStreamPos = rStrm.Tell();
// #define STORE_UNICODE_MAGIC_MARKER 0xFE331188
sal_uInt32 nMagic = 0xFE331188;
rStrm.ReadUInt32( nMagic );
if ( nMagic == 0xFE331188 )
{
aName = rStrm.ReadUniOrByteString( RTL_TEXTENCODING_UNICODE );
aStyle = rStrm.ReadUniOrByteString( RTL_TEXTENCODING_UNICODE );
}
else
{
rStrm.Seek( nStreamPos );
}
rItem.SetFamilyName(aName);
rItem.SetStyleName(aStyle);
rItem.SetFamily(static_cast<FontFamily>(_eFamily));
rItem.SetPitch(static_cast<FontPitch>(eFontPitch));
rItem.SetCharSet(static_cast<rtl_TextEncoding>(eFontTextEncoding));
}
SvStream& Store(const SvxFontItem& rItem, SvStream& rStrm, sal_uInt16)
{
const bool bToBats(IsOpenSymbol(rItem.GetFamilyName()));
rStrm.WriteUChar(rItem.GetFamily()).WriteUChar(rItem.GetPitch()).WriteUChar(bToBats ?
RTL_TEXTENCODING_SYMBOL :
GetSOStoreTextEncoding(rItem.GetCharSet()));
const OUString aStoreFamilyName(bToBats ? u"StarBats"_ustr : rItem.GetFamilyName());
rStrm.WriteUniOrByteString(aStoreFamilyName, rStrm.GetStreamCharSet());
rStrm.WriteUniOrByteString(rItem.GetStyleName(), rStrm.GetStreamCharSet());
return rStrm;
}
}
namespace SvxFontHeight
{
sal_uInt16 GetVersion(sal_uInt16 nFileFormatVersion)
{
return (nFileFormatVersion <= SOFFICE_FILEFORMAT_40)
? FONTHEIGHT_16_VERSION
: FONTHEIGHT_UNIT_VERSION;
}
void Create(SvxFontHeightItem& rItem, SvStream& rStrm, sal_uInt16 nItemVersion)
{
sal_uInt16 nsize, nprop = 0;
MapUnit nPropUnit = MapUnit::MapRelative;
rStrm.ReadUInt16( nsize );
if( FONTHEIGHT_16_VERSION <= nItemVersion )
rStrm.ReadUInt16( nprop );
else
{
sal_uInt8 nP;
rStrm .ReadUChar( nP );
nprop = static_cast<sal_uInt16>(nP);
}
if( FONTHEIGHT_UNIT_VERSION <= nItemVersion )
{
sal_uInt16 nTmp;
rStrm.ReadUInt16( nTmp );
nPropUnit = static_cast<MapUnit>(nTmp);
}
Create_legacy_direct_set(rItem, nsize, nprop, nPropUnit);
}
SvStream& Store(const SvxFontHeightItem& rItem, SvStream& rStrm, sal_uInt16 nItemVersion)
{
rStrm.WriteUInt16( rItem.GetHeight() );
if( FONTHEIGHT_UNIT_VERSION <= nItemVersion )
rStrm.WriteUInt16( rItem.GetProp() ).WriteUInt16( static_cast<sal_uInt16>(rItem.GetPropUnit()) );
else
{
// When exporting to the old versions the relative information is lost
// when there is no percentage
sal_uInt16 _nProp = rItem.GetProp();
if( MapUnit::MapRelative != rItem.GetPropUnit() )
_nProp = 100;
rStrm.WriteUInt16( _nProp );
}
return rStrm;
}
}
namespace SvxWeight
{
sal_uInt16 GetVersion(sal_uInt16)
{
return 0;
}
void Create(SvxWeightItem& rItem, SvStream& rStrm, sal_uInt16)
{
sal_uInt8 nWeight(0);
rStrm.ReadUChar(nWeight);
rItem.SetValue(static_cast<FontWeight>(nWeight));
}
SvStream& Store(const SvxWeightItem& rItem, SvStream& rStrm, sal_uInt16)
{
rStrm.WriteUChar(rItem.GetValue());
return rStrm;
}
}
namespace SvxPosture
{
sal_uInt16 GetVersion(sal_uInt16)
{
return 0;
}
void Create(SvxPostureItem& rItem, SvStream& rStrm, sal_uInt16)
{
sal_uInt8 nPosture(0);
rStrm.ReadUChar(nPosture);
rItem.SetValue(static_cast<FontItalic>(nPosture));
}
SvStream& Store(const SvxPostureItem& rItem, SvStream& rStrm, sal_uInt16)
{
rStrm.WriteUChar( rItem.GetValue() );
return rStrm;
}
}
namespace SvxTextLine // SvxUnderlineItem, SvxOverlineItem -> SvxTextLineItem
{
sal_uInt16 GetVersion(sal_uInt16)
{
return 0;
}
void Create(SvxTextLineItem& rItem, SvStream& rStrm, sal_uInt16)
{
sal_uInt8 nState(0);
rStrm.ReadUChar(nState);
rItem.SetValue(static_cast<FontLineStyle>(nState));
// GetColor() is *not* saved/loaded ?!?
}
SvStream& Store(const SvxTextLineItem& rItem, SvStream& rStrm, sal_uInt16)
{
rStrm.WriteUChar(rItem.GetValue());
// GetColor() is *not* saved/loaded ?!?
return rStrm;
}
}
namespace SvxCrossedOut
{
sal_uInt16 GetVersion(sal_uInt16)
{
return 0;
}
void Create(SvxCrossedOutItem& rItem, SvStream& rStrm, sal_uInt16)
{
sal_uInt8 eCross(0);
rStrm.ReadUChar(eCross);
rItem.SetValue(static_cast<FontStrikeout>(eCross));
}
SvStream& Store(const SvxCrossedOutItem& rItem, SvStream& rStrm, sal_uInt16)
{
rStrm.WriteUChar(rItem.GetValue());
return rStrm;
}
}
namespace SvxColor
{
sal_uInt16 GetVersion(sal_uInt16 nFileFormatVersion)
{
DBG_ASSERT( SOFFICE_FILEFORMAT_31==nFileFormatVersion ||
SOFFICE_FILEFORMAT_40==nFileFormatVersion ||
SOFFICE_FILEFORMAT_50==nFileFormatVersion,
"SvxColorItem: Is there a new file format? ");
return SOFFICE_FILEFORMAT_50 >= nFileFormatVersion ? VERSION_USEAUTOCOLOR : 0;
}
void Create(SvxColorItem& rItem, SvStream& rStrm, sal_uInt16)
{
Color aColor(COL_AUTO);
tools::GenericTypeSerializer aSerializer(rStrm);
aSerializer.readColor(aColor);
rItem.SetValue(aColor);
}
SvStream& Store(const SvxColorItem& rItem, SvStream& rStrm, sal_uInt16 nItemVersion)
{
tools::GenericTypeSerializer aSerializer(rStrm);
if( VERSION_USEAUTOCOLOR == nItemVersion && COL_AUTO == rItem.GetValue() )
aSerializer.writeColor(COL_BLACK);
else
aSerializer.writeColor(rItem.GetValue());
return rStrm;
}
}
namespace SvxBox
{
sal_uInt16 GetVersion(sal_uInt16 nFileFormatVersion)
{
DBG_ASSERT( SOFFICE_FILEFORMAT_31==nFileFormatVersion ||
SOFFICE_FILEFORMAT_40==nFileFormatVersion ||
SOFFICE_FILEFORMAT_50==nFileFormatVersion,
"SvxBoxItem: Is there a new file format?" );
return SOFFICE_FILEFORMAT_31==nFileFormatVersion ||
SOFFICE_FILEFORMAT_40==nFileFormatVersion ? 0 : BOX_BORDER_STYLE_VERSION;
}
/// Item version for saved border lines. The old version saves the line without style information.
const int BORDER_LINE_OLD_VERSION = 0;
/// Item version for saved border lies. The new version includes line style.
const int BORDER_LINE_WITH_STYLE_VERSION = 1;
/// Creates a border line from a stream.
static ::editeng::SvxBorderLine CreateBorderLine(SvStream &stream, sal_uInt16 version)
{
sal_uInt16 nOutline, nInline, nDistance;
sal_uInt16 nStyle = css::table::BorderLineStyle::NONE;
Color aColor;
tools::GenericTypeSerializer aSerializer(stream);
aSerializer.readColor(aColor);
stream.ReadUInt16( nOutline ).ReadUInt16( nInline ).ReadUInt16( nDistance );
if (version >= BORDER_LINE_WITH_STYLE_VERSION)
stream.ReadUInt16( nStyle );
::editeng::SvxBorderLine border(&aColor);
border.GuessLinesWidths(static_cast<SvxBorderLineStyle>(nStyle), nOutline, nInline, nDistance);
return border;
}
/// Retrieves a BORDER_LINE_* version from a BOX_BORDER_* version.
static sal_uInt16 BorderLineVersionFromBoxVersion(sal_uInt16 boxVersion)
{
return (boxVersion >= BOX_BORDER_STYLE_VERSION)? BORDER_LINE_WITH_STYLE_VERSION : BORDER_LINE_OLD_VERSION;
}
void Create(SvxBoxItem& rItem, SvStream& rStrm, sal_uInt16 nItemVersion)
{
sal_uInt16 nDistance(0);
rStrm.ReadUInt16( nDistance );
SvxBoxItemLine aLineMap[4] = { SvxBoxItemLine::TOP, SvxBoxItemLine::LEFT,
SvxBoxItemLine::RIGHT, SvxBoxItemLine::BOTTOM };
sal_Int8 cLine(0);
while (rStrm.good())
{
rStrm.ReadSChar( cLine );
if( cLine > 3 )
break;
::editeng::SvxBorderLine aBorder = CreateBorderLine(rStrm, BorderLineVersionFromBoxVersion(nItemVersion));
rItem.SetLine( &aBorder, aLineMap[cLine] );
}
if( nItemVersion >= BOX_4DISTS_VERSION && (cLine&0x10) != 0 )
{
for(const SvxBoxItemLine & i : aLineMap)
{
sal_uInt16 nDist;
rStrm.ReadUInt16( nDist );
rItem.SetDistance( nDist, i );
}
}
else
{
rItem.SetAllDistances(nDistance);
}
}
/// Store a border line to a stream.
static SvStream& StoreBorderLine(SvStream &stream, const ::editeng::SvxBorderLine &l, sal_uInt16 version)
{
tools::GenericTypeSerializer aSerializer(stream);
aSerializer.writeColor(l.GetColor());
stream.WriteUInt16( l.GetOutWidth() )
.WriteUInt16( l.GetInWidth() )
.WriteUInt16( l.GetDistance() );
if (version >= BORDER_LINE_WITH_STYLE_VERSION)
stream.WriteUInt16( static_cast<sal_uInt16>(l.GetBorderLineStyle()) );
return stream;
}
SvStream& Store(const SvxBoxItem& rItem, SvStream& rStrm, sal_uInt16 nItemVersion)
{
rStrm.WriteUInt16( rItem.GetSmallestDistance() );
const ::editeng::SvxBorderLine* pLine[ 4 ]; // top, left, right, bottom
pLine[ 0 ] = rItem.GetTop();
pLine[ 1 ] = rItem.GetLeft();
pLine[ 2 ] = rItem.GetRight();
pLine[ 3 ] = rItem.GetBottom();
for( int i = 0; i < 4; i++ )
{
const ::editeng::SvxBorderLine* l = pLine[ i ];
if( l )
{
rStrm.WriteSChar(i);
StoreBorderLine(rStrm, *l, BorderLineVersionFromBoxVersion(nItemVersion));
}
}
sal_Int8 cLine = 4;
const sal_uInt16 nTopDist(rItem.GetDistance(SvxBoxItemLine::TOP));
const sal_uInt16 nLeftDist(rItem.GetDistance(SvxBoxItemLine::LEFT));
const sal_uInt16 nRightDist(rItem.GetDistance(SvxBoxItemLine::RIGHT));
const sal_uInt16 nBottomDist(rItem.GetDistance(SvxBoxItemLine::BOTTOM));
if( nItemVersion >= BOX_4DISTS_VERSION &&
!(nTopDist == nLeftDist &&
nTopDist == nRightDist &&
nTopDist == nBottomDist) )
{
cLine |= 0x10;
}
rStrm.WriteSChar( cLine );
if( nItemVersion >= BOX_4DISTS_VERSION && (cLine & 0x10) != 0 )
{
rStrm.WriteUInt16( nTopDist )
.WriteUInt16( nLeftDist )
.WriteUInt16( nRightDist )
.WriteUInt16( nBottomDist );
}
return rStrm;
}
}
namespace SvxLine
{
sal_uInt16 GetVersion(sal_uInt16)
{
return 0;
}
void Create(SvxLineItem& rItem, SvStream& rStrm, sal_uInt16)
{
short nOutline, nInline, nDistance;
Color aColor;
tools::GenericTypeSerializer aSerializer(rStrm);
aSerializer.readColor(aColor);
rStrm.ReadInt16( nOutline ).ReadInt16( nInline ).ReadInt16( nDistance );
if( nOutline )
{
::editeng::SvxBorderLine aLine( &aColor );
aLine.GuessLinesWidths(SvxBorderLineStyle::NONE, nOutline, nInline, nDistance);
rItem.SetLine( &aLine );
}
}
SvStream& Store(const SvxLineItem& rItem, SvStream& rStrm, sal_uInt16)
{
const ::editeng::SvxBorderLine* pLine(rItem.GetLine());
if(nullptr != pLine)
{
tools::GenericTypeSerializer aSerializer(rStrm);
aSerializer.writeColor(pLine->GetColor());
rStrm.WriteInt16( pLine->GetOutWidth() )
.WriteInt16( pLine->GetInWidth() )
.WriteInt16( pLine->GetDistance() );
}
else
{
tools::GenericTypeSerializer aSerializer(rStrm);
aSerializer.writeColor(Color());
rStrm.WriteInt16( 0 ).WriteInt16( 0 ).WriteInt16( 0 );
}
return rStrm;
}
}
namespace SvxBrush
{
sal_uInt16 GetVersion(sal_uInt16)
{
return BRUSH_GRAPHIC_VERSION;
}
const sal_uInt16 LOAD_GRAPHIC = (sal_uInt16(0x0001));
const sal_uInt16 LOAD_LINK = (sal_uInt16(0x0002));
const sal_uInt16 LOAD_FILTER = (sal_uInt16(0x0004));
void Create(SvxBrushItem& rItem, SvStream& rStrm, sal_uInt16 nItemVersion)
{
bool bTrans;
Color aTempColor;
Color aTempFillColor;
sal_Int8 nStyle;
rStrm.ReadCharAsBool( bTrans );
TypeSerializer aSerializer(rStrm);
aSerializer.readColor(aTempColor);
aSerializer.readColor(aTempFillColor);
rStrm.ReadSChar( nStyle );
switch ( nStyle )
{
case 8: // BRUSH_25:
{
sal_uInt32 nRed = aTempColor.GetRed();
sal_uInt32 nGreen = aTempColor.GetGreen();
sal_uInt32 nBlue = aTempColor.GetBlue();
nRed += static_cast<sal_uInt32>(aTempFillColor.GetRed())*2;
nGreen += static_cast<sal_uInt32>(aTempFillColor.GetGreen())*2;
nBlue += static_cast<sal_uInt32>(aTempFillColor.GetBlue())*2;
rItem.SetColor(Color( static_cast<sal_Int8>(nRed/3), static_cast<sal_Int8>(nGreen/3), static_cast<sal_Int8>(nBlue/3) ));
}
break;
case 9: // BRUSH_50:
{
sal_uInt32 nRed = aTempColor.GetRed();
sal_uInt32 nGreen = aTempColor.GetGreen();
sal_uInt32 nBlue = aTempColor.GetBlue();
nRed += static_cast<sal_uInt32>(aTempFillColor.GetRed());
nGreen += static_cast<sal_uInt32>(aTempFillColor.GetGreen());
nBlue += static_cast<sal_uInt32>(aTempFillColor.GetBlue());
rItem.SetColor(Color( static_cast<sal_Int8>(nRed/2), static_cast<sal_Int8>(nGreen/2), static_cast<sal_Int8>(nBlue/2) ));
}
break;
case 10: // BRUSH_75:
{
sal_uInt32 nRed = aTempColor.GetRed()*2;
sal_uInt32 nGreen = aTempColor.GetGreen()*2;
sal_uInt32 nBlue = aTempColor.GetBlue()*2;
nRed += static_cast<sal_uInt32>(aTempFillColor.GetRed());
nGreen += static_cast<sal_uInt32>(aTempFillColor.GetGreen());
nBlue += static_cast<sal_uInt32>(aTempFillColor.GetBlue());
rItem.SetColor(Color( static_cast<sal_Int8>(nRed/3), static_cast<sal_Int8>(nGreen/3), static_cast<sal_Int8>(nBlue/3) ));
}
break;
case 0: // BRUSH_NULL:
rItem.SetColor(COL_TRANSPARENT);
break;
default:
rItem.SetColor(aTempColor);
}
if ( nItemVersion < BRUSH_GRAPHIC_VERSION )
return;
sal_uInt16 nDoLoad = 0;
sal_Int8 nPos;
rStrm.ReadUInt16( nDoLoad );
if ( nDoLoad & LOAD_GRAPHIC )
{
Graphic aGraphic;
aSerializer.readGraphic(aGraphic);
rItem.SetGraphicObject(GraphicObject(std::move(aGraphic)));
if( SVSTREAM_FILEFORMAT_ERROR == rStrm.GetError() )
{
rStrm.ResetError();
rStrm.SetError( ERRCODE_SVX_GRAPHIC_WRONG_FILEFORMAT.MakeWarning() );
}
}
if ( nDoLoad & LOAD_LINK )
{
// UNICODE: rStrm >> aRel;
OUString aRel = rStrm.ReadUniOrByteString(rStrm.GetStreamCharSet());
// TODO/MBA: how can we get a BaseURL here?!
OSL_FAIL("No BaseURL!");
OUString aAbs = INetURLObject::GetAbsURL( u"", aRel );
DBG_ASSERT( !aAbs.isEmpty(), "Invalid URL!" );
rItem.SetGraphicLink(aAbs);
}
if ( nDoLoad & LOAD_FILTER )
{
// UNICODE: rStrm >> maStrFilter;
rItem.SetGraphicFilter(rStrm.ReadUniOrByteString(rStrm.GetStreamCharSet()));
}
rStrm.ReadSChar( nPos );
rItem.SetGraphicPos(static_cast<SvxGraphicPosition>(nPos));
}
SvStream& Store(const SvxBrushItem& rItem, SvStream& rStrm, sal_uInt16)
{
rStrm.WriteBool( false );
TypeSerializer aSerializer(rStrm);
aSerializer.writeColor(rItem.GetColor());
aSerializer.writeColor(rItem.GetColor());
rStrm.WriteSChar( rItem.GetColor().IsTransparent() ? 0 : 1 ); //BRUSH_NULL : BRUSH_SOLID
sal_uInt16 nDoLoad = 0;
const GraphicObject* pGraphicObject(rItem.GetGraphicObject());
if (nullptr != pGraphicObject && rItem.GetGraphicLink().isEmpty())
nDoLoad |= LOAD_GRAPHIC;
if ( !rItem.GetGraphicLink().isEmpty() )
nDoLoad |= LOAD_LINK;
if ( !rItem.GetGraphicFilter().isEmpty() )
nDoLoad |= LOAD_FILTER;
rStrm.WriteUInt16( nDoLoad );
if (nullptr != pGraphicObject && rItem.GetGraphicLink().isEmpty())
{
aSerializer.writeGraphic(pGraphicObject->GetGraphic());
}
if ( !rItem.GetGraphicLink().isEmpty() )
{
OSL_FAIL("No BaseURL!");
// TODO/MBA: how to get a BaseURL?!
OUString aRel = INetURLObject::GetRelURL( u"", rItem.GetGraphicLink() );
// UNICODE: rStrm << aRel;
rStrm.WriteUniOrByteString(aRel, rStrm.GetStreamCharSet());
}
if ( !rItem.GetGraphicFilter().isEmpty() )
{
// UNICODE: rStrm << rItem.GetGraphicFilter();
rStrm.WriteUniOrByteString(rItem.GetGraphicFilter(), rStrm.GetStreamCharSet());
}
rStrm.WriteSChar( rItem.GetGraphicPos() );
return rStrm;
}
}
namespace SvxAdjust
{
sal_uInt16 GetVersion(sal_uInt16 nFileFormatVersion)
{
return (nFileFormatVersion == SOFFICE_FILEFORMAT_31)
? 0 : ADJUST_LASTBLOCK_VERSION;
}
void Create(SvxAdjustItem& rItem, SvStream& rStrm, sal_uInt16 nItemVersion)
{
char eAdjustment;
rStrm.ReadChar(eAdjustment);
rItem.SetAdjust(static_cast<::SvxAdjust>(eAdjustment));
if( nItemVersion >= ADJUST_LASTBLOCK_VERSION )
{
sal_Int8 nFlags;
rStrm.ReadSChar( nFlags );
rItem.SetAsFlags(nFlags);
}
}
SvStream& Store(const SvxAdjustItem& rItem, SvStream& rStrm, sal_uInt16 nItemVersion)
{
rStrm.WriteChar( static_cast<char>(rItem.GetAdjust()) );
if ( nItemVersion >= ADJUST_LASTBLOCK_VERSION )
{
const sal_Int8 nFlags(rItem.GetAsFlags());
rStrm.WriteSChar( nFlags );
}
return rStrm;
}
}
namespace SvxHorJustify
{
sal_uInt16 GetVersion(sal_uInt16)
{
return 0;
}
void Create(SvxHorJustifyItem& rItem, SvStream& rStrm, sal_uInt16)
{
sal_uInt16 nVal(0);
rStrm.ReadUInt16( nVal );
rItem.SetValue(static_cast<::SvxCellHorJustify>(nVal));
}
SvStream& Store(const SvxHorJustifyItem& rItem, SvStream& rStrm, sal_uInt16)
{
rStrm.WriteUInt16( static_cast<sal_uInt16>(rItem.GetValue()) );
return rStrm;
}
}
namespace SvxVerJustify
{
sal_uInt16 GetVersion(sal_uInt16)
{
return 0;
}
void Create(SvxVerJustifyItem& rItem, SvStream& rStrm, sal_uInt16)
{
sal_uInt16 nVal(0);
rStrm.ReadUInt16( nVal );
rItem.SetValue(static_cast<::SvxCellVerJustify>(nVal));
}
SvStream& Store(const SvxVerJustifyItem& rItem, SvStream& rStrm, sal_uInt16)
{
rStrm.WriteUInt16( static_cast<sal_uInt16>(rItem.GetValue()) );
return rStrm;
}
}
namespace SvxFrameDirection
{
sal_uInt16 GetVersion(sal_uInt16 nFileFormatVersion)
{
return SOFFICE_FILEFORMAT_50 > nFileFormatVersion ? USHRT_MAX : 0;
}
void Create(SvxFrameDirectionItem& rItem, SvStream& rStrm, sal_uInt16)
{
sal_uInt16 nVal(0);
rStrm.ReadUInt16( nVal );
rItem.SetValue(static_cast<::SvxFrameDirection>(nVal));
}
SvStream& Store(const SvxFrameDirectionItem& rItem, SvStream& rStrm, sal_uInt16)
{
rStrm.WriteUInt16( static_cast<sal_uInt16>(rItem.GetValue()) );
return rStrm;
}
}
namespace SvxFormatBreak
{
sal_uInt16 GetVersion(sal_uInt16 nFileFormatVersion)
{
DBG_ASSERT( SOFFICE_FILEFORMAT_31==nFileFormatVersion ||
SOFFICE_FILEFORMAT_40==nFileFormatVersion ||
SOFFICE_FILEFORMAT_50==nFileFormatVersion,
"SvxFormatBreakItem: Is there a new file format? ");
return SOFFICE_FILEFORMAT_31==nFileFormatVersion ||
SOFFICE_FILEFORMAT_40==nFileFormatVersion ? 0 : FMTBREAK_NOAUTO;
}
void Create(SvxFormatBreakItem& rItem, SvStream& rStrm, sal_uInt16 nItemVersion)
{
sal_Int8 eBreak, bDummy;
rStrm.ReadSChar( eBreak );
if( FMTBREAK_NOAUTO > nItemVersion )
rStrm.ReadSChar( bDummy );
rItem.SetValue(static_cast<::SvxBreak>(eBreak));
}
SvStream& Store(const SvxFormatBreakItem& rItem, SvStream& rStrm, sal_uInt16 nItemVersion)
{
rStrm.WriteSChar( rItem.GetEnumValue() );
if( FMTBREAK_NOAUTO > nItemVersion )
rStrm.WriteSChar( 0x01 );
return rStrm;
}
}
namespace SvxFormatKeep
{
sal_uInt16 GetVersion(sal_uInt16)
{
return 0;
}
void Create(SvxFormatKeepItem& rItem, SvStream& rStrm, sal_uInt16)
{
// derived from SfxBoolItem, but that uses
// rStream.ReadCharAsBool( tmp );
sal_Int8 bIsKeep;
rStrm.ReadSChar( bIsKeep );
rItem.SetValue(static_cast<bool>(bIsKeep));
}
SvStream& Store(const SvxFormatKeepItem& rItem, SvStream& rStrm, sal_uInt16)
{
// derived from SfxBoolItem, but that uses
// rStream.WriteBool( m_bValue ); // not bool for serialization!
rStrm.WriteSChar( static_cast<sal_Int8>(rItem.GetValue()) );
return rStrm;
}
}
namespace SvxShadow
{
sal_uInt16 GetVersion(sal_uInt16)
{
return 0;
}
void Create(SvxShadowItem& rItem, SvStream& rStrm, sal_uInt16)
{
sal_Int8 cLoc;
sal_uInt16 _nWidth;
bool bTrans;
Color aColor;
Color aFillColor;
sal_Int8 nStyle;
rStrm.ReadSChar( cLoc ).ReadUInt16( _nWidth ).ReadCharAsBool( bTrans );
tools::GenericTypeSerializer aSerializer(rStrm);
aSerializer.readColor(aColor);
aSerializer.readColor(aFillColor);
rStrm.ReadSChar(nStyle);
aColor.SetAlpha(bTrans ? 0 : 255);
rItem.SetLocation(static_cast<SvxShadowLocation>(cLoc));
rItem.SetWidth(_nWidth);
rItem.SetColor(aColor);
}
SvStream& Store(const SvxShadowItem& rItem, SvStream& rStrm, sal_uInt16)
{
rStrm.WriteSChar( static_cast<sal_uInt8>(rItem.GetLocation()) )
.WriteUInt16( rItem.GetWidth() )
.WriteBool( rItem.GetColor().IsTransparent() );
tools::GenericTypeSerializer aSerializer(rStrm);
aSerializer.writeColor(rItem.GetColor());
aSerializer.writeColor(rItem.GetColor());
rStrm.WriteSChar( rItem.GetColor().IsTransparent() ? 0 : 1 ); //BRUSH_NULL : BRUSH_SOLID
return rStrm;
}
}
}
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
↑ V781 The value of the 'cLine' variable is checked after it was used. Perhaps there is a mistake in program logic. Check lines: 352, 355.