AOO410/main/sc/source/filter/html/htmlexp.cxx

/**************************************************************
 * 
 * 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"



// INCLUDE ---------------------------------------------------------------

#include "scitems.hxx"
#include <editeng/eeitem.hxx>

#define _SVSTDARR_STRINGSSORTDTOR
#include <rtl/tencinfo.h>

#include <vcl/svapp.hxx>
#include <svx/algitem.hxx>
#include <editeng/boxitem.hxx>
#include <editeng/brshitem.hxx>
#include <editeng/colritem.hxx>
#include <editeng/fhgtitem.hxx>
#include <editeng/fontitem.hxx>
#include <editeng/postitem.hxx>
#include <editeng/udlnitem.hxx>
#include <editeng/wghtitem.hxx>
#include <svx/xoutbmp.hxx>
#include <editeng/editeng.hxx>
#include <svtools/htmlcfg.hxx>
#include <sfx2/docfile.hxx>
#include <sfx2/frmhtmlw.hxx>
#include <sfx2/objsh.hxx>
#include <svl/stritem.hxx>
#include <svl/urihelper.hxx>
#ifndef _SVSTDARR_USHORTS
#define _SVSTDARR_USHORTS
#endif
#include <svl/svstdarr.hxx>
#include <svl/zforlist.hxx>
#include <svtools/htmlkywd.hxx>
#include <svtools/htmlout.hxx>
#include <svtools/parhtml.hxx>
#include <vcl/outdev.hxx>
#include <stdio.h>

#include "htmlexp.hxx"
#include "filter.hxx"
#include "global.hxx"
#include "document.hxx"
#include "scitems.hxx"
#include "attrib.hxx"
#include "patattr.hxx"
#include "stlpool.hxx"
#include "scresid.hxx"
#include "cell.hxx"
#include "cellform.hxx"
#include "docoptio.hxx"
#include "editutil.hxx"
#include "ftools.hxx"


#include <editeng/flditem.hxx>
#include <editeng/borderline.hxx>
#include <unotools/syslocale.hxx>


// ohne sc.hrc: error C2679: binary '=' : no operator defined which takes a
// right-hand operand of type 'const class String (__stdcall *)(class ScResId)'
// bei
// const String	aStrTable( ScResId( SCSTR_TABLE ) ); aStrOut = aStrTable;
// ?!???
#include "sc.hrc"
#include "globstr.hrc"

#include <com/sun/star/uno/Reference.h>
#include <com/sun/star/document/XDocumentProperties.hpp>
#include <com/sun/star/document/XDocumentPropertiesSupplier.hpp>


//========================================================================

const static sal_Char __FAR_DATA sMyBegComment[]	= "<!-- ";
const static sal_Char __FAR_DATA sMyEndComment[]	= " -->";
const static sal_Char __FAR_DATA sFontFamily[]		= "font-family:";
const static sal_Char __FAR_DATA sFontSize[]		= "font-size:";

const sal_uInt16 __FAR_DATA ScHTMLExport::nDefaultFontSize[SC_HTML_FONTSIZES] =
{
	HTMLFONTSZ1_DFLT, HTMLFONTSZ2_DFLT, HTMLFONTSZ3_DFLT, HTMLFONTSZ4_DFLT,
	HTMLFONTSZ5_DFLT, HTMLFONTSZ6_DFLT, HTMLFONTSZ7_DFLT
};

sal_uInt16 ScHTMLExport::nFontSize[SC_HTML_FONTSIZES] = { 0 };

const char* __FAR_DATA ScHTMLExport::pFontSizeCss[SC_HTML_FONTSIZES] =
{
    "xx-small", "x-small", "small", "medium", "large", "x-large", "xx-large"
};

const sal_uInt16 ScHTMLExport::nCellSpacing = 0;
const sal_Char __FAR_DATA ScHTMLExport::sIndentSource[nIndentMax+1] =
	"\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t";

//========================================================================
// Makros fuer HTML-Export
//========================================================================
#define OUT_PROLOGUE()		(rStrm << sHTML30_Prologue << ScExportBase::sNewLine \
								<< ScExportBase::sNewLine)
#define TAG_ON( tag )		HTMLOutFuncs::Out_AsciiTag( rStrm, tag )
#define TAG_OFF( tag )		HTMLOutFuncs::Out_AsciiTag( rStrm, tag, sal_False )
#define OUT_STR( str )      HTMLOutFuncs::Out_String( rStrm, str, eDestEnc, &aNonConvertibleChars )
#define OUT_STR_NO_CONV( str )  HTMLOutFuncs::Out_String( rStrm, str, eDestEnc )
#define OUT_LF()			rStrm << ScExportBase::sNewLine << GetIndentStr()
#define lcl_OUT_LF() 		rStrm << ScExportBase::sNewLine
#define TAG_ON_LF( tag )	(TAG_ON( tag ) << ScExportBase::sNewLine << GetIndentStr())
#define TAG_OFF_LF( tag )	(TAG_OFF( tag ) << ScExportBase::sNewLine << GetIndentStr())
#define OUT_HR()			TAG_ON_LF( OOO_STRING_SVTOOLS_HTML_horzrule )
#define OUT_COMMENT( comment )	(rStrm << sMyBegComment, OUT_STR( comment ) \
								<< sMyEndComment << ScExportBase::sNewLine \
								<< GetIndentStr())
#define lcl_OUT_COMMENT( comment )  (rStrm << sMyBegComment, OUT_STR_NO_CONV( comment ) \
								<< sMyEndComment << ScExportBase::sNewLine)

#define	OUT_SP_CSTR_ASS( s )	rStrm << ' ' << s << '='
#define	APPEND_SPACE( s )	s.AppendAscii(" ")

#define GLOBSTR(id) ScGlobal::GetRscString( id )



//========================================================================

FltError ScFormatFilterPluginImpl::ScExportHTML( SvStream& rStrm, const String& rBaseURL, ScDocument* pDoc,
        const ScRange& rRange, const CharSet /*eNach*/, sal_Bool bAll,
        const String& rStreamPath, String& rNonConvertibleChars )
{
    ScHTMLExport aEx( rStrm, rBaseURL, pDoc, rRange, bAll, rStreamPath );
    FltError nErr = aEx.Write();
    rNonConvertibleChars = aEx.GetNonConvertibleChars();
    return nErr;
}


void lcl_AddStamp( String& rStr, const String& rName,
    const ::com::sun::star::util::DateTime& rDateTime,
    const LocaleDataWrapper& rLoc )
{
    Date aD(rDateTime.Day, rDateTime.Month, rDateTime.Year);
    Time aT(rDateTime.Hours, rDateTime.Minutes, rDateTime.Seconds,
            rDateTime.HundredthSeconds);
    DateTime aDateTime(aD,aT);

	String			aStrDate	= rLoc.getDate( aDateTime );
	String			aStrTime	= rLoc.getTime( aDateTime );

	rStr += GLOBSTR( STR_BY );
	APPEND_SPACE( rStr );
	if (rName.Len())
		rStr += rName;
	else
		rStr.AppendAscii( "???" );
	APPEND_SPACE( rStr );
	rStr += GLOBSTR( STR_ON );
	APPEND_SPACE( rStr );
	if (aStrDate.Len())
		rStr += aStrDate;
	else
		rStr.AppendAscii( "???" );
	rStr.AppendAscii( ", " );
	if (aStrTime.Len())
		rStr += aStrTime;
	else
		rStr.AppendAscii( "???" );
}


