Google Git
Sign in
apache / openoffice / bab44dcac0296df22024f3f10e7997de78ed4094 / . / AOO410 / main / sw / source / filter / html / swhtml.cxx
blob: 4e14fdabe345417c75f723935f12a36fe7ce84f9 [file] [log] [blame]
/**************************************************************
*
* 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_sw.hxx"
#include <com/sun/star/document/XDocumentPropertiesSupplier.hpp>
#include <com/sun/star/document/XDocumentProperties.hpp>
#include <com/sun/star/i18n/ScriptType.hpp>
#include <sfx2/sfx.hrc>
#include <svx/svxids.hrc>
#ifdef DBG_UTIL
#include <stdlib.h>
#endif
#include <hintids.hxx>
#define _SVSTDARR_STRINGS
#include <svl/svstdarr.hxx>
#include <svl/stritem.hxx>
#include <svtools/imap.hxx>
#include <svtools/htmltokn.h>
#include <svtools/htmlkywd.hxx>
#include <svtools/ctrltool.hxx>
#include <unotools/pathoptions.hxx>
#include <vcl/svapp.hxx>
#include <vcl/wrkwin.hxx>
#include <sfx2/fcontnr.hxx>
#include <sfx2/docfile.hxx>
#include <svtools/htmlcfg.hxx>
#include <sfx2/linkmgr.hxx>
#include <editeng/kernitem.hxx>
#include <editeng/boxitem.hxx>
#include <editeng/fhgtitem.hxx>
#include <editeng/brkitem.hxx>
#include <editeng/postitem.hxx>
#include <editeng/wghtitem.hxx>
#include <editeng/crsditem.hxx>
#include <editeng/udlnitem.hxx>
#include <editeng/escpitem.hxx>
#include <editeng/blnkitem.hxx>
#include <editeng/ulspitem.hxx>
#include <editeng/colritem.hxx>
#include <editeng/fontitem.hxx>
#include <editeng/adjitem.hxx>
#include <editeng/lrspitem.hxx>
#include <editeng/protitem.hxx>
#include <editeng/flstitem.hxx>
#include <frmatr.hxx>
#include <charatr.hxx>
#include <fmtfld.hxx>
#include <fmtpdsc.hxx>
#include <txtfld.hxx>
#include <fmtanchr.hxx>
#include <fmtsrnd.hxx>
#include <fmtfsize.hxx>
#include <fmtclds.hxx>
#include <fchrfmt.hxx>
#include <fmtinfmt.hxx>
#include <docary.hxx>
#include <docstat.hxx>
#include <doc.hxx>
#include <IDocumentUndoRedo.hxx>
#include <pam.hxx>
#include <ndtxt.hxx>
#include <mdiexp.hxx> // ...Percent()
#include <expfld.hxx>
#include <poolfmt.hxx>
#include <pagedesc.hxx>
#include <IMark.hxx> // fuer SwBookmark ...
#include <docsh.hxx>
#include <editsh.hxx> // fuer Start/EndAction
#include <docufld.hxx>
#include <swcss1.hxx>
#include <htmlvsh.hxx>
#include <fltini.hxx>
#include <htmltbl.hxx>
#include <htmlnum.hxx>
#include <swhtml.hxx>
#include <linkenum.hxx>
#include <breakit.hxx>
#include <SwAppletImpl.hxx>
#include <sfx2/viewfrm.hxx>
#include <statstr.hrc> // ResId fuer Statusleiste
#include <swerror.h>
#define FONTSIZE_MASK 7
#define FONTCOLOR_MASK (1<<15)
#define FONT_MASK (1<<14)
#define HTML_ESC_PROP 80
#define HTML_ESC_SUPER DFLT_ESC_SUPER
#define HTML_ESC_SUB DFLT_ESC_SUB
#define HTML_SPTYPE_NONE 0
#define HTML_SPTYPE_BLOCK 1
#define HTML_SPTYPE_HORI 2
#define HTML_SPTYPE_VERT 3
#ifndef TOOLS_CONSTASCII_STRINGPARAM
#define TOOLS_CONSTASCII_STRINGPARAM( constAsciiStr ) constAsciiStr, sizeof( constAsciiStr )-1
#endif
using namespace ::com::sun::star;
// <P ALIGN=xxx>, <Hn ALIGN=xxx>, <TD ALIGN=xxx> usw.
HTMLOptionEnum __FAR_DATA aHTMLPAlignTable[] =
{
{ OOO_STRING_SVTOOLS_HTML_AL_left, SVX_ADJUST_LEFT },
{ OOO_STRING_SVTOOLS_HTML_AL_center, SVX_ADJUST_CENTER },
{ OOO_STRING_SVTOOLS_HTML_AL_middle, SVX_ADJUST_CENTER }, // Netscape
{ OOO_STRING_SVTOOLS_HTML_AL_right, SVX_ADJUST_RIGHT },
{ OOO_STRING_SVTOOLS_HTML_AL_justify, SVX_ADJUST_BLOCK },
{ OOO_STRING_SVTOOLS_HTML_AL_char, SVX_ADJUST_LEFT },
{ 0, 0 }
};
// <SPACER TYPE=...>
static HTMLOptionEnum __FAR_DATA aHTMLSpacerTypeTable[] =
{
{ OOO_STRING_SVTOOLS_HTML_SPTYPE_block, HTML_SPTYPE_BLOCK },
{ OOO_STRING_SVTOOLS_HTML_SPTYPE_horizontal, HTML_SPTYPE_HORI },
{ OOO_STRING_SVTOOLS_HTML_SPTYPE_vertical, HTML_SPTYPE_VERT },
{ 0, 0 }
};
SV_IMPL_PTRARR( _HTMLAttrs, _HTMLAttrPtr )
HTMLReader::HTMLReader()
{
bTmplBrowseMode = sal_True;
}
String HTMLReader::GetTemplateName() const
{
String sTemplate(
String::CreateFromAscii(TOOLS_CONSTASCII_STRINGPARAM("internal")) );
sTemplate += INET_PATH_TOKEN;
sTemplate.AppendAscii( TOOLS_CONSTASCII_STRINGPARAM("html") );
String sTemplateWithoutExt( sTemplate );
#ifndef MAC_WITHOUT_EXT
// --> OD 2005-01-26 - first search for OpenDocument Writer/Web template
sTemplate.AppendAscii( TOOLS_CONSTASCII_STRINGPARAM(".oth") );
// <--
#endif
SvtPathOptions aPathOpt;
// OpenDocument Writer/Web template (extension .oth)
sal_Bool bSet = aPathOpt.SearchFile( sTemplate, SvtPathOptions::PATH_TEMPLATE );
#ifndef MAC_WITHOUT_EXT
if( !bSet )
{
// 6.0 (extension .stw)
sTemplate = sTemplateWithoutExt;
// --> OD 2005-01-26 - no OpenDocument Writer/Web template found.
// search for OpenOffice.org Writer/Web template
sTemplate.AppendAscii( TOOLS_CONSTASCII_STRINGPARAM(".stw") );
// <--
bSet = aPathOpt.SearchFile( sTemplate, SvtPathOptions::PATH_TEMPLATE );
}
#endif
if( !bSet )
{
sTemplate.Erase();
ASSERT( !this,
"Die html.vor befindet sich nicht mehr im definierten Directory!");
}
return sTemplate;
}
int HTMLReader::SetStrmStgPtr()
{
ASSERT( pMedium, "Wo ist das Medium??" );
if( pMedium->IsRemote() || !pMedium->IsStorage() )
{
pStrm = pMedium->GetInStream();
return sal_True;
}
return sal_False;
}
// Aufruf fuer die allg. Reader-Schnittstelle
sal_uLong HTMLReader::Read( SwDoc &rDoc, const String& rBaseURL, SwPaM &rPam, const String & rName )
{
if( !pStrm )
{
ASSERT( pStrm, "HTML-Read ohne Stream" );
return ERR_SWG_READ_ERROR;
}
if( !bInsertMode )
{
Reader::SetNoOutlineNum( rDoc );
Reader::ResetFrmFmts( rDoc );
// Die HTML-Seitenvorlage setzen, wenn des kein HTML-Dokument ist,
// sonst ist sie schon gesetzt.
if( !rDoc.get(IDocumentSettingAccess::HTML_MODE) )
{
rDoc.InsertPoolItem( rPam, SwFmtPageDesc(
rDoc.GetPageDescFromPool( RES_POOLPAGE_HTML, false )), 0 );
}
}
// damit keiner das Doc klaut!
rDoc.acquire();
sal_uLong nRet = 0;
SvParserRef xParser = new SwHTMLParser( &rDoc, rPam, *pStrm,
rName, rBaseURL, !bInsertMode, pMedium,
IsReadUTF8(),
bIgnoreHTMLComments );
SvParserState eState = xParser->CallParser();
if( SVPAR_PENDING == eState )
pStrm->ResetError();
else if( SVPAR_ACCEPTED != eState )
{
String sErr( String::CreateFromInt32((sal_Int32)xParser->GetLineNr()));
sErr += ',';
sErr += String::CreateFromInt32((sal_Int32)xParser->GetLinePos());
// den Stream als Fehlernummer Transporter benutzen
nRet = *new StringErrorInfo( ERR_FORMAT_ROWCOL, sErr,
ERRCODE_BUTTON_OK | ERRCODE_MSG_ERROR );
}
return nRet;
}
/* */
SwHTMLParser::SwHTMLParser( SwDoc* pD, const SwPaM& rCrsr, SvStream& rIn,
const String& rPath,
const String& rBaseURL,
int bReadNewDoc,
SfxMedium* pMed, sal_Bool bReadUTF8,
sal_Bool bNoHTMLComments )
: SfxHTMLParser( rIn, static_cast< sal_Bool >(bReadNewDoc), pMed ),
SwClient( 0 ),
aPathToFile( rPath ),
sBaseURL( rBaseURL ),
pAppletImpl( 0 ),
pCSS1Parser( 0 ),
pNumRuleInfo( new SwHTMLNumRuleInfo ),
pPendStack( 0 ),
pDoc( pD ),
pActionViewShell( 0 ),
pSttNdIdx( 0 ),
pTable(0),
pFormImpl( 0 ),
pMarquee( 0 ),
pField( 0 ),
pImageMap( 0 ),
pImageMaps( 0 ),
pFootEndNoteImpl( 0 ),
nScriptStartLineNr( 0 ),
nBaseFontStMin( 0 ),
nFontStMin( 0 ),
nDefListDeep( 0 ),
nFontStHeadStart( 0 ),
nSBModuleCnt( 0 ),
nMissingImgMaps( 0 ),
nParaCnt( 5 ),
// --> OD 2007-10-26 #i83625#
nContextStMin( 0 ),
nContextStAttrMin( 0 ),
// <--
nOpenParaToken( 0 ),
eJumpTo( JUMPTO_NONE ),
#ifdef DBG_UTIL
nContinue( 0 ),
#endif
eParaAdjust( SVX_ADJUST_END ),
bDocInitalized( sal_False ),
bSetModEnabled( sal_False ),
bInFloatingFrame( sal_False ),
bInField( sal_False ),
bCallNextToken( sal_False ),
bIgnoreRawData( sal_False ),
bNoParSpace( sal_False ),
bInNoEmbed( sal_False ),
bInTitle( sal_False ),
bUpdateDocStat( sal_False ),
bFixSelectWidth( sal_False ),
bFixSelectHeight( sal_False ),
bTextArea( sal_False ),
bSelect( sal_False ),
bInFootEndNoteAnchor( sal_False ),
bInFootEndNoteSymbol( sal_False ),
// bIgnoreHTMLComments( bNoHTMLComments )
bIgnoreHTMLComments( bNoHTMLComments ),
bRemoveHidden( sal_False ),
pTempViewFrame(0)
{
nEventId = 0;
bUpperSpace = bViewCreated = bChkJumpMark =
bSetCrsr = sal_False;
eScriptLang = HTML_SL_UNKNOWN;
bAnyStarBasic = sal_True;
pPam = new SwPaM( *rCrsr.GetPoint() );
memset( &aAttrTab, 0, sizeof( _HTMLAttrTable ));
// Die Font-Groessen 1-7 aus der INI-Datei lesen
SvxHtmlOptions* pHtmlOptions = SvxHtmlOptions::Get();
aFontHeights[0] = pHtmlOptions->GetFontSize( 0 ) * 20;
aFontHeights[1] = pHtmlOptions->GetFontSize( 1 ) * 20;
aFontHeights[2] = pHtmlOptions->GetFontSize( 2 ) * 20;
aFontHeights[3] = pHtmlOptions->GetFontSize( 3 ) * 20;
aFontHeights[4] = pHtmlOptions->GetFontSize( 4 ) * 20;
aFontHeights[5] = pHtmlOptions->GetFontSize( 5 ) * 20;
aFontHeights[6] = pHtmlOptions->GetFontSize( 6 ) * 20;
bKeepUnknown = pHtmlOptions->IsImportUnknown();
if(bReadNewDoc)
{
SvxFontHeightItem aFontHeight(aFontHeights[2], 100, RES_CHRATR_FONTSIZE);
pDoc->SetDefault( aFontHeight );
aFontHeight.SetWhich( RES_CHRATR_CJK_FONTSIZE );
pDoc->SetDefault( aFontHeight );
aFontHeight.SetWhich( RES_CHRATR_CTL_FONTSIZE );
pDoc->SetDefault( aFontHeight );
}
// Waehrend des Imports in den HTML-Modus schalten, damit die
// richrigen Vorlagen angelegt werden
bOldIsHTMLMode = pDoc->get(IDocumentSettingAccess::HTML_MODE);
pDoc->set(IDocumentSettingAccess::HTML_MODE, true);
pCSS1Parser = new SwCSS1Parser( pDoc, aFontHeights, sBaseURL, IsNewDoc() );
pCSS1Parser->SetIgnoreFontFamily( pHtmlOptions->IsIgnoreFontFamily() );
if( bReadUTF8 )
{
SetSrcEncoding( RTL_TEXTENCODING_UTF8 );
}
else
{
SwDocShell *pDocSh = pDoc->GetDocShell();
SvKeyValueIterator *pHeaderAttrs =
pDocSh->GetHeaderAttributes();
if( pHeaderAttrs )
SetEncodingByHTTPHeader( pHeaderAttrs );
}
pCSS1Parser->SetDfltEncoding( gsl_getSystemTextEncoding() );
// Timer nur bei ganz normalen Dokumenten aufsetzen!
SwDocShell* pDocSh = pDoc->GetDocShell();
if( pDocSh )
{
bViewCreated = sal_True; // nicht, synchron laden
// es ist ein Sprungziel vorgegeben.
if( pMed )
{
sJmpMark = pMed->GetURLObject().GetMark();
if( sJmpMark.Len() )
{
eJumpTo = JUMPTO_MARK;
String sCmp;
xub_StrLen nLastPos, nPos = 0;
while( STRING_NOTFOUND != ( nLastPos =
sJmpMark.Search( cMarkSeperator, nPos + 1 )) )
nPos = nLastPos;
if( nPos && ( sCmp = sJmpMark.Copy( nPos + 1 ) ).
EraseAllChars().Len() )
{
sCmp.ToLowerAscii();
if( sCmp.EqualsAscii( pMarkToRegion ) )
eJumpTo = JUMPTO_REGION;
else if( sCmp.EqualsAscii( pMarkToTable ) )
eJumpTo = JUMPTO_TABLE;
else if( sCmp.EqualsAscii( pMarkToGraphic ) )
eJumpTo = JUMPTO_GRAPHIC;
else if( sCmp.EqualsAscii( pMarkToOutline ) ||
sCmp.EqualsAscii( pMarkToText ) ||
sCmp.EqualsAscii( pMarkToFrame ) )
eJumpTo = JUMPTO_NONE; // das ist nichts gueltiges!
else
// ansonsten ist das ein normaler (Book)Mark
nPos = STRING_LEN;
}
else
nPos = STRING_LEN;
sJmpMark.Erase( nPos );
if( !sJmpMark.Len() )
eJumpTo = JUMPTO_NONE;
}
}
}
}
__EXPORT SwHTMLParser::~SwHTMLParser()
{
#ifdef DBG_UTIL
ASSERT( !nContinue, "DTOR im Continue - Das geht schief!!!" );
#endif
sal_Bool bAsync = pDoc->IsInLoadAsynchron();
pDoc->SetInLoadAsynchron( sal_False );
pDoc->set(IDocumentSettingAccess::HTML_MODE, bOldIsHTMLMode);
if( pDoc->GetDocShell() && nEventId )
Application::RemoveUserEvent( nEventId );
// das DocumentDetected kann ggfs. die DocShells loeschen, darum nochmals
// abfragen
if( pDoc->GetDocShell() )
{
// Gelinkte Bereiche updaten
sal_uInt16 nLinkMode = pDoc->getLinkUpdateMode( true );
if( nLinkMode != NEVER && bAsync &&
SFX_CREATE_MODE_INTERNAL!=pDoc->GetDocShell()->GetCreateMode() )
pDoc->GetLinkManager().UpdateAllLinks( nLinkMode == MANUAL,
sal_True, sal_False );
if ( pDoc->GetDocShell()->IsLoading() )
{
// --> OD 2006-11-07 #i59688#
pDoc->GetDocShell()->LoadingFinished();
}
}
delete pSttNdIdx;
if( aSetAttrTab.Count() )
{
ASSERT( !aSetAttrTab.Count(),"Es stehen noch Attribute auf dem Stack" );
aSetAttrTab.DeleteAndDestroy( 0, aSetAttrTab.Count() );
}
delete pPam;
delete pCSS1Parser;
delete pNumRuleInfo;
DeleteFormImpl();
DeleteFootEndNoteImpl();
ASSERT( !pTable, "Es existiert noch eine offene Tabelle" );
delete pImageMaps;
//delete pTable;
ASSERT( !pPendStack,
"SwHTMLParser::~SwHTMLParser: Hier sollte es keinen Pending-Stack mehr geben" );
while( pPendStack )
{
SwPendingStack* pTmp = pPendStack;
pPendStack = pPendStack->pNext;
delete pTmp->pData;
delete pTmp;
}
if( !pDoc->release() )
{
// keiner will mehr das Doc haben, also weg damit
delete pDoc;
pDoc = NULL;
}
if ( pTempViewFrame )
{
pTempViewFrame->DoClose();
// the temporary view frame is hidden, so the hidden flag might need to be removed
if ( bRemoveHidden && pDoc && pDoc->GetDocShell() && pDoc->GetDocShell()->GetMedium() )
pDoc->GetDocShell()->GetMedium()->GetItemSet()->ClearItem( SID_HIDDEN );
}
}
IMPL_LINK( SwHTMLParser, AsyncCallback, void*, /*pVoid*/ )
{
nEventId=0;
// --> FME 2005-08-18 #i47907# If the document has already been destructed,
// the parser should be aware of this:
if( ( pDoc->GetDocShell() && pDoc->GetDocShell()->IsAbortingImport() )
|| 1 == pDoc->getReferenceCount() )
{
// wurde der Import vom SFX abgebrochen?
eState = SVPAR_ERROR;
}
// <--
GetAsynchCallLink().Call(0);
return 0;
}
SvParserState __EXPORT SwHTMLParser::CallParser()
{
// einen temporaeren Index anlegen, auf Pos 0 so wird er nicht bewegt!
pSttNdIdx = new SwNodeIndex( pDoc->GetNodes() );
if( !IsNewDoc() ) // in ein Dokument einfuegen ?
{
const SwPosition* pPos = pPam->GetPoint();
pDoc->SplitNode( *pPos, false );
*pSttNdIdx = pPos->nNode.GetIndex()-1;
pDoc->SplitNode( *pPos, false );
SwPaM aInsertionRangePam( *pPos );
pPam->Move( fnMoveBackward );
// #106634# split any redline over the insertion point
aInsertionRangePam.SetMark();
*aInsertionRangePam.GetPoint() = *pPam->GetPoint();
aInsertionRangePam.Move( fnMoveBackward );
pDoc->SplitRedline( aInsertionRangePam );
pDoc->SetTxtFmtColl( *pPam,
pCSS1Parser->GetTxtCollFromPool( RES_POOLCOLL_STANDARD ));
}
if( GetMedium() )
{
if( !bViewCreated )
{
nEventId = Application::PostUserEvent( LINK( this, SwHTMLParser, AsyncCallback ), 0 );
}
else
{
bViewCreated = sal_True;
nEventId = 0;
}
}
// Laufbalken anzeigen
else if( !GetMedium() || !GetMedium()->IsRemote() )
{
rInput.Seek(STREAM_SEEK_TO_END);
rInput.ResetError();
::StartProgress( STR_STATSTR_W4WREAD, 0, rInput.Tell(),
pDoc->GetDocShell() );
rInput.Seek(STREAM_SEEK_TO_BEGIN);
rInput.ResetError();
}
SwPageDesc& rDesc = pDoc->_GetPageDesc( 0 );
rDesc.Add( this );
SvParserState eRet = HTMLParser::CallParser();
return eRet;
}
void __EXPORT SwHTMLParser::Continue( int nToken )
{
#ifdef DBG_UTIL
ASSERT( !nContinue, "Continue im Continue - Das sollte doch nicht sein, oder?" );
nContinue++;
#endif
// Wenn der Import (vom SFX) abgebrochen wurde, wird ein Fehler
// gesetzt aber trotzdem noch weiter gemacht, damit vernuenftig
// aufgeraeumt wird.
ASSERT( SVPAR_ERROR!=eState,
"SwHTMLParser::Continue: bereits ein Fehler gesetzt" );
if( pDoc->GetDocShell() && pDoc->GetDocShell()->IsAbortingImport() )
eState = SVPAR_ERROR;
// Die ViewShell vom Dokument holen, merken und als aktuelle setzen.
ViewShell *pInitVSh = CallStartAction();
if( SVPAR_ERROR != eState && GetMedium() && !bViewCreated )
{
// Beim ersten Aufruf erstmal returnen, Doc anzeigen
// und auf Timer Callback warten.
// An dieser Stelle wurde im CallParser gerade mal ein Zeichen
// gelesen und ein SaveState(0) gerufen.
eState = SVPAR_PENDING;
bViewCreated = sal_True;
pDoc->SetInLoadAsynchron( sal_True );
#ifdef DBG_UTIL
nContinue--;
#endif
return;
}
bSetModEnabled = sal_False;
if( pDoc->GetDocShell() &&
0 != (bSetModEnabled = pDoc->GetDocShell()->IsEnableSetModified()) )
{
pDoc->GetDocShell()->EnableSetModified( sal_False );
}
// waehrend des einlesens kein OLE-Modified rufen
Link aOLELink( pDoc->GetOle2Link() );
pDoc->SetOle2Link( Link() );
sal_Bool bModified = pDoc->IsModified();
bool const bWasUndo = pDoc->GetIDocumentUndoRedo().DoesUndo();
pDoc->GetIDocumentUndoRedo().DoUndo(false);
// Wenn der Import abgebrochen wird, kein Continue mehr rufen.
// Falls ein Pending-Stack existiert aber durch einen Aufruf
// von NextToken dafuer sorgen, dass der Pending-Stack noch
// beendet wird.
if( SVPAR_ERROR == eState )
{
ASSERT( !pPendStack || pPendStack->nToken,
"SwHTMLParser::Continue: Pending-Stack ohne Token" );
if( pPendStack && pPendStack->nToken )
NextToken( pPendStack->nToken );
ASSERT( !pPendStack,
"SwHTMLParser::Continue: Es gibt wieder einen Pend-Stack" );
}
else
{
HTMLParser::Continue( pPendStack ? pPendStack->nToken : nToken );
}
// Laufbalken wieder abschalten
EndProgress( pDoc->GetDocShell() );
sal_Bool bLFStripped = sal_False;
if( SVPAR_PENDING != GetStatus() )
{
// noch die letzten Attribute setzen
{
if( aScriptSource.Len() )
{
SwScriptFieldType *pType =
(SwScriptFieldType*)pDoc->GetSysFldType( RES_SCRIPTFLD );
SwScriptField aFld( pType, aScriptType, aScriptSource,
sal_False );
InsertAttr( SwFmtFld( aFld ) );
}
if( pAppletImpl )
{
if( pAppletImpl->GetApplet().is() )
EndApplet();
else
EndObject();
}
// ggf. ein noch vorhandes LF hinter dem letzen Absatz entfernen
if( IsNewDoc() )
bLFStripped = StripTrailingLF() > 0;
// noch offene Nummerierungen beenden.
while( GetNumInfo().GetNumRule() )
EndNumBulList();
ASSERT( !nContextStMin, "Es gibt geschuetzte Kontexte" );
nContextStMin = 0;
while( aContexts.Count() )
{
_HTMLAttrContext *pCntxt = PopContext();
if( pCntxt )
{
EndContext( pCntxt );
delete pCntxt;
}
}
if( aParaAttrs.Count() )
aParaAttrs.Remove( 0, aParaAttrs.Count() );
SetAttr( sal_False );
// Noch die erst verzoegert gesetzten Styles setzen
pCSS1Parser->SetDelayedStyles();
}
// den Start wieder korrigieren
if( !IsNewDoc() && pSttNdIdx->GetIndex() )
{
SwTxtNode* pTxtNode = pSttNdIdx->GetNode().GetTxtNode();
SwNodeIndex aNxtIdx( *pSttNdIdx );
if( pTxtNode && pTxtNode->CanJoinNext( &aNxtIdx ))
{
xub_StrLen nStt = pTxtNode->GetTxt().Len();
// wenn der Cursor noch in dem Node steht, dann setze in an das Ende
if( pPam->GetPoint()->nNode == aNxtIdx )
{
pPam->GetPoint()->nNode = *pSttNdIdx;
pPam->GetPoint()->nContent.Assign( pTxtNode, nStt );
}
#ifdef DBG_UTIL
// !!! sollte nicht moeglich sein, oder ??
ASSERT( pSttNdIdx->GetIndex()+1 != pPam->GetBound( sal_True ).nNode.GetIndex(),
"Pam.Bound1 steht noch im Node" );
ASSERT( pSttNdIdx->GetIndex()+1 != pPam->GetBound( sal_False ).nNode.GetIndex(),
"Pam.Bound2 steht noch im Node" );
if( pSttNdIdx->GetIndex()+1 == pPam->GetBound( sal_True ).nNode.GetIndex() )
{
xub_StrLen nCntPos = pPam->GetBound( sal_True ).nContent.GetIndex();
pPam->GetBound( sal_True ).nContent.Assign( pTxtNode,
pTxtNode->GetTxt().Len() + nCntPos );
}
if( pSttNdIdx->GetIndex()+1 == pPam->GetBound( sal_False ).nNode.GetIndex() )
{
xub_StrLen nCntPos = pPam->GetBound( sal_False ).nContent.GetIndex();
pPam->GetBound( sal_False ).nContent.Assign( pTxtNode,
pTxtNode->GetTxt().Len() + nCntPos );
}
#endif
// Zeichen Attribute beibehalten!
SwTxtNode* pDelNd = aNxtIdx.GetNode().GetTxtNode();
if( pTxtNode->GetTxt().Len() )
pDelNd->FmtToTxtAttr( pTxtNode );
else
pTxtNode->ChgFmtColl( pDelNd->GetTxtColl() );
pTxtNode->JoinNext();
}
}
}
if( SVPAR_ACCEPTED == eState )
{
if( nMissingImgMaps )
{
// es fehlen noch ein paar Image-Map zuordungen.
// vielleicht sind die Image-Maps ja jetzt da?
ConnectImageMaps();
}
// jetzt noch den letzten ueberfluessigen Absatz loeschen
SwPosition* pPos = pPam->GetPoint();
if( !pPos->nContent.GetIndex() && !bLFStripped )
{
SwTxtNode* pAktNd;
sal_uLong nNodeIdx = pPos->nNode.GetIndex();
sal_Bool bHasFlysOrMarks =
HasCurrentParaFlys() || HasCurrentParaBookmarks( sal_True );
if( IsNewDoc() )
{
const SwNode *pPrev = pDoc->GetNodes()[nNodeIdx -1];
if( !pPam->GetPoint()->nContent.GetIndex() &&
( pPrev->IsCntntNode() ||
(pPrev->IsEndNode() &&
pPrev->StartOfSectionNode()->IsSectionNode()) ) )
{
SwCntntNode* pCNd = pPam->GetCntntNode();
if( pCNd && pCNd->StartOfSectionIndex()+2 <
pCNd->EndOfSectionIndex() && !bHasFlysOrMarks )
{
ViewShell *pVSh = CheckActionViewShell();
SwCrsrShell *pCrsrSh = pVSh && pVSh->ISA(SwCrsrShell)
? static_cast < SwCrsrShell * >( pVSh )
: 0;
if( pCrsrSh &&
pCrsrSh->GetCrsr()->GetPoint()
->nNode.GetIndex() == nNodeIdx )
{
pCrsrSh->MovePara(fnParaPrev, fnParaEnd );
pCrsrSh->SetMark();
pCrsrSh->ClearMark();
}
pPam->GetBound(sal_True).nContent.Assign( 0, 0 );
pPam->GetBound(sal_False).nContent.Assign( 0, 0 );
pDoc->GetNodes().Delete( pPam->GetPoint()->nNode );
}
}
}
else if( 0 != ( pAktNd = pDoc->GetNodes()[ nNodeIdx ]->GetTxtNode()) && !bHasFlysOrMarks )
{
if( pAktNd->CanJoinNext( &pPos->nNode ))
{
SwTxtNode* pNextNd = pPos->nNode.GetNode().GetTxtNode();
pPos->nContent.Assign( pNextNd, 0 );
pPam->SetMark(); pPam->DeleteMark();
pNextNd->JoinPrev();
}
else if( !pAktNd->GetTxt().Len() )
{
pPos->nContent.Assign( 0, 0 );
pPam->SetMark(); pPam->DeleteMark();
pDoc->GetNodes().Delete( pPos->nNode, 1 );
pPam->Move( fnMoveBackward );
}
}
}
// nun noch das SplitNode vom Anfang aufheben
else if( !IsNewDoc() )
{
if( pPos->nContent.GetIndex() ) // dann gabs am Ende kein <P>,
pPam->Move( fnMoveForward, fnGoNode ); // als zum naechsten Node
SwTxtNode* pTxtNode = pPos->nNode.GetNode().GetTxtNode();
SwNodeIndex aPrvIdx( pPos->nNode );
if( pTxtNode && pTxtNode->CanJoinPrev( &aPrvIdx ) &&
*pSttNdIdx <= aPrvIdx )
{
// eigentlich muss hier ein JoinNext erfolgen, aber alle Cursor
// usw. sind im pTxtNode angemeldet, so dass der bestehen
// bleiben MUSS.
// Absatz in Zeichen-Attribute umwandeln, aus dem Prev die
// Absatzattribute und die Vorlage uebernehmen!
SwTxtNode* pPrev = aPrvIdx.GetNode().GetTxtNode();
pTxtNode->ChgFmtColl( pPrev->GetTxtColl() );
pTxtNode->FmtToTxtAttr( pPrev );
pTxtNode->ResetAllAttr();
if( pPrev->HasSwAttrSet() )
pTxtNode->SetAttr( *pPrev->GetpSwAttrSet() );
if( &pPam->GetBound(sal_True).nNode.GetNode() == pPrev )
pPam->GetBound(sal_True).nContent.Assign( pTxtNode, 0 );
if( &pPam->GetBound(sal_False).nNode.GetNode() == pPrev )
pPam->GetBound(sal_False).nContent.Assign( pTxtNode, 0 );
pTxtNode->JoinPrev();
}
}
// und noch die DocumentInfo aufbereiten
if( IsNewDoc() )
{
SwDocShell *pDocShell(pDoc->GetDocShell());
DBG_ASSERT(pDocShell, "no SwDocShell");
if (pDocShell) {
uno::Reference<document::XDocumentPropertiesSupplier> xDPS(
pDocShell->GetModel(), uno::UNO_QUERY_THROW);
uno::Reference<document::XDocumentProperties> xDocProps(
xDPS->getDocumentProperties());
DBG_ASSERT(xDocProps.is(), "DocumentProperties is null");
if ( xDocProps.is() && (xDocProps->getAutoloadSecs() > 0) &&
xDocProps->getAutoloadURL().equalsAscii("") )
{
xDocProps->setAutoloadURL(aPathToFile);
}
}
}
if( bUpdateDocStat )
{
SwDocStat aStat( pDoc->GetDocStat() );
pDoc->UpdateDocStat( aStat );
}
}
if( SVPAR_PENDING != GetStatus() )
delete pSttNdIdx, pSttNdIdx = 0;
// sollte der Parser der Letzte sein, der das Doc haelt, dann braucht
// man hier auch nichts mehr tun, Doc wird gleich zerstoert!
if( 1 < pDoc->getReferenceCount() )
{
if( bWasUndo )
{
pDoc->GetIDocumentUndoRedo().DelAllUndoObj();
pDoc->GetIDocumentUndoRedo().DoUndo(true);
}
else if( !pInitVSh )
{
// Wenn zu Beginn des Continue keine Shell vorhanden war,
// kann trotzdem mitlerweile eine angelegt worden sein.
// In dieses Fall stimmt das bWasUndo-Flag nicht und
// wir muessen das Undo noch anschalten.
ViewShell *pTmpVSh = CheckActionViewShell();
if( pTmpVSh )
{
pDoc->GetIDocumentUndoRedo().DoUndo(true);
}
}
pDoc->SetOle2Link( aOLELink );
if( !bModified )
pDoc->ResetModified();
if( bSetModEnabled && pDoc->GetDocShell() )
{
pDoc->GetDocShell()->EnableSetModified( sal_True );
bSetModEnabled = sal_False; // this is unnecessary here
}
}
// Wenn die Dokuemnt-ViewShell noch existiert und eine Action
// offen ist (muss bei Abbruch nicht sein), die Action beenden,
// uns von der Shell abmelden und schliesslich die alte Shell
// wieder rekonstruieren.
CallEndAction( sal_True );
#ifdef DBG_UTIL
nContinue--;
#endif
}
void SwHTMLParser::Modify( const SfxPoolItem* pOld, const SfxPoolItem *pNew )
{
switch( pOld ? pOld->Which() : pNew ? pNew->Which() : 0 )
{
case RES_OBJECTDYING:
if( ((SwPtrMsgPoolItem *)pOld)->pObject == GetRegisteredIn() )
{
// dann uns selbst beenden
GetRegisteredInNonConst()->Remove( this );
ReleaseRef(); // ansonsten sind wir fertig!
}
break;
}
}
void SwHTMLParser::DocumentDetected()
{
ASSERT( !bDocInitalized, "DocumentDetected mehrfach aufgerufen" );
bDocInitalized = sal_True;
if( IsNewDoc() )
{
if( IsInHeader() )
FinishHeader( sal_True );
CallEndAction( sal_True, sal_True );
pDoc->GetIDocumentUndoRedo().DoUndo(false);
// Durch das DocumentDetected wurde im allgemeinen eine
// ViewShell angelegt. Es kann aber auch sein, dass sie
// erst spaeter angelegt wird, naemlich dann, wenn die UI
// gecaptured ist.
CallStartAction();
}
}
// wird fuer jedes Token gerufen, das in CallParser erkannt wird
void __EXPORT SwHTMLParser::NextToken( int nToken )
{
if( ( pDoc->GetDocShell() && pDoc->GetDocShell()->IsAbortingImport() )
|| 1 == pDoc->getReferenceCount() )
{
// wurde der Import vom SFX abgebrochen? Wenn ein Pending-Stack
// existiert den noch aufraumen
eState = SVPAR_ERROR;
ASSERT( !pPendStack || pPendStack->nToken,
"SwHTMLParser::NextToken: Pending-Stack ohne Token" );
if( 1 == pDoc->getReferenceCount() || !pPendStack )
return ;
}
#ifdef DBG_UTIL
if( pPendStack )
{
switch( nToken )
{
// Tabellen werden ueber rekusive Methodenaufrufe gelesen
case HTML_TABLE_ON:
// Bei CSS-Deklarationen muss evtl. noch auf das
// Ende eines File-Downloads gewartet werden.
case HTML_LINK:
// Bei Controls muss evtl. noch die Groesse gesetzt werden.
case HTML_INPUT:
case HTML_TEXTAREA_ON:
case HTML_SELECT_ON:
case HTML_SELECT_OFF:
break;
default:
ASSERT( !pPendStack, "Unbekanntes Token fuer Pending-Stack" );
break;
}
}
#endif
// Die folgeneden Spezialfaelle muessen vor der Filter-Detection behandelt
// werden, denn der Inhalt des Titels, etc. wird auch in Netcape nicht
// zur Filter-Detection herangezogen.
if( !pPendStack )
{
if( bInTitle )
{
switch( nToken )
{
case HTML_TITLE_OFF:
if( IsNewDoc() && sTitle.Len() )
{
if( pDoc->GetDocShell() ) {
uno::Reference<document::XDocumentPropertiesSupplier>
xDPS(pDoc->GetDocShell()->GetModel(),
uno::UNO_QUERY_THROW);
uno::Reference<document::XDocumentProperties> xDocProps(
xDPS->getDocumentProperties());
DBG_ASSERT(xDocProps.is(), "no DocumentProperties");
if (xDocProps.is()) {
xDocProps->setTitle(sTitle);
}
pDoc->GetDocShell()->SetTitle( sTitle );
}
}
bInTitle = sal_False;
sTitle.Erase();
break;
case HTML_NONBREAKSPACE:
sTitle += ' ';
break;
case HTML_SOFTHYPH:
sTitle += '-';
break;
case HTML_TEXTTOKEN:
sTitle += aToken;
break;
default:
sTitle += '<';
if( (HTML_TOKEN_ONOFF & nToken) && (1 & nToken) )
sTitle += '/';
sTitle += sSaveToken;
if( aToken.Len() )
{
sTitle += ' ';
sTitle += aToken;
}
sTitle += '>';
break;
}
return;
}
}
// Wenn wir noch nicht wissen, was fuer ein Dokument wir vor uns haben,
// versuchen wir das erstmal rauszufinden. Das muss fuer Controls in
// Fall vor dem Einfuegen des Controls passieren, weil beim Einfuegen
// bereits eine View benoetigt wird.
if( !bDocInitalized )
DocumentDetected();
sal_Bool bGetIDOption = sal_False, bInsertUnknown = sal_False;
sal_Bool bUpperSpaceSave = bUpperSpace;
bUpperSpace = sal_False;
// Die folgenden Speziallfaelle muessen oder koennen nach der
// Filter-Detection erfolgen.
if( !pPendStack )
{
if( bInFloatingFrame )
{
// <SCRIPT> wird hier (von uns) ignoriert, weil es auch in
// Applets ignoriert wird!
if( HTML_IFRAME_OFF == nToken )
{
bCallNextToken = sal_False;
EndFloatingFrame();
}
return;
}
else if( bInNoEmbed )
{
switch( nToken )
{
case HTML_NOEMBED_OFF:
aContents.ConvertLineEnd();
InsertComment( aContents, OOO_STRING_SVTOOLS_HTML_noembed );
aContents.Erase();
bCallNextToken = sal_False;
bInNoEmbed = sal_False;
break;
case HTML_RAWDATA:
InsertCommentText( OOO_STRING_SVTOOLS_HTML_noembed );
break;
default:
ASSERT( !this, "SwHTMLParser::NextToken: ungueltiges Tag" );
break;
}
return;
}
else if( pAppletImpl )
{
// in einem Applet interessieren uns (erstmal) nur <PARAM>-Tags
// und das </APPLET>.
// <SCRIPT> wird hier (von Netscape) ignoriert!
switch( nToken )
{
case HTML_APPLET_OFF:
bCallNextToken = sal_False;
EndApplet();
break;
case HTML_OBJECT_OFF:
bCallNextToken = sal_False;
EndObject();
break;
case HTML_PARAM:
InsertParam();
break;
}
return;
}
else if( bTextArea )
{
// in einer TextArea wird alles bis zum </TEXTAREA> als Text
// eingefuegt
// <SCRIPT> wird hier (von Netscape) ignoriert!
switch( nToken )
{
case HTML_TEXTAREA_OFF:
bCallNextToken = sal_False;
EndTextArea();
break;
default:
InsertTextAreaText( static_cast< sal_uInt16 >(nToken) );
break;
}
return;
}
else if( bSelect )
{
// MUSS nach bNoScript kommen!
switch( nToken )
{
case HTML_SELECT_OFF:
bCallNextToken = sal_False;
EndSelect();
return;
case HTML_OPTION:
InsertSelectOption();
return;
case HTML_TEXTTOKEN:
InsertSelectText();
return;
case HTML_INPUT:
case HTML_SCRIPT_ON:
case HTML_SCRIPT_OFF:
case HTML_NOSCRIPT_ON:
case HTML_NOSCRIPT_OFF:
case HTML_RAWDATA:
// im normalen switch bahandeln
break;
default:
// ignorieren
return;
}
}
else if( pMarquee )
{
// in einer TextArea wird alles bis zum </TEXTAREA> als Text
// eingefuegt
// Die <SCRIPT>-Tags werden vom MS-IE ignoriert, von uns das
// geasmte Script
switch( nToken )
{
case HTML_MARQUEE_OFF:
bCallNextToken = sal_False;
EndMarquee();
break;
case HTML_TEXTTOKEN:
InsertMarqueeText();
break;
}
return;
}
else if( bInField )
{
switch( nToken )
{
case HTML_SDFIELD_OFF:
bCallNextToken = sal_False;
EndField();
break;
case HTML_TEXTTOKEN:
InsertFieldText();
break;
}
return;
}
else if( bInFootEndNoteAnchor || bInFootEndNoteSymbol )
{
switch( nToken )
{
case HTML_ANCHOR_OFF:
EndAnchor();
bCallNextToken = sal_False;
break;
case HTML_TEXTTOKEN:
InsertFootEndNoteText();
break;
}
return;
}
else if( aUnknownToken.Len() )
{
// Unbekannte Token im Header werden nur durch ein passendes
// End-Token, </HEAD> oder <BODY> wieder beendet. Darin wird Text
// ignoriert.
switch( nToken )
{
case HTML_UNKNOWNCONTROL_OFF:
if( aUnknownToken.CompareTo(sSaveToken) != COMPARE_EQUAL )
return;
case HTML_FRAMESET_ON:
case HTML_HEAD_OFF:
case HTML_BODY_ON:
case HTML_IMAGE: // Warum auch immer Netscape das tut.
aUnknownToken.Erase();
break;
case HTML_TEXTTOKEN:
return;
default:
break;
}
}
}
switch( nToken )
{
case HTML_BODY_ON:
if( aStyleSource.Len() )
{
pCSS1Parser->ParseStyleSheet( aStyleSource );
aStyleSource.Erase();
}
if( IsNewDoc() )
{
InsertBodyOptions();
// Falls es eine Vorlage fuer die erste oder rechte Seite gibt,
// setzen wir die hier.
const SwPageDesc *pPageDesc = 0;
if( pCSS1Parser->IsSetFirstPageDesc() )
pPageDesc = pCSS1Parser->GetFirstPageDesc();
else if( pCSS1Parser->IsSetRightPageDesc() )
pPageDesc = pCSS1Parser->GetRightPageDesc();
if( pPageDesc )
{
pDoc->InsertPoolItem( *pPam, SwFmtPageDesc( pPageDesc ), 0 );
}
}
break;
case HTML_LINK:
InsertLink();
break;
case HTML_BASE:
{
const HTMLOptions *pHTMLOptions = GetOptions();
for( sal_uInt16 i = pHTMLOptions->Count(); i; )
{
const HTMLOption *pOption = (*pHTMLOptions)[ --i ];
switch( pOption->GetToken() )
{
case HTML_O_HREF:
sBaseURL = pOption->GetString();
break;
case HTML_O_TARGET:
if( IsNewDoc() )
{
SwDocShell *pDocShell(pDoc->GetDocShell());
DBG_ASSERT(pDocShell, "no SwDocShell");
if (pDocShell) {
uno::Reference<document::XDocumentPropertiesSupplier> xDPS(
pDocShell->GetModel(), uno::UNO_QUERY_THROW);
uno::Reference<document::XDocumentProperties>
xDocProps(xDPS->getDocumentProperties());
DBG_ASSERT(xDocProps.is(),"no DocumentProperties");
if (xDocProps.is()) {
xDocProps->setDefaultTarget(
pOption->GetString());
}
}
}
break;
}
}
}
break;
case HTML_META:
{
SvKeyValueIterator *pHTTPHeader = 0;
if( IsNewDoc() )
{
SwDocShell *pDocSh = pDoc->GetDocShell();
if( pDocSh )
pHTTPHeader = pDocSh->GetHeaderAttributes();
}
SwDocShell *pDocShell(pDoc->GetDocShell());
DBG_ASSERT(pDocShell, "no SwDocShell");
if (pDocShell)
{
uno::Reference<document::XDocumentProperties> xDocProps;
if (IsNewDoc())
{
const uno::Reference<document::XDocumentPropertiesSupplier>
xDPS( pDocShell->GetModel(), uno::UNO_QUERY_THROW );
xDocProps = xDPS->getDocumentProperties();
DBG_ASSERT(xDocProps.is(), "DocumentProperties is null");
}
ParseMetaOptions( xDocProps, pHTTPHeader );
}
}
break;
case HTML_TITLE_ON:
bInTitle = sal_True;
break;
case HTML_SCRIPT_ON:
NewScript();
break;
case HTML_SCRIPT_OFF:
EndScript();
break;
case HTML_NOSCRIPT_ON:
case HTML_NOSCRIPT_OFF:
bInsertUnknown = sal_True;
break;
case HTML_STYLE_ON:
NewStyle();
break;
case HTML_STYLE_OFF:
EndStyle();
break;
case HTML_RAWDATA:
if( !bIgnoreRawData )
{
if( IsReadScript() )
{
AddScriptSource();
}
else if( IsReadStyle() )
{
if( aStyleSource.Len() )
aStyleSource += '\n';
aStyleSource += aToken;
}
}
break;
case HTML_OBJECT_ON:
#ifdef SOLAR_JAVA
NewObject();
bCallNextToken = pAppletImpl!=0 && pTable!=0;
#endif
break;
case HTML_APPLET_ON:
#ifdef SOLAR_JAVA
InsertApplet();
bCallNextToken = pAppletImpl!=0 && pTable!=0;
#endif
break;
case HTML_IFRAME_ON:
InsertFloatingFrame();
bCallNextToken = bInFloatingFrame && pTable!=0;
break;
case HTML_LINEBREAK:
if( !IsReadPRE() )
{
InsertLineBreak();
break;
}
else
bGetIDOption = sal_True;
// <BR>s in <PRE> aehneln echten LFs, deshalb kein break
case HTML_NEWPARA:
// CR in PRE/LISTING/XMP
{
if( HTML_NEWPARA==nToken ||
pPam->GetPoint()->nContent.GetIndex() )
{
AppendTxtNode(); // lf gibts hier nicht, deshalb unkritisch
SetTxtCollAttrs();
}
// Laufbalkenanzeige
if( !GetMedium() || !GetMedium()->IsRemote() )
::SetProgressState( rInput.Tell(), pDoc->GetDocShell() );
}
break;
case HTML_NONBREAKSPACE:
pDoc->InsertString( *pPam, CHAR_HARDBLANK );
break;
case HTML_SOFTHYPH:
pDoc->InsertString( *pPam, CHAR_SOFTHYPHEN );
break;
case HTML_LINEFEEDCHAR:
if( pPam->GetPoint()->nContent.GetIndex() )
AppendTxtNode();
if( !pTable && !pDoc->IsInHeaderFooter( pPam->GetPoint()->nNode ) )
{
NewAttr( &aAttrTab.pBreak, SvxFmtBreakItem(SVX_BREAK_PAGE_BEFORE, RES_BREAK) );
EndAttr( aAttrTab.pBreak, 0, sal_False );
}
break;
case HTML_TEXTTOKEN:
// dann fuege den String ein, ohne das Attribute am Ende
// aufgespannt werden.
if( aToken.Len() && ' '==aToken.GetChar(0) && !IsReadPRE() )
{
xub_StrLen nPos = pPam->GetPoint()->nContent.GetIndex();
if( nPos )
{
const String& rText =
pPam->GetPoint()->nNode.GetNode().GetTxtNode()->GetTxt();
sal_Unicode cLast = rText.GetChar(--nPos);
if( ' ' == cLast || '\x0a' == cLast)
aToken.Erase(0,1);
}
else
aToken.Erase(0,1);
if( !aToken.Len() )
{
bUpperSpace = bUpperSpaceSave;
break;
}
}
if( aToken.Len() )
{
if( !bDocInitalized )
DocumentDetected();
pDoc->InsertString( *pPam, aToken );
// wenn es noch vorlaefige Absatz-Attribute gibt, der Absatz aber
// nicht leer ist, dann sind die Absatz-Attribute entgueltig.
if( aParaAttrs.Count() )
aParaAttrs.Remove( 0, aParaAttrs.Count() );
SetAttr();
}
break;
case HTML_HORZRULE:
InsertHorzRule();
break;
case HTML_IMAGE:
InsertImage();
// sollte der Parser der Letzte sein, der das Doc haelt, dann kann
// man hier abbrechen und einen Fehler setzen.
if( 1 == pDoc->getReferenceCount() )
{
eState = SVPAR_ERROR;
}
break;
case HTML_SPACER:
InsertSpacer();
break;
case HTML_EMBED:
InsertEmbed();
break;
case HTML_NOEMBED_ON:
bInNoEmbed = sal_True;
bCallNextToken = pTable!=0;
ReadRawData( OOO_STRING_SVTOOLS_HTML_noembed );
break;
case HTML_DEFLIST_ON:
if( nOpenParaToken )
EndPara();
NewDefList();
break;
case HTML_DEFLIST_OFF:
if( nOpenParaToken )
EndPara();
EndDefListItem( 0, sal_False, 1==nDefListDeep );
EndDefList();
break;
case HTML_DD_ON:
case HTML_DT_ON:
if( nOpenParaToken )
EndPara();
EndDefListItem( 0, sal_False );// <DD>/<DT> beenden und keine Vorl. setzen
NewDefListItem( nToken );
break;
case HTML_DD_OFF:
case HTML_DT_OFF:
// siehe HTML_LI_OFF
// eigentlich muesste man ein DD/DT jetzt beenden. Da aber sowhl
// Netscape als auch Microsoft das nicht tun, machen wir das eben
// auch nicht.
EndDefListItem( nToken, sal_False );
break;
// Bereiche
case HTML_DIVISION_ON:
case HTML_CENTER_ON:
if( nOpenParaToken )
{
if( IsReadPRE() )
nOpenParaToken = 0;
else
EndPara();
}
NewDivision( nToken );
break;
case HTML_DIVISION_OFF:
case HTML_CENTER_OFF:
if( nOpenParaToken )
{
if( IsReadPRE() )
nOpenParaToken = 0;
else
EndPara();
}
EndDivision( nToken );
break;
case HTML_MULTICOL_ON:
if( nOpenParaToken )
EndPara();
NewMultiCol();
break;
case HTML_MULTICOL_OFF:
if( nOpenParaToken )
EndPara();
EndTag( HTML_MULTICOL_ON );
break;
case HTML_MARQUEE_ON:
NewMarquee();
bCallNextToken = pMarquee!=0 && pTable!=0;
break;
case HTML_FORM_ON:
NewForm();
break;
case HTML_FORM_OFF:
EndForm();
break;
// Vorlagen:
case HTML_PARABREAK_ON:
if( nOpenParaToken )
EndPara( sal_True );
NewPara();
break;
case HTML_PARABREAK_OFF:
EndPara( sal_True );
break;
case HTML_ADDRESS_ON:
if( nOpenParaToken )
EndPara();
NewTxtFmtColl( HTML_ADDRESS_ON, RES_POOLCOLL_SENDADRESS );
break;
case HTML_ADDRESS_OFF:
if( nOpenParaToken )
EndPara();
EndTxtFmtColl( HTML_ADDRESS_OFF );
break;
case HTML_BLOCKQUOTE_ON:
case HTML_BLOCKQUOTE30_ON:
if( nOpenParaToken )
EndPara();
NewTxtFmtColl( HTML_BLOCKQUOTE_ON, RES_POOLCOLL_HTML_BLOCKQUOTE );
break;
case HTML_BLOCKQUOTE_OFF:
case HTML_BLOCKQUOTE30_OFF:
if( nOpenParaToken )
EndPara();
EndTxtFmtColl( HTML_BLOCKQUOTE_ON );
break;
case HTML_PREFORMTXT_ON:
case HTML_LISTING_ON:
case HTML_XMP_ON:
if( nOpenParaToken )
EndPara();
NewTxtFmtColl( nToken, RES_POOLCOLL_HTML_PRE );
break;
case HTML_PREFORMTXT_OFF:
bNoParSpace = sal_True; // der letzte PRE-Absatz muss einen Zeilenabstand bekommen
EndTxtFmtColl( HTML_PREFORMTXT_OFF );
break;
case HTML_LISTING_OFF:
case HTML_XMP_OFF:
EndTxtFmtColl( nToken );
break;
case HTML_HEAD1_ON:
case HTML_HEAD2_ON:
case HTML_HEAD3_ON:
case HTML_HEAD4_ON:
case HTML_HEAD5_ON:
case HTML_HEAD6_ON:
if( nOpenParaToken )
{
if( IsReadPRE() )
nOpenParaToken = 0;
else
EndPara();
}
NewHeading( nToken );
break;
case HTML_HEAD1_OFF:
case HTML_HEAD2_OFF:
case HTML_HEAD3_OFF:
case HTML_HEAD4_OFF:
case HTML_HEAD5_OFF:
case HTML_HEAD6_OFF:
EndHeading();
break;
case HTML_TABLE_ON:
if( pPendStack )
BuildTable( SVX_ADJUST_END );
else
{
if( nOpenParaToken )
EndPara();
ASSERT( !pTable, "Tabelle in Tabelle darf hier nicht vorkommen" );
if( !pTable && (IsNewDoc() || !pPam->GetNode()->FindTableNode()) &&
(pPam->GetPoint()->nNode.GetIndex() >
pDoc->GetNodes().GetEndOfExtras().GetIndex() ||
!pPam->GetNode()->FindFootnoteStartNode() ) )
{
if ( nParaCnt < 5 )
Show(); // bis hierhin schon mal anzeigen
SvxAdjust eAdjust = aAttrTab.pAdjust
? ((const SvxAdjustItem&)aAttrTab.pAdjust->GetItem()).
GetAdjust()
: SVX_ADJUST_END;
BuildTable( eAdjust );
}
else
bInsertUnknown = bKeepUnknown;
}
break;
// Listen
case HTML_DIRLIST_ON:
case HTML_MENULIST_ON:
case HTML_ORDERLIST_ON:
case HTML_UNORDERLIST_ON:
if( nOpenParaToken )
EndPara();
NewNumBulList( nToken );
break;
case HTML_DIRLIST_OFF:
case HTML_MENULIST_OFF:
case HTML_ORDERLIST_OFF:
case HTML_UNORDERLIST_OFF:
if( nOpenParaToken )
EndPara();
EndNumBulListItem( 0, sal_True, GetNumInfo().GetDepth()==1 );
EndNumBulList( nToken );
break;
case HTML_LI_ON:
case HTML_LISTHEADER_ON:
if( nOpenParaToken &&
(pPam->GetPoint()->nContent.GetIndex()
|| HTML_PARABREAK_ON==nOpenParaToken) )
{
// nure bei <P><LI> den Absatz beenden, aber nicht bei <DD><LI>
EndPara();
}
EndNumBulListItem( 0, sal_False );// <LI>/<LH> beenden und keine Vorl. setzen
NewNumBulListItem( nToken );
break;
case HTML_LI_OFF:
case HTML_LISTHEADER_OFF:
EndNumBulListItem( nToken, sal_False );
break;
// Attribute :
case HTML_ITALIC_ON:
{
SvxPostureItem aPosture( ITALIC_NORMAL, RES_CHRATR_POSTURE );
SvxPostureItem aPostureCJK( ITALIC_NORMAL, RES_CHRATR_CJK_POSTURE );
SvxPostureItem aPostureCTL( ITALIC_NORMAL, RES_CHRATR_CTL_POSTURE );
NewStdAttr( HTML_ITALIC_ON,
&aAttrTab.pItalic, aPosture,
&aAttrTab.pItalicCJK, &aPostureCJK,
&aAttrTab.pItalicCTL, &aPostureCTL );
}
break;
case HTML_BOLD_ON:
{
SvxWeightItem aWeight( WEIGHT_BOLD, RES_CHRATR_WEIGHT );
SvxWeightItem aWeightCJK( WEIGHT_BOLD, RES_CHRATR_CJK_WEIGHT );
SvxWeightItem aWeightCTL( WEIGHT_BOLD, RES_CHRATR_CTL_WEIGHT );
NewStdAttr( HTML_BOLD_ON,
&aAttrTab.pBold, aWeight,
&aAttrTab.pBoldCJK, &aWeightCJK,
&aAttrTab.pBoldCTL, &aWeightCTL );
}
break;
case HTML_STRIKE_ON:
case HTML_STRIKETHROUGH_ON:
{
NewStdAttr( HTML_STRIKE_ON, &aAttrTab.pStrike,
SvxCrossedOutItem(STRIKEOUT_SINGLE, RES_CHRATR_CROSSEDOUT) );
}
break;
case HTML_UNDERLINE_ON:
{
NewStdAttr( HTML_UNDERLINE_ON, &aAttrTab.pUnderline,
SvxUnderlineItem(UNDERLINE_SINGLE, RES_CHRATR_UNDERLINE) );
}
break;
case HTML_SUPERSCRIPT_ON:
{
NewStdAttr( HTML_SUPERSCRIPT_ON, &aAttrTab.pEscapement,
SvxEscapementItem(HTML_ESC_SUPER,HTML_ESC_PROP, RES_CHRATR_ESCAPEMENT) );
}
break;
case HTML_SUBSCRIPT_ON:
{
NewStdAttr( HTML_SUBSCRIPT_ON, &aAttrTab.pEscapement,
SvxEscapementItem(HTML_ESC_SUB,HTML_ESC_PROP, RES_CHRATR_ESCAPEMENT) );
}
break;
case HTML_BLINK_ON:
{
NewStdAttr( HTML_BLINK_ON, &aAttrTab.pBlink,
SvxBlinkItem( sal_True, RES_CHRATR_BLINK ) );
}
break;
case HTML_SPAN_ON:
NewStdAttr( HTML_SPAN_ON );
break;
case HTML_ITALIC_OFF:
case HTML_BOLD_OFF:
case HTML_STRIKE_OFF:
case HTML_UNDERLINE_OFF:
case HTML_SUPERSCRIPT_OFF:
case HTML_SUBSCRIPT_OFF:
case HTML_BLINK_OFF:
case HTML_SPAN_OFF:
EndTag( nToken );
break;
case HTML_STRIKETHROUGH_OFF:
EndTag( HTML_STRIKE_OFF );
break;
case HTML_BASEFONT_ON:
NewBasefontAttr();
break;
case HTML_BASEFONT_OFF:
EndBasefontAttr();
break;
case HTML_FONT_ON:
case HTML_BIGPRINT_ON:
case HTML_SMALLPRINT_ON:
NewFontAttr( nToken );
break;
case HTML_FONT_OFF:
case HTML_BIGPRINT_OFF:
case HTML_SMALLPRINT_OFF:
EndFontAttr( nToken );
break;
case HTML_EMPHASIS_ON:
case HTML_CITIATION_ON:
case HTML_STRONG_ON:
case HTML_CODE_ON:
case HTML_SAMPLE_ON:
case HTML_KEYBOARD_ON:
case HTML_VARIABLE_ON:
case HTML_DEFINSTANCE_ON:
case HTML_SHORTQUOTE_ON:
case HTML_LANGUAGE_ON:
case HTML_AUTHOR_ON:
case HTML_PERSON_ON:
case HTML_ACRONYM_ON:
case HTML_ABBREVIATION_ON:
case HTML_INSERTEDTEXT_ON:
case HTML_DELETEDTEXT_ON:
case HTML_TELETYPE_ON:
NewCharFmt( nToken );
break;
case HTML_SDFIELD_ON:
NewField();
bCallNextToken = bInField && pTable!=0;
break;
case HTML_EMPHASIS_OFF:
case HTML_CITIATION_OFF:
case HTML_STRONG_OFF:
case HTML_CODE_OFF:
case HTML_SAMPLE_OFF:
case HTML_KEYBOARD_OFF:
case HTML_VARIABLE_OFF:
case HTML_DEFINSTANCE_OFF:
case HTML_SHORTQUOTE_OFF:
case HTML_LANGUAGE_OFF:
case HTML_AUTHOR_OFF:
case HTML_PERSON_OFF:
case HTML_ACRONYM_OFF:
case HTML_ABBREVIATION_OFF:
case HTML_INSERTEDTEXT_OFF:
case HTML_DELETEDTEXT_OFF:
case HTML_TELETYPE_OFF:
EndTag( nToken );
break;
case HTML_HEAD_OFF:
if( aStyleSource.Len() )
{
pCSS1Parser->ParseStyleSheet( aStyleSource );
aStyleSource.Erase();
}
break;
case HTML_DOCTYPE:
case HTML_BODY_OFF:
case HTML_HTML_OFF:
case HTML_HEAD_ON:
case HTML_TITLE_OFF:
break; // nicht weiter auswerten, oder???
case HTML_HTML_ON:
{
const HTMLOptions *pHTMLOptions = GetOptions();
for( sal_uInt16 i = pHTMLOptions->Count(); i; )
{
const HTMLOption *pOption = (*pHTMLOptions)[ --i ];
if( HTML_O_DIR == pOption->GetToken() )
{
const String& rDir = pOption->GetString();
SfxItemSet aItemSet( pDoc->GetAttrPool(),
pCSS1Parser->GetWhichMap() );
SvxCSS1PropertyInfo aPropInfo;
String aDummy;
ParseStyleOptions( aDummy, aDummy, aDummy, aItemSet,
aPropInfo, 0, &rDir );
pCSS1Parser->SetPageDescAttrs( 0, &aItemSet );
break;
}
}
}
break;
case HTML_INPUT:
InsertInput();
break;
case HTML_TEXTAREA_ON:
NewTextArea();
bCallNextToken = bTextArea && pTable!=0;
break;
case HTML_SELECT_ON:
NewSelect();
bCallNextToken = bSelect && pTable!=0;
break;
case HTML_ANCHOR_ON:
NewAnchor();
break;
case HTML_ANCHOR_OFF:
EndAnchor();
break;
case HTML_COMMENT:
if( ( aToken.Len() > 5 ) && ( ! bIgnoreHTMLComments ) )
{
// als Post-It einfuegen
// MIB 8.12.2000: If there are no space characters right behind
// the <!-- and on front of the -->, leave the comment untouched.
if( ' ' == aToken.GetChar( 3 ) &&
' ' == aToken.GetChar( aToken.Len()-3 ) )
{
String aComment( aToken.Copy( 3, aToken.Len()-5 ) );
aComment.EraseLeadingChars().EraseTrailingChars();
InsertComment( aComment );
}
else
{
String aComment( '<' );
(aComment += aToken) += '>';
InsertComment( aComment );
}
}
break;
case HTML_MAP_ON:
// Image Maps werden asynchron gelesen: Zunaechst wird nur eine
// ImageMap angelegt. Die Bereiche kommen spaeter. Trozdem wird
// die ImageMap schon in das IMap-Array eingetragen, denn sie
// koennte ja schon verwendet werden.
pImageMap = new ImageMap;
if( ParseMapOptions( pImageMap) )
{
if( !pImageMaps )
pImageMaps = new ImageMaps;
pImageMaps->Insert( pImageMap, pImageMaps->Count() );
}
else
{
delete pImageMap;
pImageMap = 0;
}
break;
case HTML_MAP_OFF:
// jetzt gibt es keine ImageMap mehr (IMap nicht Loeschen, denn
// die stckt ja schon in dem Array!)
pImageMap = 0;
break;
case HTML_AREA:
if( pImageMap )
ParseAreaOptions( pImageMap, sBaseURL, SFX_EVENT_MOUSEOVER_OBJECT,
SFX_EVENT_MOUSEOUT_OBJECT );
break;
case HTML_FRAMESET_ON:
bInsertUnknown = bKeepUnknown;
break;
case HTML_NOFRAMES_ON:
if( IsInHeader() )
FinishHeader( sal_True );
bInsertUnknown = bKeepUnknown;
break;
case HTML_UNKNOWNCONTROL_ON:
// Im Header muss der Inhalt von unbekannten Token ignoriert werden,
// es sei denn, das Token faengt mit einem '!' an.
if( IsInHeader() && !IsReadPRE() && !aUnknownToken.Len() &&
sSaveToken.Len() && '!' != sSaveToken.GetChar(0) &&
'%' != sSaveToken.GetChar(0) )
aUnknownToken = sSaveToken;
// kein break
default:
bInsertUnknown = bKeepUnknown;
break;
}
if( bGetIDOption )
InsertIDOption();
if( bInsertUnknown )
{
String aComment(
String::CreateFromAscii(TOOLS_CONSTASCII_STRINGPARAM("HTML: <")) );
if( (HTML_TOKEN_ONOFF & nToken) != 0 && (1 & nToken) != 0 )
aComment += '/';
aComment += sSaveToken;
if( aToken.Len() )
{
UnescapeToken();
(aComment += ' ') += aToken;
}
aComment += '>';
InsertComment( aComment );
}
// wenn es noch vorlaefige Absatz-Attribute gibt, der Absatz aber
// nicht leer ist, dann sind die Absatz-Attribute entgueltig.
if( aParaAttrs.Count() && pPam->GetPoint()->nContent.GetIndex() )
aParaAttrs.Remove( 0, aParaAttrs.Count() );
}
/* */
extern sal_Bool lcl_css1atr_equalFontItems( const SfxPoolItem& r1, const SfxPoolItem& r2 );
void lcl_swhtml_getItemInfo( const _HTMLAttr& rAttr,
sal_Bool& rScriptDependent, sal_Bool& rFont,
sal_uInt16& rScriptType )
{
sal_uInt16 nWhich = rAttr.GetItem().Which();
switch( nWhich )
{
case RES_CHRATR_FONT:
rFont = sal_True;
case RES_CHRATR_FONTSIZE:
case RES_CHRATR_LANGUAGE:
case RES_CHRATR_POSTURE:
case RES_CHRATR_WEIGHT:
rScriptType = i18n::ScriptType::LATIN;
rScriptDependent = sal_True;
break;
case RES_CHRATR_CJK_FONT:
rFont = sal_True;
case RES_CHRATR_CJK_FONTSIZE:
case RES_CHRATR_CJK_LANGUAGE:
case RES_CHRATR_CJK_POSTURE:
case RES_CHRATR_CJK_WEIGHT:
rScriptType = i18n::ScriptType::ASIAN;
rScriptDependent = sal_True;
break;
case RES_CHRATR_CTL_FONT:
rFont = sal_True;
case RES_CHRATR_CTL_FONTSIZE:
case RES_CHRATR_CTL_LANGUAGE:
case RES_CHRATR_CTL_POSTURE:
case RES_CHRATR_CTL_WEIGHT:
rScriptType = i18n::ScriptType::COMPLEX;
rScriptDependent = sal_True;
break;
default:
rScriptDependent = sal_False;
rFont = sal_False;
break;
}
}
sal_Bool SwHTMLParser::AppendTxtNode( SwHTMLAppendMode eMode, sal_Bool bUpdateNum )
{
// Ein harter Zeilen-Umbruch am Ende muss immer entfernt werden.
// Einen zweiten ersetzen wir durch einen Absatz-Abstand.
xub_StrLen nLFStripped = StripTrailingLF();
if( (AM_NOSPACE==eMode || AM_SOFTNOSPACE==eMode) && nLFStripped > 1 )
eMode = AM_SPACE;
// die harten Attribute an diesem Absatz werden nie mehr ungueltig
if( aParaAttrs.Count() )
aParaAttrs.Remove( 0, aParaAttrs.Count() );
if( AM_SPACE==eMode || AM_NOSPACE==eMode )
{
SwTxtNode *pTxtNode =
pPam->GetPoint()->nNode.GetNode().GetTxtNode();
const SvxULSpaceItem& rULSpace =
(const SvxULSpaceItem&)pTxtNode->SwCntntNode::GetAttr( RES_UL_SPACE );
sal_Bool bChange = AM_NOSPACE==eMode ? rULSpace.GetLower() > 0
: rULSpace.GetLower() == 0;
if( bChange )
{
const SvxULSpaceItem& rCollULSpace =
pTxtNode->GetAnyFmtColl().GetULSpace();
sal_Bool bMayReset = AM_NOSPACE==eMode ? rCollULSpace.GetLower() == 0
: rCollULSpace.GetLower() > 0;
if( bMayReset &&
rCollULSpace.GetUpper() == rULSpace.GetUpper() )
{
pTxtNode->ResetAttr( RES_UL_SPACE );
}
else
{
pTxtNode->SetAttr(
SvxULSpaceItem( rULSpace.GetUpper(),
AM_NOSPACE==eMode ? 0 : HTML_PARSPACE, RES_UL_SPACE ) );
}
}
}
bNoParSpace = AM_NOSPACE==eMode || AM_SOFTNOSPACE==eMode;
SwPosition aOldPos( *pPam->GetPoint() );
sal_Bool bRet = pDoc->AppendTxtNode( *pPam->GetPoint() );
// Zeichen-Attribute aufspalten und ggf keine setzen, die ueber den
// ganzen Absatz gesetzt sind
const SwNodeIndex& rEndIdx = aOldPos.nNode;
xub_StrLen nEndCnt = aOldPos.nContent.GetIndex();
const SwPosition& rPos = *pPam->GetPoint();
_HTMLAttr** pTbl = (_HTMLAttr**)&aAttrTab;
for( sal_uInt16 nCnt = sizeof( _HTMLAttrTable ) / sizeof( _HTMLAttr* );
nCnt--; ++pTbl )
{
_HTMLAttr *pAttr = *pTbl;
if( pAttr && pAttr->GetItem().Which() < RES_PARATR_BEGIN )
{
sal_Bool bWholePara = sal_False;
while( pAttr )
{
_HTMLAttr *pNext = pAttr->GetNext();
if( pAttr->GetSttParaIdx() < rEndIdx.GetIndex() ||
(!bWholePara &&
pAttr->GetSttPara() == rEndIdx &&
pAttr->GetSttCnt() != nEndCnt) )
{
bWholePara =
pAttr->GetSttPara() == rEndIdx &&
pAttr->GetSttCnt() == 0;
xub_StrLen nStt = pAttr->nSttCntnt;
sal_Bool bScript = sal_False, bFont = sal_False;
sal_uInt16 nScriptItem;
sal_Bool bInsert = sal_True;
lcl_swhtml_getItemInfo( *pAttr, bScript, bFont,
nScriptItem );
// den besehrigen Teil setzen
if( bInsert && bScript )
{
const SwTxtNode *pTxtNd =
pAttr->GetSttPara().GetNode().GetTxtNode();
ASSERT( pTxtNd, "No text node" );
if( pTxtNd )
{
const String& rText = pTxtNd->GetTxt();
sal_uInt16 nScriptTxt =
pBreakIt->GetBreakIter()->getScriptType(
rText, pAttr->GetSttCnt() );
xub_StrLen nScriptEnd = (xub_StrLen)pBreakIt->GetBreakIter()
->endOfScript( rText, nStt, nScriptTxt );
while( nScriptEnd < nEndCnt )
{
if( nScriptItem == nScriptTxt )
{
_HTMLAttr *pSetAttr =
pAttr->Clone( rEndIdx, nScriptEnd );
pSetAttr->nSttCntnt = nStt;
pSetAttr->ClearPrev();
if( !pNext || bWholePara )
{
sal_uInt16 nTmp = pSetAttr->bInsAtStart ? 0
: aSetAttrTab.Count();
aSetAttrTab.Insert( pSetAttr, nTmp );
}
else
pNext->InsertPrev( pSetAttr );
}
nStt = nScriptEnd;
nScriptTxt = pBreakIt->GetBreakIter()->getScriptType(
rText, nStt );
nScriptEnd = (xub_StrLen)pBreakIt->GetBreakIter()
->endOfScript( rText, nStt, nScriptTxt );
}
bInsert = nScriptItem == nScriptTxt;
}
}
if( bInsert )
{
_HTMLAttr *pSetAttr =
pAttr->Clone( rEndIdx, nEndCnt );
pSetAttr->nSttCntnt = nStt;
// Wenn das Attribut den gesamten Absatz umspannt, werden
// alle auesseren Attribute nicht mehr beachtet. Deshalb
// darf es auch nicht in die Prev-Liste eines ausseren
// Attributs eingetragen werden, denn dieses wird ja
// erstmal nicht gesetzt. Das fuehrt zu verschiebenungen,
// wenn Felder ins Rennen kommen (siehe #51020#)
if( !pNext || bWholePara )
{
sal_uInt16 nTmp = pSetAttr->bInsAtStart ? 0
: aSetAttrTab.Count();
aSetAttrTab.Insert( pSetAttr, nTmp );
}
else
pNext->InsertPrev( pSetAttr );
}
else
{
_HTMLAttr *pPrev = pAttr->GetPrev();
if( pPrev )
{
// Die Previous-Attribute muessen trotzdem gesetzt werden.
if( !pNext || bWholePara )
{
sal_uInt16 nTmp = pPrev->bInsAtStart ? 0 : aSetAttrTab.Count();
aSetAttrTab.Insert( pPrev, nTmp );
}
else
pNext->InsertPrev( pPrev );
}
}
pAttr->ClearPrev();
}
pAttr->SetStart( rPos );
pAttr = pNext;
}
}
}
if( bUpdateNum )
{
if( GetNumInfo().GetDepth() )
{
sal_uInt8 nLvl = GetNumInfo().GetLevel();
SetNodeNum( nLvl, false );
}
else
pPam->GetNode()->GetTxtNode()->ResetAttr( RES_PARATR_NUMRULE );
}
// Attrubute im Absatz davor sollte man jetzt setzen (wegen JavaScript)
SetAttr();
// Now it is time to get rid of all script dependent hints that are
// equal to the settings in the style
SwTxtNode *pTxtNd = rEndIdx.GetNode().GetTxtNode();
ASSERT( pTxtNd, "There is the txt node" );
sal_uInt16 nCntAttr = (pTxtNd && pTxtNd->GetpSwpHints())
? pTxtNd->GetSwpHints().Count() : 0;
if( nCntAttr )
{
// These are the end position of all script depenent hints.
// If we find a hint that starts before the current end position,
// we have to set it. If we finf a hint that start behind or at
// that position, we have to take the hint's value into account.
// If it is equal to the style, or in fact the paragarph's value
// for that hint, the hint is removed. Otherwise it's end position
// is remembered.
xub_StrLen aEndPos[15] =
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
SwpHints& rHints = pTxtNd->GetSwpHints();
for( sal_uInt16 i=0; i < nCntAttr; i++ )
{
SwTxtAttr *pHt = rHints.GetTextHint( i );
sal_uInt16 nWhich = pHt->Which();
sal_Int16 nIdx = -1;
if( RES_CHRATR_CJK_FONT <= nWhich &&
nWhich <= RES_CHRATR_CTL_WEIGHT )
{
nIdx = static_cast< sal_uInt16 >(nWhich - RES_CHRATR_CJK_FONT + 5);
}
else switch( nWhich )
{
case RES_CHRATR_FONT: nIdx = 0; break;
case RES_CHRATR_FONTSIZE: nIdx = 1; break;
case RES_CHRATR_LANGUAGE: nIdx = 2; break;
case RES_CHRATR_POSTURE: nIdx = 3; break;
case RES_CHRATR_WEIGHT: nIdx = 4; break;
}
if( nIdx != -1 )
{
xub_StrLen nStt = *pHt->GetStart();
if( nStt >= aEndPos[nIdx] )
{
sal_Bool bFont = (nIdx % 5) == 0;
const SfxPoolItem& rItem =
((const SwCntntNode *)pTxtNd)->GetAttr( nWhich );
if( bFont ? lcl_css1atr_equalFontItems(rItem,pHt->GetAttr())
: rItem == pHt->GetAttr() )
{
// The hint is the same as set in the paragraph and
// therfor, it can be deleted
// CAUTION!!! This WILL delete the hint and it MAY
// also delete the SwpHints!!! To avoid any trouble
// we leave the loop immediately if this is the last
// hint.
pTxtNd->DeleteAttribute( pHt );
if( 1 == nCntAttr )
break;
i--;
nCntAttr--;
}
else
{
// The hint is deifferent. Therfor all hints within that
// hint have to be ignored.
aEndPos[nIdx] = pHt->GetEnd() ? *pHt->GetEnd() : nStt;
}
}
else
{
// The hint starts before another one ends.
// The hint in this case is not deleted
ASSERT( pHt->GetEnd() && *pHt->GetEnd() <= aEndPos[nIdx],
"hints aren't nested properly!" );
}
}
}
}
if( !pTable && !--nParaCnt )
Show();
return bRet;
}
void SwHTMLParser::AddParSpace()
{
if( !bNoParSpace )
return;
bNoParSpace = sal_False;
sal_uLong nNdIdx = pPam->GetPoint()->nNode.GetIndex() - 1;
SwTxtNode *pTxtNode = pDoc->GetNodes()[nNdIdx]->GetTxtNode();
if( !pTxtNode )
return;
SvxULSpaceItem rULSpace =
(const SvxULSpaceItem&)pTxtNode->SwCntntNode::GetAttr( RES_UL_SPACE );
if( !rULSpace.GetLower() )
{
const SvxULSpaceItem& rCollULSpace =
pTxtNode->GetAnyFmtColl().GetULSpace();
if( rCollULSpace.GetLower() &&
rCollULSpace.GetUpper() == rULSpace.GetUpper() )
{
pTxtNode->ResetAttr( RES_UL_SPACE );
}
else
{
pTxtNode->SetAttr(
SvxULSpaceItem( rULSpace.GetUpper(), HTML_PARSPACE, RES_UL_SPACE ) );
}
}
}
void SwHTMLParser::Show()
{
// Hier wird
// - ein EndAction gerufen, damit formatiert wird
// - ein Reschedule gerufen,
// - die eiegen View-Shell wieder gesetzt
// - und Start-Action gerufen
ASSERT( SVPAR_WORKING==eState, "Show nicht im Working-State - Das kann ins Auge gehen" );
ViewShell *pOldVSh = CallEndAction();
GetpApp()->Reschedule();
if( ( pDoc->GetDocShell() && pDoc->GetDocShell()->IsAbortingImport() )
|| 1 == pDoc->getReferenceCount() )
{
// wurde der Import vom SFX abgebrochen?
eState = SVPAR_ERROR;
}
// Die ViewShell nochmal holen, denn sie koennte im Reschedule
// zerstoert wirden sein.
ViewShell *pVSh = CallStartAction( pOldVSh );
// ist der aktuelle Node nicht mehr sichtbar, dann benutzen wir
// eine groessere Schrittweite
if( pVSh )
{
nParaCnt = (pPam->GetPoint()->nNode.GetNode().IsInVisibleArea(pVSh))
? 5 : 50;
}
}
void SwHTMLParser::ShowStatline()
{
// Hier wird
// - ein Reschedule gerufen, damit gescrollt werden kann
// - die eiegen View-Shell wieder gesetzt
// - ein Start/End-Action gerufen, wenn gescrollt wurde.
ASSERT( SVPAR_WORKING==eState, "ShowStatLine nicht im Working-State - Das kann ins Auge gehen" );
// Laufbalkenanzeige
if( !GetMedium() || !GetMedium()->IsRemote() )
{
::SetProgressState( rInput.Tell(), pDoc->GetDocShell() );
CheckActionViewShell();
}
else
{
GetpApp()->Reschedule();
if( ( pDoc->GetDocShell() && pDoc->GetDocShell()->IsAbortingImport() )
|| 1 == pDoc->getReferenceCount() )
// wurde der Import vom SFX abgebrochen?
eState = SVPAR_ERROR;
ViewShell *pVSh = CheckActionViewShell();
if( pVSh && pVSh->HasInvalidRect() )
{
CallEndAction( sal_False, sal_False );
CallStartAction( pVSh, sal_False );
}
}
}
ViewShell *SwHTMLParser::CallStartAction( ViewShell *pVSh, sal_Bool bChkPtr )
{
ASSERT( !pActionViewShell, "CallStartAction: ViewShell schon gesetzt" );
if( !pVSh || bChkPtr )
{
#ifdef DBG_UTIL
ViewShell *pOldVSh = pVSh;
#endif
pDoc->GetEditShell( &pVSh );
ASSERT( !pVSh || !pOldVSh || pOldVSh == pVSh, "CallStartAction: Wer hat die ViewShell ausgetauscht?" );
#ifdef DBG_UTIL
if( pOldVSh && !pVSh )
pVSh = 0;
#endif
}
pActionViewShell = pVSh;
if( pActionViewShell )
{
if( pActionViewShell->ISA( SwEditShell ) )
((SwEditShell*)pActionViewShell)->StartAction();
else
pActionViewShell->StartAction();
}
return pActionViewShell;
}
ViewShell *SwHTMLParser::CallEndAction( sal_Bool bChkAction, sal_Bool bChkPtr )
{
if( bChkPtr )
{
ViewShell *pVSh = 0;
pDoc->GetEditShell( &pVSh );
ASSERT( !pVSh || pActionViewShell == pVSh,
"CallEndAction: Wer hat die ViewShell ausgetauscht?" );
#if OSL_DEBUG_LEVEL > 1
if( pActionViewShell && !pVSh )
pVSh = 0;
#endif
if( pVSh != pActionViewShell )
pActionViewShell = 0;
}
if( !pActionViewShell || (bChkAction && !pActionViewShell->ActionPend()) )
return pActionViewShell;
if( bSetCrsr )
{
// an allen CrsrEditShells die Cursor auf den Doc-Anfang setzen
ViewShell *pSh = pActionViewShell;
do {
if( pSh->IsA( TYPE( SwCrsrShell ) ) )
((SwCrsrShell*)pSh)->SttEndDoc(sal_True);
pSh = (ViewShell *)pSh->GetNext();
} while( pSh != pActionViewShell );
bSetCrsr = sal_False;
}
if( pActionViewShell->ISA( SwEditShell ) )
{
//Schon gescrollt?, dann dafuer sorgen, dass die View sich nicht bewegt!
const sal_Bool bOldLock = pActionViewShell->IsViewLocked();
pActionViewShell->LockView( sal_True );
const sal_Bool bOldEndActionByVirDev = pActionViewShell->IsEndActionByVirDev();
pActionViewShell->SetEndActionByVirDev( sal_True );;
((SwEditShell*)pActionViewShell)->EndAction();
pActionViewShell->SetEndActionByVirDev( bOldEndActionByVirDev );
pActionViewShell->LockView( bOldLock );
// bChkJumpMark ist nur gesetzt, wenn das Object auch gefunden wurde
if( bChkJumpMark )
{
const Point aVisSttPos( DOCUMENTBORDER, DOCUMENTBORDER );
if( GetMedium() && aVisSttPos == pActionViewShell->VisArea().Pos() )
::JumpToSwMark( pActionViewShell,
GetMedium()->GetURLObject().GetMark() );
bChkJumpMark = sal_False;
}
}
else
pActionViewShell->EndAction();
// sollte der Parser der Letzte sein, der das Doc haelt, dann kann
// man hier abbrechen und einen Fehler setzen.
if( 1 == pDoc->getReferenceCount() )
{
eState = SVPAR_ERROR;
}
ViewShell *pVSh = pActionViewShell;
pActionViewShell = 0;
return pVSh;
}
ViewShell *SwHTMLParser::CheckActionViewShell()
{
ViewShell *pVSh = 0;
pDoc->GetEditShell( &pVSh );
ASSERT( !pVSh || pActionViewShell == pVSh,
"CheckActionViewShell: Wer hat die ViewShell ausgetauscht?" );
#if OSL_DEBUG_LEVEL > 1
if( pActionViewShell && !pVSh )
pVSh = 0;
#endif
if( pVSh != pActionViewShell )
pActionViewShell = 0;
return pActionViewShell;
}
/* */
void SwHTMLParser::_SetAttr( sal_Bool bChkEnd, sal_Bool bBeforeTable,
_HTMLAttrs *pPostIts )
{
SwPaM* pAttrPam = new SwPaM( *pPam->GetPoint() );
const SwNodeIndex& rEndIdx = pPam->GetPoint()->nNode;
xub_StrLen nEndCnt = pPam->GetPoint()->nContent.GetIndex();
_HTMLAttr* pAttr;
SwCntntNode* pCNd;
sal_uInt16 n;
_HTMLAttrs aFields( 5, 5 );
for( n = aSetAttrTab.Count(); n; )
{
pAttr = aSetAttrTab[ --n ];
sal_uInt16 nWhich = pAttr->pItem->Which();
sal_uLong nEndParaIdx = pAttr->GetEndParaIdx();
sal_Bool bSetAttr;
if( bChkEnd )
{
// fix #42192#: Zechen-Attribute mit Ende moeglich frueh,
// also noch im aktuellen Absatz setzen (wegen JavaScript
// und diversen Chats). das darf man aber nicht fuer Attribute,
// die ueber den ganzen Absatz aufgspannt werden sollen, weil
// sie aus Absatzvorlgen stammen, die nicht gesetzt werden
// koennen. Weil die Attribute mit SETATTR_DONTREPLACE
// eingefuegt werden, sollte man sie auch anchtraeglich
// noch setzen koennen.
bSetAttr = ( nEndParaIdx < rEndIdx.GetIndex() &&
(RES_LR_SPACE != nWhich || !GetNumInfo().GetNumRule()) ) ||
( !pAttr->IsLikePara() &&
nEndParaIdx == rEndIdx.GetIndex() &&
pAttr->GetEndCnt() < nEndCnt &&
(isCHRATR(nWhich) || isTXTATR_WITHEND(nWhich)) ) ||
( bBeforeTable &&
nEndParaIdx == rEndIdx.GetIndex() &&
!pAttr->GetEndCnt() );
}
else
{
// Attribiute im Content-Bereich duerfen nicht gesetzt
// werden, wenn wir in einem Sonderbereich stehen, aber
// umgekekehrt schon.
sal_uLong nEndOfIcons = pDoc->GetNodes().GetEndOfExtras().GetIndex();
bSetAttr = nEndParaIdx < rEndIdx.GetIndex() ||
rEndIdx.GetIndex() > nEndOfIcons ||
nEndParaIdx <= nEndOfIcons;
}
if( bSetAttr )
{
// Das Attribute darf nicht in der liste der vorlaeufigen
// Absatz-Attribute stehen, weil es sonst geloescht wurde.
sal_uInt16 ii = aParaAttrs.Count();
while( ii-- )
{
ASSERT( pAttr != aParaAttrs[ii],
"SetAttr: Attribut duerfte noch nicht gesetzt werden" );
aParaAttrs.Remove( ii );
}
// dann also setzen
aSetAttrTab.Remove( n, 1 );
while( pAttr )
{
_HTMLAttr *pPrev = pAttr->GetPrev();
if( !pAttr->bValid )
{
// ungueltige Attribute koennen gloescht werden
delete pAttr;
pAttr = pPrev;
continue; //break;
}
pCNd = pAttr->nSttPara.GetNode().GetCntntNode();
if( !pCNd )
{
// durch die elende Loescherei von Nodes kann auch mal
// ein Index auf einen End-Node zeigen :-(
if ( (pAttr->GetSttPara() == pAttr->GetEndPara()) &&
!isTXTATR_NOEND(nWhich) )
{
// wenn der End-Index auch auf den Node zeigt
// brauchen wir auch kein Attribut mehr zu setzen,
// es sei denn, es ist ein Text-Attribut.
delete pAttr;
pAttr = pPrev;
continue; //break;
}
pCNd = pDoc->GetNodes().GoNext( &(pAttr->nSttPara) );
if( pCNd )
pAttr->nSttCntnt = 0;
else
{
ASSERT( !this, "SetAttr: GoNext() failed!" );
delete pAttr;
pAttr = pPrev;
continue; // break;
}
}
pAttrPam->GetPoint()->nNode = pAttr->nSttPara;
// durch das Loeschen von BRs kann der Start-Index
// auch mal hinter das Ende des Textes zeigen
if( pAttr->nSttCntnt > pCNd->Len() )
pAttr->nSttCntnt = pCNd->Len();
pAttrPam->GetPoint()->nContent.Assign( pCNd, pAttr->nSttCntnt );
pAttrPam->SetMark();
if ( (pAttr->GetSttPara() != pAttr->GetEndPara()) &&
!isTXTATR_NOEND(nWhich) )
{
pCNd = pAttr->nEndPara.GetNode().GetCntntNode();
if( !pCNd )
{
pCNd = pDoc->GetNodes().GoPrevious( &(pAttr->nEndPara) );
if( pCNd )
pAttr->nEndCntnt = pCNd->Len();
else
{
ASSERT( !this, "SetAttr: GoPrevious() failed!" );
pAttrPam->DeleteMark();
delete pAttr;
pAttr = pPrev;
continue; // break;
}
}
pAttrPam->GetPoint()->nNode = pAttr->nEndPara;
}
else if( pAttr->IsLikePara() )
{
pAttr->nEndCntnt = pCNd->Len();
}
// durch das Loeschen von BRs kann der End-Index
// auch mal hinter das Ende des Textes zeigen
if( pAttr->nEndCntnt > pCNd->Len() )
pAttr->nEndCntnt = pCNd->Len();
pAttrPam->GetPoint()->nContent.Assign( pCNd, pAttr->nEndCntnt );
if( bBeforeTable &&
pAttrPam->GetPoint()->nNode.GetIndex() ==
rEndIdx.GetIndex() )
{
// wenn wir vor dem Einfuegen einer Tabelle stehen
// und das Attribut im aktuellen Node beendet wird,
// muessen wir es im Node davor beenden oder wegschmeissen,
// wenn es erst in dem Node beginnt
if( nWhich != RES_BREAK && nWhich != RES_PAGEDESC &&
!isTXTATR_NOEND(nWhich) )
{
if( pAttrPam->GetMark()->nNode.GetIndex() !=
rEndIdx.GetIndex() )
{
ASSERT( !pAttrPam->GetPoint()->nContent.GetIndex(),
"Content-Position vor Tabelle nicht 0???" );
pAttrPam->Move( fnMoveBackward );
}
else
{
pAttrPam->DeleteMark();
delete pAttr;
pAttr = pPrev;
continue;
}
}
}
switch( nWhich )
{
case RES_FLTR_BOOKMARK: // insert bookmark
{
const String sName( ((SfxStringItem*)pAttr->pItem)->GetValue() );
IDocumentMarkAccess* const pMarkAccess = pDoc->getIDocumentMarkAccess();
IDocumentMarkAccess::const_iterator_t ppBkmk = pMarkAccess->findMark( sName );
if( ppBkmk != pMarkAccess->getAllMarksEnd() &&
ppBkmk->get()->GetMarkStart() == *pAttrPam->GetPoint() )
break; // do not generate duplicates on this position
pAttrPam->DeleteMark();
const ::sw::mark::IMark* const pNewMark = pMarkAccess->makeMark(
*pAttrPam,
sName,
IDocumentMarkAccess::BOOKMARK );
// jump to bookmark
if( JUMPTO_MARK == eJumpTo && pNewMark->GetName() == ::rtl::OUString(sJmpMark) )
{
bChkJumpMark = sal_True;
eJumpTo = JUMPTO_NONE;
}
}
break;
case RES_TXTATR_FIELD:
case RES_TXTATR_ANNOTATION:
case RES_TXTATR_INPUTFIELD:
{
sal_uInt16 nFldWhich =
pPostIts
? ((const SwFmtFld *)pAttr->pItem)->GetField()->GetTyp()->Which()
: 0;
if( pPostIts && (RES_POSTITFLD == nFldWhich ||
RES_SCRIPTFLD == nFldWhich) )
{
pPostIts->Insert( pAttr, 0 );
}
else
{
aFields.Insert( pAttr, aFields.Count() );
}
}
pAttrPam->DeleteMark();
pAttr = pPrev;
continue;
case RES_LR_SPACE:
if( pAttrPam->GetPoint()->nNode.GetIndex() ==
pAttrPam->GetMark()->nNode.GetIndex() &&
pCNd )
{
// wegen Numerierungen dieses Attribut direkt
// am Node setzen
pCNd->SetAttr( *pAttr->pItem );
break;
}
ASSERT( !this,
"LRSpace ueber mehrere Absaetze gesetzt!" );
// kein break (hier sollen wir trotzdem nie hinkommen;
default:
// ggfs. ein Bookmark anspringen
if( RES_TXTATR_INETFMT == nWhich &&
JUMPTO_MARK == eJumpTo &&
sJmpMark == ((SwFmtINetFmt*)pAttr->pItem)->GetName() )
{
bChkJumpMark = sal_True;
eJumpTo = JUMPTO_NONE;
}
pDoc->InsertPoolItem( *pAttrPam, *pAttr->pItem, nsSetAttrMode::SETATTR_DONTREPLACE );
}
pAttrPam->DeleteMark();
delete pAttr;
pAttr = pPrev;
}
}
}
for( n = aMoveFlyFrms.Count(); n; )
{
SwFrmFmt *pFrmFmt = aMoveFlyFrms[ --n ];
const SwFmtAnchor& rAnchor = pFrmFmt->GetAnchor();
ASSERT( FLY_AT_PARA == rAnchor.GetAnchorId(),
"Nur Auto-Rahmen brauchen eine Spezialbehandlung" );
const SwPosition *pFlyPos = rAnchor.GetCntntAnchor();
sal_uLong nFlyParaIdx = pFlyPos->nNode.GetIndex();
sal_Bool bMoveFly;
if( bChkEnd )
{
bMoveFly = nFlyParaIdx < rEndIdx.GetIndex() ||
( nFlyParaIdx == rEndIdx.GetIndex() &&
aMoveFlyCnts[n] < nEndCnt );
}
else
{
sal_uLong nEndOfIcons = pDoc->GetNodes().GetEndOfExtras().GetIndex();
bMoveFly = nFlyParaIdx < rEndIdx.GetIndex() ||
rEndIdx.GetIndex() > nEndOfIcons ||
nFlyParaIdx <= nEndOfIcons;
}
if( bMoveFly )
{
pFrmFmt->DelFrms();
*pAttrPam->GetPoint() = *pFlyPos;
pAttrPam->GetPoint()->nContent.Assign( pAttrPam->GetCntntNode(),
aMoveFlyCnts[n] );
SwFmtAnchor aAnchor( rAnchor );
aAnchor.SetType( FLY_AT_CHAR );
aAnchor.SetAnchor( pAttrPam->GetPoint() );
pFrmFmt->SetFmtAttr( aAnchor );
const SwFmtHoriOrient& rHoriOri = pFrmFmt->GetHoriOrient();
if( text::HoriOrientation::LEFT == rHoriOri.GetHoriOrient() )
{
SwFmtHoriOrient aHoriOri( rHoriOri );
aHoriOri.SetRelationOrient( text::RelOrientation::CHAR );
pFrmFmt->SetFmtAttr( aHoriOri );
}
const SwFmtVertOrient& rVertOri = pFrmFmt->GetVertOrient();
if( text::VertOrientation::TOP == rVertOri.GetVertOrient() )
{
SwFmtVertOrient aVertOri( rVertOri );
aVertOri.SetRelationOrient( text::RelOrientation::CHAR );
pFrmFmt->SetFmtAttr( aVertOri );
}
pFrmFmt->MakeFrms();
aMoveFlyFrms.Remove( n, 1 );
aMoveFlyCnts.erase( aMoveFlyCnts.begin() + n );
}
}
while( aFields.Count() )
{
pAttr = aFields[0];
pCNd = pAttr->nSttPara.GetNode().GetCntntNode();
pAttrPam->GetPoint()->nNode = pAttr->nSttPara;
pAttrPam->GetPoint()->nContent.Assign( pCNd, pAttr->nSttCntnt );
if( bBeforeTable &&
pAttrPam->GetPoint()->nNode.GetIndex() == rEndIdx.GetIndex() )
{
ASSERT( !bBeforeTable, "Aha, der Fall tritt also doch ein" );
ASSERT( !pAttrPam->GetPoint()->nContent.GetIndex(),
"Content-Position vor Tabelle nicht 0???" );
// !!!
pAttrPam->Move( fnMoveBackward );
}
pDoc->InsertPoolItem( *pAttrPam, *pAttr->pItem, 0 );
aFields.Remove( 0, 1 );
delete pAttr;
}
delete pAttrPam;
}
void SwHTMLParser::NewAttr( _HTMLAttr **ppAttr, const SfxPoolItem& rItem )
{
// Font-Hoehen und -Farben- sowie Escapement-Attribute duerfen nicht
// zusammengefasst werden. Sie werden deshalb in einer Liste gespeichert,
// in der das zuletzt aufgespannte Attribut vorne steht und der Count
// immer 1 ist. Fuer alle anderen Attribute wird der Count einfach
// hochgezaehlt.
if( *ppAttr )
{
_HTMLAttr *pAttr = new _HTMLAttr( *pPam->GetPoint(), rItem,
ppAttr );
pAttr->InsertNext( *ppAttr );
(*ppAttr) = pAttr;
}
else
(*ppAttr) = new _HTMLAttr( *pPam->GetPoint(), rItem, ppAttr );
}
void SwHTMLParser::EndAttr( _HTMLAttr* pAttr, _HTMLAttr **ppDepAttr,
sal_Bool bChkEmpty )
{
ASSERT( !ppDepAttr, "SwHTMLParser::EndAttr: ppDepAttr-Feature ungetestet?" );
// Der Listenkopf ist im Attribut gespeichert
_HTMLAttr **ppHead = pAttr->ppHead;
ASSERT( ppHead, "keinen Attributs-Listenkopf gefunden!" );
// die aktuelle Psoition als Ende-Position merken
const SwNodeIndex* pEndIdx = &pPam->GetPoint()->nNode;
xub_StrLen nEndCnt = pPam->GetPoint()->nContent.GetIndex();
// WIrd das zueltzt gestartete oder ein frueher gestartetes Attribut
// beendet?
_HTMLAttr *pLast = 0;
if( ppHead && pAttr != *ppHead )
{
// Es wird nicht das zuletzt gestartete Attribut beendet
// Dann suche wir das unmittelbar danach gestartete Attribut, das
// ja ebenfalls noch nicht beendet wurde (sonst stuende es nicht
// mehr in der Liste
pLast = *ppHead;
while( pLast && pLast->GetNext() != pAttr )
pLast = pLast->GetNext();
ASSERT( pLast, "Attribut nicht in eigener Liste gefunden!" );
// das Attribut nicht an der PaM-Psoition beenden, sondern da,
// wo das danch gestartete Attribut anfing???
//pEndIdx = &pPrev->GetSttPara();
//nEndCnt = pPrev->GetSttCnt();
}
sal_Bool bMoveBack = sal_False;
sal_uInt16 nWhich = pAttr->pItem->Which();
if( /*!pLast &&*/ !nEndCnt && RES_PARATR_BEGIN <= nWhich &&
*pEndIdx != pAttr->GetSttPara() )
{
// dann eine Cntntnt Position zurueck!
bMoveBack = pPam->Move( fnMoveBackward );
nEndCnt = pPam->GetPoint()->nContent.GetIndex();
}
// nun das Attrubut beenden
_HTMLAttr *pNext = pAttr->GetNext();
sal_Bool bInsert;
sal_uInt16 nScriptItem = 0;
sal_Bool bScript = sal_False, bFont = sal_False;
// ein Bereich ??
if( !bChkEmpty || (RES_PARATR_BEGIN <= nWhich && bMoveBack) ||
RES_PAGEDESC == nWhich || RES_BREAK == nWhich ||
*pEndIdx != pAttr->GetSttPara() ||
nEndCnt != pAttr->GetSttCnt() )
{
bInsert = sal_True;
// We do some optimization for script depenedent attribtes here.
if( *pEndIdx == pAttr->GetSttPara() )
{
lcl_swhtml_getItemInfo( *pAttr, bScript, bFont, nScriptItem );
}
}
else
{
bInsert = sal_False;
}
if( bInsert && bScript )
{
const SwTxtNode *pTxtNd = pAttr->GetSttPara().GetNode()
.GetTxtNode();
ASSERT( pTxtNd, "No text node" );
const String& rText = pTxtNd->GetTxt();
sal_uInt16 nScriptTxt = pBreakIt->GetBreakIter()->getScriptType(
rText, pAttr->GetSttCnt() );
xub_StrLen nScriptEnd = (xub_StrLen)pBreakIt->GetBreakIter()
->endOfScript( rText, pAttr->GetSttCnt(), nScriptTxt );
while( nScriptEnd < nEndCnt )
{
if( nScriptItem == nScriptTxt )
{
_HTMLAttr *pSetAttr = pAttr->Clone( *pEndIdx, nScriptEnd );
pSetAttr->ClearPrev();
if( pNext )
pNext->InsertPrev( pSetAttr );
else
{
sal_uInt16 nTmp = pSetAttr->bInsAtStart ? 0
: aSetAttrTab.Count();
aSetAttrTab.Insert( pSetAttr, nTmp );
}
}
pAttr->nSttCntnt = nScriptEnd;
nScriptTxt = pBreakIt->GetBreakIter()->getScriptType(
rText, nScriptEnd );
nScriptEnd = (xub_StrLen)pBreakIt->GetBreakIter()
->endOfScript( rText, nScriptEnd, nScriptTxt );
}
bInsert = nScriptItem == nScriptTxt;
}
if( bInsert )
{
pAttr->nEndPara = *pEndIdx;
pAttr->nEndCntnt = nEndCnt;
pAttr->bInsAtStart = RES_TXTATR_INETFMT != nWhich &&
RES_TXTATR_CHARFMT != nWhich;
if( !pNext )
{
// keine offenen Attribute dieses Typs mehr da,
// dann koennen alle gesetzt werden, es sei denn
// sie haengen noch von einem anderen Attribut ab,
// dann werden sie dort angehaengt
if( ppDepAttr && *ppDepAttr )
(*ppDepAttr)->InsertPrev( pAttr );
else
{
sal_uInt16 nTmp = pAttr->bInsAtStart ? 0 : aSetAttrTab.Count();
aSetAttrTab.Insert( pAttr, nTmp );
}
}
else
{
// es gibt noch andere offene Attribute des Typs,
// daher muss das Setzen zurueckgestellt werden.
// das aktuelle Attribut wird deshalb hinten an die
// Previous-Liste des Nachfolgers angehaengt
pNext->InsertPrev( pAttr );
}
}
else
{
// dann nicht einfuegen, sondern Loeschen. Durch das "tuerken" von
// Vorlagen durch harte Attributierung koennen sich auch mal andere
// leere Attribute in der Prev-Liste befinden, die dann trotzdem
// gesetzt werden muessen
_HTMLAttr *pPrev = pAttr->GetPrev();
delete pAttr;
if( pPrev )
{
// Die Previous-Attribute muessen trotzdem gesetzt werden.
if( pNext )
pNext->InsertPrev( pPrev );
else
{
sal_uInt16 nTmp = pPrev->bInsAtStart ? 0 : aSetAttrTab.Count();
aSetAttrTab.Insert( pPrev, nTmp );
}
}
}
// wenn das erste Attribut der Liste gesetzt wurde muss noch der
// Listenkopf korrigiert werden.
if( pLast )
pLast->pNext = pNext;
else if( ppHead )
*ppHead = pNext;
if( bMoveBack )
pPam->Move( fnMoveForward );
}
void SwHTMLParser::DeleteAttr( _HTMLAttr* pAttr )
{
// Hier darf es keine vorlauefigen Absatz-Attribute geben, den die
// koennten jetzt gesetzt werden und dann sind die Zeiger ungueltig!!!
ASSERT( !aParaAttrs.Count(),
"Hoechste Gefahr: Es gibt noch nicht-endgueltige Absatz-Attribute" );
if( aParaAttrs.Count() )
aParaAttrs.Remove( 0, aParaAttrs.Count() );
// Der Listenkopf ist im Attribut gespeichert
_HTMLAttr **ppHead = pAttr->ppHead;
ASSERT( ppHead, "keinen Attributs-Listenkopf gefunden!" );
// Wird das zueltzt gestartete oder ein frueher gestartetes Attribut
// entfernt?
_HTMLAttr *pLast = 0;
if( ppHead && pAttr != *ppHead )
{
// Es wird nicht das zuletzt gestartete Attribut beendet
// Dann suche wir das unmittelbar danach gestartete Attribut, das
// ja ebenfalls noch nicht beendet wurde (sonst stuende es nicht
// mehr in der Liste
pLast = *ppHead;
while( pLast && pLast->GetNext() != pAttr )
pLast = pLast->GetNext();
ASSERT( pLast, "Attribut nicht in eigener Liste gefunden!" );
}
// nun das Attrubut entfernen
_HTMLAttr *pNext = pAttr->GetNext();
_HTMLAttr *pPrev = pAttr->GetPrev();
delete pAttr;
if( pPrev )
{
// Die Previous-Attribute muessen trotzdem gesetzt werden.
if( pNext )
pNext->InsertPrev( pPrev );
else
{
sal_uInt16 nTmp = pPrev->bInsAtStart ? 0 : aSetAttrTab.Count();
aSetAttrTab.Insert( pPrev, nTmp );
}
}
// wenn das erste Attribut der Liste entfernt wurde muss noch der
// Listenkopf korrigiert werden.
if( pLast )
pLast->pNext = pNext;
else if( ppHead )
*ppHead = pNext;
}
void SwHTMLParser::SaveAttrTab( _HTMLAttrTable& rNewAttrTab )
{
// Hier darf es keine vorlauefigen Absatz-Attribute geben, den die
// koennten jetzt gesetzt werden und dann sind die Zeiger ungueltig!!!
ASSERT( !aParaAttrs.Count(),
"Hoechste Gefahr: Es gibt noch nicht-endgueltige Absatz-Attribute" );
if( aParaAttrs.Count() )
aParaAttrs.Remove( 0, aParaAttrs.Count() );
_HTMLAttr** pTbl = (_HTMLAttr**)&aAttrTab;
_HTMLAttr** pSaveTbl = (_HTMLAttr**)&rNewAttrTab;
for( sal_uInt16 nCnt = sizeof( _HTMLAttrTable ) / sizeof( _HTMLAttr* );
nCnt--; (++pTbl, ++pSaveTbl) )
{
*pSaveTbl = *pTbl;
_HTMLAttr *pAttr = *pSaveTbl;
while( pAttr )
{
pAttr->SetHead( pSaveTbl );
pAttr = pAttr->GetNext();
}
*pTbl = 0;
}
}
void SwHTMLParser::SplitAttrTab( _HTMLAttrTable& rNewAttrTab,
sal_Bool bMoveEndBack )
{
// Hier darf es keine vorlauefigen Absatz-Attribute geben, den die
// koennten jetzt gesetzt werden und dann sind die Zeiger ungueltig!!!
ASSERT( !aParaAttrs.Count(),
"Hoechste Gefahr: Es gibt noch nicht-endgueltige Absatz-Attribute" );
if( aParaAttrs.Count() )
aParaAttrs.Remove( 0, aParaAttrs.Count() );
const SwNodeIndex& nSttIdx = pPam->GetPoint()->nNode;
SwNodeIndex nEndIdx( nSttIdx );
// alle noch offenen Attribute beenden und hinter der Tabelle
// neu aufspannen
_HTMLAttr** pTbl = (_HTMLAttr**)&aAttrTab;
_HTMLAttr** pSaveTbl = (_HTMLAttr**)&rNewAttrTab;
sal_Bool bSetAttr = sal_True;
xub_StrLen nSttCnt = pPam->GetPoint()->nContent.GetIndex();
xub_StrLen nEndCnt = nSttCnt;
if( bMoveEndBack )
{
sal_uLong nOldEnd = nEndIdx.GetIndex();
sal_uLong nTmpIdx;
if( ( nTmpIdx = pDoc->GetNodes().GetEndOfExtras().GetIndex()) >= nOldEnd ||
( nTmpIdx = pDoc->GetNodes().GetEndOfAutotext().GetIndex()) >= nOldEnd )
{
nTmpIdx = pDoc->GetNodes().GetEndOfInserts().GetIndex();
}
SwCntntNode* pCNd = pDoc->GetNodes().GoPrevious(&nEndIdx);
// keine Attribute setzen, wenn der PaM aus dem Content-Bereich
// herausgeschoben wurde.
bSetAttr = pCNd && nTmpIdx < nEndIdx.GetIndex();
nEndCnt = (bSetAttr ? pCNd->Len() : 0);
}
for( sal_uInt16 nCnt = sizeof( _HTMLAttrTable ) / sizeof( _HTMLAttr* );
nCnt--; (++pTbl, ++pSaveTbl) )
{
_HTMLAttr *pAttr = *pTbl;
*pSaveTbl = 0;
while( pAttr )
{
_HTMLAttr *pNext = pAttr->GetNext();
_HTMLAttr *pPrev = pAttr->GetPrev();
if( bSetAttr &&
( pAttr->GetSttParaIdx() < nEndIdx.GetIndex() ||
(pAttr->GetSttPara() == nEndIdx &&
pAttr->GetSttCnt() != nEndCnt) ) )
{
// das Attribut muss vor der Liste gesetzt werden. Da wir
// das Original noch brauchen, weil Zeiger auf das Attribut
// noch in den Kontexten existieren, muessen wir es clonen.
// Die Next-Liste geht dabei verloren, aber die
// Previous-Liste bleibt erhalten
_HTMLAttr *pSetAttr = pAttr->Clone( nEndIdx, nEndCnt );
if( pNext )
pNext->InsertPrev( pSetAttr );
else
{
sal_uInt16 nTmp = pSetAttr->bInsAtStart ? 0
: aSetAttrTab.Count();
aSetAttrTab.Insert( pSetAttr, nTmp );
}
}
else if( pPrev )
{
// Wenn das Attribut nicht gesetzt vor der Tabelle
// gesetzt werden muss, muessen der Previous-Attribute
// trotzdem gesetzt werden.
if( pNext )
pNext->InsertPrev( pPrev );
else
{
sal_uInt16 nTmp = pPrev->bInsAtStart ? 0 : aSetAttrTab.Count();
aSetAttrTab.Insert( pPrev, nTmp );
}
}
// den Start des Attributs neu setzen und die Verkettungen
// aufbrechen
pAttr->Reset( nSttIdx, nSttCnt, pSaveTbl );
if( *pSaveTbl )
{
_HTMLAttr *pSAttr = *pSaveTbl;
while( pSAttr->GetNext() )
pSAttr = pSAttr->GetNext();
pSAttr->InsertNext( pAttr );
}
else
*pSaveTbl = pAttr;
pAttr = pNext;
}
*pTbl = 0;
}
}
void SwHTMLParser::RestoreAttrTab( const _HTMLAttrTable& rNewAttrTab,
sal_Bool bSetNewStart )
{
// Hier darf es keine vorlauefigen Absatz-Attribute geben, den die
// koennten jetzt gesetzt werden und dann sind die Zeiger ungueltig!!!
ASSERT( !aParaAttrs.Count(),
"Hoechste Gefahr: Es gibt noch nicht-endgueltige Absatz-Attribute" );
if( aParaAttrs.Count() )
aParaAttrs.Remove( 0, aParaAttrs.Count() );
_HTMLAttr** pTbl = (_HTMLAttr**)&aAttrTab;
_HTMLAttr** pSaveTbl = (_HTMLAttr**)&rNewAttrTab;
for( sal_uInt16 nCnt = sizeof( _HTMLAttrTable ) / sizeof( _HTMLAttr* );
nCnt--; (++pTbl, ++pSaveTbl) )
{
ASSERT( !*pTbl, "Die Attribut-Tabelle ist nicht leer!" );
const SwPosition *pPos = pPam->GetPoint();
const SwNodeIndex& rSttPara = pPos->nNode;
xub_StrLen nSttCnt = pPos->nContent.GetIndex();
*pTbl = *pSaveTbl;
_HTMLAttr *pAttr = *pTbl;
while( pAttr )
{
ASSERT( !pAttr->GetPrev() || !pAttr->GetPrev()->ppHead,
"Previous-Attribut hat noch einen Header" );
pAttr->SetHead( pTbl );
if( bSetNewStart )
{
pAttr->nSttPara = rSttPara;
pAttr->nEndPara = rSttPara;
pAttr->nSttCntnt = nSttCnt;
pAttr->nEndCntnt = nSttCnt;
}
pAttr = pAttr->GetNext();
}
*pSaveTbl = 0;
}
}
void SwHTMLParser::InsertAttr( const SfxPoolItem& rItem, sal_Bool bLikePara,
sal_Bool bInsAtStart )
{
_HTMLAttr* pTmp = new _HTMLAttr( *pPam->GetPoint(),
rItem );
if( bLikePara )
pTmp->SetLikePara();
sal_uInt16 nTmp = bInsAtStart ? 0 : aSetAttrTab.Count();
aSetAttrTab.Insert( pTmp, nTmp );
}
void SwHTMLParser::InsertAttrs( _HTMLAttrs& rAttrs )
{
while( rAttrs.Count() )
{
_HTMLAttr *pAttr = rAttrs[0];
InsertAttr( pAttr->GetItem() );
rAttrs.Remove( 0, 1 );
delete pAttr;
}
}
/* */
void SwHTMLParser::NewStdAttr( int nToken )
{
String aId, aStyle, aClass, aLang, aDir;
const HTMLOptions *pHTMLOptions = GetOptions();
for( sal_uInt16 i = pHTMLOptions->Count(); i; )
{
const HTMLOption *pOption = (*pHTMLOptions)[--i];
switch( pOption->GetToken() )
{
case HTML_O_ID:
aId = pOption->GetString();
break;
case HTML_O_STYLE:
aStyle = pOption->GetString();
break;
case HTML_O_CLASS:
aClass = pOption->GetString();
break;
case HTML_O_LANG:
aLang = pOption->GetString();
break;
case HTML_O_DIR:
aDir = pOption->GetString();
break;
}
}
// einen neuen Kontext anlegen
_HTMLAttrContext *pCntxt = new _HTMLAttrContext( static_cast< sal_uInt16 >(nToken) );
// Styles parsen
if( HasStyleOptions( aStyle, aId, aClass, &aLang, &aDir ) )
{
SfxItemSet aItemSet( pDoc->GetAttrPool(), pCSS1Parser->GetWhichMap() );
SvxCSS1PropertyInfo aPropInfo;
if( ParseStyleOptions( aStyle, aId, aClass, aItemSet, aPropInfo, &aLang, &aDir ) )
{
if( HTML_SPAN_ON != nToken || !aClass.Len() ||
!CreateContainer( aClass, aItemSet, aPropInfo, pCntxt ) )
DoPositioning( aItemSet, aPropInfo, pCntxt );
InsertAttrs( aItemSet, aPropInfo, pCntxt, sal_True );
}
}
// den Kontext merken
PushContext( pCntxt );
}
void SwHTMLParser::NewStdAttr( int nToken,
_HTMLAttr **ppAttr, const SfxPoolItem & rItem,
_HTMLAttr **ppAttr2, const SfxPoolItem *pItem2,
_HTMLAttr **ppAttr3, const SfxPoolItem *pItem3 )
{
String aId, aStyle, aClass, aLang, aDir;
const HTMLOptions *pHTMLOptions = GetOptions();
for( sal_uInt16 i = pHTMLOptions->Count(); i; )
{
const HTMLOption *pOption = (*pHTMLOptions)[--i];
switch( pOption->GetToken() )
{
case HTML_O_ID:
aId = pOption->GetString();
break;
case HTML_O_STYLE:
aStyle = pOption->GetString();
break;
case HTML_O_CLASS:
aClass = pOption->GetString();
break;
case HTML_O_LANG:
aLang = pOption->GetString();
break;
case HTML_O_DIR:
aDir = pOption->GetString();
break;
}
}
// einen neuen Kontext anlegen
_HTMLAttrContext *pCntxt = new _HTMLAttrContext( static_cast< sal_uInt16 >(nToken) );
// Styles parsen
if( HasStyleOptions( aStyle, aId, aClass, &aLang, &aDir ) )
{
SfxItemSet aItemSet( pDoc->GetAttrPool(), pCSS1Parser->GetWhichMap() );
SvxCSS1PropertyInfo aPropInfo;
aItemSet.Put( rItem );
if( pItem2 )
aItemSet.Put( *pItem2 );
if( pItem3 )
aItemSet.Put( *pItem3 );
if( ParseStyleOptions( aStyle, aId, aClass, aItemSet, aPropInfo, &aLang, &aDir ) )
DoPositioning( aItemSet, aPropInfo, pCntxt );
InsertAttrs( aItemSet, aPropInfo, pCntxt, sal_True );
}
else
{
InsertAttr( ppAttr ,rItem, pCntxt );
if( pItem2 )
{
ASSERT( ppAttr2, "missing table entry for item2" );
InsertAttr( ppAttr2, *pItem2, pCntxt );
}
if( pItem3 )
{
ASSERT( ppAttr3, "missing table entry for item3" );
InsertAttr( ppAttr3, *pItem3, pCntxt );
}
}
// den Kontext merken
PushContext( pCntxt );
}
void SwHTMLParser::EndTag( int nToken )
{
// den Kontext holen
_HTMLAttrContext *pCntxt = PopContext( static_cast< sal_uInt16 >(nToken & ~1) );
if( pCntxt )
{
// und ggf. die Attribute beenden
EndContext( pCntxt );
delete pCntxt;
}
}
void SwHTMLParser::NewBasefontAttr()
{
String aId, aStyle, aClass, aLang, aDir;
sal_uInt16 nSize = 3;
const HTMLOptions *pHTMLOptions = GetOptions();
for( sal_uInt16 i = pHTMLOptions->Count(); i; )
{
const HTMLOption *pOption = (*pHTMLOptions)[--i];
switch( pOption->GetToken() )
{
case HTML_O_SIZE:
nSize = (sal_uInt16)pOption->GetNumber();
break;
case HTML_O_ID:
aId = pOption->GetString();
break;
case HTML_O_STYLE:
aStyle = pOption->GetString();
break;
case HTML_O_CLASS:
aClass = pOption->GetString();
break;
case HTML_O_LANG:
aLang = pOption->GetString();
break;
case HTML_O_DIR:
aDir = pOption->GetString();
break;
}
}
if( nSize < 1 )
nSize = 1;
if( nSize > 7 )
nSize = 7;
// einen neuen Kontext anlegen
_HTMLAttrContext *pCntxt = new _HTMLAttrContext( HTML_BASEFONT_ON );
// Styles parsen
if( HasStyleOptions( aStyle, aId, aClass, &aLang, &aDir ) )
{
SfxItemSet aItemSet( pDoc->GetAttrPool(), pCSS1Parser->GetWhichMap() );
SvxCSS1PropertyInfo aPropInfo;
SvxFontHeightItem aFontHeight( aFontHeights[nSize-1], 100, RES_CHRATR_FONTSIZE );
aItemSet.Put( aFontHeight );
aFontHeight.SetWhich( RES_CHRATR_CJK_FONTSIZE );
aItemSet.Put( aFontHeight );
aFontHeight.SetWhich( RES_CHRATR_CTL_FONTSIZE );
aItemSet.Put( aFontHeight );
if( ParseStyleOptions( aStyle, aId, aClass, aItemSet, aPropInfo, &aLang, &aDir ) )
DoPositioning( aItemSet, aPropInfo, pCntxt );
InsertAttrs( aItemSet, aPropInfo, pCntxt, sal_True );
}
else
{
SvxFontHeightItem aFontHeight( aFontHeights[nSize-1], 100, RES_CHRATR_FONTSIZE );
InsertAttr( &aAttrTab.pFontHeight, aFontHeight, pCntxt );
aFontHeight.SetWhich( RES_CHRATR_CJK_FONTSIZE );
InsertAttr( &aAttrTab.pFontHeightCJK, aFontHeight, pCntxt );
aFontHeight.SetWhich( RES_CHRATR_CTL_FONTSIZE );
InsertAttr( &aAttrTab.pFontHeightCTL, aFontHeight, pCntxt );
}
// den Kontext merken
PushContext( pCntxt );
// die Font-Size merken
aBaseFontStack.Insert( nSize, aBaseFontStack.Count() );
}
void SwHTMLParser::EndBasefontAttr()
{
EndTag( HTML_BASEFONT_ON );
// Stack-Unterlauf in Tabellen vermeiden
if( aBaseFontStack.Count() > nBaseFontStMin )
aBaseFontStack.Remove( aBaseFontStack.Count()-1, 1 );
}
void SwHTMLParser::NewFontAttr( int nToken )
{
sal_uInt16 nBaseSize =
( aBaseFontStack.Count() > nBaseFontStMin
? (aBaseFontStack[aBaseFontStack.Count()-1] & FONTSIZE_MASK)
: 3 );
sal_uInt16 nFontSize =
( aFontStack.Count() > nFontStMin
? (aFontStack[aFontStack.Count()-1] & FONTSIZE_MASK)
: nBaseSize );
String aFace, aId, aStyle, aClass, aLang, aDir;
Color aColor;
sal_uLong nFontHeight = 0; // tatsaechlich einzustellende Font-Hoehe
sal_uInt16 nSize = 0; // Fontgroesse in Netscape-Notation (1-7)
sal_Bool bColor = sal_False;
const HTMLOptions *pHTMLOptions = GetOptions();
for( sal_uInt16 i = pHTMLOptions->Count(); i; )
{
const HTMLOption *pOption = (*pHTMLOptions)[--i];
switch( pOption->GetToken() )
{
case HTML_O_SIZE:
if( HTML_FONT_ON==nToken && pOption->GetString().Len() )
{
sal_Int32 nSSize;
if( '+' == pOption->GetString().GetChar(0) ||
'-' == pOption->GetString().GetChar(0) )
nSSize = nBaseSize + pOption->GetSNumber();
else
nSSize = (sal_Int32)pOption->GetNumber();
if( nSSize < 1 )
nSSize = 1;
else if( nSSize > 7 )
nSSize = 7;
nSize = (sal_uInt16)nSSize;
nFontHeight = aFontHeights[nSize-1];
}
break;
case HTML_O_COLOR:
if( HTML_FONT_ON==nToken )
{
pOption->GetColor( aColor );
bColor = sal_True;
}
break;
case HTML_O_FACE:
if( HTML_FONT_ON==nToken )
aFace = pOption->GetString();
break;
case HTML_O_ID:
aId = pOption->GetString();
break;
case HTML_O_STYLE:
aStyle = pOption->GetString();
break;
case HTML_O_CLASS:
aClass = pOption->GetString();
break;
case HTML_O_LANG:
aLang = pOption->GetString();
break;
case HTML_O_DIR:
aDir = pOption->GetString();
break;
}
}
if( HTML_FONT_ON != nToken )
{
// HTML_BIGPRINT_ON oder HTML_SMALLPRINT_ON
// in Ueberschriften bestimmt die aktuelle Ueberschrift
// die Font-Hoehe und nicht BASEFONT
sal_uInt16 nPoolId = GetCurrFmtColl()->GetPoolFmtId();
if( (nPoolId>=RES_POOLCOLL_HEADLINE1 &&
nPoolId<=RES_POOLCOLL_HEADLINE6) )
{
// wenn die Schriftgroesse in der Ueberschrift noch
// nicht veraendert ist, die aus der Vorlage nehmen
if( nFontStHeadStart==aFontStack.Count() )
nFontSize = static_cast< sal_uInt16 >(6 - (nPoolId - RES_POOLCOLL_HEADLINE1));
}
else
nPoolId = 0;
if( HTML_BIGPRINT_ON == nToken )
nSize = ( nFontSize<7 ? nFontSize+1 : 7 );
else
nSize = ( nFontSize>1 ? nFontSize-1 : 1 );
// in Ueberschriften wird die neue Fonthoehe wenn moeglich aus
// den Vorlagen geholt.
if( nPoolId && nSize>=1 && nSize <=6 )
nFontHeight =
pCSS1Parser->GetTxtCollFromPool(
RES_POOLCOLL_HEADLINE1+6-nSize )->GetSize().GetHeight();
else
nFontHeight = aFontHeights[nSize-1];
}
ASSERT( !nSize == !nFontHeight, "HTML-Font-Size != Font-Height" );
String aFontName, aStyleName;
FontFamily eFamily = FAMILY_DONTKNOW; // Family und Pitch,
FontPitch ePitch = PITCH_DONTKNOW; // falls nicht gefunden
rtl_TextEncoding eEnc = gsl_getSystemTextEncoding();
if( aFace.Len() && !pCSS1Parser->IsIgnoreFontFamily() )
{
const FontList *pFList = 0;
SwDocShell *pDocSh = pDoc->GetDocShell();
if( pDocSh )
{
const SvxFontListItem *pFListItem =
(const SvxFontListItem *)pDocSh->GetItem(SID_ATTR_CHAR_FONTLIST);
if( pFListItem )
pFList = pFListItem->GetFontList();
}
sal_Bool bFound = sal_False;
xub_StrLen nStrPos = 0;
while( nStrPos!=STRING_NOTFOUND )
{
String aFName = aFace.GetToken( 0, ',', nStrPos );
aFName.EraseTrailingChars().EraseLeadingChars();
if( aFName.Len() )
{
if( !bFound && pFList )
{
sal_Handle hFont = pFList->GetFirstFontInfo( aFName );
if( 0 != hFont )
{
const FontInfo& rFInfo = pFList->GetFontInfo( hFont );
if( RTL_TEXTENCODING_DONTKNOW != rFInfo.GetCharSet() )
{
bFound = sal_True;
if( RTL_TEXTENCODING_SYMBOL == rFInfo.GetCharSet() )
eEnc = RTL_TEXTENCODING_SYMBOL;
}
}
}
if( aFontName.Len() )
aFontName += ';';
aFontName += aFName;
}
}
}
// einen neuen Kontext anlegen
_HTMLAttrContext *pCntxt = new _HTMLAttrContext( static_cast< sal_uInt16 >(nToken) );
// Styles parsen
if( HasStyleOptions( aStyle, aId, aClass, &aLang, &aDir ) )
{
SfxItemSet aItemSet( pDoc->GetAttrPool(), pCSS1Parser->GetWhichMap() );
SvxCSS1PropertyInfo aPropInfo;
if( nFontHeight )
{
SvxFontHeightItem aFontHeight( nFontHeight, 100, RES_CHRATR_FONTSIZE );
aItemSet.Put( aFontHeight );
aFontHeight.SetWhich( RES_CHRATR_CJK_FONTSIZE );
aItemSet.Put( aFontHeight );
aFontHeight.SetWhich( RES_CHRATR_CTL_FONTSIZE );
aItemSet.Put( aFontHeight );
}
if( bColor )
aItemSet.Put( SvxColorItem(aColor, RES_CHRATR_COLOR) );
if( aFontName.Len() )
{
SvxFontItem aFont( eFamily, aFontName, aStyleName, ePitch, eEnc, RES_CHRATR_FONT );
aItemSet.Put( aFont );
aFont.SetWhich( RES_CHRATR_CJK_FONT );
aItemSet.Put( aFont );
aFont.SetWhich( RES_CHRATR_CTL_FONT );
aItemSet.Put( aFont );
}
if( ParseStyleOptions( aStyle, aId, aClass, aItemSet, aPropInfo, &aLang, &aDir ) )
DoPositioning( aItemSet, aPropInfo, pCntxt );
InsertAttrs( aItemSet, aPropInfo, pCntxt, sal_True );
}
else
{
if( nFontHeight )
{
SvxFontHeightItem aFontHeight( nFontHeight, 100, RES_CHRATR_FONTSIZE );
InsertAttr( &aAttrTab.pFontHeight, aFontHeight, pCntxt );
aFontHeight.SetWhich( RES_CHRATR_CJK_FONTSIZE );
InsertAttr( &aAttrTab.pFontHeightCJK, aFontHeight, pCntxt );
aFontHeight.SetWhich( RES_CHRATR_CTL_FONTSIZE );
InsertAttr( &aAttrTab.pFontHeightCTL, aFontHeight, pCntxt );
}
if( bColor )
InsertAttr( &aAttrTab.pFontColor, SvxColorItem(aColor, RES_CHRATR_COLOR), pCntxt );
if( aFontName.Len() )
{
SvxFontItem aFont( eFamily, aFontName, aStyleName, ePitch, eEnc, RES_CHRATR_FONT );
InsertAttr( &aAttrTab.pFont, aFont, pCntxt );
aFont.SetWhich( RES_CHRATR_CJK_FONT );
InsertAttr( &aAttrTab.pFontCJK, aFont, pCntxt );
aFont.SetWhich( RES_CHRATR_CTL_FONT );
InsertAttr( &aAttrTab.pFontCTL, aFont, pCntxt );
}
}
// den Kontext merken
PushContext( pCntxt );
aFontStack.Insert( nSize, aFontStack.Count() );
}
void SwHTMLParser::EndFontAttr( int nToken )
{
EndTag( nToken );
// Stack-Unterlauf in Tabellen vermeiden
if( aFontStack.Count() > nFontStMin )
aFontStack.Remove( aFontStack.Count()-1, 1 );
}
/* */
void SwHTMLParser::NewPara()
{
if( pPam->GetPoint()->nContent.GetIndex() )
AppendTxtNode( AM_SPACE );
else
AddParSpace();
eParaAdjust = SVX_ADJUST_END;
String aId, aStyle, aClass, aLang, aDir;
const HTMLOptions *pHTMLOptions = GetOptions();
for( sal_uInt16 i = pHTMLOptions->Count(); i; )
{
const HTMLOption *pOption = (*pHTMLOptions)[--i];
switch( pOption->GetToken() )
{
case HTML_O_ID:
aId = pOption->GetString();
break;
case HTML_O_ALIGN:
eParaAdjust = (SvxAdjust)pOption->GetEnum( aHTMLPAlignTable, static_cast< sal_uInt16 >(eParaAdjust) );
break;
case HTML_O_STYLE:
aStyle = pOption->GetString();
break;
case HTML_O_CLASS:
aClass = pOption->GetString();
break;
case HTML_O_LANG:
aLang = pOption->GetString();
break;
case HTML_O_DIR:
aDir = pOption->GetString();
break;
}
}
// einen neuen Kontext anlegen
_HTMLAttrContext *pCntxt =
aClass.Len() ? new _HTMLAttrContext( HTML_PARABREAK_ON,
RES_POOLCOLL_TEXT, aClass )
: new _HTMLAttrContext( HTML_PARABREAK_ON );
// Styles parsen (Class nicht beruecksichtigen. Das geht nur, solange
// keine der CSS1-Properties der Klasse hart formatiert werden muss!!!)
if( HasStyleOptions( aStyle, aId, aEmptyStr, &aLang, &aDir ) )
{
SfxItemSet aItemSet( pDoc->GetAttrPool(), pCSS1Parser->GetWhichMap() );
SvxCSS1PropertyInfo aPropInfo;
if( ParseStyleOptions( aStyle, aId, aEmptyStr, aItemSet, aPropInfo, &aLang, &aDir ) )
{
ASSERT( !aClass.Len() || !pCSS1Parser->GetClass( aClass ),
"Class wird nicht beruecksichtigt" );
DoPositioning( aItemSet, aPropInfo, pCntxt );
InsertAttrs( aItemSet, aPropInfo, pCntxt );
}
}
if( SVX_ADJUST_END != eParaAdjust )
InsertAttr( &aAttrTab.pAdjust, SvxAdjustItem(eParaAdjust, RES_PARATR_ADJUST), pCntxt );
// und auf den Stack packen
PushContext( pCntxt );
// die aktuelle Vorlage oder deren Attribute setzen
SetTxtCollAttrs( aClass.Len() ? pCntxt : 0 );
// Laufbalkenanzeige
ShowStatline();
ASSERT( !nOpenParaToken, "Jetzt geht ein offenes Absatz-Element verloren" );
nOpenParaToken = HTML_PARABREAK_ON;
}
void SwHTMLParser::EndPara( sal_Bool bReal )
{
if( HTML_LI_ON==nOpenParaToken && pTable )
{
#ifdef DBG_UTIL
const SwNumRule *pNumRule = pPam->GetNode()->GetTxtNode()->GetNumRule();
#endif
ASSERT( pNumRule, "Wo ist die Numrule geblieben" );
}
// leere Absaetze werden von Netscape uebersprungen, von uns jetzt auch
if( bReal )
{
if( pPam->GetPoint()->nContent.GetIndex() )
AppendTxtNode( AM_SPACE );
else
AddParSpace();
}
// wenn ein DD oder DT offen war, handelt es sich um eine
// implizite Def-Liste, die jetzt beendet werden muss
if( (nOpenParaToken==HTML_DT_ON || nOpenParaToken==HTML_DD_ON) &&
nDefListDeep)
{
nDefListDeep--;
}
// den Kontext vom Stack holen. Er kann auch von einer implizit
// geoeffneten Definitionsliste kommen
_HTMLAttrContext *pCntxt =
PopContext( static_cast< sal_uInt16 >(nOpenParaToken ? (nOpenParaToken & ~1)
: HTML_PARABREAK_ON) );
// Attribute beenden
if( pCntxt )
{
EndContext( pCntxt );
SetAttr(); // Absatz-Atts wegen JavaScript moeglichst schnell setzen
delete pCntxt;
}
// und die bisherige Vorlage neu setzen
if( bReal )
SetTxtCollAttrs();
nOpenParaToken = 0;
}
void SwHTMLParser::NewHeading( int nToken )
{
eParaAdjust = SVX_ADJUST_END;
String aId, aStyle, aClass, aLang, aDir;
const HTMLOptions *pHTMLOptions = GetOptions();
for( sal_uInt16 i = pHTMLOptions->Count(); i; )
{
const HTMLOption *pOption = (*pHTMLOptions)[--i];
switch( pOption->GetToken() )
{
case HTML_O_ID:
aId = pOption->GetString();
break;
case HTML_O_ALIGN:
eParaAdjust = (SvxAdjust)pOption->GetEnum( aHTMLPAlignTable, static_cast< sal_uInt16 >(eParaAdjust) );
break;
case HTML_O_STYLE:
aStyle = pOption->GetString();
break;
case HTML_O_CLASS:
aClass = pOption->GetString();
break;
case HTML_O_LANG:
aLang = pOption->GetString();
break;
case HTML_O_DIR:
aDir = pOption->GetString();
break;
}
}
// einen neuen Absatz aufmachen
if( pPam->GetPoint()->nContent.GetIndex() )
AppendTxtNode( AM_SPACE );
else
AddParSpace();
// die passende Vorlage suchen
sal_uInt16 nTxtColl;
switch( nToken )
{
case HTML_HEAD1_ON: nTxtColl = RES_POOLCOLL_HEADLINE1; break;
case HTML_HEAD2_ON: nTxtColl = RES_POOLCOLL_HEADLINE2; break;
case HTML_HEAD3_ON: nTxtColl = RES_POOLCOLL_HEADLINE3; break;
case HTML_HEAD4_ON: nTxtColl = RES_POOLCOLL_HEADLINE4; break;
case HTML_HEAD5_ON: nTxtColl = RES_POOLCOLL_HEADLINE5; break;
case HTML_HEAD6_ON: nTxtColl = RES_POOLCOLL_HEADLINE6; break;
default: nTxtColl = RES_POOLCOLL_STANDARD; break;
}
// den Kontext anlegen
_HTMLAttrContext *pCntxt = new _HTMLAttrContext( static_cast< sal_uInt16 >(nToken), nTxtColl, aClass );
// Styles parsen (zu Class siehe auch NewPara)
if( HasStyleOptions( aStyle, aId, aEmptyStr, &aLang, &aDir ) )
{
SfxItemSet aItemSet( pDoc->GetAttrPool(), pCSS1Parser->GetWhichMap() );
SvxCSS1PropertyInfo aPropInfo;
if( ParseStyleOptions( aStyle, aId, aEmptyStr, aItemSet, aPropInfo, &aLang, &aDir ) )
{
ASSERT( !aClass.Len() || !pCSS1Parser->GetClass( aClass ),
"Class wird nicht beruecksichtigt" );
DoPositioning( aItemSet, aPropInfo, pCntxt );
InsertAttrs( aItemSet, aPropInfo, pCntxt );
}
}
if( SVX_ADJUST_END != eParaAdjust )
InsertAttr( &aAttrTab.pAdjust, SvxAdjustItem(eParaAdjust, RES_PARATR_ADJUST), pCntxt );
// udn auf den Stack packen
PushContext( pCntxt );
// und die Vorlage oder deren Attribute setzen
SetTxtCollAttrs( pCntxt );
nFontStHeadStart = aFontStack.Count();
// Laufbalkenanzeige
ShowStatline();
}
void SwHTMLParser::EndHeading()
{
// einen neuen Absatz aufmachen
if( pPam->GetPoint()->nContent.GetIndex() )
AppendTxtNode( AM_SPACE );
else
AddParSpace();
// Kontext zu dem Token suchen und vom Stack holen
_HTMLAttrContext *pCntxt = 0;
sal_uInt16 nPos = aContexts.Count();
while( !pCntxt && nPos>nContextStMin )
{
switch( aContexts[--nPos]->GetToken() )
{
case HTML_HEAD1_ON:
case HTML_HEAD2_ON:
case HTML_HEAD3_ON:
case HTML_HEAD4_ON:
case HTML_HEAD5_ON:
case HTML_HEAD6_ON:
pCntxt = aContexts[nPos];
aContexts.Remove( nPos, 1 );
break;
}
}
// und noch Attribute beenden
if( pCntxt )
{
EndContext( pCntxt );
SetAttr(); // Absatz-Atts wegen JavaScript moeglichst schnell setzen
delete pCntxt;
}
// die bisherige Vorlage neu setzen
SetTxtCollAttrs();
nFontStHeadStart = nFontStMin;
}
/* */
void SwHTMLParser::NewTxtFmtColl( int nToken, sal_uInt16 nColl )
{
String aId, aStyle, aClass, aLang, aDir;
const HTMLOptions *pHTMLOptions = GetOptions();
for( sal_uInt16 i = pHTMLOptions->Count(); i; )
{
const HTMLOption *pOption = (*pHTMLOptions)[--i];
switch( pOption->GetToken() )
{
case HTML_O_ID:
aId = pOption->GetString();
break;
case HTML_O_STYLE:
aStyle = pOption->GetString();
break;
case HTML_O_CLASS:
aClass = pOption->GetString();
break;
case HTML_O_LANG:
aLang = pOption->GetString();
break;
case HTML_O_DIR:
aDir = pOption->GetString();
break;
}
}
// einen neuen Absatz aufmachen
SwHTMLAppendMode eMode = AM_NORMAL;
switch( nToken )
{
case HTML_LISTING_ON:
case HTML_XMP_ON:
// Diese beiden Tags werden jetzt auf die PRE-Vorlage gemappt.
// Fuer dem Fall, dass ein CLASS angegeben ist, loeschen wir
// es damit wir nicht die CLASS der PRE-Vorlage bekommen.
aClass = aEmptyStr;
case HTML_BLOCKQUOTE_ON:
case HTML_BLOCKQUOTE30_ON:
case HTML_PREFORMTXT_ON:
eMode = AM_SPACE;
break;
case HTML_ADDRESS_ON:
eMode = AM_NOSPACE; // ADDRESS kann auf einen <P> ohne </P> folgen
break;
case HTML_DT_ON:
case HTML_DD_ON:
eMode = AM_SOFTNOSPACE;
break;
default:
ASSERT( !this, "unbekannte Vorlage" );
break;
}
if( pPam->GetPoint()->nContent.GetIndex() )
AppendTxtNode( eMode );
else if( AM_SPACE==eMode )
AddParSpace();
// ... und in einem Kontext merken
_HTMLAttrContext *pCntxt = new _HTMLAttrContext( static_cast< sal_uInt16 >(nToken), nColl, aClass );
// Styles parsen (zu Class siehe auch NewPara)
if( HasStyleOptions( aStyle, aId, aEmptyStr, &aLang, &aDir ) )
{
SfxItemSet aItemSet( pDoc->GetAttrPool(), pCSS1Parser->GetWhichMap() );
SvxCSS1PropertyInfo aPropInfo;
if( ParseStyleOptions( aStyle, aId, aEmptyStr, aItemSet, aPropInfo, &aLang, &aDir ) )
{
ASSERT( !aClass.Len() || !pCSS1Parser->GetClass( aClass ),
"Class wird nicht beruecksichtigt" );
DoPositioning( aItemSet, aPropInfo, pCntxt );
InsertAttrs( aItemSet, aPropInfo, pCntxt );
}
}
PushContext( pCntxt );
// die neue Vorlage setzen
SetTxtCollAttrs( pCntxt );
// Laufbalkenanzeige aktualisieren
ShowStatline();
}
void SwHTMLParser::EndTxtFmtColl( int nToken )
{
SwHTMLAppendMode eMode = AM_NORMAL;
switch( nToken & ~1 )
{
case HTML_BLOCKQUOTE_ON:
case HTML_BLOCKQUOTE30_ON:
case HTML_PREFORMTXT_ON:
case HTML_LISTING_ON:
case HTML_XMP_ON:
eMode = AM_SPACE;
break;
case HTML_ADDRESS_ON:
case HTML_DT_ON:
case HTML_DD_ON:
eMode = AM_SOFTNOSPACE;
break;
default:
ASSERT( !this, "unbekannte Vorlage" );
break;
}
if( pPam->GetPoint()->nContent.GetIndex() )
AppendTxtNode( eMode );
else if( AM_SPACE==eMode )
AddParSpace();
// den aktuellen Kontext vom Stack holen
_HTMLAttrContext *pCntxt = PopContext( static_cast< sal_uInt16 >(nToken & ~1) );
// und noch Attribute beenden
if( pCntxt )
{
EndContext( pCntxt );
SetAttr(); // Absatz-Atts wegen JavaScript moeglichst schnell setzen
delete pCntxt;
}
// und die bisherige Vorlage setzen
SetTxtCollAttrs();
}
/* */
void SwHTMLParser::NewDefList()
{
String aId, aStyle, aClass, aLang, aDir;
const HTMLOptions *pHTMLOptions = GetOptions();
for( sal_uInt16 i = pHTMLOptions->Count(); i; )
{
const HTMLOption *pOption = (*pHTMLOptions)[--i];
switch( pOption->GetToken() )
{
case HTML_O_ID:
aId = pOption->GetString();
break;
case HTML_O_STYLE:
aStyle = pOption->GetString();
break;
case HTML_O_CLASS:
aClass = pOption->GetString();
break;
case HTML_O_LANG:
aLang = pOption->GetString();
break;
case HTML_O_DIR:
aDir = pOption->GetString();
break;
}
}
// einen neuen Absatz aufmachen
sal_Bool bSpace = (GetNumInfo().GetDepth() + nDefListDeep) == 0;
if( pPam->GetPoint()->nContent.GetIndex() )
AppendTxtNode( bSpace ? AM_SPACE : AM_SOFTNOSPACE );
else if( bSpace )
AddParSpace();
// ein Level mehr
nDefListDeep++;
sal_Bool bInDD = sal_False, bNotInDD = sal_False;
sal_uInt16 nPos = aContexts.Count();
while( !bInDD && !bNotInDD && nPos>nContextStMin )
{
sal_uInt16 nCntxtToken = aContexts[--nPos]->GetToken();
switch( nCntxtToken )
{
case HTML_DEFLIST_ON:
case HTML_DIRLIST_ON:
case HTML_MENULIST_ON:
case HTML_ORDERLIST_ON:
case HTML_UNORDERLIST_ON:
bNotInDD = sal_True;
break;
case HTML_DD_ON:
bInDD = sal_True;
break;
}
}
// ... und in einem Kontext merken
_HTMLAttrContext *pCntxt = new _HTMLAttrContext( HTML_DEFLIST_ON );
// darin auch die Raender merken
sal_uInt16 nLeft=0, nRight=0;
short nIndent=0;
GetMarginsFromContext( nLeft, nRight, nIndent );
// Die Einrueckung, die sich schon aus einem DL-ergibt, entspricht der
// eines DT auf dem aktuellen Level, und die entspricht der eines
// DD auf dem Level davor. Fue einen Level >=2 muss also ein DD-Abstand
// hinzugefuegt werden
if( !bInDD && nDefListDeep > 1 )
{
// und den der DT-Vorlage des aktuellen Levels
SvxLRSpaceItem rLRSpace =
pCSS1Parser->GetTxtFmtColl( RES_POOLCOLL_HTML_DD, aEmptyStr )
->GetLRSpace();
nLeft = nLeft + static_cast< sal_uInt16 >(rLRSpace.GetTxtLeft());
}
pCntxt->SetMargins( nLeft, nRight, nIndent );
// Styles parsen
if( HasStyleOptions( aStyle, aId, aClass, &aLang, &aDir ) )
{
SfxItemSet aItemSet( pDoc->GetAttrPool(), pCSS1Parser->GetWhichMap() );
SvxCSS1PropertyInfo aPropInfo;
if( ParseStyleOptions( aStyle, aId, aClass, aItemSet, aPropInfo, &aLang, &aDir ) )
{
DoPositioning( aItemSet, aPropInfo, pCntxt );
InsertAttrs( aItemSet, aPropInfo, pCntxt );
}
}
PushContext( pCntxt );
// die Attribute der neuen Vorlage setzen
if( nDefListDeep > 1 )
SetTxtCollAttrs( pCntxt );
}
void SwHTMLParser::EndDefList()
{
sal_Bool bSpace = (GetNumInfo().GetDepth() + nDefListDeep) == 1;
if( pPam->GetPoint()->nContent.GetIndex() )
AppendTxtNode( bSpace ? AM_SPACE : AM_SOFTNOSPACE );
else if( bSpace )
AddParSpace();
// ein Level weniger
if( nDefListDeep > 0 )
nDefListDeep--;
// den aktuellen Kontext vom Stack holen
_HTMLAttrContext *pCntxt = PopContext( HTML_DEFLIST_ON );
// und noch Attribute beenden
if( pCntxt )
{
EndContext( pCntxt );
SetAttr(); // Absatz-Atts wegen JavaScript moeglichst schnell setzen
delete pCntxt;
}
// und Vorlage setzen
SetTxtCollAttrs();
}
void SwHTMLParser::NewDefListItem( int nToken )
{
// festellen, ob das DD/DT in einer DL vorkommt
sal_Bool bInDefList = sal_False, bNotInDefList = sal_False;
sal_uInt16 nPos = aContexts.Count();
while( !bInDefList && !bNotInDefList && nPos>nContextStMin )
{
sal_uInt16 nCntxtToken = aContexts[--nPos]->GetToken();
switch( nCntxtToken )
{
case HTML_DEFLIST_ON:
bInDefList = sal_True;
break;
case HTML_DIRLIST_ON:
case HTML_MENULIST_ON:
case HTML_ORDERLIST_ON:
case HTML_UNORDERLIST_ON:
bNotInDefList = sal_True;
break;
}
}
// wenn nicht, implizit eine neue DL aufmachen
if( !bInDefList )
{
nDefListDeep++;
ASSERT( !nOpenParaToken,
"Jetzt geht ein offenes Absatz-Element verloren" );
nOpenParaToken = static_cast< sal_uInt16 >(nToken);
}
NewTxtFmtColl( nToken, static_cast< sal_uInt16 >(nToken==HTML_DD_ON ? RES_POOLCOLL_HTML_DD
: RES_POOLCOLL_HTML_DT) );
}
void SwHTMLParser::EndDefListItem( int nToken, sal_Bool bSetColl,
sal_Bool /*bLastPara*/ )
{
// einen neuen Absatz aufmachen
if( !nToken && pPam->GetPoint()->nContent.GetIndex() )
AppendTxtNode( AM_SOFTNOSPACE );
// Kontext zu dem Token suchen und vom Stack holen
nToken &= ~1;
_HTMLAttrContext *pCntxt = 0;
sal_uInt16 nPos = aContexts.Count();
while( !pCntxt && nPos>nContextStMin )
{
sal_uInt16 nCntxtToken = aContexts[--nPos]->GetToken();
switch( nCntxtToken )
{
case HTML_DD_ON:
case HTML_DT_ON:
if( !nToken || nToken == nCntxtToken )
{
pCntxt = aContexts[nPos];
aContexts.Remove( nPos, 1 );
}
break;
case HTML_DEFLIST_ON:
// keine DD/DT ausserhalb der aktuelen DefListe betrachten
case HTML_DIRLIST_ON:
case HTML_MENULIST_ON:
case HTML_ORDERLIST_ON:
case HTML_UNORDERLIST_ON:
// und auch nicht ausserhalb einer anderen Liste
nPos = nContextStMin;
break;
}
}
// und noch Attribute beenden
if( pCntxt )
{
EndContext( pCntxt );
SetAttr(); // Absatz-Atts wegen JavaScript moeglichst schnell setzen
delete pCntxt;
}
// und die bisherige Vorlage setzen
if( bSetColl )
SetTxtCollAttrs();
}
/* */
sal_Bool SwHTMLParser::HasCurrentParaFlys( sal_Bool bNoSurroundOnly,
sal_Bool bSurroundOnly ) const
{
// bNoSurroundOnly: Der Absatz enthaelt mindestens einen Rahmen
// ohne Umlauf
// bSurroundOnly: Der Absatz enthaelt mindestens einen Rahmen
// mit Umlauf aber keinen ohne Umlauf
// sonst: Der Absatz enthaelt irgendeinen Rahmen
SwNodeIndex& rNodeIdx = pPam->GetPoint()->nNode;
const SwSpzFrmFmts& rFrmFmtTbl = *pDoc->GetSpzFrmFmts();
sal_Bool bFound = sal_False;
for ( sal_uInt16 i=0; i<rFrmFmtTbl.Count(); i++ )
{
SwFrmFmt *const pFmt = rFrmFmtTbl[i];
SwFmtAnchor const*const pAnchor = &pFmt->GetAnchor();
// Ein Rahmen wurde gefunden, wenn
// - er absatzgebunden ist, und
// - im aktuellen Absatz verankert ist, und
// - jeder absatzgebunene Rahmen zaehlt, oder
// - (nur Rahmen oder umlauf zaehlen und ) der Rahmen keinen
// Umlauf besitzt
SwPosition const*const pAPos = pAnchor->GetCntntAnchor();
if (pAPos &&
((FLY_AT_PARA == pAnchor->GetAnchorId()) ||
(FLY_AT_CHAR == pAnchor->GetAnchorId())) &&
pAPos->nNode == rNodeIdx )
{
if( !(bNoSurroundOnly || bSurroundOnly) )
{
bFound = sal_True;
break;
}
else
{
// fix #42282#: Wenn Rahmen mit Umlauf gesucht sind,
// auch keine mit Durchlauf beachten. Dabei handelt es
// sich (noch) um HIDDEN-Controls, und denen weicht man
// besser auch nicht aus.
SwSurround eSurround = pFmt->GetSurround().GetSurround();
if( bNoSurroundOnly )
{
if( SURROUND_NONE==eSurround )
{
bFound = sal_True;
break;
}
}
if( bSurroundOnly )
{
if( SURROUND_NONE==eSurround )
{
bFound = sal_False;
break;
}
else if( SURROUND_THROUGHT!=eSurround )
{
bFound = sal_True;
// weitersuchen: Es koennten ja noch welche ohne
// Umlauf kommen ...
}
}
}
}
}
return bFound;
}
/* */
// die speziellen Methoden zum Einfuegen von Objecten
const SwFmtColl *SwHTMLParser::GetCurrFmtColl() const
{
const SwCntntNode* pCNd = pPam->GetCntntNode();
return &pCNd->GetAnyFmtColl();
}
void SwHTMLParser::SetTxtCollAttrs( _HTMLAttrContext *pContext )
{
SwTxtFmtColl *pCollToSet = 0; // die zu setzende Vorlage
SfxItemSet *pItemSet = 0; // der Set fuer harte Attrs
sal_uInt16 nTopColl = pContext ? pContext->GetTxtFmtColl() : 0;
const String& rTopClass = pContext ? pContext->GetClass() : (const String&) aEmptyStr;
sal_uInt16 nDfltColl = RES_POOLCOLL_TEXT;
sal_Bool bInPRE=sal_False; // etwas Kontext Info
sal_uInt16 nLeftMargin = 0, nRightMargin = 0; // die Einzuege und
short nFirstLineIndent = 0; // Abstaende
sal_uInt16 i;
for( i = nContextStAttrMin; i < aContexts.Count(); i++ )
{
const _HTMLAttrContext *pCntxt = aContexts[i];
sal_uInt16 nColl = pCntxt->GetTxtFmtColl();
if( nColl )
{
// Es gibt eine Vorlage, die zu setzen ist. Dann
// muss zunaechst einmal entschieden werden,
// ob die Vorlage auch gesetzt werden kann
sal_Bool bSetThis = sal_True;
switch( nColl )
{
case sal_uInt16(RES_POOLCOLL_HTML_PRE):
bInPRE = sal_True;
break;
case sal_uInt16(RES_POOLCOLL_TEXT):
// <TD><P CLASS=xxx> muss TD.xxx werden
if( nDfltColl==RES_POOLCOLL_TABLE ||
nDfltColl==RES_POOLCOLL_TABLE_HDLN )
nColl = nDfltColl;
break;
case sal_uInt16(RES_POOLCOLL_HTML_HR):
// <HR> auch in <PRE> als Vorlage setzen, sonst kann man sie
// nicht mehr exportieren
break;
default:
if( bInPRE )
bSetThis = sal_False;
break;
}
SwTxtFmtColl *pNewColl =
pCSS1Parser->GetTxtFmtColl( nColl, pCntxt->GetClass() );
if( bSetThis )
{
// wenn jetzt eine andere Vorlage gesetzt werden soll als
// bisher, muss die bishere Vorlage durch harte Attributierung
// ersetzt werden
if( pCollToSet )
{
// die Attribute, die die bisherige Vorlage setzt
// hart einfuegen
if( !pItemSet )
pItemSet = new SfxItemSet( pCollToSet->GetAttrSet() );
else
{
const SfxItemSet& rCollSet = pCollToSet->GetAttrSet();
SfxItemSet aItemSet( *rCollSet.GetPool(),
rCollSet.GetRanges() );
aItemSet.Set( rCollSet );
pItemSet->Put( aItemSet );
}
// aber die Attribute, die aktuelle Vorlage setzt
// entfernen, weil sie sonst spaeter ueberschrieben
// werden
pItemSet->Differentiate( pNewColl->GetAttrSet() );
}
pCollToSet = pNewColl;
}
else
{
// hart Attributieren
if( !pItemSet )
pItemSet = new SfxItemSet( pNewColl->GetAttrSet() );
else
{
const SfxItemSet& rCollSet = pNewColl->GetAttrSet();
SfxItemSet aItemSet( *rCollSet.GetPool(),
rCollSet.GetRanges() );
aItemSet.Set( rCollSet );
pItemSet->Put( aItemSet );
}
}
}
else
{
// vielliecht gibt es ja eine Default-Vorlage?
nColl = pCntxt->GetDfltTxtFmtColl();
if( nColl )
nDfltColl = nColl;
}
// ggf. neue Absatz-Einzuege holen
if( pCntxt->IsLRSpaceChanged() )
{
sal_uInt16 nLeft=0, nRight=0;
pCntxt->GetMargins( nLeft, nRight, nFirstLineIndent );
nLeftMargin = nLeft;
nRightMargin = nRight;
}
}
// wenn im aktuellen Kontext eine neue Vorlage gesetzt werden soll,
// muessen deren Absatz-Abstaende noch in den Kontext eingetragen werden
if( pContext && nTopColl )
{
// <TD><P CLASS=xxx> muss TD.xxx werden
if( nTopColl==RES_POOLCOLL_TEXT &&
(nDfltColl==RES_POOLCOLL_TABLE ||
nDfltColl==RES_POOLCOLL_TABLE_HDLN) )
nTopColl = nDfltColl;
const SwTxtFmtColl *pTopColl =
pCSS1Parser->GetTxtFmtColl( nTopColl, rTopClass );
const SfxItemSet& rItemSet = pTopColl->GetAttrSet();
const SfxPoolItem *pItem;
if( SFX_ITEM_SET == rItemSet.GetItemState(RES_LR_SPACE,sal_True, &pItem) )
{
const SvxLRSpaceItem *pLRItem =
(const SvxLRSpaceItem *)pItem;
sal_Int32 nLeft = pLRItem->GetTxtLeft();
sal_Int32 nRight = pLRItem->GetRight();
nFirstLineIndent = pLRItem->GetTxtFirstLineOfst();
// In Definitions-Listen enthalten die Abstaende auch die der
// vorhergehenden Level
if( RES_POOLCOLL_HTML_DD == nTopColl )
{
const SvxLRSpaceItem& rDTLRSpace = pCSS1Parser
->GetTxtFmtColl( RES_POOLCOLL_HTML_DT, aEmptyStr )
->GetLRSpace();
nLeft -= rDTLRSpace.GetTxtLeft();
nRight -= rDTLRSpace.GetRight();
}
else if( RES_POOLCOLL_HTML_DT == nTopColl )
{
nLeft = 0;
nRight = 0;
}
// die Absatz-Abstaende addieren sich
nLeftMargin = nLeftMargin + static_cast< sal_uInt16 >(nLeft);
nRightMargin = nRightMargin + static_cast< sal_uInt16 >(nRight);
pContext->SetMargins( nLeftMargin, nRightMargin,
nFirstLineIndent );
}
if( SFX_ITEM_SET == rItemSet.GetItemState(RES_UL_SPACE,sal_True, &pItem) )
{
const SvxULSpaceItem *pULItem =
(const SvxULSpaceItem *)pItem;
pContext->SetULSpace( pULItem->GetUpper(), pULItem->GetLower() );
}
}
// wenn gar keine Vorlage im Kontext gesetzt ist, Textkoerper nehmen
if( !pCollToSet )
{
pCollToSet = pCSS1Parser->GetTxtCollFromPool( nDfltColl );
const SvxLRSpaceItem& rLRItem = pCollToSet->GetLRSpace();
if( !nLeftMargin )
nLeftMargin = static_cast< sal_uInt16 >(rLRItem.GetTxtLeft());
if( !nRightMargin )
nRightMargin = static_cast< sal_uInt16 >(rLRItem.GetRight());
if( !nFirstLineIndent )
nFirstLineIndent = rLRItem.GetTxtFirstLineOfst();
}
// bisherige harte Attributierung des Absatzes entfernen
if( aParaAttrs.Count() )
{
for( i=0; i<aParaAttrs.Count(); i++ )
aParaAttrs[i]->Invalidate();
aParaAttrs.Remove( 0, aParaAttrs.Count() );
}
// Die Vorlage setzen
pDoc->SetTxtFmtColl( *pPam, pCollToSet );
// ggf. noch den Absatz-Einzug korrigieren
const SvxLRSpaceItem& rLRItem = pCollToSet->GetLRSpace();
sal_Bool bSetLRSpace;
bSetLRSpace = nLeftMargin != rLRItem.GetTxtLeft() ||
nFirstLineIndent != rLRItem.GetTxtFirstLineOfst() ||
nRightMargin != rLRItem.GetRight();
if( bSetLRSpace )
{
SvxLRSpaceItem aLRItem( rLRItem );
aLRItem.SetTxtLeft( nLeftMargin );
aLRItem.SetRight( nRightMargin );
aLRItem.SetTxtFirstLineOfst( nFirstLineIndent );
if( pItemSet )
pItemSet->Put( aLRItem );
else
{
NewAttr( &aAttrTab.pLRSpace, aLRItem );
aAttrTab.pLRSpace->SetLikePara();
aParaAttrs.Insert( aAttrTab.pLRSpace, aParaAttrs.Count() );
EndAttr( aAttrTab.pLRSpace, 0, sal_False );
}
}
// und nun noch die Attribute setzen
if( pItemSet )
{
InsertParaAttrs( *pItemSet );
delete pItemSet;
}
}
/* */
void SwHTMLParser::NewCharFmt( int nToken )
{
String aId, aStyle, aClass, aLang, aDir;
const HTMLOptions *pHTMLOptions = GetOptions();
for( sal_uInt16 i = pHTMLOptions->Count(); i; )
{
const HTMLOption *pOption = (*pHTMLOptions)[--i];
switch( pOption->GetToken() )
{
case HTML_O_ID:
aId = pOption->GetString();
break;
case HTML_O_STYLE:
aStyle = pOption->GetString();
break;
case HTML_O_CLASS:
aClass = pOption->GetString();
break;
case HTML_O_LANG:
aLang = pOption->GetString();
break;
case HTML_O_DIR:
aDir = pOption->GetString();
break;
}
}
// einen neuen Kontext anlegen
_HTMLAttrContext *pCntxt = new _HTMLAttrContext( static_cast< sal_uInt16 >(nToken) );
// die Vorlage setzen und im Kontext merken
SwCharFmt* pCFmt = pCSS1Parser->GetChrFmt( static_cast< sal_uInt16 >(nToken), aClass );
ASSERT( pCFmt, "keine Zeichenvorlage zu Token gefunden" );
// Styles parsen (zu Class siehe auch NewPara)
if( HasStyleOptions( aStyle, aId, aEmptyStr, &aLang, &aDir ) )
{
SfxItemSet aItemSet( pDoc->GetAttrPool(), pCSS1Parser->GetWhichMap() );
SvxCSS1PropertyInfo aPropInfo;
if( ParseStyleOptions( aStyle, aId, aEmptyStr, aItemSet, aPropInfo, &aLang, &aDir ) )
{
ASSERT( !aClass.Len() || !pCSS1Parser->GetClass( aClass ),
"Class wird nicht beruecksichtigt" );
DoPositioning( aItemSet, aPropInfo, pCntxt );
InsertAttrs( aItemSet, aPropInfo, pCntxt, sal_True );
}
}
// Zeichen-Vorlagen werden in einem eigenen Stack gehalten und
// koennen nie durch Styles eingefuegt werden. Das Attribut ist deshalb
// auch gar nicht im CSS1-Which-Range enthalten
if( pCFmt )
InsertAttr( &aAttrTab.pCharFmts, SwFmtCharFmt( pCFmt ), pCntxt );
// den Kontext merken
PushContext( pCntxt );
}
/* */
void SwHTMLParser::InsertSpacer()
{
// und es ggf. durch die Optionen veraendern
String aId;
sal_Int16 eVertOri = text::VertOrientation::TOP;
sal_Int16 eHoriOri = text::HoriOrientation::NONE;
Size aSize( 0, 0);
long nSize = 0;
sal_Bool bPrcWidth = sal_False;
sal_Bool bPrcHeight = sal_False;
sal_uInt16 nType = HTML_SPTYPE_HORI;
const HTMLOptions *pHTMLOptions = GetOptions();
for( sal_uInt16 i = pHTMLOptions->Count(); i; )
{
const HTMLOption *pOption = (*pHTMLOptions)[--i];
switch( pOption->GetToken() )
{
case HTML_O_ID:
aId = pOption->GetString();
break;
case HTML_O_TYPE:
pOption->GetEnum( nType, aHTMLSpacerTypeTable );
break;
case HTML_O_ALIGN:
eVertOri =
pOption->GetEnum( aHTMLImgVAlignTable,
eVertOri );
eHoriOri =
pOption->GetEnum( aHTMLImgHAlignTable,
eHoriOri );
break;
case HTML_O_WIDTH:
// erstmal nur als Pixelwerte merken!
bPrcWidth = (pOption->GetString().Search('%') != STRING_NOTFOUND);
aSize.Width() = (long)pOption->GetNumber();
break;
case HTML_O_HEIGHT:
// erstmal nur als Pixelwerte merken!
bPrcHeight = (pOption->GetString().Search('%') != STRING_NOTFOUND);
aSize.Height() = (long)pOption->GetNumber();
break;
case HTML_O_SIZE:
// erstmal nur als Pixelwerte merken!
nSize = pOption->GetNumber();
break;
}
}
switch( nType )
{
case HTML_SPTYPE_BLOCK:
{
// einen leeren Textrahmen anlegen
// den Itemset holen
SfxItemSet aFrmSet( pDoc->GetAttrPool(),
RES_FRMATR_BEGIN, RES_FRMATR_END-1 );
if( !IsNewDoc() )
Reader::ResetFrmFmtAttrs( aFrmSet );
// den Anker und die Ausrichtung setzen
SetAnchorAndAdjustment( eVertOri, eHoriOri, aFrmSet );
// und noch die Groesse des Rahmens
Size aDfltSz( MINFLY, MINFLY );
Size aSpace( 0, 0 );
SfxItemSet aDummyItemSet( pDoc->GetAttrPool(),
pCSS1Parser->GetWhichMap() );
SvxCSS1PropertyInfo aDummyPropInfo;
SetFixSize( aSize, aDfltSz, bPrcWidth, bPrcHeight,
aDummyItemSet, aDummyPropInfo, aFrmSet );
SetSpace( aSpace, aDummyItemSet, aDummyPropInfo, aFrmSet );
// den Inhalt schuetzen
SvxProtectItem aProtectItem( RES_PROTECT) ;
aProtectItem.SetCntntProtect( sal_True );
aFrmSet.Put( aProtectItem );
// der Rahmen anlegen
RndStdIds eAnchorId =
((const SwFmtAnchor &)aFrmSet.Get(RES_ANCHOR)).GetAnchorId();
SwFrmFmt *pFlyFmt = pDoc->MakeFlySection( eAnchorId,
pPam->GetPoint(), &aFrmSet );
// Ggf Frames anlegen und auto-geb. Rahmen registrieren
RegisterFlyFrm( pFlyFmt );
}
break;
case HTML_SPTYPE_VERT:
if( nSize > 0 )
{
if( nSize && Application::GetDefaultDevice() )
{
nSize = Application::GetDefaultDevice()
->PixelToLogic( Size(0,nSize),
MapMode(MAP_TWIP) ).Height();
}
// einen Absatz-Abstand setzen
SwTxtNode *pTxtNode = 0;
if( !pPam->GetPoint()->nContent.GetIndex() )
{
// den unteren Absatz-Abstand des vorherigen Nodes aendern,
// wenn moeglich
SetAttr(); // noch offene Absatz-Attribute setzen
pTxtNode = pDoc->GetNodes()[pPam->GetPoint()->nNode.GetIndex()-1]
->GetTxtNode();
// Wenn der Abstz davor kein Txtenode ist, dann wird jetzt
// ein leere Absatz angelegt, der eh schon eine Zeilenhoehe
// Abstand erzeugt.
if( !pTxtNode )
nSize = nSize>HTML_PARSPACE ? nSize-HTML_PARSPACE : 0;
}
if( pTxtNode )
{
SvxULSpaceItem aULSpace( (const SvxULSpaceItem&)pTxtNode
->SwCntntNode::GetAttr( RES_UL_SPACE ) );
aULSpace.SetLower( aULSpace.GetLower() + (sal_uInt16)nSize );
pTxtNode->SetAttr( aULSpace );
}
else
{
NewAttr( &aAttrTab.pULSpace, SvxULSpaceItem( 0, (sal_uInt16)nSize, RES_UL_SPACE ) );
EndAttr( aAttrTab.pULSpace, 0, sal_False );
AppendTxtNode(); // nicht am Abstand drehen!
}
}
break;
case HTML_SPTYPE_HORI:
if( nSize > 0 )
{
// wenn der Absatz noch leer ist, einen Erstzeilen-Einzug
// setzen, sondern Sperrschrift ueber einem Space aufspannen
if( nSize && Application::GetDefaultDevice() )
{
nSize = Application::GetDefaultDevice()
->PixelToLogic( Size(nSize,0),
MapMode(MAP_TWIP) ).Width();
}
if( !pPam->GetPoint()->nContent.GetIndex() )
{
sal_uInt16 nLeft=0, nRight=0;
short nIndent = 0;
GetMarginsFromContextWithNumBul( nLeft, nRight, nIndent );
nIndent = nIndent + (short)nSize;
SvxLRSpaceItem aLRItem( RES_LR_SPACE );
aLRItem.SetTxtLeft( nLeft );
aLRItem.SetRight( nRight );
aLRItem.SetTxtFirstLineOfst( nIndent );
NewAttr( &aAttrTab.pLRSpace, aLRItem );
EndAttr( aAttrTab.pLRSpace, 0, sal_False );
}
else
{
NewAttr( &aAttrTab.pKerning, SvxKerningItem( (short)nSize, RES_CHRATR_KERNING ) );
String aTmp( ' ' );
pDoc->InsertString( *pPam, aTmp );
EndAttr( aAttrTab.pKerning );
}
}
}
}
sal_uInt16 SwHTMLParser::ToTwips( sal_uInt16 nPixel ) const
{
if( nPixel && Application::GetDefaultDevice() )
{
long nTwips = Application::GetDefaultDevice()->PixelToLogic(
Size( nPixel, nPixel ), MapMode( MAP_TWIP ) ).Width();
return nTwips <= USHRT_MAX ? (sal_uInt16)nTwips : USHRT_MAX;
}
else
return nPixel;
}
SwTwips SwHTMLParser::GetCurrentBrowseWidth()
{
const SwTwips nWidth = SwHTMLTableLayout::GetBrowseWidth( *pDoc );
if( nWidth )
return nWidth;
if( !aHTMLPageSize.Width() )
{
const SwFrmFmt& rPgFmt = pCSS1Parser->GetMasterPageDesc()->GetMaster();
const SwFmtFrmSize& rSz = rPgFmt.GetFrmSize();
const SvxLRSpaceItem& rLR = rPgFmt.GetLRSpace();
const SvxULSpaceItem& rUL = rPgFmt.GetULSpace();
const SwFmtCol& rCol = rPgFmt.GetCol();
aHTMLPageSize.Width() = rSz.GetWidth() - rLR.GetLeft() - rLR.GetRight();
aHTMLPageSize.Height() = rSz.GetHeight() - rUL.GetUpper() - rUL.GetLower();
if( 1 < rCol.GetNumCols() )
aHTMLPageSize.Width() /= rCol.GetNumCols();
}
return aHTMLPageSize.Width();
}
/* */
void SwHTMLParser::InsertIDOption()
{
String aId;
const HTMLOptions *pHTMLOptions = GetOptions();
for( sal_uInt16 i = pHTMLOptions->Count(); i; )
{
const HTMLOption *pOption = (*pHTMLOptions)[--i];
if( HTML_O_ID==pOption->GetToken() )
{
aId = pOption->GetString();
break;
}
}
if( aId.Len() )
InsertBookmark( aId );
}
/* */
void SwHTMLParser::InsertLineBreak()
{
// <BR CLEAR=xxx> wird wie folgt behandelt:
// 1.) Es werden nur nur absatzgebundene Rahmen betrachtet, die
// im aktuellen Absatz verankert sind.
// 2.) Fuer linksbuendig ausgerichtete Rahmen wird bei CLEAR=LEFT
// oder ALL und auf rechtsbuendige ausgerichtete Rahmen bei
// CLEAR=RIGHT oder ALL der Durchlauf wie folgt geaendert:
// 3.) Wenn der Absatz keinen Text enthaelt, bekommt der Rahmen keinen
// Umlauf
// 4.) sonst erhaelt ein links ausgerichteter Rahmen eine rechten
// "nur Anker" Umlauf und recht rechst ausg. Rahmen einen linken
// "nur Anker" Umlauf.
// 5.) wenn in einem nicht-leeren Absatz der Umlauf eines Rahmens
// geaendert wird, wird ein neuer Absatz aufgemacht
// 6.) Wenn von keinem Rahmen der Umlauf geaendert wird, wird ein
// harter Zeilenumbruch eingefuegt
String aId, aStyle, aClass; // die ID der Bookmark
sal_Bool bClearLeft = sal_False, bClearRight = sal_False;
sal_Bool bCleared = sal_False; // wurde ein CLEAR ausgefuehrt?
// dann holen wir mal die Optionen
const HTMLOptions *pHTMLOptions = GetOptions();
for( sal_uInt16 i = pHTMLOptions->Count(); i; )
{
const HTMLOption *pOption = (*pHTMLOptions)[--i];
switch( pOption->GetToken() )
{
case HTML_O_CLEAR:
{
const String &aClear = pOption->GetString();
if( aClear.EqualsIgnoreCaseAscii( OOO_STRING_SVTOOLS_HTML_AL_all ) )
{
bClearLeft = sal_True;
bClearRight = sal_True;
}
else if( aClear.EqualsIgnoreCaseAscii( OOO_STRING_SVTOOLS_HTML_AL_left ) )
bClearLeft = sal_True;
else if( aClear.EqualsIgnoreCaseAscii( OOO_STRING_SVTOOLS_HTML_AL_right ) )
bClearRight = sal_True;
}
break;
case HTML_O_ID:
aId = pOption->GetString();
break;
case HTML_O_STYLE:
aStyle = pOption->GetString();
break;
case HTML_O_CLASS:
aClass = pOption->GetString();
break;
}
}
// CLEAR wird nur fuer den aktuellen Absaetz unterstuetzt
if( bClearLeft || bClearRight )
{
SwNodeIndex& rNodeIdx = pPam->GetPoint()->nNode;
SwTxtNode* pTxtNd = rNodeIdx.GetNode().GetTxtNode();
if( pTxtNd )
{
const SwSpzFrmFmts& rFrmFmtTbl = *pDoc->GetSpzFrmFmts();
for( sal_uInt16 i=0; i<rFrmFmtTbl.Count(); i++ )
{
SwFrmFmt *const pFmt = rFrmFmtTbl[i];
SwFmtAnchor const*const pAnchor = &pFmt->GetAnchor();
SwPosition const*const pAPos = pAnchor->GetCntntAnchor();
if (pAPos &&
((FLY_AT_PARA == pAnchor->GetAnchorId()) ||
(FLY_AT_CHAR == pAnchor->GetAnchorId())) &&
pAPos->nNode == rNodeIdx &&
pFmt->GetSurround().GetSurround() != SURROUND_NONE )
{
sal_Int16 eHori = RES_DRAWFRMFMT == pFmt->Which()
? text::HoriOrientation::LEFT
: pFmt->GetHoriOrient().GetHoriOrient();
SwSurround eSurround = SURROUND_PARALLEL;
if( pPam->GetPoint()->nContent.GetIndex() )
{
if( bClearLeft && text::HoriOrientation::LEFT==eHori )
eSurround = SURROUND_RIGHT;
else if( bClearRight && text::HoriOrientation::RIGHT==eHori )
eSurround = SURROUND_LEFT;
}
else if( (bClearLeft && text::HoriOrientation::LEFT==eHori) ||
(bClearRight && text::HoriOrientation::RIGHT==eHori) )
{
eSurround = SURROUND_NONE;
}
if( SURROUND_PARALLEL != eSurround )
{
SwFmtSurround aSurround( eSurround );
if( SURROUND_NONE != eSurround )
aSurround.SetAnchorOnly( sal_True );
pFmt->SetFmtAttr( aSurround );
bCleared = sal_True;
}
} // Anker ist nicht im Node
} // Schleife ueber Fly-Frames
} // kein Text-Node
} // kein CLEAR
// Styles parsen
SvxFmtBreakItem aBreakItem( SVX_BREAK_NONE, RES_BREAK );
sal_Bool bBreakItem = sal_False;
if( HasStyleOptions( aStyle, aId, aClass ) )
{
SfxItemSet aItemSet( pDoc->GetAttrPool(), pCSS1Parser->GetWhichMap() );
SvxCSS1PropertyInfo aPropInfo;
if( ParseStyleOptions( aStyle, aId, aClass, aItemSet, aPropInfo ) )
{
if( pCSS1Parser->SetFmtBreak( aItemSet, aPropInfo ) )
{
aBreakItem = (const SvxFmtBreakItem &)aItemSet.Get( RES_BREAK );
bBreakItem = sal_True;
}
if( aPropInfo.aId.Len() )
InsertBookmark( aPropInfo.aId );
}
}
if( bBreakItem && SVX_BREAK_PAGE_AFTER==aBreakItem.GetBreak() )
{
NewAttr( &aAttrTab.pBreak, aBreakItem );
EndAttr( aAttrTab.pBreak, 0, sal_False );
}
if( !bCleared && !bBreakItem )
{
// wenn kein CLEAR ausgefuehrt werden sollte oder konnte, wird
// ein Zeilenumbruch eingef?gt
String sTmp( (sal_Unicode)0x0a ); // make the Mac happy :-)
pDoc->InsertString( *pPam, sTmp );
}
else if( pPam->GetPoint()->nContent.GetIndex() )
{
// wenn ein Claer in einem nicht-leeren Absatz ausgefuehrt wurde,
// muss anschliessen ein neuer Absatz aufgemacht werden
// MIB 21.02.97: Eigentlich muesste man hier den unteren Absatz-
// Absatnd auf 0 drehen. Das geht aber bei sowas wie <BR ..><P>
// schief (>Netacpe). Deshalb lassen wir das erstmal.
AppendTxtNode( AM_NOSPACE );
}
if( bBreakItem && SVX_BREAK_PAGE_BEFORE==aBreakItem.GetBreak() )
{
NewAttr( &aAttrTab.pBreak, aBreakItem );
EndAttr( aAttrTab.pBreak, 0, sal_False );
}
}
void SwHTMLParser::InsertHorzRule()
{
sal_uInt16 nSize = 0;
sal_uInt16 nWidth = 0;
SvxAdjust eAdjust = SVX_ADJUST_END;
sal_Bool bPrcWidth = sal_False;
sal_Bool bNoShade = sal_False;
sal_Bool bColor = sal_False;
Color aColor;
String aId;
// dann holen wir mal die Optionen
const HTMLOptions *pHTMLOptions = GetOptions();
for( sal_uInt16 i = pHTMLOptions->Count(); i; )
{
const HTMLOption *pOption = (*pHTMLOptions)[--i];
switch( pOption->GetToken() )
{
case HTML_O_ID:
aId = pOption->GetString();
break;
case HTML_O_SIZE:
nSize = (sal_uInt16)pOption->GetNumber();
break;
case HTML_O_WIDTH:
bPrcWidth = (pOption->GetString().Search('%') != STRING_NOTFOUND);
nWidth = (sal_uInt16)pOption->GetNumber();
if( bPrcWidth && nWidth>=100 )
{
// 100%-Linien sind der default-Fall (keine Attrs neotig)
nWidth = 0;
bPrcWidth = sal_False;
}
break;
case HTML_O_ALIGN:
eAdjust =
(SvxAdjust)pOption->GetEnum( aHTMLPAlignTable, static_cast< sal_uInt16 >(eAdjust) );
break;
case HTML_O_NOSHADE:
bNoShade = sal_True;
break;
case HTML_O_COLOR:
pOption->GetColor( aColor );
bColor = sal_True;
break;
}
}
if( pPam->GetPoint()->nContent.GetIndex() )
AppendTxtNode( AM_NOSPACE );
if( nOpenParaToken )
EndPara();
AppendTxtNode();
pPam->Move( fnMoveBackward );
// ... und in einem Kontext merken
_HTMLAttrContext *pCntxt =
new _HTMLAttrContext( HTML_HORZRULE, RES_POOLCOLL_HTML_HR, aEmptyStr );
PushContext( pCntxt );
// die neue Vorlage setzen
SetTxtCollAttrs( pCntxt );
// die harten Attribute an diesem Absatz werden nie mehr ungueltig
if( aParaAttrs.Count() )
aParaAttrs.Remove( 0, aParaAttrs.Count() );
if( nSize>0 || bColor || bNoShade )
{
// Farbe und/oder Breite der Linie setzen
if( !bColor )
aColor.SetColor( COL_GRAY );
SvxBorderLine aBorderLine( &aColor );
if( nSize )
{
long nPWidth = 0;
long nPHeight = (long)nSize;
SvxCSS1Parser::PixelToTwip( nPWidth, nPHeight );
SvxCSS1Parser::SetBorderWidth( aBorderLine, (sal_uInt16)nPHeight,
!bNoShade );
}
else if( bNoShade )
{
aBorderLine.SetOutWidth( DEF_LINE_WIDTH_2 );
}
else
{
aBorderLine.SetOutWidth( DEF_DOUBLE_LINE0_OUT );
aBorderLine.SetInWidth( DEF_DOUBLE_LINE0_IN );
aBorderLine.SetDistance( DEF_DOUBLE_LINE0_DIST );
}
SvxBoxItem aBoxItem(RES_BOX);
aBoxItem.SetLine( &aBorderLine, BOX_LINE_BOTTOM );
_HTMLAttr* pTmp = new _HTMLAttr( *pPam->GetPoint(), aBoxItem );
aSetAttrTab.Insert( pTmp, aSetAttrTab.Count() );
}
if( nWidth )
{
// Wenn wir in keiner Tabelle sind, wird die Breitenangabe durch
// Absatz-Einzuege "getuerkt". In einer Tabelle macht das wenig
// Sinn. Um zu Vermeiden, dass die Linie bei der Breitenberechnung
// beruecksichtigt wird, bekommt sie aber trotzdem entsprechendes
// LRSpace-Item verpasst.
#ifdef FIX41370
const SwFmtColl *pColl = GetCurrFmtColl();
SvxLRSpaceItem aLRItem( pColl->GetLRSpace() );
#endif
if( !pTable )
{
// Laenge und Ausrichtung der Linie ueber Absatz-Einzuege "tuerken"
long nBrowseWidth = GetCurrentBrowseWidth();
nWidth = bPrcWidth ? (sal_uInt16)((nWidth*nBrowseWidth) / 100)
: ToTwips( (sal_uInt16)nBrowseWidth );
if( nWidth < MINLAY )
nWidth = MINLAY;
if( (long)nWidth < nBrowseWidth )
{
#ifndef FIX41370
const SwFmtColl *pColl = GetCurrFmtColl();
SvxLRSpaceItem aLRItem( pColl->GetLRSpace() );
#endif
long nDist = nBrowseWidth - nWidth;
switch( eAdjust )
{
case SVX_ADJUST_RIGHT:
aLRItem.SetTxtLeft( (sal_uInt16)nDist );
break;
case SVX_ADJUST_LEFT:
aLRItem.SetRight( (sal_uInt16)nDist );
break;
case SVX_ADJUST_CENTER:
default:
nDist /= 2;
aLRItem.SetTxtLeft( (sal_uInt16)nDist );
aLRItem.SetRight( (sal_uInt16)nDist );
break;
}
#ifndef FIX41370
_HTMLAttr* pTmp = new _HTMLAttr( *pPam->GetPoint(), aLRItem );
aSetAttrTab.Insert( pTmp, aSetAttrTab.Count() );
#endif
}
}
#ifdef FIX41370
_HTMLAttr* pTmp = new _HTMLAttr( *pPam->GetPoint(), aLRItem );
aSetAttrTab.Insert( pTmp, aSetAttrTab.Count() );
#endif
}
// Bookmarks koennen nicht in Hyperlinks eingefueht werden
if( aId.Len() )
InsertBookmark( aId );
// den aktuellen Kontext vom Stack holen
_HTMLAttrContext *pPoppedContext = PopContext( HTML_HORZRULE );
ASSERT( pPoppedContext==pCntxt, "wo kommt denn da ein HR-Kontext her?" );
delete pPoppedContext;
pPam->Move( fnMoveForward );
// und im Absatz danach die dort aktuelle Vorlage setzen
SetTxtCollAttrs();
}
void SwHTMLParser::ParseMoreMetaOptions()
{
String aName, aContent;
sal_Bool bHTTPEquiv = sal_False;
const HTMLOptions *pHTMLOptions = GetOptions();
for( sal_uInt16 i = pHTMLOptions->Count(); i; )
{
const HTMLOption *pOption = (*pHTMLOptions)[ --i ];
switch( pOption->GetToken() )
{
case HTML_O_NAME:
aName = pOption->GetString();
bHTTPEquiv = sal_False;
break;
case HTML_O_HTTPEQUIV:
aName = pOption->GetString();
bHTTPEquiv = sal_True;
break;
case HTML_O_CONTENT:
aContent = pOption->GetString();
break;
}
}
// Hier wird es etwas tricky: Wir wissen genau, da? die Dok-Info
// nicht geaendert wurde. Deshalb genuegt es, auf Generator und
// auf refresh abzufragen, um noch nicht verarbeitete Token zu finden,
// denn das sind die einzigen, die die Dok-Info nicht modifizieren.
if( aName.EqualsIgnoreCaseAscii( OOO_STRING_SVTOOLS_HTML_META_generator ) ||
aName.EqualsIgnoreCaseAscii( OOO_STRING_SVTOOLS_HTML_META_refresh ) ||
aName.EqualsIgnoreCaseAscii( OOO_STRING_SVTOOLS_HTML_META_content_type ) ||
aName.EqualsIgnoreCaseAscii( OOO_STRING_SVTOOLS_HTML_META_content_script_type ) )
return;
aContent.EraseAllChars( _CR );
aContent.EraseAllChars( _LF );
if( aName.EqualsIgnoreCaseAscii( OOO_STRING_SVTOOLS_HTML_META_sdendnote ) )
{
FillEndNoteInfo( aContent );
return;
}
if( aName.EqualsIgnoreCaseAscii( OOO_STRING_SVTOOLS_HTML_META_sdfootnote ) )
{
FillFootNoteInfo( aContent );
return;
}
String sText( String::CreateFromAscii(TOOLS_CONSTASCII_STRINGPARAM("HTML: <")) );
sText.AppendAscii( TOOLS_CONSTASCII_STRINGPARAM(OOO_STRING_SVTOOLS_HTML_meta) );
sText.Append( ' ' );
if( bHTTPEquiv )
sText.AppendAscii( TOOLS_CONSTASCII_STRINGPARAM(OOO_STRING_SVTOOLS_HTML_O_httpequiv) );
else
sText.AppendAscii( TOOLS_CONSTASCII_STRINGPARAM(OOO_STRING_SVTOOLS_HTML_O_name) );
sText.AppendAscii( TOOLS_CONSTASCII_STRINGPARAM("=\"") );
sText.Append( aName );
sText.AppendAscii( TOOLS_CONSTASCII_STRINGPARAM("\" ") );
sText.AppendAscii( TOOLS_CONSTASCII_STRINGPARAM(OOO_STRING_SVTOOLS_HTML_O_content) );
sText.AppendAscii( TOOLS_CONSTASCII_STRINGPARAM("=\"") );
sText.Append( aContent );
sText.AppendAscii( TOOLS_CONSTASCII_STRINGPARAM("\">") );
SwPostItField aPostItFld(
(SwPostItFieldType*)pDoc->GetSysFldType( RES_POSTITFLD ),
sText,
aEmptyStr,
aEmptyStr,
aEmptyStr,
DateTime() );
SwFmtFld aFmtFld( aPostItFld );
InsertAttr( aFmtFld );
}
/* */
_HTMLAttr::_HTMLAttr( const SwPosition& rPos, const SfxPoolItem& rItem,
_HTMLAttr **ppHd ) :
nSttPara( rPos.nNode ),
nEndPara( rPos.nNode ),
nSttCntnt( rPos.nContent.GetIndex() ),
nEndCntnt(rPos.nContent.GetIndex() ),
bInsAtStart( sal_True ),
bLikePara( sal_False ),
bValid( sal_True ),
nCount( 1 ),
pNext( 0 ),
pPrev( 0 ),
ppHead( ppHd )
{
pItem = rItem.Clone();
}
_HTMLAttr::_HTMLAttr( const _HTMLAttr &rAttr, const SwNodeIndex &rEndPara,
sal_uInt16 nEndCnt, _HTMLAttr **ppHd ) :
nSttPara( rAttr.nSttPara ),
nEndPara( rEndPara ),
nSttCntnt( rAttr.nSttCntnt ),
nEndCntnt( nEndCnt ),
bInsAtStart( rAttr.bInsAtStart ),
bLikePara( rAttr.bLikePara ),
bValid( rAttr.bValid ),
nCount( rAttr.nCount ),
pNext( 0 ),
pPrev( 0 ),
ppHead( ppHd )
{
pItem = rAttr.pItem->Clone();
}
_HTMLAttr::~_HTMLAttr()
{
delete pItem;
}
_HTMLAttr *_HTMLAttr::Clone( const SwNodeIndex& rEndPara, sal_uInt16 nEndCnt ) const
{
// das Attribut mit der alten Start-Position neu anlegen
_HTMLAttr *pNew = new _HTMLAttr( *this, rEndPara, nEndCnt, ppHead );
// die Previous-Liste muss uebernommen werden, die Next-Liste nicht!
pNew->pPrev = pPrev;
return pNew;
}
void _HTMLAttr::Reset( const SwNodeIndex& rSttPara, sal_uInt16 nSttCnt,
_HTMLAttr **ppHd )
{
// den Anfang (und das Ende) neu setzen
nSttPara = rSttPara;
nSttCntnt = nSttCnt;
nEndPara = rSttPara;
nEndCntnt = nSttCnt;
// den Head korrigieren und die Verkettungen aufheben
pNext = 0;
pPrev = 0;
ppHead = ppHd;
}
void _HTMLAttr::InsertPrev( _HTMLAttr *pPrv )
{
ASSERT( !pPrv->pNext || pPrv->pNext == this,
"_HTMLAttr::InsertPrev: pNext falsch" );
pPrv->pNext = 0;
ASSERT( 0 == pPrv->ppHead || ppHead == pPrv->ppHead,
"_HTMLAttr::InsertPrev: ppHead falsch" );
pPrv->ppHead = 0;
_HTMLAttr *pAttr = this;
while( pAttr->GetPrev() )
pAttr = pAttr->GetPrev();
pAttr->pPrev = pPrv;
}
bool SwHTMLParser::ParseMetaOptions(
const uno::Reference<document::XDocumentProperties> & i_xDocProps,
SvKeyValueIterator *i_pHeader )
{
// always call base ParseMetaOptions, it sets the encoding (#i96700#)
bool ret( HTMLParser::ParseMetaOptions(i_xDocProps, i_pHeader) );
if (!ret && IsNewDoc())
{
ParseMoreMetaOptions();
}
return ret;
}
// override so we can parse DOCINFO field subtypes INFO[1-4]
void SwHTMLParser::AddMetaUserDefined( ::rtl::OUString const & i_rMetaName )
{
// unless we already have 4 names, append the argument to m_InfoNames
::rtl::OUString* pName // the first empty string in m_InfoNames
(!m_InfoNames[0].getLength() ? &m_InfoNames[0] :
(!m_InfoNames[1].getLength() ? &m_InfoNames[1] :
(!m_InfoNames[2].getLength() ? &m_InfoNames[2] :
(!m_InfoNames[3].getLength() ? &m_InfoNames[3] : 0 ))));
if (pName)
{
(*pName) = i_rMetaName;
}
}