826 lines
29 KiB
C++
826 lines
29 KiB
C++
/* -*- 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: */
|