void lcl_AppendHTMLColorTripel( ByteString& rStr, const Color& rColor )
{
	// <font COLOR="#00FF40">hallo</font>
	sal_Char	buf[64];
	sal_Char*	p = buf;

	rStr += "\"#";
	p += sprintf( p, "%02X", rColor.GetRed() );     // #100211# - checked
	p += sprintf( p, "%02X", rColor.GetGreen() );   // #100211# - checked
	p += sprintf( p, "%02X", rColor.GetBlue() );    // #100211# - checked
	rStr += buf;
	rStr += '\"';
}


/*void lcl_TagOn( String& rResult, const String& rTag, const String* pStrOpt )
{
	rResult  = '<';
	rResult += rTag;
	if ( pStrOpt )
	{
		rResult += ' ';
		rResult += *pStrOpt;
	}
	rResult += '>';
}
*/

/*void lcl_TagOff( String& rResult, const String& rTag )
{
	rResult = '<'; rResult += rTag; rResult += '>';
}
*/

//////////////////////////////////////////////////////////////////////////////

ScHTMLExport::ScHTMLExport( SvStream& rStrmP, const String& rBaseURL, ScDocument* pDocP,
							const ScRange& rRangeP,
							sal_Bool bAllP, const String& rStreamPathP ) :
	ScExportBase( rStrmP, pDocP, rRangeP ),
    aBaseURL( rBaseURL ),
	aStreamPath( rStreamPathP ),
	pAppWin( Application::GetDefaultDevice() ),
	pSrcArr( NULL ),
	pDestArr( NULL ),
	nUsedTables( 0 ),
	nIndent( 0 ),
	bAll( bAllP ),
	bTabHasGraphics( sal_False ),
	bCalcAsShown( pDocP->GetDocOptions().IsCalcAsShown() ),
    bTableDataWidth( sal_True ),
    bTableDataHeight( sal_True )
{
	strcpy( sIndent, sIndentSource );       // #100211# - checked
	sIndent[0] = 0;

	// set HTML configuration
	SvxHtmlOptions* pHtmlOptions = SvxHtmlOptions::Get();
    eDestEnc = (pDoc->IsClipOrUndo() ? RTL_TEXTENCODING_UTF8 : pHtmlOptions->GetTextEncoding());
	bCopyLocalFileToINet = pHtmlOptions->IsSaveGraphicsLocal();
	for ( sal_uInt16 j=0; j < SC_HTML_FONTSIZES; j++ )
	{
		sal_uInt16 nSize = pHtmlOptions->GetFontSize( j );
		// remember in Twips, like our SvxFontHeightItem
		if ( nSize )
			nFontSize[j] = nSize * 20;
		else
			nFontSize[j] = nDefaultFontSize[j] * 20;
	}

	const SCTAB nCount = pDoc->GetTableCount();
	for ( SCTAB nTab = 0; nTab < nCount; nTab++ )
	{
		if ( !IsEmptyTable( nTab ) )
			nUsedTables++;
	}

	// Content-Id fuer Mail-Export?
	SfxObjectShell* pDocSh = pDoc->GetDocumentShell();
	if ( pDocSh )
	{
		const SfxPoolItem* pItem = pDocSh->GetItem( SID_ORIGURL );
		if( pItem )
		{
			aCId = ((const SfxStringItem *)pItem)->GetValue();
			DBG_ASSERT( aCId.Len(), "CID ohne Laenge!" );
		}
	}
}


ScHTMLExport::~ScHTMLExport()
{
	for ( ScHTMLGraphEntry* pE = aGraphList.First(); pE; pE = aGraphList.Next() )
		delete pE;
	delete pSrcArr;
	delete pDestArr;
}


sal_uInt16 ScHTMLExport::GetFontSizeNumber( sal_uInt16 nHeight )
{
	sal_uInt16 nSize = 1;
	for ( sal_uInt16 j=SC_HTML_FONTSIZES-1; j>0; j-- )
	{
		if( nHeight > (nFontSize[j] + nFontSize[j-1]) / 2 )
		{	// der naechstgelegene
			nSize = j+1;
			break;
		}
	}
	return nSize;
}

const char* ScHTMLExport::GetFontSizeCss( sal_uInt16 nHeight )
{
    sal_uInt16 nSize = GetFontSizeNumber( nHeight );
    return pFontSizeCss[ nSize-1 ];
}


sal_uInt16 ScHTMLExport::ToPixel( sal_uInt16 nVal )
{
	if( nVal )
	{
		nVal = (sal_uInt16)pAppWin->LogicToPixel(
					Size( nVal, nVal ), MapMode( MAP_TWIP ) ).Width();
		if( !nVal )		// wo ein Twip ist sollte auch ein Pixel sein
			nVal = 1;
	}
	return nVal;
}


Size ScHTMLExport::MMToPixel( const Size& rSize )
{
	Size aSize( rSize );
	aSize = pAppWin->LogicToPixel( rSize, MapMode( MAP_100TH_MM ) );
	// wo etwas ist sollte auch ein Pixel sein
	if ( !aSize.Width() && rSize.Width() )
		aSize.Width() = 1;
	if ( !aSize.Height() && rSize.Height() )
		aSize.Height() = 1;
	return aSize;
}


sal_uLong ScHTMLExport::Write()
{
	rStrm << '<' << OOO_STRING_SVTOOLS_HTML_doctype << ' ' << OOO_STRING_SVTOOLS_HTML_doctype32 << '>'
		<< sNewLine << sNewLine;
	TAG_ON_LF( OOO_STRING_SVTOOLS_HTML_html );
    WriteHeader();
    OUT_LF();
    WriteBody();
	OUT_LF();
	TAG_OFF_LF( OOO_STRING_SVTOOLS_HTML_html );

	return rStrm.GetError();
}


