xref: /AOO41X/main/sc/source/core/tool/autoform.cxx (revision 79aad27f7f29270c03e208e3d687e8e3850af11d)

/**************************************************************
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/



// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_sc.hxx"



#define READ_OLDVERS

#include "autoform.hxx"

#include <sfx2/app.hxx>
#include <sfx2/docfile.hxx>
#include <unotools/pathoptions.hxx>
#include <svl/itemset.hxx>
#include <tools/shl.hxx>
#include <vcl/svapp.hxx>
#include <vcl/outdev.hxx>
#include <svx/dialmgr.hxx>
#include <svx/dialogs.hrc>
#include <editeng/langitem.hxx>
#include <tools/urlobj.hxx>
#include <unotools/transliterationwrapper.hxx>
#include <tools/tenccvt.hxx>

#include "globstr.hrc"
#include "document.hxx"

//------------------------------------------------------------------------

const sal_Char *linker_dummy = "";

//	Standard-Name ist jetzt STR_STYLENAME_STANDARD (wie Vorlagen)
//static const sal_Char __FAR_DATA cStandardName[] = "Standard";

static const sal_Char __FAR_DATA sAutoTblFmtName[] = "autotbl.fmt";

// bis SO5PF
const sal_uInt16 AUTOFORMAT_ID_X		= 9501;
const sal_uInt16 AUTOFORMAT_ID_358		= 9601;
const sal_uInt16 AUTOFORMAT_DATA_ID_X	= 9502;

// ab SO5
//! in nachfolgenden Versionen muss der Betrag dieser IDs groesser sein
const sal_uInt16 AUTOFORMAT_ID_504		= 9801;
const sal_uInt16 AUTOFORMAT_DATA_ID_504	= 9802;

const sal_uInt16 AUTOFORMAT_ID_552		= 9901;
const sal_uInt16 AUTOFORMAT_DATA_ID_552	= 9902;

// --- from 641 on: CJK and CTL font settings
const sal_uInt16 AUTOFORMAT_ID_641      = 10001;
const sal_uInt16 AUTOFORMAT_DATA_ID_641 = 10002;

// --- from 680/dr14 on: diagonal frame lines
const sal_uInt16 AUTOFORMAT_ID_680DR14      = 10011;
const sal_uInt16 AUTOFORMAT_DATA_ID_680DR14 = 10012;

// --- from 680/dr25 on: #21549# store strings as UTF-8
const sal_uInt16 AUTOFORMAT_ID_680DR25      = 10021;
const sal_uInt16 AUTOFORMAT_DATA_ID_680DR25 = 10022;

// --- from DEV300/overline2 on: #5991# overline support
const sal_uInt16 AUTOFORMAT_ID_300OVRLN      = 10031;
const sal_uInt16 AUTOFORMAT_DATA_ID_300OVRLN = 10032;

// aktuelle Version
const sal_uInt16 AUTOFORMAT_ID          = AUTOFORMAT_ID_300OVRLN;
const sal_uInt16 AUTOFORMAT_DATA_ID     = AUTOFORMAT_DATA_ID_300OVRLN;


#ifdef READ_OLDVERS
const sal_uInt16 AUTOFORMAT_OLD_ID_OLD	= 4201;
const sal_uInt16 AUTOFORMAT_OLD_DATA_ID	= 4202;
const sal_uInt16 AUTOFORMAT_OLD_ID_NEW 	= 4203;
#endif


//	Struct mit Versionsnummern der Items

struct ScAfVersions
{
public:
	sal_uInt16 nFontVersion;
	sal_uInt16 nFontHeightVersion;
	sal_uInt16 nWeightVersion;
	sal_uInt16 nPostureVersion;
	sal_uInt16 nUnderlineVersion;
	sal_uInt16 nOverlineVersion;
	sal_uInt16 nCrossedOutVersion;
	sal_uInt16 nContourVersion;
	sal_uInt16 nShadowedVersion;
	sal_uInt16 nColorVersion;
	sal_uInt16 nBoxVersion;
    sal_uInt16 nLineVersion;
	sal_uInt16 nBrushVersion;

	sal_uInt16 nAdjustVersion;

	sal_uInt16 nHorJustifyVersion;
	sal_uInt16 nVerJustifyVersion;
	sal_uInt16 nOrientationVersion;
	sal_uInt16 nMarginVersion;
	sal_uInt16 nBoolVersion;
	sal_uInt16 nInt32Version;
	sal_uInt16 nRotateModeVersion;

	sal_uInt16 nNumFmtVersion;

	ScAfVersions();
	void Load( SvStream& rStream, sal_uInt16 nVer );
	static void Write(SvStream& rStream);
};

ScAfVersions::ScAfVersions() :
	nFontVersion(0),
	nFontHeightVersion(0),
	nWeightVersion(0),
	nPostureVersion(0),
	nUnderlineVersion(0),
	nOverlineVersion(0),
	nCrossedOutVersion(0),
	nContourVersion(0),
	nShadowedVersion(0),
	nColorVersion(0),
	nBoxVersion(0),
    nLineVersion(0),
	nBrushVersion(0),
	nAdjustVersion(0),
	nHorJustifyVersion(0),
	nVerJustifyVersion(0),
	nOrientationVersion(0),
	nMarginVersion(0),
	nBoolVersion(0),
	nInt32Version(0),
	nRotateModeVersion(0),
	nNumFmtVersion(0)
{
}

void ScAfVersions::Load( SvStream& rStream, sal_uInt16 nVer )
{
	rStream >> nFontVersion;
	rStream >> nFontHeightVersion;
	rStream >> nWeightVersion;
	rStream >> nPostureVersion;
	rStream >> nUnderlineVersion;
    if ( nVer >= AUTOFORMAT_ID_300OVRLN )
		rStream >> nOverlineVersion;
	rStream >> nCrossedOutVersion;
	rStream >> nContourVersion;
	rStream >> nShadowedVersion;
	rStream >> nColorVersion;
	rStream >> nBoxVersion;
    if ( nVer >= AUTOFORMAT_ID_680DR14 )
        rStream >> nLineVersion;
	rStream >> nBrushVersion;
	rStream >> nAdjustVersion;
	rStream >> nHorJustifyVersion;
	rStream >> nVerJustifyVersion;
	rStream >> nOrientationVersion;
	rStream >> nMarginVersion;
	rStream >> nBoolVersion;
	if ( nVer >= AUTOFORMAT_ID_504 )
	{
		rStream >> nInt32Version;
		rStream >> nRotateModeVersion;
	}
	rStream >> nNumFmtVersion;
}

void ScAfVersions::Write(SvStream& rStream)
{
    rStream << SvxFontItem(ATTR_FONT).GetVersion(SOFFICE_FILEFORMAT_40);
    rStream << SvxFontHeightItem(240, 100, ATTR_FONT_HEIGHT).GetVersion(SOFFICE_FILEFORMAT_40);
    rStream << SvxWeightItem(WEIGHT_NORMAL, ATTR_FONT_WEIGHT).GetVersion(SOFFICE_FILEFORMAT_40);
    rStream << SvxPostureItem(ITALIC_NONE, ATTR_FONT_POSTURE).GetVersion(SOFFICE_FILEFORMAT_40);
    rStream << SvxUnderlineItem(UNDERLINE_NONE, ATTR_FONT_UNDERLINE).GetVersion(SOFFICE_FILEFORMAT_40);
    rStream << SvxOverlineItem(UNDERLINE_NONE, ATTR_FONT_OVERLINE).GetVersion(SOFFICE_FILEFORMAT_40);
    rStream << SvxCrossedOutItem(STRIKEOUT_NONE, ATTR_FONT_CROSSEDOUT).GetVersion(SOFFICE_FILEFORMAT_40);
    rStream << SvxContourItem(sal_False, ATTR_FONT_CONTOUR).GetVersion(SOFFICE_FILEFORMAT_40);
    rStream << SvxShadowedItem(sal_False, ATTR_FONT_SHADOWED).GetVersion(SOFFICE_FILEFORMAT_40);
    rStream << SvxColorItem(ATTR_FONT_COLOR).GetVersion(SOFFICE_FILEFORMAT_40);
    rStream << SvxBoxItem(ATTR_BORDER).GetVersion(SOFFICE_FILEFORMAT_40);
    rStream << SvxLineItem(SID_FRAME_LINESTYLE).GetVersion(SOFFICE_FILEFORMAT_40);
    rStream << SvxBrushItem(ATTR_BACKGROUND).GetVersion(SOFFICE_FILEFORMAT_40);

    rStream << SvxAdjustItem(SVX_ADJUST_LEFT, 0).GetVersion(SOFFICE_FILEFORMAT_40);

    rStream << SvxHorJustifyItem(SVX_HOR_JUSTIFY_STANDARD, ATTR_HOR_JUSTIFY).GetVersion(SOFFICE_FILEFORMAT_40);
    rStream << SvxVerJustifyItem(SVX_VER_JUSTIFY_STANDARD, ATTR_VER_JUSTIFY).GetVersion(SOFFICE_FILEFORMAT_40);
    rStream << SvxOrientationItem(SVX_ORIENTATION_STANDARD, 0).GetVersion(SOFFICE_FILEFORMAT_40);
    rStream << SvxMarginItem(ATTR_MARGIN).GetVersion(SOFFICE_FILEFORMAT_40);
	rStream << SfxBoolItem(ATTR_LINEBREAK).GetVersion(SOFFICE_FILEFORMAT_40);
	rStream << SfxInt32Item(ATTR_ROTATE_VALUE).GetVersion(SOFFICE_FILEFORMAT_40);
	rStream << SvxRotateModeItem(SVX_ROTATE_MODE_STANDARD,0).GetVersion(SOFFICE_FILEFORMAT_40);

	rStream << (sal_uInt16)0;		// Num-Format
}

//	---------------------------------------------------------------------------

ScAutoFormatDataField::ScAutoFormatDataField() :
    aFont( ATTR_FONT ),
    aHeight( 240, 100, ATTR_FONT_HEIGHT ),
    aWeight( WEIGHT_NORMAL, ATTR_FONT_WEIGHT ),
    aPosture( ITALIC_NONE, ATTR_FONT_POSTURE ),

    aCJKFont( ATTR_CJK_FONT ),
    aCJKHeight( 240, 100, ATTR_CJK_FONT_HEIGHT ),
    aCJKWeight( WEIGHT_NORMAL, ATTR_CJK_FONT_WEIGHT ),
    aCJKPosture( ITALIC_NONE, ATTR_CJK_FONT_POSTURE ),

    aCTLFont( ATTR_CTL_FONT ),
    aCTLHeight( 240, 100, ATTR_CTL_FONT_HEIGHT ),
    aCTLWeight( WEIGHT_NORMAL, ATTR_CTL_FONT_WEIGHT ),
    aCTLPosture( ITALIC_NONE, ATTR_CTL_FONT_POSTURE ),

    aUnderline( UNDERLINE_NONE,ATTR_FONT_UNDERLINE ),
    aOverline( UNDERLINE_NONE,ATTR_FONT_OVERLINE ),
    aCrossedOut( STRIKEOUT_NONE, ATTR_FONT_CROSSEDOUT ),
    aContour( sal_False, ATTR_FONT_CONTOUR ),
    aShadowed( sal_False, ATTR_FONT_SHADOWED ),
    aColor( ATTR_FONT_COLOR ),
    aBox( ATTR_BORDER ),
    aTLBR( ATTR_BORDER_TLBR ),
    aBLTR( ATTR_BORDER_BLTR ),
    aBackground( ATTR_BACKGROUND ),
    aAdjust( SVX_ADJUST_LEFT, 0 ),
    aHorJustify( SVX_HOR_JUSTIFY_STANDARD, ATTR_HOR_JUSTIFY ),
    aVerJustify( SVX_VER_JUSTIFY_STANDARD, ATTR_VER_JUSTIFY ),
    aMargin( ATTR_MARGIN ),
    aLinebreak( ATTR_LINEBREAK ),
    aRotateAngle( ATTR_ROTATE_VALUE ),
    aRotateMode( SVX_ROTATE_MODE_STANDARD, ATTR_ROTATE_MODE )
{
}

ScAutoFormatDataField::ScAutoFormatDataField( const ScAutoFormatDataField& rCopy ) :
    aFont( rCopy.aFont ),
    aHeight( rCopy.aHeight ),
    aWeight( rCopy.aWeight ),
    aPosture( rCopy.aPosture ),
    aCJKFont( rCopy.aCJKFont ),
    aCJKHeight( rCopy.aCJKHeight ),
    aCJKWeight( rCopy.aCJKWeight ),
    aCJKPosture( rCopy.aCJKPosture ),
    aCTLFont( rCopy.aCTLFont ),
    aCTLHeight( rCopy.aCTLHeight ),
    aCTLWeight( rCopy.aCTLWeight ),
    aCTLPosture( rCopy.aCTLPosture ),
    aUnderline( rCopy.aUnderline ),
    aOverline( rCopy.aOverline ),
    aCrossedOut( rCopy.aCrossedOut ),
    aContour( rCopy.aContour ),
    aShadowed( rCopy.aShadowed ),
    aColor( rCopy.aColor ),
    aBox( rCopy.aBox ),
    aTLBR( rCopy.aTLBR ),
    aBLTR( rCopy.aBLTR ),
    aBackground( rCopy.aBackground ),
    aAdjust( rCopy.aAdjust ),
    aHorJustify( rCopy.aHorJustify ),
    aVerJustify( rCopy.aVerJustify ),
    aStacked( rCopy.aStacked ),
    aMargin( rCopy.aMargin ),
    aLinebreak( rCopy.aLinebreak ),
    aRotateAngle( rCopy.aRotateAngle ),
    aRotateMode( rCopy.aRotateMode ),
    aNumFormat( rCopy.aNumFormat )
{
}

ScAutoFormatDataField::~ScAutoFormatDataField()
{
}

void ScAutoFormatDataField::SetAdjust( const SvxAdjustItem& rAdjust )
{
    aAdjust.SetAdjust( rAdjust.GetAdjust() );
    aAdjust.SetOneWord( rAdjust.GetOneWord() );
    aAdjust.SetLastBlock( rAdjust.GetLastBlock() );
}

#define READ( aItem, ItemType, nVers )      \
    pNew = aItem.Create( rStream, nVers );  \
    aItem = *(ItemType*)pNew;               \
	delete pNew;

sal_Bool ScAutoFormatDataField::Load( SvStream& rStream, const ScAfVersions& rVersions, sal_uInt16 nVer )
{
    SfxPoolItem* pNew;
    SvxOrientationItem aOrientation( SVX_ORIENTATION_STANDARD, 0 );

    READ( aFont,        SvxFontItem,        rVersions.nFontVersion)
    READ( aHeight,      SvxFontHeightItem,  rVersions.nFontHeightVersion)
    READ( aWeight,      SvxWeightItem,      rVersions.nWeightVersion)
    READ( aPosture,     SvxPostureItem,     rVersions.nPostureVersion)
    // --- from 641 on: CJK and CTL font settings
    if( AUTOFORMAT_DATA_ID_641 <= nVer )
    {
        READ( aCJKFont,     SvxFontItem,        rVersions.nFontVersion)
        READ( aCJKHeight,   SvxFontHeightItem,  rVersions.nFontHeightVersion)
        READ( aCJKWeight,   SvxWeightItem,      rVersions.nWeightVersion)
        READ( aCJKPosture,  SvxPostureItem,     rVersions.nPostureVersion)
        READ( aCTLFont,     SvxFontItem,        rVersions.nFontVersion)
        READ( aCTLHeight,   SvxFontHeightItem,  rVersions.nFontHeightVersion)
        READ( aCTLWeight,   SvxWeightItem,      rVersions.nWeightVersion)
        READ( aCTLPosture,  SvxPostureItem,     rVersions.nPostureVersion)
    }
    READ( aUnderline,   SvxUnderlineItem,   rVersions.nUnderlineVersion)
    if ( nVer >= AUTOFORMAT_DATA_ID_300OVRLN )
    {
		READ( aOverline,    SvxOverlineItem,    rVersions.nOverlineVersion)
    }
    READ( aCrossedOut,  SvxCrossedOutItem,  rVersions.nCrossedOutVersion)
    READ( aContour,     SvxContourItem,     rVersions.nContourVersion)
    READ( aShadowed,    SvxShadowedItem,    rVersions.nShadowedVersion)
    READ( aColor,       SvxColorItem,       rVersions.nColorVersion)
    READ( aBox,         SvxBoxItem,         rVersions.nBoxVersion)

    // --- from 680/dr14 on: diagonal frame lines
    if( AUTOFORMAT_DATA_ID_680DR14 <= nVer )
    {
        READ( aTLBR, SvxLineItem, rVersions.nLineVersion)
        READ( aBLTR, SvxLineItem, rVersions.nLineVersion)
    }

    READ( aBackground,  SvxBrushItem,       rVersions.nBrushVersion)

    pNew = aAdjust.Create( rStream, rVersions.nAdjustVersion );
    SetAdjust( *(SvxAdjustItem*)pNew );
    delete pNew;

    READ( aHorJustify,   SvxHorJustifyItem,  rVersions.nHorJustifyVersion)
    READ( aVerJustify,   SvxVerJustifyItem,  rVersions.nVerJustifyVersion)
    READ( aOrientation,  SvxOrientationItem, rVersions.nOrientationVersion)
    READ( aMargin,       SvxMarginItem,      rVersions.nMarginVersion)

    pNew = aLinebreak.Create( rStream, rVersions.nBoolVersion );
    SetLinebreak( *(SfxBoolItem*)pNew );
    delete pNew;

    if ( nVer >= AUTOFORMAT_DATA_ID_504 )
    {
        pNew = aRotateAngle.Create( rStream, rVersions.nInt32Version );
        SetRotateAngle( *(SfxInt32Item*)pNew );
        delete pNew;
        pNew = aRotateMode.Create( rStream, rVersions.nRotateModeVersion );
        SetRotateMode( *(SvxRotateModeItem*)pNew );
        delete pNew;
    }

    if( 0 == rVersions.nNumFmtVersion )
    {
        // --- from 680/dr25 on: #21549# store strings as UTF-8
        CharSet eCharSet = (nVer >= AUTOFORMAT_ID_680DR25) ? RTL_TEXTENCODING_UTF8 : rStream.GetStreamCharSet();
        aNumFormat.Load( rStream, eCharSet );
    }

    //  adjust charset in font
    CharSet eSysSet = gsl_getSystemTextEncoding();
    CharSet eSrcSet = rStream.GetStreamCharSet();
    if( eSrcSet != eSysSet && aFont.GetCharSet() == eSrcSet )
        aFont.SetCharSet(eSysSet);

    aStacked.SetValue( aOrientation.IsStacked() );
    aRotateAngle.SetValue( aOrientation.GetRotation( aRotateAngle.GetValue() ) );

    return (rStream.GetError() == 0);
}

#ifdef READ_OLDVERS
sal_Bool ScAutoFormatDataField::LoadOld( SvStream& rStream, const ScAfVersions& rVersions )
{
    SfxPoolItem* pNew;
    SvxOrientationItem aOrientation( SVX_ORIENTATION_STANDARD, 0 );

    aNumFormat.Load(rStream, rStream.GetStreamCharSet());

    READ( aFont,        SvxFontItem,        rVersions.nFontVersion)
    READ( aHeight,      SvxFontHeightItem,  rVersions.nFontHeightVersion)
    READ( aWeight,      SvxWeightItem,      rVersions.nWeightVersion)
    READ( aPosture,     SvxPostureItem,     rVersions.nPostureVersion)
    READ( aUnderline,   SvxUnderlineItem,   rVersions.nUnderlineVersion)
    READ( aCrossedOut,  SvxCrossedOutItem,  rVersions.nCrossedOutVersion)
    READ( aContour,     SvxContourItem,     rVersions.nContourVersion)
    READ( aShadowed,    SvxShadowedItem,    rVersions.nShadowedVersion)
    READ( aColor,       SvxColorItem,       rVersions.nColorVersion)
    READ( aHorJustify,  SvxHorJustifyItem,  rVersions.nHorJustifyVersion)
    READ( aVerJustify,  SvxVerJustifyItem,  rVersions.nVerJustifyVersion)
    READ( aOrientation, SvxOrientationItem, rVersions.nOrientationVersion)
    pNew = aLinebreak.Create( rStream, rVersions.nBoolVersion );
    SetLinebreak( *(SfxBoolItem*)pNew );
    delete pNew;
    READ( aMargin,      SvxMarginItem,      rVersions.nMarginVersion)
    READ( aBox,         SvxBoxItem,         rVersions.nBoxVersion)
    READ( aBackground,  SvxBrushItem,       rVersions.nBrushVersion)

    aStacked.SetValue( aOrientation.IsStacked() );
    aRotateAngle.SetValue( aOrientation.GetRotation( aRotateAngle.GetValue() ) );

    return (rStream.GetError() == 0);
}
#endif

sal_Bool ScAutoFormatDataField::Save( SvStream& rStream )
{
    SvxOrientationItem aOrientation( aRotateAngle.GetValue(), aStacked.GetValue(), 0 );

    aFont.Store         ( rStream, aFont.GetVersion( SOFFICE_FILEFORMAT_40 ) );
    aHeight.Store       ( rStream, aHeight.GetVersion( SOFFICE_FILEFORMAT_40 ) );
    aWeight.Store       ( rStream, aWeight.GetVersion( SOFFICE_FILEFORMAT_40 ) );
    aPosture.Store      ( rStream, aPosture.GetVersion( SOFFICE_FILEFORMAT_40 ) );
    // --- from 641 on: CJK and CTL font settings
    aCJKFont.Store      ( rStream, aCJKFont.GetVersion( SOFFICE_FILEFORMAT_40 ) );
    aCJKHeight.Store    ( rStream, aCJKHeight.GetVersion( SOFFICE_FILEFORMAT_40 ) );
    aCJKWeight.Store    ( rStream, aCJKWeight.GetVersion( SOFFICE_FILEFORMAT_40 ) );
    aCJKPosture.Store   ( rStream, aCJKPosture.GetVersion( SOFFICE_FILEFORMAT_40 ) );
    aCTLFont.Store      ( rStream, aCTLFont.GetVersion( SOFFICE_FILEFORMAT_40 ) );
    aCTLHeight.Store    ( rStream, aCTLHeight.GetVersion( SOFFICE_FILEFORMAT_40 ) );
    aCTLWeight.Store    ( rStream, aCTLWeight.GetVersion( SOFFICE_FILEFORMAT_40 ) );
    aCTLPosture.Store   ( rStream, aCTLPosture.GetVersion( SOFFICE_FILEFORMAT_40 ) );

    aUnderline.Store    ( rStream, aUnderline.GetVersion( SOFFICE_FILEFORMAT_40 ) );
    // --- from DEV300/overline2 on: overline support
    aOverline.Store     ( rStream, aOverline.GetVersion( SOFFICE_FILEFORMAT_40 ) );
    aCrossedOut.Store   ( rStream, aCrossedOut.GetVersion( SOFFICE_FILEFORMAT_40 ) );
    aContour.Store      ( rStream, aContour.GetVersion( SOFFICE_FILEFORMAT_40 ) );
    aShadowed.Store     ( rStream, aShadowed.GetVersion( SOFFICE_FILEFORMAT_40 ) );
    aColor.Store        ( rStream, aColor.GetVersion( SOFFICE_FILEFORMAT_40 ) );
    aBox.Store          ( rStream, aBox.GetVersion( SOFFICE_FILEFORMAT_40 ) );

    // --- from 680/dr14 on: diagonal frame lines
    aTLBR.Store         ( rStream, aTLBR.GetVersion( SOFFICE_FILEFORMAT_40 ) );
    aBLTR.Store         ( rStream, aBLTR.GetVersion( SOFFICE_FILEFORMAT_40 ) );

    aBackground.Store   ( rStream, aBackground.GetVersion( SOFFICE_FILEFORMAT_40 ) );

    aAdjust.Store       ( rStream, aAdjust.GetVersion( SOFFICE_FILEFORMAT_40 ) );

    aHorJustify.Store   ( rStream, aHorJustify.GetVersion( SOFFICE_FILEFORMAT_40 ) );
    aVerJustify.Store   ( rStream, aVerJustify.GetVersion( SOFFICE_FILEFORMAT_40 ) );
    aOrientation.Store  ( rStream, aOrientation.GetVersion( SOFFICE_FILEFORMAT_40 ) );
    aMargin.Store       ( rStream, aMargin.GetVersion( SOFFICE_FILEFORMAT_40 ) );
    aLinebreak.Store    ( rStream, aLinebreak.GetVersion( SOFFICE_FILEFORMAT_40 ) );
    // Rotation ab SO5
    aRotateAngle.Store  ( rStream, aRotateAngle.GetVersion( SOFFICE_FILEFORMAT_40 ) );
    aRotateMode.Store   ( rStream, aRotateMode.GetVersion( SOFFICE_FILEFORMAT_40 ) );

    // --- from 680/dr25 on: #21549# store strings as UTF-8
    aNumFormat.Save( rStream, RTL_TEXTENCODING_UTF8 );

    return (rStream.GetError() == 0);
}


//	---------------------------------------------------------------------------

ScAutoFormatData::ScAutoFormatData()
{
	nStrResId = USHRT_MAX;

	bIncludeValueFormat =
	bIncludeFont =
	bIncludeJustify =
	bIncludeFrame =
	bIncludeBackground =
	bIncludeWidthHeight = sal_True;

    ppDataField = new ScAutoFormatDataField*[ 16 ];
    for( sal_uInt16 nIndex = 0; nIndex < 16; ++nIndex )
        ppDataField[ nIndex ] = new ScAutoFormatDataField;
}

ScAutoFormatData::ScAutoFormatData( const ScAutoFormatData& rData ) :
        ScDataObject(),
		aName( rData.aName ),
		nStrResId( rData.nStrResId ),
		bIncludeFont( rData.bIncludeFont ),
		bIncludeJustify( rData.bIncludeJustify ),
		bIncludeFrame( rData.bIncludeFrame ),
		bIncludeBackground( rData.bIncludeBackground ),
		bIncludeValueFormat( rData.bIncludeValueFormat ),
		bIncludeWidthHeight( rData.bIncludeWidthHeight )
{
    ppDataField = new ScAutoFormatDataField*[ 16 ];
    for( sal_uInt16 nIndex = 0; nIndex < 16; ++nIndex )
        ppDataField[ nIndex ] = new ScAutoFormatDataField( rData.GetField( nIndex ) );
}

ScAutoFormatData::~ScAutoFormatData()
{
    for( sal_uInt16 nIndex = 0; nIndex < 16; ++nIndex )
        delete ppDataField[ nIndex ];
    delete[] ppDataField;
}

ScAutoFormatDataField& ScAutoFormatData::GetField( sal_uInt16 nIndex )
{
    DBG_ASSERT( nIndex < 16, "ScAutoFormatData::GetField - illegal index" );
    DBG_ASSERT( ppDataField && ppDataField[ nIndex ], "ScAutoFormatData::GetField - no data" );
    return *ppDataField[ nIndex ];
}

const ScAutoFormatDataField& ScAutoFormatData::GetField( sal_uInt16 nIndex ) const
{
    DBG_ASSERT( nIndex < 16, "ScAutoFormatData::GetField - illegal index" );
    DBG_ASSERT( ppDataField && ppDataField[ nIndex ], "ScAutoFormatData::GetField - no data" );
    return *ppDataField[ nIndex ];
}

const SfxPoolItem* ScAutoFormatData::GetItem( sal_uInt16 nIndex, sal_uInt16 nWhich ) const
{
    const ScAutoFormatDataField& rField = GetField( nIndex );
    switch( nWhich )
	{
        case ATTR_FONT:             return &rField.GetFont();
        case ATTR_FONT_HEIGHT:      return &rField.GetHeight();
        case ATTR_FONT_WEIGHT:      return &rField.GetWeight();
        case ATTR_FONT_POSTURE:     return &rField.GetPosture();
        case ATTR_CJK_FONT:         return &rField.GetCJKFont();
        case ATTR_CJK_FONT_HEIGHT:  return &rField.GetCJKHeight();
        case ATTR_CJK_FONT_WEIGHT:  return &rField.GetCJKWeight();
        case ATTR_CJK_FONT_POSTURE: return &rField.GetCJKPosture();
        case ATTR_CTL_FONT:         return &rField.GetCTLFont();
        case ATTR_CTL_FONT_HEIGHT:  return &rField.GetCTLHeight();
        case ATTR_CTL_FONT_WEIGHT:  return &rField.GetCTLWeight();
        case ATTR_CTL_FONT_POSTURE: return &rField.GetCTLPosture();
        case ATTR_FONT_UNDERLINE:   return &rField.GetUnderline();
        case ATTR_FONT_OVERLINE:    return &rField.GetOverline();
        case ATTR_FONT_CROSSEDOUT:  return &rField.GetCrossedOut();
        case ATTR_FONT_CONTOUR:     return &rField.GetContour();
        case ATTR_FONT_SHADOWED:    return &rField.GetShadowed();
        case ATTR_FONT_COLOR:       return &rField.GetColor();
        case ATTR_BORDER:           return &rField.GetBox();
        case ATTR_BORDER_TLBR:      return &rField.GetTLBR();
        case ATTR_BORDER_BLTR:      return &rField.GetBLTR();
        case ATTR_BACKGROUND:       return &rField.GetBackground();
        case ATTR_HOR_JUSTIFY:      return &rField.GetHorJustify();
        case ATTR_VER_JUSTIFY:      return &rField.GetVerJustify();
        case ATTR_STACKED:          return &rField.GetStacked();
        case ATTR_MARGIN:           return &rField.GetMargin();
        case ATTR_LINEBREAK:        return &rField.GetLinebreak();
        case ATTR_ROTATE_VALUE:     return &rField.GetRotateAngle();
        case ATTR_ROTATE_MODE:      return &rField.GetRotateMode();
	}
	return NULL;
}

void ScAutoFormatData::PutItem( sal_uInt16 nIndex, const SfxPoolItem& rItem )
{
    ScAutoFormatDataField& rField = GetField( nIndex );
    switch( rItem.Which() )
	{
        case ATTR_FONT:             rField.SetFont( (const SvxFontItem&)rItem );              break;
        case ATTR_FONT_HEIGHT:      rField.SetHeight( (const SvxFontHeightItem&)rItem );      break;
        case ATTR_FONT_WEIGHT:      rField.SetWeight( (const SvxWeightItem&)rItem );          break;
        case ATTR_FONT_POSTURE:     rField.SetPosture( (const SvxPostureItem&)rItem );        break;
        case ATTR_CJK_FONT:         rField.SetCJKFont( (const SvxFontItem&)rItem );           break;
        case ATTR_CJK_FONT_HEIGHT:  rField.SetCJKHeight( (const SvxFontHeightItem&)rItem );   break;
        case ATTR_CJK_FONT_WEIGHT:  rField.SetCJKWeight( (const SvxWeightItem&)rItem );       break;
        case ATTR_CJK_FONT_POSTURE: rField.SetCJKPosture( (const SvxPostureItem&)rItem );     break;
        case ATTR_CTL_FONT:         rField.SetCTLFont( (const SvxFontItem&)rItem );           break;
        case ATTR_CTL_FONT_HEIGHT:  rField.SetCTLHeight( (const SvxFontHeightItem&)rItem );   break;
        case ATTR_CTL_FONT_WEIGHT:  rField.SetCTLWeight( (const SvxWeightItem&)rItem );       break;
        case ATTR_CTL_FONT_POSTURE: rField.SetCTLPosture( (const SvxPostureItem&)rItem );     break;
        case ATTR_FONT_UNDERLINE:   rField.SetUnderline( (const SvxUnderlineItem&)rItem );    break;
        case ATTR_FONT_OVERLINE:    rField.SetOverline( (const SvxOverlineItem&)rItem );      break;
        case ATTR_FONT_CROSSEDOUT:  rField.SetCrossedOut( (const SvxCrossedOutItem&)rItem );  break;
        case ATTR_FONT_CONTOUR:     rField.SetContour( (const SvxContourItem&)rItem );        break;
        case ATTR_FONT_SHADOWED:    rField.SetShadowed( (const SvxShadowedItem&)rItem );      break;
        case ATTR_FONT_COLOR:       rField.SetColor( (const SvxColorItem&)rItem );            break;
        case ATTR_BORDER:           rField.SetBox( (const SvxBoxItem&)rItem );                break;
        case ATTR_BORDER_TLBR:      rField.SetTLBR( (const SvxLineItem&)rItem );              break;
        case ATTR_BORDER_BLTR:      rField.SetBLTR( (const SvxLineItem&)rItem );              break;
        case ATTR_BACKGROUND:       rField.SetBackground( (const SvxBrushItem&)rItem );       break;
        case ATTR_HOR_JUSTIFY:      rField.SetHorJustify( (const SvxHorJustifyItem&)rItem );  break;
        case ATTR_VER_JUSTIFY:      rField.SetVerJustify( (const SvxVerJustifyItem&)rItem );  break;
        case ATTR_STACKED:          rField.SetStacked( (const SfxBoolItem&)rItem );           break;
        case ATTR_MARGIN:           rField.SetMargin( (const SvxMarginItem&)rItem );          break;
        case ATTR_LINEBREAK:        rField.SetLinebreak( (const SfxBoolItem&)rItem );         break;
        case ATTR_ROTATE_VALUE:     rField.SetRotateAngle( (const SfxInt32Item&)rItem );      break;
        case ATTR_ROTATE_MODE:      rField.SetRotateMode( (const SvxRotateModeItem&)rItem );  break;
	}
}

void ScAutoFormatData::CopyItem( sal_uInt16 nToIndex, sal_uInt16 nFromIndex, sal_uInt16 nWhich )
{
    const SfxPoolItem* pItem = GetItem( nFromIndex, nWhich );
    if( pItem )
        PutItem( nToIndex, *pItem );
}

const ScNumFormatAbbrev& ScAutoFormatData::GetNumFormat( sal_uInt16 nIndex ) const
{
    return GetField( nIndex ).GetNumFormat();
}

sal_Bool ScAutoFormatData::IsEqualData( sal_uInt16 nIndex1, sal_uInt16 nIndex2 ) const
{
	sal_Bool bEqual = sal_True;
    const ScAutoFormatDataField& rField1 = GetField( nIndex1 );
    const ScAutoFormatDataField& rField2 = GetField( nIndex2 );

    if( bIncludeValueFormat )
	{
        bEqual = bEqual
            && (rField1.GetNumFormat()      == rField2.GetNumFormat());
	}
    if( bIncludeFont )
	{
        bEqual = bEqual
            && (rField1.GetFont()           == rField2.GetFont())
            && (rField1.GetHeight()         == rField2.GetHeight())
            && (rField1.GetWeight()         == rField2.GetWeight())
            && (rField1.GetPosture()        == rField2.GetPosture())
            && (rField1.GetCJKFont()        == rField2.GetCJKFont())
            && (rField1.GetCJKHeight()      == rField2.GetCJKHeight())
            && (rField1.GetCJKWeight()      == rField2.GetCJKWeight())
            && (rField1.GetCJKPosture()     == rField2.GetCJKPosture())
            && (rField1.GetCTLFont()        == rField2.GetCTLFont())
            && (rField1.GetCTLHeight()      == rField2.GetCTLHeight())
            && (rField1.GetCTLWeight()      == rField2.GetCTLWeight())
            && (rField1.GetCTLPosture()     == rField2.GetCTLPosture())
            && (rField1.GetUnderline()      == rField2.GetUnderline())
            && (rField1.GetOverline()       == rField2.GetOverline())
            && (rField1.GetCrossedOut()     == rField2.GetCrossedOut())
            && (rField1.GetContour()        == rField2.GetContour())
            && (rField1.GetShadowed()       == rField2.GetShadowed())
            && (rField1.GetColor()          == rField2.GetColor());
	}
    if( bIncludeJustify )
	{
        bEqual = bEqual
            && (rField1.GetHorJustify()     == rField2.GetHorJustify())
            && (rField1.GetVerJustify()     == rField2.GetVerJustify())
            && (rField1.GetStacked()        == rField2.GetStacked())
            && (rField1.GetLinebreak()      == rField2.GetLinebreak())
            && (rField1.GetMargin()         == rField2.GetMargin())
            && (rField1.GetRotateAngle()    == rField2.GetRotateAngle())
            && (rField1.GetRotateMode()     == rField2.GetRotateMode());
	}
    if( bIncludeFrame )
    {
        bEqual = bEqual
            && (rField1.GetBox()            == rField2.GetBox())
            && (rField1.GetTLBR()           == rField2.GetTLBR())
            && (rField1.GetBLTR()           == rField2.GetBLTR());
    }
    if( bIncludeBackground )
    {
        bEqual = bEqual
            && (rField1.GetBackground()     == rField2.GetBackground());
    }
	return bEqual;
}

void ScAutoFormatData::FillToItemSet( sal_uInt16 nIndex, SfxItemSet& rItemSet, ScDocument& rDoc ) const
{
    const ScAutoFormatDataField& rField = GetField( nIndex );

    if( bIncludeValueFormat )
    {
        ScNumFormatAbbrev& rNumFormat = (ScNumFormatAbbrev&)rField.GetNumFormat();
        SfxUInt32Item aValueFormat( ATTR_VALUE_FORMAT, 0 );
        aValueFormat.SetValue( rNumFormat.GetFormatIndex( *rDoc.GetFormatTable() ) );
        rItemSet.Put( aValueFormat );
        rItemSet.Put( SvxLanguageItem( rNumFormat.GetLanguage(), ATTR_LANGUAGE_FORMAT ) );
    }
    if( bIncludeFont )
    {
        rItemSet.Put( rField.GetFont() );
        rItemSet.Put( rField.GetHeight() );
        rItemSet.Put( rField.GetWeight() );
        rItemSet.Put( rField.GetPosture() );
        // #103065# do not insert empty CJK font
        const SvxFontItem& rCJKFont = rField.GetCJKFont();
        if( rCJKFont.GetStyleName().Len() )
        {
            rItemSet.Put( rCJKFont );
            rItemSet.Put( rField.GetCJKHeight() );
            rItemSet.Put( rField.GetCJKWeight() );
            rItemSet.Put( rField.GetCJKPosture() );
        }
        else
        {
            rItemSet.Put( rField.GetHeight(), ATTR_CJK_FONT_HEIGHT );
            rItemSet.Put( rField.GetWeight(), ATTR_CJK_FONT_WEIGHT );
            rItemSet.Put( rField.GetPosture(), ATTR_CJK_FONT_POSTURE );
        }
        // #103065# do not insert empty CTL font
        const SvxFontItem& rCTLFont = rField.GetCTLFont();
        if( rCTLFont.GetStyleName().Len() )
        {
            rItemSet.Put( rCTLFont );
            rItemSet.Put( rField.GetCTLHeight() );
            rItemSet.Put( rField.GetCTLWeight() );
            rItemSet.Put( rField.GetCTLPosture() );
        }
        else
        {
            rItemSet.Put( rField.GetHeight(), ATTR_CTL_FONT_HEIGHT );
            rItemSet.Put( rField.GetWeight(), ATTR_CTL_FONT_WEIGHT );
            rItemSet.Put( rField.GetPosture(), ATTR_CTL_FONT_POSTURE );
        }
        rItemSet.Put( rField.GetUnderline() );
        rItemSet.Put( rField.GetOverline() );
        rItemSet.Put( rField.GetCrossedOut() );
        rItemSet.Put( rField.GetContour() );
        rItemSet.Put( rField.GetShadowed() );
        rItemSet.Put( rField.GetColor() );
    }
    if( bIncludeJustify )
    {
        rItemSet.Put( rField.GetHorJustify() );
        rItemSet.Put( rField.GetVerJustify() );
        rItemSet.Put( rField.GetStacked() );
        rItemSet.Put( rField.GetLinebreak() );
        rItemSet.Put( rField.GetMargin() );
        rItemSet.Put( rField.GetRotateAngle() );
        rItemSet.Put( rField.GetRotateMode() );
    }
    if( bIncludeFrame )
    {
        rItemSet.Put( rField.GetBox() );
        rItemSet.Put( rField.GetTLBR() );
        rItemSet.Put( rField.GetBLTR() );
    }
    if( bIncludeBackground )
        rItemSet.Put( rField.GetBackground() );
}

void ScAutoFormatData::GetFromItemSet( sal_uInt16 nIndex, const SfxItemSet& rItemSet, const ScNumFormatAbbrev& rNumFormat )
{
    ScAutoFormatDataField& rField = GetField( nIndex );

    rField.SetNumFormat     ( rNumFormat);
    rField.SetFont          ( (const SvxFontItem&)          rItemSet.Get( ATTR_FONT ) );
    rField.SetHeight        ( (const SvxFontHeightItem&)    rItemSet.Get( ATTR_FONT_HEIGHT ) );
    rField.SetWeight        ( (const SvxWeightItem&)        rItemSet.Get( ATTR_FONT_WEIGHT ) );
    rField.SetPosture       ( (const SvxPostureItem&)       rItemSet.Get( ATTR_FONT_POSTURE ) );
    rField.SetCJKFont       ( (const SvxFontItem&)          rItemSet.Get( ATTR_CJK_FONT ) );
    rField.SetCJKHeight     ( (const SvxFontHeightItem&)    rItemSet.Get( ATTR_CJK_FONT_HEIGHT ) );
    rField.SetCJKWeight     ( (const SvxWeightItem&)        rItemSet.Get( ATTR_CJK_FONT_WEIGHT ) );
    rField.SetCJKPosture    ( (const SvxPostureItem&)       rItemSet.Get( ATTR_CJK_FONT_POSTURE ) );
    rField.SetCTLFont       ( (const SvxFontItem&)          rItemSet.Get( ATTR_CTL_FONT ) );
    rField.SetCTLHeight     ( (const SvxFontHeightItem&)    rItemSet.Get( ATTR_CTL_FONT_HEIGHT ) );
    rField.SetCTLWeight     ( (const SvxWeightItem&)        rItemSet.Get( ATTR_CTL_FONT_WEIGHT ) );
    rField.SetCTLPosture    ( (const SvxPostureItem&)       rItemSet.Get( ATTR_CTL_FONT_POSTURE ) );
    rField.SetUnderline     ( (const SvxUnderlineItem&)     rItemSet.Get( ATTR_FONT_UNDERLINE ) );
    rField.SetOverline      ( (const SvxOverlineItem&)      rItemSet.Get( ATTR_FONT_OVERLINE ) );
    rField.SetCrossedOut    ( (const SvxCrossedOutItem&)    rItemSet.Get( ATTR_FONT_CROSSEDOUT ) );
    rField.SetContour       ( (const SvxContourItem&)       rItemSet.Get( ATTR_FONT_CONTOUR ) );
    rField.SetShadowed      ( (const SvxShadowedItem&)      rItemSet.Get( ATTR_FONT_SHADOWED ) );
    rField.SetColor         ( (const SvxColorItem&)         rItemSet.Get( ATTR_FONT_COLOR ) );
    rField.SetTLBR          ( (const SvxLineItem&)          rItemSet.Get( ATTR_BORDER_TLBR ) );
    rField.SetBLTR          ( (const SvxLineItem&)          rItemSet.Get( ATTR_BORDER_BLTR ) );
    rField.SetHorJustify    ( (const SvxHorJustifyItem&)    rItemSet.Get( ATTR_HOR_JUSTIFY ) );
    rField.SetVerJustify    ( (const SvxVerJustifyItem&)    rItemSet.Get( ATTR_VER_JUSTIFY ) );
    rField.SetStacked       ( (const SfxBoolItem&)          rItemSet.Get( ATTR_STACKED ) );
    rField.SetLinebreak     ( (const SfxBoolItem&)          rItemSet.Get( ATTR_LINEBREAK ) );
    rField.SetMargin        ( (const SvxMarginItem&)        rItemSet.Get( ATTR_MARGIN ) );
    rField.SetBackground    ( (const SvxBrushItem&)         rItemSet.Get( ATTR_BACKGROUND ) );
    rField.SetRotateAngle   ( (const SfxInt32Item&)         rItemSet.Get( ATTR_ROTATE_VALUE ) );
    rField.SetRotateMode    ( (const SvxRotateModeItem&)    rItemSet.Get( ATTR_ROTATE_MODE ) );
}

sal_Bool ScAutoFormatData::Load( SvStream& rStream, const ScAfVersions& rVersions )
{
	sal_Bool    bRet = sal_True;
    sal_uInt16  nVer = 0;
    rStream >> nVer;
	bRet = 0 == rStream.GetError();
    if( bRet && (nVer == AUTOFORMAT_DATA_ID_X ||
            (AUTOFORMAT_DATA_ID_504 <= nVer && nVer <= AUTOFORMAT_DATA_ID)) )
	{
        // --- from 680/dr25 on: #21549# store strings as UTF-8
        CharSet eCharSet = (nVer >= AUTOFORMAT_ID_680DR25) ? RTL_TEXTENCODING_UTF8 : rStream.GetStreamCharSet();
        rStream.ReadByteString( aName, eCharSet );
        if( AUTOFORMAT_DATA_ID_552 <= nVer )
		{
			rStream >> nStrResId;
			sal_uInt16 nId = RID_SVXSTR_TBLAFMT_BEGIN + nStrResId;
			if( RID_SVXSTR_TBLAFMT_BEGIN <= nId &&
				nId < RID_SVXSTR_TBLAFMT_END )
			{
				aName = SVX_RESSTR( nId );
			}
			else
				nStrResId = USHRT_MAX;
		}

        sal_Bool b;
		rStream >> b; bIncludeFont = b;
		rStream >> b; bIncludeJustify = b;
		rStream >> b; bIncludeFrame = b;
		rStream >> b; bIncludeBackground = b;
		rStream >> b; bIncludeValueFormat = b;
		rStream >> b; bIncludeWidthHeight = b;

		bRet = 0 == rStream.GetError();
		for( sal_uInt16 i = 0; bRet && i < 16; ++i )
            bRet = GetField( i ).Load( rStream, rVersions, nVer );
	}
	else
		bRet = sal_False;
	return bRet;
}

#ifdef READ_OLDVERS
sal_Bool ScAutoFormatData::LoadOld( SvStream& rStream, const ScAfVersions& rVersions )
{
	sal_Bool    bRet = sal_True;
	sal_uInt16  nVal = 0;
	rStream >> nVal;
	bRet = (rStream.GetError() == 0);
	if (bRet && (nVal == AUTOFORMAT_OLD_DATA_ID))
	{
		rStream.ReadByteString( aName, rStream.GetStreamCharSet() );
		sal_Bool b;
		rStream >> b; bIncludeFont = b;
		rStream >> b; bIncludeJustify = b;
		rStream >> b; bIncludeFrame = b;
		rStream >> b; bIncludeBackground = b;
		rStream >> b; bIncludeValueFormat = b;
		rStream >> b; bIncludeWidthHeight = b;

		bRet = 0 == rStream.GetError();
		for (sal_uInt16 i=0; bRet && i < 16; i++)
            bRet = GetField( i ).LoadOld( rStream, rVersions );
	}
	else
		bRet = sal_False;
	return bRet;
}
#endif

sal_Bool ScAutoFormatData::Save(SvStream& rStream)
{
	sal_uInt16 nVal = AUTOFORMAT_DATA_ID;
	sal_Bool b;
	rStream << nVal;
    // --- from 680/dr25 on: #21549# store strings as UTF-8
    rStream.WriteByteString( aName, RTL_TEXTENCODING_UTF8 );

#if 0
	//	This was an internal flag to allow creating AutoFormats with localized names

	if ( USHRT_MAX == nStrResId )
	{
		String aIniVal( SFX_APP()->GetIniManager()->Get(
			SFX_GROUP_WORKINGSET_IMPL,
			String( RTL_CONSTASCII_USTRINGPARAM( "SaveTableAutoFmtNameId" ))));
		if( 0 != aIniVal.ToInt32() )
		{
			// check Name for ResId
			for( sal_uInt16 nId = RID_SVXSTR_TBLAFMT_BEGIN;
						RID_SVXSTR_TBLAFMT_END > nId; ++nId )
			{
				String s( SVX_RES( nId ) );
				if( s == aName )
				{
					nStrResId = nId - RID_SVXSTR_TBLAFMT_BEGIN;
					break;
				}
			}
		}
	}
#endif

	rStream << nStrResId;
	rStream << ( b = bIncludeFont );
	rStream << ( b = bIncludeJustify );
	rStream << ( b = bIncludeFrame );
	rStream << ( b = bIncludeBackground );
	rStream << ( b = bIncludeValueFormat );
	rStream << ( b = bIncludeWidthHeight );

    sal_Bool bRet = 0 == rStream.GetError();
	for (sal_uInt16 i = 0; bRet && (i < 16); i++)
        bRet = GetField( i ).Save( rStream );

	return bRet;
}

//---------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------

ScAutoFormat::ScAutoFormat(sal_uInt16 nLim, sal_uInt16 nDel, sal_Bool bDup):
	ScSortedCollection        (nLim, nDel, bDup),
	bSaveLater				(sal_False)
{
    //  create default autoformat
    ScAutoFormatData* pData = new ScAutoFormatData;
	String aName(ScGlobal::GetRscString(STR_STYLENAME_STANDARD));
	pData->SetName(aName);

    //  default font, default height
    Font aStdFont = OutputDevice::GetDefaultFont(
        DEFAULTFONT_LATIN_SPREADSHEET, LANGUAGE_ENGLISH_US, DEFAULTFONT_FLAGS_ONLYONE );
    SvxFontItem aFontItem(
        aStdFont.GetFamily(), aStdFont.GetName(), aStdFont.GetStyleName(),
        aStdFont.GetPitch(), aStdFont.GetCharSet(), ATTR_FONT );

    aStdFont = OutputDevice::GetDefaultFont(
        DEFAULTFONT_CJK_SPREADSHEET, LANGUAGE_ENGLISH_US, DEFAULTFONT_FLAGS_ONLYONE );
    SvxFontItem aCJKFontItem(
        aStdFont.GetFamily(), aStdFont.GetName(), aStdFont.GetStyleName(),
        aStdFont.GetPitch(), aStdFont.GetCharSet(), ATTR_CJK_FONT );

    aStdFont = OutputDevice::GetDefaultFont(
        DEFAULTFONT_CTL_SPREADSHEET, LANGUAGE_ENGLISH_US, DEFAULTFONT_FLAGS_ONLYONE );
    SvxFontItem aCTLFontItem(
        aStdFont.GetFamily(), aStdFont.GetName(), aStdFont.GetStyleName(),
        aStdFont.GetPitch(), aStdFont.GetCharSet(), ATTR_CTL_FONT );

    SvxFontHeightItem aHeight( 200, 100, ATTR_FONT_HEIGHT );      // 10 pt;

    //  black thin border
	Color aBlack( COL_BLACK );
	SvxBorderLine aLine( &aBlack, DEF_LINE_WIDTH_0 );
    SvxBoxItem aBox( ATTR_BORDER );
	aBox.SetLine(&aLine, BOX_LINE_LEFT);
	aBox.SetLine(&aLine, BOX_LINE_TOP);
	aBox.SetLine(&aLine, BOX_LINE_RIGHT);
	aBox.SetLine(&aLine, BOX_LINE_BOTTOM);

	Color aWhite(COL_WHITE);
	Color aBlue(COL_BLUE);
    SvxColorItem aWhiteText( aWhite, ATTR_FONT_COLOR );
    SvxColorItem aBlackText( aBlack, ATTR_FONT_COLOR );
    SvxBrushItem aBlueBack( aBlue, ATTR_BACKGROUND );
    SvxBrushItem aWhiteBack( aWhite, ATTR_BACKGROUND );
    SvxBrushItem aGray70Back( Color(0x4d, 0x4d, 0x4d), ATTR_BACKGROUND );
    SvxBrushItem aGray20Back( Color(0xcc, 0xcc, 0xcc), ATTR_BACKGROUND );

	for (sal_uInt16 i=0; i<16; i++)
	{
        pData->PutItem( i, aBox );
        pData->PutItem( i, aFontItem );
        pData->PutItem( i, aCJKFontItem );
        pData->PutItem( i, aCTLFontItem );
        aHeight.SetWhich( ATTR_FONT_HEIGHT );
        pData->PutItem( i, aHeight );
        aHeight.SetWhich( ATTR_CJK_FONT_HEIGHT );
        pData->PutItem( i, aHeight );
        aHeight.SetWhich( ATTR_CTL_FONT_HEIGHT );
        pData->PutItem( i, aHeight );
        if (i<4)                                    // top: white on blue
		{
            pData->PutItem( i, aWhiteText );
            pData->PutItem( i, aBlueBack );
		}
        else if ( i%4 == 0 )                        // left: white on gray70
		{
            pData->PutItem( i, aWhiteText );
            pData->PutItem( i, aGray70Back );
		}
        else if ( i%4 == 3 || i >= 12 )             // right and bottom: black on gray20
		{
            pData->PutItem( i, aBlackText );
            pData->PutItem( i, aGray20Back );
		}
        else                                        // center: black on white
		{
            pData->PutItem( i, aBlackText );
            pData->PutItem( i, aWhiteBack );
		}
	}

	Insert(pData);
}

ScAutoFormat::ScAutoFormat(const ScAutoFormat& rAutoFormat) :
	ScSortedCollection (rAutoFormat),
	bSaveLater		 (sal_False)
{}

ScAutoFormat::~ScAutoFormat()
{
	//	Bei Aenderungen per StarOne wird nicht sofort gespeichert, sondern zuerst nur
	//	das SaveLater Flag gesetzt. Wenn das Flag noch gesetzt ist, jetzt speichern.

	if (bSaveLater)
		Save();
}

void ScAutoFormat::SetSaveLater( sal_Bool bSet )
{
	bSaveLater = bSet;
}

short ScAutoFormat::Compare(ScDataObject* pKey1, ScDataObject* pKey2) const
{
	String aStr1;
	String aStr2;
	((ScAutoFormatData*)pKey1)->GetName(aStr1);
	((ScAutoFormatData*)pKey2)->GetName(aStr2);
	String aStrStandard = ScGlobal::GetRscString(STR_STYLENAME_STANDARD);
    if ( ScGlobal::GetpTransliteration()->isEqual( aStr1, aStrStandard ) )
		return -1;
    if ( ScGlobal::GetpTransliteration()->isEqual( aStr2, aStrStandard ) )
		return 1;
    return (short) ScGlobal::GetpTransliteration()->compareString( aStr1, aStr2 );
}

sal_Bool ScAutoFormat::Load()
{
	sal_Bool bRet = sal_True;

	INetURLObject aURL;
	SvtPathOptions aPathOpt;
	aURL.SetSmartURL( aPathOpt.GetUserConfigPath() );
	aURL.setFinalSlash();
	aURL.Append( String( RTL_CONSTASCII_USTRINGPARAM( sAutoTblFmtName ) ) );

	SfxMedium aMedium( aURL.GetMainURL(INetURLObject::NO_DECODE), STREAM_READ, sal_True );
	SvStream* pStream = aMedium.GetInStream();
	bRet = (pStream && pStream->GetError() == 0);
	if (bRet)
	{
		SvStream& rStream = *pStream;
		// Achtung hier muss ein allgemeiner Header gelesen werden
		sal_uInt16 nVal = 0;
		rStream >> nVal;
		bRet = 0 == rStream.GetError();

		ScAfVersions aVersions;

		if (bRet)
		{
			if( nVal == AUTOFORMAT_ID_358 ||
					(AUTOFORMAT_ID_504 <= nVal && nVal <= AUTOFORMAT_ID) )
			{
				sal_uInt16 nFileVers = SOFFICE_FILEFORMAT_40;
				sal_uInt8 nChrSet, nCnt;
				long nPos = rStream.Tell();
				rStream >> nCnt >> nChrSet;
//				if( 4 <= nCnt )
//					rStream >> nFileVers;
				if( rStream.Tell() != sal_uLong(nPos + nCnt) )
				{
					DBG_ERRORFILE( "Der Header enthaelt mehr/neuere Daten" );
					rStream.Seek( nPos + nCnt );
				}
                rStream.SetStreamCharSet( GetSOLoadTextEncoding( nChrSet, nFileVers ) );
				rStream.SetVersion( nFileVers );
			}

			if( nVal == AUTOFORMAT_ID_358 || nVal == AUTOFORMAT_ID_X ||
					(AUTOFORMAT_ID_504 <= nVal && nVal <= AUTOFORMAT_ID) )
			{
				aVersions.Load( rStream, nVal );		// Item-Versionen

				ScAutoFormatData* pData;
				sal_uInt16 nAnz = 0;
				rStream >> nAnz;
				bRet = (rStream.GetError() == 0);
				for (sal_uInt16 i=0; bRet && (i < nAnz); i++)
				{
					pData = new ScAutoFormatData();
					bRet = pData->Load(rStream, aVersions);
					Insert(pData);
				}
			}
#ifdef READ_OLDVERS
			else
			{
				if( AUTOFORMAT_OLD_ID_NEW == nVal )
				{
					// alte Version der Versions laden
					rStream >> aVersions.nFontVersion;
					rStream >> aVersions.nFontHeightVersion;
					rStream >> aVersions.nWeightVersion;
					rStream >> aVersions.nPostureVersion;
					rStream >> aVersions.nUnderlineVersion;
					rStream >> aVersions.nCrossedOutVersion;
					rStream >> aVersions.nContourVersion;
					rStream >> aVersions.nShadowedVersion;
					rStream >> aVersions.nColorVersion;
					rStream >> aVersions.nHorJustifyVersion;
					rStream >> aVersions.nVerJustifyVersion;
					rStream >> aVersions.nOrientationVersion;
					rStream >> aVersions.nBoolVersion;
					rStream >> aVersions.nMarginVersion;
					rStream >> aVersions.nBoxVersion;
					rStream >> aVersions.nBrushVersion;
				}
				if( AUTOFORMAT_OLD_ID_OLD == nVal ||
					AUTOFORMAT_OLD_ID_NEW == nVal )
				{
					ScAutoFormatData* pData;
					sal_uInt16 nAnz = 0;
					rStream >> nAnz;
					bRet = 0 == rStream.GetError();
					for( sal_uInt16 i=0; bRet && (i < nAnz); ++i )
					{
						pData = new ScAutoFormatData();
						bRet = pData->LoadOld( rStream, aVersions );
						Insert( pData );
					}
				}
				else
					bRet = sal_False;
			}
#endif
		}
	}
	bSaveLater = sal_False;
	return bRet;
}

sal_Bool ScAutoFormat::Save()
{
	sal_Bool bRet = sal_True;

	INetURLObject aURL;
	SvtPathOptions aPathOpt;
	aURL.SetSmartURL( aPathOpt.GetUserConfigPath() );
	aURL.setFinalSlash();
	aURL.Append( String( RTL_CONSTASCII_USTRINGPARAM( sAutoTblFmtName ) ) );

	SfxMedium aMedium( aURL.GetMainURL(INetURLObject::NO_DECODE), STREAM_WRITE, sal_True );
	SvStream* pStream = aMedium.GetOutStream();
	bRet = (pStream && pStream->GetError() == 0);
	if (bRet)
	{
		SvStream& rStream = *pStream;
		rStream.SetVersion( SOFFICE_FILEFORMAT_40 );

		// Achtung hier muss ein allgemeiner Header gespeichert werden
		sal_uInt16 nVal = AUTOFORMAT_ID;
		rStream << nVal
				<< (sal_uInt8)2 		// Anzahl von Zeichen des Headers incl. diesem
                << (sal_uInt8)::GetSOStoreTextEncoding(
                    gsl_getSystemTextEncoding(), sal::static_int_cast<sal_uInt16>(rStream.GetVersion()) );
//				<< (sal_uInt8)4 		// Anzahl von Zeichen des Headers incl. diesem
//				<< (sal_uInt8)::GetStoreCharSet(::GetSystemCharSet())
//				<< (UNIT16)SOFFICE_FILEFORMAT_NOW;
		ScAfVersions::Write(rStream);			// Item-Versionen

		bRet = (rStream.GetError() == 0);
		//-----------------------------------------------------------
		rStream << (sal_uInt16)(nCount - 1);
		bRet = (rStream.GetError() == 0);
		for (sal_uInt16 i=1; bRet && (i < nCount); i++)
			bRet = ((ScAutoFormatData*)pItems[i])->Save(rStream);
		rStream.Flush();

		aMedium.Commit();
	}
	bSaveLater = sal_False;
	return bRet;
}

sal_uInt16 ScAutoFormat::FindIndexPerName( const String& rName ) const
{
	String				aName;

	for( sal_uInt16 i=0; i<nCount ; i++ )
	{
		ScAutoFormatData* pItem = (ScAutoFormatData*)pItems[i];
		pItem->GetName( aName );

		if( aName == rName )
			return i;
	}

	return 0;
}