void ScHTMLExport::WriteHeader()
{
	IncIndent(1); TAG_ON_LF( OOO_STRING_SVTOOLS_HTML_head );

    if ( pDoc->IsClipOrUndo() )
    {   // no real DocInfo available, but some META information like charset needed
        SfxFrameHTMLWriter::Out_DocInfo( rStrm, aBaseURL, NULL, sIndent, eDestEnc, &aNonConvertibleChars );
    }
    else
    {
        using namespace ::com::sun::star;
        uno::Reference<document::XDocumentPropertiesSupplier> xDPS(
            pDoc->GetDocumentShell()->GetModel(), uno::UNO_QUERY_THROW);
        uno::Reference<document::XDocumentProperties> xDocProps
            = xDPS->getDocumentProperties();
        SfxFrameHTMLWriter::Out_DocInfo( rStrm, aBaseURL, xDocProps,
            sIndent, eDestEnc, &aNonConvertibleChars );
        OUT_LF();

        //----------------------------------------------------------
        if (!xDocProps->getPrintedBy().equalsAscii(""))
        {
            OUT_COMMENT( GLOBSTR( STR_DOC_INFO ) );
            String aStrOut( GLOBSTR( STR_DOC_PRINTED ) );
            aStrOut.AppendAscii( ": " );
            lcl_AddStamp( aStrOut, xDocProps->getPrintedBy(),
                xDocProps->getPrintDate(), *ScGlobal::pLocaleData );
            OUT_COMMENT( aStrOut );
        }
        //----------------------------------------------------------
    }
	OUT_LF();

	// CSS1 StyleSheet
	PageDefaults( bAll ? 0 : aRange.aStart.Tab() );
	IncIndent(1); TAG_ON_LF( OOO_STRING_SVTOOLS_HTML_style );
	rStrm << sMyBegComment; OUT_LF();
	rStrm << OOO_STRING_SVTOOLS_HTML_body << "," << OOO_STRING_SVTOOLS_HTML_division << "," << OOO_STRING_SVTOOLS_HTML_table << ","
        << OOO_STRING_SVTOOLS_HTML_thead << "," << OOO_STRING_SVTOOLS_HTML_tbody << "," << OOO_STRING_SVTOOLS_HTML_tfoot << ","
        << OOO_STRING_SVTOOLS_HTML_tablerow << "," << OOO_STRING_SVTOOLS_HTML_tableheader << ","
        << OOO_STRING_SVTOOLS_HTML_tabledata << "," << OOO_STRING_SVTOOLS_HTML_parabreak << " { " << sFontFamily;
	xub_StrLen nFonts = aHTMLStyle.aFontFamilyName.GetTokenCount( ';' );
	if ( nFonts == 1 )
	{
		rStrm << '\"';
		OUT_STR( aHTMLStyle.aFontFamilyName );
		rStrm << '\"';
	}
	else
	{	// Fontliste, VCL: Semikolon als Separator,
		// CSS1: Komma als Separator und jeder einzelne Fontname quoted
		const String& rList = aHTMLStyle.aFontFamilyName;
		for ( xub_StrLen j = 0, nPos = 0; j < nFonts; j++ )
		{
			rStrm << '\"';
			OUT_STR( rList.GetToken( 0, ';', nPos ) );
			rStrm << '\"';
			if ( j < nFonts-1 )
				rStrm << ", ";
		}
	}
	rStrm << "; " << sFontSize
        << GetFontSizeCss( ( sal_uInt16 ) aHTMLStyle.nFontHeight ) << " }";
	OUT_LF();
	rStrm << sMyEndComment;
	IncIndent(-1); OUT_LF(); TAG_OFF_LF( OOO_STRING_SVTOOLS_HTML_style );

	IncIndent(-1); OUT_LF(); TAG_OFF_LF( OOO_STRING_SVTOOLS_HTML_head );
}


void ScHTMLExport::WriteOverview()
{
	if ( nUsedTables > 1 )
	{
		IncIndent(1);
		OUT_HR();
		IncIndent(1); TAG_ON( OOO_STRING_SVTOOLS_HTML_parabreak ); TAG_ON_LF( OOO_STRING_SVTOOLS_HTML_center );
		TAG_ON( OOO_STRING_SVTOOLS_HTML_head1 );
		OUT_STR( ScGlobal::GetRscString( STR_OVERVIEW ) );
		TAG_OFF_LF( OOO_STRING_SVTOOLS_HTML_head1 );

		String		 aStr;

		const SCTAB nCount = pDoc->GetTableCount();
		for ( SCTAB nTab = 0; nTab < nCount; nTab++ )
		{
			if ( !IsEmptyTable( nTab ) )
			{
				pDoc->GetName( nTab, aStr );
				rStrm << "<A HREF=\"#table"
					<< ByteString::CreateFromInt32( nTab ).GetBuffer()
					<< "\">";
				OUT_STR( aStr );
				rStrm << "</A>";
				TAG_ON_LF( OOO_STRING_SVTOOLS_HTML_linebreak );
			}
		}

		IncIndent(-1); OUT_LF();
		IncIndent(-1); TAG_OFF( OOO_STRING_SVTOOLS_HTML_center ); TAG_OFF_LF( OOO_STRING_SVTOOLS_HTML_parabreak );
	}
}


const SfxItemSet& ScHTMLExport::PageDefaults( SCTAB nTab )
{
	SfxStyleSheetBasePool*	pStylePool	= pDoc->GetStyleSheetPool();
	SfxStyleSheetBase*		pStyleSheet = NULL;
	DBG_ASSERT( pStylePool, "StylePool not found! :-(" );

    // remember defaults for compare in WriteCell
    if ( !aHTMLStyle.bInitialized )
    {
        pStylePool->SetSearchMask( SFX_STYLE_FAMILY_PARA, SFXSTYLEBIT_ALL );
        pStyleSheet = pStylePool->Find(
                ScGlobal::GetRscString(STR_STYLENAME_STANDARD),
                SFX_STYLE_FAMILY_PARA );
        DBG_ASSERT( pStyleSheet, "ParaStyle not found! :-(" );
        if (!pStyleSheet)
            pStyleSheet = pStylePool->First();
        const SfxItemSet& rSetPara = pStyleSheet->GetItemSet();

        aHTMLStyle.nDefaultScriptType = ScGlobal::GetDefaultScriptType();
        aHTMLStyle.aFontFamilyName = ((const SvxFontItem&)(rSetPara.Get(
                        ScGlobal::GetScriptedWhichID(
                            aHTMLStyle.nDefaultScriptType, ATTR_FONT
                            )))).GetFamilyName();
        aHTMLStyle.nFontHeight = ((const SvxFontHeightItem&)(rSetPara.Get(
                        ScGlobal::GetScriptedWhichID(
                            aHTMLStyle.nDefaultScriptType, ATTR_FONT_HEIGHT
                            )))).GetHeight();
        aHTMLStyle.nFontSizeNumber = GetFontSizeNumber( static_cast< sal_uInt16 >( aHTMLStyle.nFontHeight ) );
    }

	// Page style sheet printer settings, e.g. for background graphics.
	// There's only one background graphic in HTML!
	pStylePool->SetSearchMask( SFX_STYLE_FAMILY_PAGE, SFXSTYLEBIT_ALL );
	pStyleSheet = pStylePool->Find( pDoc->GetPageStyle( nTab ), SFX_STYLE_FAMILY_PAGE );
	DBG_ASSERT( pStyleSheet, "PageStyle not found! :-(" );
	if (!pStyleSheet)
		pStyleSheet = pStylePool->First();
	const SfxItemSet& rSet = pStyleSheet->GetItemSet();
    if ( !aHTMLStyle.bInitialized )
    {
	    const SvxBrushItem* pBrushItem = (const SvxBrushItem*)&rSet.Get( ATTR_BACKGROUND );
	    aHTMLStyle.aBackgroundColor = pBrushItem->GetColor();
        aHTMLStyle.bInitialized = sal_True;
    }
	return rSet;
}


void ScHTMLExport::BorderToStyle( ByteString& rOut, const char* pBorderName,
		const SvxBorderLine* pLine, bool& bInsertSemicolon )
{
	if ( pLine )
	{
		if ( bInsertSemicolon )
			rOut += "; ";

		// which border
		((rOut += "border-") += pBorderName) += ": ";

		// thickness
		int nWidth = pLine->GetOutWidth();
		int nPxWidth = ( nWidth > 0 )? std::max( int( nWidth / TWIPS_PER_PIXEL ), 1 ): 0;
		(rOut += ByteString::CreateFromInt32( nPxWidth )) += "px solid #";

		// color
		char hex[7];
        snprintf( hex, 7, "%06x", static_cast< unsigned int >( pLine->GetColor().GetRGBColor() ) );
		hex[6] = 0;

		rOut += hex;

		bInsertSemicolon = true;
	}
}

void ScHTMLExport::WriteBody()
{
	const SfxItemSet& rSet = PageDefaults( bAll ? 0 : aRange.aStart.Tab() );
	const SvxBrushItem* pBrushItem = (const SvxBrushItem*)&rSet.Get( ATTR_BACKGROUND );

	// default Textfarbe schwarz
	rStrm << '<' << OOO_STRING_SVTOOLS_HTML_body << ' ' << OOO_STRING_SVTOOLS_HTML_O_text << "=\"#000000\"";

	if ( bAll && GPOS_NONE != pBrushItem->GetGraphicPos() )
	{
		const String* pLink = pBrushItem->GetGraphicLink();
		String aGrfNm;

		// embeddete Grafik -> via WriteGraphic schreiben
		if( !pLink )
		{
			const Graphic* pGrf = pBrushItem->GetGraphic();
			if( pGrf )
			{
				// Grafik als (JPG-)File speichern
				aGrfNm = aStreamPath;
                sal_uInt16 nErr = XOutBitmap::WriteGraphic( *pGrf, aGrfNm,
                    CREATE_STRING( "JPG" ), XOUTBMP_USE_NATIVE_IF_POSSIBLE );
				if( !nErr )		// fehlerhaft, da ist nichts auszugeben
				{
                    aGrfNm = URIHelper::SmartRel2Abs(
                            INetURLObject(aBaseURL),
                            aGrfNm, URIHelper::GetMaybeFileHdl(), true, false);
					if ( HasCId() )
						MakeCIdURL( aGrfNm );
					pLink = &aGrfNm;
				}
			}
		}
		else
		{
			aGrfNm = *pLink;
			if( bCopyLocalFileToINet || HasCId() )
			{
				CopyLocalFileToINet( aGrfNm, aStreamPath );
				if ( HasCId() )
					MakeCIdURL( aGrfNm );
			}
			else
                aGrfNm = URIHelper::SmartRel2Abs(
                        INetURLObject(aBaseURL),
                        aGrfNm, URIHelper::GetMaybeFileHdl(), true, false);
			pLink = &aGrfNm;
		}
		if( pLink )
		{
			rStrm << ' ' << OOO_STRING_SVTOOLS_HTML_O_background << "=\"";
            OUT_STR( URIHelper::simpleNormalizedMakeRelative(
                        aBaseURL,
                        *pLink ) ) << '\"';
		}
	}
    if ( !aHTMLStyle.aBackgroundColor.GetTransparency() )
    {   // A transparent background color should always result in default
        // background of the browser. Also, HTMLOutFuncs::Out_Color() writes
        // black #000000 for COL_AUTO which is the same as white #ffffff with
        // transparency set to 0xff, our default background.
        OUT_SP_CSTR_ASS( OOO_STRING_SVTOOLS_HTML_O_bgcolor );
        HTMLOutFuncs::Out_Color( rStrm, aHTMLStyle.aBackgroundColor );
    }

	rStrm << '>'; OUT_LF();

	if ( bAll )
		WriteOverview();

	WriteTables();

	TAG_OFF_LF( OOO_STRING_SVTOOLS_HTML_body );
}


void ScHTMLExport::WriteTables()
{
	const SCTAB	nTabCount = pDoc->GetTableCount();
	const String	aStrTable( ScResId( SCSTR_TABLE ) );
	String			aStr;
	String			aStrOut;
	SCCOL			nStartCol;
	SCROW			nStartRow;
	SCTAB			nStartTab;
	SCCOL			nEndCol;
	SCROW			nEndRow;
	SCTAB			nEndTab;
    SCCOL           nStartColFix = 0;
    SCROW           nStartRowFix = 0;
    SCCOL           nEndColFix = 0;
    SCROW           nEndRowFix = 0;
	ScDrawLayer*	pDrawLayer = pDoc->GetDrawLayer();
	if ( bAll )
	{
		nStartTab = 0;
		nEndTab = nTabCount - 1;
	}
	else
	{
		nStartCol = nStartColFix = aRange.aStart.Col();
		nStartRow = nStartRowFix = aRange.aStart.Row();
		nStartTab = aRange.aStart.Tab();
		nEndCol = nEndColFix = aRange.aEnd.Col();
		nEndRow = nEndRowFix = aRange.aEnd.Row();
		nEndTab = aRange.aEnd.Tab();
	}
	SCTAB nTableStrNum = 1;
	for ( SCTAB nTab=nStartTab; nTab<=nEndTab; nTab++ )
	{
		if ( !pDoc->IsVisible( nTab ) )
			continue;	// for

		if ( bAll )
		{
			if ( !GetDataArea( nTab, nStartCol, nStartRow, nEndCol, nEndRow ) )
				continue;	// for

			if ( nUsedTables > 1 )
			{
				aStrOut  = aStrTable;
				aStrOut.AppendAscii( " " );
				aStrOut += String::CreateFromInt32( nTableStrNum++ );
				aStrOut.AppendAscii( ": " );

				OUT_HR();

				// Anker festlegen:
				rStrm << "<A NAME=\"table"
					<< ByteString::CreateFromInt32( nTab ).GetBuffer()
					<< "\">";
				TAG_ON( OOO_STRING_SVTOOLS_HTML_head1 );
				OUT_STR( aStrOut );
				TAG_ON( OOO_STRING_SVTOOLS_HTML_emphasis );

				pDoc->GetName( nTab, aStr );
				OUT_STR( aStr );

				TAG_OFF( OOO_STRING_SVTOOLS_HTML_emphasis );
				TAG_OFF( OOO_STRING_SVTOOLS_HTML_head1 );
				rStrm << "</A>"; OUT_LF();
			}
		}
		else
		{
			nStartCol = nStartColFix;
			nStartRow = nStartRowFix;
			nEndCol = nEndColFix;
			nEndRow = nEndRowFix;
			if ( !TrimDataArea( nTab, nStartCol, nStartRow, nEndCol, nEndRow ) )
				continue;	// for
		}

		// <TABLE ...>
		ByteString	aByteStrOut = OOO_STRING_SVTOOLS_HTML_table;
//		aStrOut  = OOO_STRING_SVTOOLS_HTML_table;

		// FRAME=VOID, we do the styling of the cells in <TD>
		(((aByteStrOut += ' ') += OOO_STRING_SVTOOLS_HTML_frame) += '=') += OOO_STRING_SVTOOLS_HTML_TF_void;

		bTabHasGraphics = bTabAlignedLeft = sal_False;
		if ( bAll && pDrawLayer )
			PrepareGraphics( pDrawLayer, nTab, nStartCol, nStartRow,
				nEndCol, nEndRow );

		// more <TABLE ...>
		if ( bTabAlignedLeft )
			(((aByteStrOut += ' ') += OOO_STRING_SVTOOLS_HTML_O_align) += '=') += OOO_STRING_SVTOOLS_HTML_AL_left;
			// ALIGN=LEFT allow text and graphics to flow around
		// CELLSPACING
		(((aByteStrOut += ' ' ) += OOO_STRING_SVTOOLS_HTML_O_cellspacing ) += '=') +=
									ByteString::CreateFromInt32( nCellSpacing );
		// COLS=n
		SCCOL nColCnt = 0;
		SCCOL nCol;
		for ( nCol=nStartCol; nCol<=nEndCol; nCol++ )
		{
			if ( !pDoc->ColHidden(nCol, nTab) )
				++nColCnt;
		}
		(((aByteStrOut += ' ') += OOO_STRING_SVTOOLS_HTML_O_cols) += '=') += ByteString::CreateFromInt32( nColCnt );

		// RULES=NONE, we do the styling of the cells in <TD>
		(((aByteStrOut += ' ') += OOO_STRING_SVTOOLS_HTML_O_rules) += '=') += OOO_STRING_SVTOOLS_HTML_TR_none;

		// BORDER=0, we do the styling of the cells in <TD>
		((aByteStrOut += ' ') += OOO_STRING_SVTOOLS_HTML_O_border) += "=0";
		IncIndent(1); TAG_ON_LF( aByteStrOut.GetBuffer() );

		// <COLGROUP>
		TAG_ON( OOO_STRING_SVTOOLS_HTML_colgroup );
		// <COL WIDTH=x> as pre-info for long tables
		ByteString	aByteStr = OOO_STRING_SVTOOLS_HTML_col;
		aByteStr += ' ';
		aByteStr += OOO_STRING_SVTOOLS_HTML_O_width;
		aByteStr += '=';
		for ( nCol=nStartCol; nCol<=nEndCol; nCol++ )
		{
			if ( pDoc->ColHidden(nCol, nTab) )
				continue;	// for

			aByteStrOut  = aByteStr;
			aByteStrOut += ByteString::CreateFromInt32(
								ToPixel( pDoc->GetColWidth( nCol, nTab ) ) );
			TAG_ON( aByteStrOut.GetBuffer() );
		}
		TAG_OFF_LF( OOO_STRING_SVTOOLS_HTML_colgroup );

		// <TBODY>
		IncIndent(1); TAG_ON_LF( OOO_STRING_SVTOOLS_HTML_tbody );
        // At least old (3.x, 4.x?) Netscape doesn't follow <TABLE COLS=n> and
        // <COL WIDTH=x> specified, but needs a width at every column.
        bTableDataWidth = sal_True;     // widths in first row
		bool bHasHiddenRows = pDoc->HasHiddenRows(nStartRow, nEndRow, nTab);
		for ( SCROW nRow=nStartRow; nRow<=nEndRow; nRow++ )
		{
			if ( bHasHiddenRows && pDoc->RowHidden(nRow, nTab) )
            {
                nRow = pDoc->FirstVisibleRow(nRow+1, nEndRow, nTab);
                --nRow;
				continue;	// for
            }

			IncIndent(1); TAG_ON_LF( OOO_STRING_SVTOOLS_HTML_tablerow );
            bTableDataHeight = sal_True;  // height at every first cell of each row
            for ( SCCOL nCol2=nStartCol; nCol2<=nEndCol; nCol2++ )
			{
				if ( pDoc->ColHidden(nCol2, nTab) )
					continue;	// for

                if ( nCol2 == nEndCol )
					IncIndent(-1);
                WriteCell( nCol2, nRow, nTab );
                bTableDataHeight = sal_False;
			}
            bTableDataWidth = sal_False;    // widths only in first row

			if ( nRow == nEndRow )
				IncIndent(-1);
			TAG_OFF_LF( OOO_STRING_SVTOOLS_HTML_tablerow );
		}
		IncIndent(-1); TAG_OFF_LF( OOO_STRING_SVTOOLS_HTML_tbody );

		IncIndent(-1); TAG_OFF_LF( OOO_STRING_SVTOOLS_HTML_table );

		if ( bTabHasGraphics )
		{
			// the rest that is not in a cell
			for ( ScHTMLGraphEntry* pE = aGraphList.First(); pE; pE = aGraphList.Next() )
			{
				if ( !pE->bWritten )
					WriteGraphEntry( pE );
				delete pE;
			}
			aGraphList.Clear();
			if ( bTabAlignedLeft )
			{	// clear <TABLE ALIGN=LEFT> with <BR CLEAR=LEFT>
				aByteStrOut = OOO_STRING_SVTOOLS_HTML_linebreak;
				(((aByteStrOut += ' ') += OOO_STRING_SVTOOLS_HTML_O_clear) += '=') += OOO_STRING_SVTOOLS_HTML_AL_left;
				TAG_ON_LF( aByteStrOut.GetBuffer() );
			}
		}

		if ( bAll )
            OUT_COMMENT( CREATE_STRING( "**************************************************************************" ) );
	}
}


void ScHTMLExport::WriteCell( SCCOL nCol, SCROW nRow, SCTAB nTab )
{
	const ScPatternAttr* pAttr = pDoc->GetPattern( nCol, nRow, nTab );
    const SfxItemSet* pCondItemSet = pDoc->GetCondResult( nCol, nRow, nTab );

	const ScMergeFlagAttr& rMergeFlagAttr = (const ScMergeFlagAttr&) pAttr->GetItem( ATTR_MERGE_FLAG, pCondItemSet );
	if ( rMergeFlagAttr.IsOverlapped() )
		return ;

	ScAddress aPos( nCol, nRow, nTab );
    ScHTMLGraphEntry* pGraphEntry = NULL;
	if ( bTabHasGraphics )
	{
		for ( pGraphEntry = aGraphList.First();	pGraphEntry;
			  pGraphEntry = aGraphList.Next() )
		{
			if ( pGraphEntry->bInCell && pGraphEntry->aRange.In( aPos ) )
			{
				if ( pGraphEntry->aRange.aStart == aPos )
                    break;  // for
				else
					return ;		// ist ein Col/RowSpan, Overlapped
			}
		}
	}

	ScBaseCell* pCell = pDoc->GetCell( aPos );
	sal_uLong nFormat = pAttr->GetNumberFormat( pFormatter );
	sal_Bool bValueData;
    sal_uInt8 nScriptType;
	if ( pCell )
    {
		bValueData = pCell->HasValueData();
        nScriptType = pDoc->GetScriptType( nCol, nRow, nTab, pCell );
    }
	else
    {
		bValueData = sal_False;
        nScriptType = 0;
    }
    if ( nScriptType == 0 )
        nScriptType = aHTMLStyle.nDefaultScriptType;


	ByteString aStrTD = OOO_STRING_SVTOOLS_HTML_tabledata;

	// border of the cells
	SvxBoxItem* pBorder = (SvxBoxItem*) pDoc->GetAttr( nCol, nRow, nTab, ATTR_BORDER );
	if ( pBorder && (pBorder->GetTop() || pBorder->GetBottom() || pBorder->GetLeft() || pBorder->GetRight()) )
	{
		((aStrTD += ' ') += OOO_STRING_SVTOOLS_HTML_style) += "=\"";

		bool bInsertSemicolon = false;
		BorderToStyle( aStrTD, "top", pBorder->GetTop(), bInsertSemicolon );
		BorderToStyle( aStrTD, "bottom", pBorder->GetBottom(), bInsertSemicolon );
		BorderToStyle( aStrTD, "left", pBorder->GetLeft(), bInsertSemicolon );
		BorderToStyle( aStrTD, "right", pBorder->GetRight(), bInsertSemicolon );

		aStrTD += '"';
	}

	const sal_Char* pChar;
	sal_uInt16 nWidthPixel;
	sal_uInt16 nHeightPixel;

	const ScMergeAttr& rMergeAttr = (const ScMergeAttr&) pAttr->GetItem( ATTR_MERGE, pCondItemSet );
    if ( pGraphEntry || rMergeAttr.IsMerged() )
	{
        SCCOL nC, jC;
        SCROW nR;
		sal_uLong v;
        if ( pGraphEntry )
            nC = Max( SCCOL(pGraphEntry->aRange.aEnd.Col() - nCol + 1),
                SCCOL(rMergeAttr.GetColMerge()) );
		else
			nC = rMergeAttr.GetColMerge();
		if ( nC > 1 )
		{
			(((aStrTD += ' ') += OOO_STRING_SVTOOLS_HTML_O_colspan) += '=') += ByteString::CreateFromInt32( nC );
            nC = nC + nCol;
			for ( jC=nCol, v=0; jC<nC; jC++ )
				v += pDoc->GetColWidth( jC, nTab );
            nWidthPixel = ToPixel( static_cast< sal_uInt16 >( v ) );
		}
		else
			nWidthPixel = ToPixel( pDoc->GetColWidth( nCol, nTab ) );

        if ( pGraphEntry )
            nR = Max( SCROW(pGraphEntry->aRange.aEnd.Row() - nRow + 1),
                SCROW(rMergeAttr.GetRowMerge()) );
		else
			nR = rMergeAttr.GetRowMerge();
		if ( nR > 1 )
		{
			(((aStrTD += ' ') += OOO_STRING_SVTOOLS_HTML_O_rowspan) += '=') += ByteString::CreateFromInt32( nR );
			nR += nRow;
            v = pDoc->GetRowHeight( nRow, nR-1, nTab );
            nHeightPixel = ToPixel( static_cast< sal_uInt16 >( v ) );
		}
		else
			nHeightPixel = ToPixel( pDoc->GetRowHeight( nRow, nTab ) );
	}
	else
	{
		nWidthPixel = ToPixel( pDoc->GetColWidth( nCol, nTab ) );
		nHeightPixel = ToPixel( pDoc->GetRowHeight( nRow, nTab ) );
	}

	if ( bTableDataWidth )
        (((aStrTD += ' ') += OOO_STRING_SVTOOLS_HTML_O_width) += '=') += ByteString::CreateFromInt32( nWidthPixel );
	if ( bTableDataHeight )
        (((aStrTD += ' ') += OOO_STRING_SVTOOLS_HTML_O_height) += '=') += ByteString::CreateFromInt32( nHeightPixel );

    const SvxFontItem& rFontItem = (const SvxFontItem&) pAttr->GetItem(
            ScGlobal::GetScriptedWhichID( nScriptType, ATTR_FONT),
            pCondItemSet);

    const SvxFontHeightItem& rFontHeightItem = (const SvxFontHeightItem&)
        pAttr->GetItem( ScGlobal::GetScriptedWhichID( nScriptType,
                    ATTR_FONT_HEIGHT), pCondItemSet);

    const SvxWeightItem& rWeightItem = (const SvxWeightItem&) pAttr->GetItem(
            ScGlobal::GetScriptedWhichID( nScriptType, ATTR_FONT_WEIGHT),
            pCondItemSet);

    const SvxPostureItem& rPostureItem = (const SvxPostureItem&)
        pAttr->GetItem( ScGlobal::GetScriptedWhichID( nScriptType,
                    ATTR_FONT_POSTURE), pCondItemSet);

    const SvxUnderlineItem& rUnderlineItem = (const SvxUnderlineItem&)
        pAttr->GetItem( ATTR_FONT_UNDERLINE, pCondItemSet );

    const SvxColorItem& rColorItem = (const SvxColorItem&) pAttr->GetItem(
            ATTR_FONT_COLOR, pCondItemSet );

    const SvxHorJustifyItem& rHorJustifyItem = (const SvxHorJustifyItem&)
        pAttr->GetItem( ATTR_HOR_JUSTIFY, pCondItemSet );

    const SvxVerJustifyItem& rVerJustifyItem = (const SvxVerJustifyItem&)
        pAttr->GetItem( ATTR_VER_JUSTIFY, pCondItemSet );

    const SvxBrushItem& rBrushItem = (const SvxBrushItem&) pAttr->GetItem(
            ATTR_BACKGROUND, pCondItemSet );

	Color aBgColor;
	if ( rBrushItem.GetColor().GetTransparency() == 255 )
		aBgColor = aHTMLStyle.aBackgroundColor;		// #55121# keine ungewollte Hintergrundfarbe
	else
		aBgColor = rBrushItem.GetColor();

	sal_Bool bBold			= ( WEIGHT_BOLD		<= rWeightItem.GetWeight() );
	sal_Bool bItalic		= ( ITALIC_NONE		!= rPostureItem.GetPosture() );
	sal_Bool bUnderline		= ( UNDERLINE_NONE	!= rUnderlineItem.GetLineStyle() );
	sal_Bool bSetFontColor	= ( COL_AUTO		!= rColorItem.GetValue().GetColor() );	// #97650# default is AUTO now
#if 0
// keine StyleSheet-Fontangaben: hart fuer jede Zelle
	sal_Bool bSetFontName	= sal_True;
    sal_uInt16 nSetFontSizeNumber = GetFontSizeNumber( (sal_uInt16)rFontHeightItem.GetHeight() );
#else
	sal_Bool bSetFontName	= ( aHTMLStyle.aFontFamilyName	!= rFontItem.GetFamilyName() );
    sal_uInt16 nSetFontSizeNumber = 0;
    sal_uInt32 nFontHeight = rFontHeightItem.GetHeight();
	if ( nFontHeight != aHTMLStyle.nFontHeight )
    {
        nSetFontSizeNumber = GetFontSizeNumber( (sal_uInt16) nFontHeight );
        if ( nSetFontSizeNumber == aHTMLStyle.nFontSizeNumber )
            nSetFontSizeNumber = 0;   // no difference, don't set
    }
#endif
	sal_Bool bSetFont = (bSetFontColor || bSetFontName || nSetFontSizeNumber);

    //! TODO: we could entirely use CSS1 here instead, but that would exclude
    //! Netscape 3.0 and Netscape 4.x without JavaScript enabled.
    //! Do we want that?

	switch( rHorJustifyItem.GetValue() )
	{
		case SVX_HOR_JUSTIFY_STANDARD:
			pChar = (bValueData ? OOO_STRING_SVTOOLS_HTML_AL_right : OOO_STRING_SVTOOLS_HTML_AL_left);
			break;
		case SVX_HOR_JUSTIFY_CENTER:	pChar = OOO_STRING_SVTOOLS_HTML_AL_center;	break;
		case SVX_HOR_JUSTIFY_BLOCK:		pChar = OOO_STRING_SVTOOLS_HTML_AL_justify;	break;
		case SVX_HOR_JUSTIFY_RIGHT:		pChar = OOO_STRING_SVTOOLS_HTML_AL_right;		break;
		case SVX_HOR_JUSTIFY_LEFT:
		case SVX_HOR_JUSTIFY_REPEAT:
		default:						pChar = OOO_STRING_SVTOOLS_HTML_AL_left;		break;
	}

	(((aStrTD += ' ') += OOO_STRING_SVTOOLS_HTML_O_align) += '=') += pChar;

	switch( rVerJustifyItem.GetValue() )
	{
		case SVX_VER_JUSTIFY_TOP:		pChar = OOO_STRING_SVTOOLS_HTML_VA_top;		break;
		case SVX_VER_JUSTIFY_CENTER:	pChar = OOO_STRING_SVTOOLS_HTML_VA_middle;	break;
		case SVX_VER_JUSTIFY_BOTTOM:	pChar = OOO_STRING_SVTOOLS_HTML_VA_bottom;	break;
		case SVX_VER_JUSTIFY_STANDARD:
		default:						pChar = NULL;
	}
	if ( pChar )
		(((aStrTD += ' ') += OOO_STRING_SVTOOLS_HTML_O_valign) += '=') += pChar;

	if ( aHTMLStyle.aBackgroundColor != aBgColor )
	{
		((aStrTD += ' ') += OOO_STRING_SVTOOLS_HTML_O_bgcolor) += '=';
		lcl_AppendHTMLColorTripel( aStrTD, aBgColor );
	}

	double fVal = 0.0;
	if ( bValueData )
	{
		if ( pCell )
		{
			switch ( pCell->GetCellType() )
			{
				case CELLTYPE_VALUE:
					fVal = ((ScValueCell*)pCell)->GetValue();
					if ( bCalcAsShown && fVal != 0.0 )
						fVal = pDoc->RoundValueAsShown( fVal, nFormat );
					break;
				case CELLTYPE_FORMULA:
					fVal = ((ScFormulaCell*)pCell)->GetValue();
					if ( (nFormat % SV_COUNTRY_LANGUAGE_OFFSET) == 0 )
						nFormat = ScGlobal::GetStandardFormat( fVal, *pFormatter,
							nFormat, ((ScFormulaCell*)pCell)->GetFormatType() );
					break;
				default:
					DBG_ERRORFILE( "value data with unsupported cell type" );
			}
		}
	}
	HTMLOutFuncs::CreateTableDataOptionsValNum( aStrTD, bValueData, fVal,
        nFormat, *pFormatter, eDestEnc, &aNonConvertibleChars );

	TAG_ON( aStrTD.GetBuffer() );

	if ( bBold )		TAG_ON( OOO_STRING_SVTOOLS_HTML_bold );
	if ( bItalic )		TAG_ON( OOO_STRING_SVTOOLS_HTML_italic );
	if ( bUnderline )	TAG_ON( OOO_STRING_SVTOOLS_HTML_underline );


	if ( bSetFont )
	{
		ByteString	aStr = OOO_STRING_SVTOOLS_HTML_font;
		if ( bSetFontName )
		{
			((aStr += ' ') += OOO_STRING_SVTOOLS_HTML_O_face) += "=\"";
			xub_StrLen nFonts = rFontItem.GetFamilyName().GetTokenCount( ';' );
			if ( nFonts == 1 )
			{
				ByteString	aTmpStr;
                HTMLOutFuncs::ConvertStringToHTML( rFontItem.GetFamilyName(),
                    aTmpStr, eDestEnc, &aNonConvertibleChars );
				aStr += aTmpStr;
			}
			else
			{	// Fontliste, VCL: Semikolon als Separator, HTML: Komma
				const String& rList = rFontItem.GetFamilyName();
				for ( xub_StrLen j = 0, nPos = 0; j < nFonts; j++ )
				{
					ByteString	aTmpStr;
                    HTMLOutFuncs::ConvertStringToHTML(
                        rList.GetToken( 0, ';', nPos ), aTmpStr, eDestEnc,
                        &aNonConvertibleChars );
					aStr += aTmpStr;
					if ( j < nFonts-1 )
						aStr += ',';
				}
			}
			aStr += '\"';
		}
		if ( nSetFontSizeNumber )
		{
			(((aStr += ' ') += OOO_STRING_SVTOOLS_HTML_O_size) += '=')
				+= ByteString::CreateFromInt32( nSetFontSizeNumber );
		}
		if ( bSetFontColor )
		{
			Color	aColor = rColorItem.GetValue();

			//	always export automatic text color as black
			if ( aColor.GetColor() == COL_AUTO )
				aColor.SetColor( COL_BLACK );

			((aStr += ' ') += OOO_STRING_SVTOOLS_HTML_O_color) += '=';
			lcl_AppendHTMLColorTripel( aStr, aColor );
		}
		TAG_ON( aStr.GetBuffer() );
	}

	String aStrOut;
	sal_Bool bFieldText = sal_False;
	if ( pCell )
	{	// cell content
		Color* pColor;
		switch ( pCell->GetCellType() )
		{
			case CELLTYPE_NOTE :
				// nothing
			break;
			case CELLTYPE_EDIT :
				bFieldText = WriteFieldText( (const ScEditCell*) pCell );
				if ( bFieldText )
					break;
				//! else: fallthru
			default:
				ScCellFormat::GetString( pCell, nFormat, aStrOut, &pColor, *pFormatter );
		}
	}
	if ( !bFieldText )
	{
		if ( !aStrOut.Len() )
        {
			TAG_ON( OOO_STRING_SVTOOLS_HTML_linebreak );		// #42573# keine komplett leere Zelle
        }
		else
        {
            xub_StrLen nPos = aStrOut.Search( _LF );
            if ( nPos == STRING_NOTFOUND )
            {
                OUT_STR( aStrOut );
            }
            else
            {
                xub_StrLen nStartPos = 0;
                do
                {
                    String aSingleLine( aStrOut, nStartPos, nPos - nStartPos );
                    OUT_STR( aSingleLine );
                    TAG_ON( OOO_STRING_SVTOOLS_HTML_linebreak );
                    nStartPos = nPos + 1;
                } 
                while( ( nPos = aStrOut.Search( _LF, nStartPos ) ) != STRING_NOTFOUND );
                String aSingleLine( aStrOut, nStartPos, aStrOut.Len() - nStartPos );
                OUT_STR( aSingleLine );
            }
        }
	}
    if ( pGraphEntry )
		WriteGraphEntry( pGraphEntry );

	if ( bSetFont )		TAG_OFF( OOO_STRING_SVTOOLS_HTML_font );
	if ( bUnderline )	TAG_OFF( OOO_STRING_SVTOOLS_HTML_underline );
	if ( bItalic )		TAG_OFF( OOO_STRING_SVTOOLS_HTML_italic );
	if ( bBold )		TAG_OFF( OOO_STRING_SVTOOLS_HTML_bold );

	TAG_OFF_LF( OOO_STRING_SVTOOLS_HTML_tabledata );
}


sal_Bool ScHTMLExport::WriteFieldText( const ScEditCell* pCell )
{
	sal_Bool bFields = sal_False;
	const EditTextObject* pData;
	pCell->GetData( pData );
	// text and anchor of URL fields, Doc-Engine is a ScFieldEditEngine
	EditEngine& rEngine = pDoc->GetEditEngine();
	rEngine.SetText( *pData );
	sal_uInt16 nParas = rEngine.GetParagraphCount();
	if ( nParas )
	{
		ESelection aSel( 0, 0, nParas-1, rEngine.GetTextLen( nParas-1 ) );
		SfxItemSet aSet( rEngine.GetAttribs( aSel ) );
		SfxItemState eFieldState = aSet.GetItemState( EE_FEATURE_FIELD, sal_False );
		if ( eFieldState == SFX_ITEM_DONTCARE || eFieldState == SFX_ITEM_SET )
			bFields = sal_True;
	}
	if ( bFields )
	{
		sal_Bool bOldUpdateMode = rEngine.GetUpdateMode();
		rEngine.SetUpdateMode( sal_True );		// no portions if not formatted
		for ( sal_uInt16 nPar=0; nPar < nParas; nPar++ )
		{
			if ( nPar > 0 )
                TAG_ON( OOO_STRING_SVTOOLS_HTML_linebreak );
			SvUShorts aPortions;
			rEngine.GetPortions( nPar, aPortions );
			sal_uInt16 nCnt = aPortions.Count();
			sal_uInt16 nStart = 0;
			for ( sal_uInt16 nPos = 0; nPos < nCnt; nPos++ )
			{
				sal_uInt16 nEnd = aPortions.GetObject( nPos );
				ESelection aSel( nPar, nStart, nPar, nEnd );
				sal_Bool bUrl = sal_False;
				// fields are single characters
				if ( nEnd == nStart+1 )
				{
					const SfxPoolItem* pItem;
					SfxItemSet aSet = rEngine.GetAttribs( aSel );
					if ( aSet.GetItemState( EE_FEATURE_FIELD, sal_False, &pItem ) == SFX_ITEM_ON )
					{
						const SvxFieldData* pField = ((const SvxFieldItem*)pItem)->GetField();
						if ( pField && pField->ISA(SvxURLField) )
						{
							bUrl = sal_True;
							const SvxURLField*	pURLField = (const SvxURLField*)pField;
//							String				aFieldText = rEngine.GetText( aSel );
							rStrm << '<' << OOO_STRING_SVTOOLS_HTML_anchor << ' ' << OOO_STRING_SVTOOLS_HTML_O_href << "=\"";
							OUT_STR( pURLField->GetURL() );
							rStrm << "\">";
							OUT_STR( pURLField->GetRepresentation() );
							rStrm << "</" << OOO_STRING_SVTOOLS_HTML_anchor << '>';
						}
					}
				}
				if ( !bUrl )
					OUT_STR( rEngine.GetText( aSel ) );
				nStart = nEnd;
			}
		}
		rEngine.SetUpdateMode( bOldUpdateMode );
	}
	return bFields;
}


sal_Bool ScHTMLExport::CopyLocalFileToINet( String& rFileNm,
		const String& rTargetNm, sal_Bool bFileToFile )
{
	sal_Bool bRet = sal_False;
	INetURLObject aFileUrl, aTargetUrl;
	aFileUrl.SetSmartURL( rFileNm );
	aTargetUrl.SetSmartURL( rTargetNm );
	if( INET_PROT_FILE == aFileUrl.GetProtocol() &&
		( (bFileToFile && INET_PROT_FILE == aTargetUrl.GetProtocol()) ||
		  (!bFileToFile && INET_PROT_FILE != aTargetUrl.GetProtocol() &&
						   INET_PROT_FTP <= aTargetUrl.GetProtocol() &&
						   INET_PROT_NEWS >= aTargetUrl.GetProtocol()) ) )
	{
		if( pSrcArr )
		{
			// wurde die Datei schon verschoben
			sal_uInt16 nPos;
			if( pSrcArr->Seek_Entry( &rFileNm, &nPos ))
			{
				rFileNm = *(*pDestArr)[ nPos ];
				return sal_True;
			}
		}
		else
		{
			pSrcArr = new SvStringsSortDtor( 4, 4 );
			pDestArr = new SvStringsSortDtor( 4, 4 );
		}

		String* pSrc = new String( rFileNm );
		SvFileStream aTmp( aFileUrl.PathToFileName(), STREAM_READ );

		String* pDest = new String( aTargetUrl.GetPartBeforeLastName() );
		*pDest += String(aFileUrl.GetName());

		if( bFileToFile )
		{
			INetURLObject aCpyURL( *pDest );
			SvFileStream aCpy( aCpyURL.PathToFileName(), STREAM_WRITE );
			aCpy << aTmp;

			aCpy.Close();
			bRet = SVSTREAM_OK == aCpy.GetError();
		}
		else
		{
			SfxMedium aMedium( *pDest, STREAM_WRITE | STREAM_SHARE_DENYNONE,
								sal_False );

			// temp. File anlegen
	//		aMedium.DownLoad();

			{
				SvFileStream aCpy( aMedium.GetPhysicalName(), STREAM_WRITE );
				aCpy << aTmp;
			}

			// uebertragen
			aMedium.Close();
			aMedium.Commit();

			bRet = 0 == aMedium.GetError();
		}

		if( bRet )
		{
			pSrcArr->Insert( pSrc );
			pDestArr->Insert( pDest );
			rFileNm = *pDest;
		}
		else
		{
			delete pSrc;
			delete pDest;
		}
	}

	return bRet;
}


void ScHTMLExport::MakeCIdURL( String& rURL )
{
	if( !aCId.Len() )
		return;

	INetURLObject aURLObj( rURL );
	if( INET_PROT_FILE != aURLObj.GetProtocol() )
		return;

	String aLastName( aURLObj.GetLastName() );
	DBG_ASSERT( aLastName.Len(), "Dateiname ohne Laenge!" );
	aLastName.ToLowerAscii();

	rURL.AssignAscii( "cid:" );
	rURL += aLastName;
	rURL.AppendAscii( "." );
	rURL += aCId;
}


void ScHTMLExport::IncIndent( short nVal )
{
	sIndent[nIndent] = '\t';
    nIndent = nIndent + nVal;
	if ( nIndent < 0 )
		nIndent = 0;
	else if ( nIndent > nIndentMax )
		nIndent = nIndentMax;
	sIndent[nIndent] = 0;
}