/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*************************************************************************
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
*
* - GNU Lesser General Public License Version 2.1
* - Sun Industry Standards Source License Version 1.1
*
* Sun Microsystems Inc., October, 2000
*
* GNU Lesser General Public License Version 2.1
* =============================================
* Copyright 2000 by Sun Microsystems, Inc.
* 901 San Antonio Road, Palo Alto, CA 94303, USA
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
*
* Sun Industry Standards Source License Version 1.1
* =================================================
* The contents of this file are subject to the Sun Industry Standards
* Source License Version 1.1 (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.openoffice.org/license.html.
*
* Software provided under this License is provided on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
* WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
* MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
* See the License for the specific provisions governing your rights and
* obligations concerning the Software.
*
* The Initial Developer of the Original Code is: IBM Corporation
*
* Copyright: 2008 by IBM Corporation
*
* All Rights Reserved.
*
* Contributor(s): _______________________________________
*
*
************************************************************************/
/*************************************************************************
* @file
* For LWP filter architecture prototype
************************************************************************/
#include "lwppara.hxx"
#include <lwpglobalmgr.hxx>
#include <lwpfilehdr.hxx>
#include "lwpparaproperty.hxx"
#include <lwptools.hxx>
#include "lwpparastyle.hxx"
#include <xfilter/xffont.hxx>
#include <xfilter/xftextstyle.hxx>
#include <xfilter/xfstylemanager.hxx>
#include <xfilter/xfparagraph.hxx>
#include <xfilter/xftextcontent.hxx>
#include <xfilter/xftextspan.hxx>
#include <xfilter/xfmargins.hxx>
#include <xfilter/xftabstop.hxx>
#include <xfilter/xflinebreak.hxx>
#include <xfilter/xfsection.hxx>
#include <xfilter/xfsectionstyle.hxx>
#include <xfilter/xfcolor.hxx>
#include <xfilter/xfhyperlink.hxx>
#include <xfilter/xfliststyle.hxx>
#include "lwpcharsetmgr.hxx"
#include "lwpsection.hxx"
#include "lwplayout.hxx"
#include "lwpusewhen.hxx"
#include "lwpbulletstylemgr.hxx"
#include "lwpstory.hxx"
#include "lwpsilverbullet.hxx"
#include <xfilter/xflist.hxx>
#include <xfilter/xfframe.hxx>
#include "lwpdivinfo.hxx"
#include "lwpdoc.hxx"
#include "lwpholder.hxx"
#include "lwppagehint.hxx"
#include <lwpdropcapmgr.hxx>
#include "lwptable.hxx"
#include <memory>
#include <set>
LwpPara::LwpPara(LwpObjectHeader const & objHdr, LwpSvStream* pStrm)
: LwpDLVList(objHdr, pStrm)
, m_nOrdinal(0)
, m_nFlags(0)
, m_nLevel(0)
, m_FontID(0)
, m_AllText("")
, m_bHasBullet(false)
, m_pSilverBullet(nullptr)
, m_bBullContinue(false)
, m_SectionStyleName("")
, m_bHasDropcap(false)
, m_nLines(0)
, m_nChars(0)
, m_pDropcapLayout(nullptr)
, m_BelowSpacing(0)
{
}
LwpPara::~LwpPara()
{
}
void LwpPara::Read()
{
LwpDLVList::Read();
bool Simple;
bool Notify = false;
if(LwpFileHeader::m_nFileRevision<0x0006)
Simple = false;
else if(LwpFileHeader::m_nFileRevision<0x000B)
Simple = m_pObjStrm->QuickReaduInt8() != 0;
else
{
sal_uInt8 Flag = m_pObjStrm->QuickReaduInt8();
const int DISK_SIMPLE = 1;
const int DISK_NOTIFY = 2;
Simple = (Flag & DISK_SIMPLE) != 0;
Notify = (Flag & DISK_NOTIFY) != 0;
}
if(!Simple)
{
m_nOrdinal = m_pObjStrm->QuickReaduInt32();
if(LwpFileHeader::m_nFileRevision<0x000B)
{
assert(false);
}
else
{
if (Notify)
{
std::unique_ptr<LwpForked3NotifyList> pNotifyList( new LwpForked3NotifyList );
pNotifyList->GetExtraList().Read(m_pObjStrm.get());
pNotifyList->Read(m_pObjStrm.get());
}
}
}
else
m_nOrdinal = 0x0001;
m_nFlags = m_pObjStrm->QuickReaduInt16();
m_ParaStyle.ReadIndexed(m_pObjStrm.get());
if(!Simple)
{
m_Hint.Read(m_pObjStrm.get());
}
m_Story.ReadIndexed(m_pObjStrm.get());
if(!Simple)
{
if(LwpFileHeader::m_nFileRevision<0x000B)
{
// TODO: to process
assert(false);
}
m_nLevel = m_pObjStrm->QuickReaduInt16();
if (m_nLevel > 9)
{
m_nLevel = 9;
}
}
else
m_nLevel = 0x0001;
m_Fribs.SetPara(this);// for silver bullet
m_Fribs.ReadPara(m_pObjStrm.get());
ReadPropertyList(m_pObjStrm.get());
}
void LwpPara::Parse(IXFStream* pOutputStream)
{
m_xXFContainer.set(new XFContentContainer);
XFConvert(m_xXFContainer.get());
if (!m_xXFContainer)
return;
m_xXFContainer->ToXml(pOutputStream);
m_xXFContainer->Reset();
m_xXFContainer.clear();
}
void LwpPara::XFConvert(XFContentContainer* pCont)
{
m_xXFContainer.set(pCont);
LwpStory *pStory = dynamic_cast<LwpStory*>(m_Story.obj().get());
if (pStory && pStory->GetDropcapFlag())
{
ParseDropcapContent();
return;
}
//Add the break before para
if (m_pBreaks && m_nOrdinal!=0)
AddBreakBefore(pCont);
//Create an XFPara for this VO_PARA
rtl::Reference<XFParagraph> xPara(new XFParagraph);
xPara->SetStyleName(m_StyleName);
if(!m_SectionStyleName.isEmpty())
{
rtl::Reference<XFSection> xSection(CreateXFSection());
if (pStory)
pStory->AddXFContent(xSection.get());
m_xXFContainer.set(xSection.get());
}
if (m_bHasBullet && m_pSilverBullet)
{
rtl::Reference<XFContentContainer> xListItem = AddBulletList(m_xXFContainer.get());
if (xListItem)
{
xListItem->Add(xPara.get());
}
}
else if (m_xXFContainer)
{
LwpBulletStyleMgr* pBulletStyleMgr = GetBulletStyleMgr();
if (pBulletStyleMgr)
{
pBulletStyleMgr->SetCurrentSilverBullet(LwpObjectID());
pBulletStyleMgr->SetContinueFlag(false);
}
m_xXFContainer->Add(xPara.get());
}
m_Fribs.SetXFPara(xPara.get());
m_Fribs.XFConvert();
if (m_pBreaks && m_xXFContainer)
AddBreakAfter(m_xXFContainer.get());
}
void LwpPara::RegisterMasterPage(XFParaStyle const * pBaseStyle)
{
//get story
LwpStory* pStory = dynamic_cast<LwpStory*>(m_Story.obj().get());
//if pagelayout is modified, register the pagelayout
if(pStory && pStory->IsPMModified())
{
bool bNewSection = pStory->IsNeedSection();
LwpPageLayout* pLayout = pStory->GetCurrentLayout();
if(bNewSection)
{
RegisterNewSectionStyle(pLayout);
}
//register master page style
std::unique_ptr<XFParaStyle> xOverStyle(new XFParaStyle);
*xOverStyle = *pBaseStyle;
xOverStyle->SetStyleName( "");
xOverStyle->SetMasterPage(pLayout->GetStyleName());
if (!m_ParentStyleName.isEmpty())
xOverStyle->SetParentStyleName(m_ParentStyleName);
XFStyleManager* pXFStyleManager = LwpGlobalMgr::GetInstance()->GetXFStyleManager();
m_StyleName = pXFStyleManager->AddStyle(std::move(xOverStyle)).m_pStyle->GetStyleName();
}
}
/**
* @short register paragraph style
*/
void LwpPara::RegisterStyle()
{ //1 reg autostyle
// m_Fribs.SetPara(this);
// m_Fribs.RegisterStyle();
//2 reg para style
if (!m_pFoundry)
return;
XFParaStyle* pBaseStyle = dynamic_cast<XFParaStyle*>(m_pFoundry->GetStyleManager()->GetStyle(m_ParaStyle));
if (pBaseStyle == nullptr) return;
m_StyleName = pBaseStyle->GetStyleName();//such intf to be added
m_ParentStyleName = m_StyleName;
XFStyleManager* pXFStyleManager = LwpGlobalMgr::GetInstance()->GetXFStyleManager();
LwpParaStyle* pParaStyle = GetParaStyle();
if (pParaStyle && pParaStyle->GetIndent())
{
std::unique_ptr<LwpIndentOverride> pIndentOverride(GetParaStyle()->GetIndent()->clone());
m_pIndentOverride = std::move(pIndentOverride);
}
std::unique_ptr<XFParaStyle> xOverStyle;
bool noSpacing = true;
LwpParaProperty* pBulletProps = nullptr, *pNumberingProps = nullptr;
if (!m_vProps.empty())
{
bool noIndent = true;
xOverStyle.reset(new XFParaStyle);
*xOverStyle = *pBaseStyle;
xOverStyle->SetStyleName("");
sal_uInt32 PropType;
LwpParaStyle& rParaStyle = dynamic_cast<LwpParaStyle&>(*m_ParaStyle.obj());
for (auto & pProps : m_vProps)
{
PropType = pProps->GetType();
switch(PropType)
{
case PP_LOCAL_ALIGN:
{
LwpAlignmentOverride *pAlignment = static_cast<LwpParaAlignProperty*>(pProps.get())->GetAlignment();
if (pAlignment)
{
if (!rParaStyle.GetAlignment())
OverrideAlignment(nullptr, pAlignment, xOverStyle.get());
else
{
std::unique_ptr<LwpAlignmentOverride> const pAlign(
rParaStyle.GetAlignment()->clone());
OverrideAlignment(pAlign.get(),
pAlignment,
xOverStyle.get());
}
}
break;
}
case PP_LOCAL_INDENT:
{
noIndent = false;
LwpIndentOverride *pIndent = static_cast<LwpParaIndentProperty*>(pProps.get())->GetIndent();
if (pIndent)
{
if (!rParaStyle.GetIndent())
OverrideIndent(nullptr, pIndent, xOverStyle.get());
else
OverrideIndent(m_pIndentOverride.get(), pIndent, xOverStyle.get());
}
break;
}
case PP_LOCAL_SPACING:
{
noSpacing = false;
LwpSpacingOverride *pSpacing = static_cast<LwpParaSpacingProperty*>(pProps.get())->GetSpacing();
if (pSpacing)
{
if (!rParaStyle.GetSpacing())
OverrideSpacing(nullptr, pSpacing, xOverStyle.get());
else
{
std::unique_ptr<LwpSpacingOverride> const
pNewSpacing(rParaStyle.GetSpacing()->clone());
OverrideSpacing(pNewSpacing.get(), pSpacing, xOverStyle.get());
}
}
break;
}
case PP_LOCAL_BORDER:
{
OverrideParaBorder(pProps.get(), xOverStyle.get());
break;
}
case PP_LOCAL_BREAKS:
{
OverrideParaBreaks(pProps.get(), xOverStyle.get());
break;
}
case PP_LOCAL_BULLET:
{
pBulletProps = pProps.get();
break;
}
case PP_LOCAL_NUMBERING:
{
pNumberingProps = pProps.get();
break;
}
case PP_LOCAL_TABRACK:
{
break;
}
case PP_LOCAL_BACKGROUND:
{
LwpBackgroundOverride* pBGOver = static_cast<LwpParaBackGroundProperty*>(pProps.get())->GetBackground();
if (pBGOver)
{
LwpBackgroundStuff& rBGStuff = pBGOver->GetBGStuff();
if (!rBGStuff.IsTransparent() )
{
if (rBGStuff.IsPatternFill())
{
std::unique_ptr<XFBGImage> xXFBGImage(rBGStuff.GetFillPattern());
xOverStyle->SetBackImage(xXFBGImage);
}
else
{
LwpColor* pColor = rBGStuff.GetFillColor();
if (pColor && pColor->IsValidColor())
{
XFColor aXFColor( pColor->To24Color());
xOverStyle->SetBackColor( aXFColor );
}
}
}
}
break;
}
default:
break;
}
}
if (noIndent && m_pIndentOverride)
{
if (m_pIndentOverride->IsUseRelative() && GetParent())
{
OverrideIndent(nullptr,m_pIndentOverride.get(),xOverStyle.get());
}
}
if (!m_ParentStyleName.isEmpty())
xOverStyle->SetParentStyleName(m_ParentStyleName);
m_StyleName = pXFStyleManager->AddStyle(std::move(xOverStyle)).m_pStyle->GetStyleName();
}
else //use named style
{
if (m_pIndentOverride)
{
if (m_pIndentOverride->IsUseRelative() && GetParent())
{
xOverStyle.reset(new XFParaStyle);
*xOverStyle = *pBaseStyle;
OverrideIndent(nullptr,m_pIndentOverride.get(),xOverStyle.get());
if (!m_ParentStyleName.isEmpty())
xOverStyle->SetParentStyleName(m_ParentStyleName);
m_StyleName = pXFStyleManager->AddStyle(std::move(xOverStyle)).m_pStyle->GetStyleName();
}
}
}
if (IsInCell())
{
XFParaStyle* pOldStyle = pXFStyleManager->FindParaStyle(m_StyleName);
if (pOldStyle->GetNumberRight())
{
xOverStyle.reset(new XFParaStyle);
*xOverStyle = *pOldStyle;
xOverStyle->SetAlignType(enumXFAlignStart);
if (!m_ParentStyleName.isEmpty())
xOverStyle->SetParentStyleName(m_ParentStyleName);
m_StyleName = pXFStyleManager->AddStyle(std::move(xOverStyle)).m_pStyle->GetStyleName();
}
}
// override bullet and numbering
OverrideParaBullet(pBulletProps);
OverrideParaNumbering(pNumberingProps);
//register bullet style
LwpBulletStyleMgr* pBulletStyleMgr = GetBulletStyleMgr();
if (pBulletStyleMgr)
{
// if has bullet or numbering
if (m_bHasBullet)
{
//if it's normal bullet
if (m_pSilverBullet)
{
if (m_pSilverBullet->HasName())
{
m_aBulletStyleName = m_pSilverBullet->GetBulletStyleName();
}
else if (!m_xBullOver->IsEditable())
{
m_aBulletStyleName = pBulletStyleMgr->RegisterBulletStyle(this, m_xBullOver.get(), m_pIndentOverride.get());
}
// test codes
if (m_pSilverBullet->IsBulletOrdered())
{
OUString aPreBullStyleName;
LwpNumberingOverride* pNumbering = GetParaNumbering();
sal_uInt16 nPosition = pNumbering->GetPosition();
bool bLesser = m_pSilverBullet->IsLesserLevel(nPosition);
LwpPara* pPara = this;
LwpPara* pPrePara = nullptr;
sal_uInt16 nNum = 0, nLevel = 0, nFoundLevel = 0xffff, nFoundBound = 0;
nFoundBound = nLevel = pNumbering->GetLevel();
if (nPosition == pNumbering->GetPosition())
{
nFoundBound++;
}
bool bHeading = pNumbering->IsHeading();
std::set<LwpPara*> aSeen;
while(true)
{
aSeen.insert(pPara);
LwpSilverBullet* pParaSilverBullet = pPara->GetSilverBullet();
pNumbering = pPara->GetParaNumbering();
if (pPara->GetObjectID() != GetObjectID())
{
if (!pParaSilverBullet)
{
break;
}
/* If lesser, stop when we hit an outline style whose level is
* higher than our current level.
*/
// restart based on Outline level?
if (pNumbering && bLesser && (!bHeading || pNumbering->IsHeading()))
{
if (nFoundLevel != 0xffff)
{
if (pNumbering->GetLevel() < nFoundLevel)
{
break;
}
if ((pNumbering->GetLevel() == nFoundLevel)
&& (pParaSilverBullet->GetObjectID() != m_pSilverBullet->GetObjectID()
|| pNumbering->GetPosition() != nPosition))
{
break;
}
}
else
{
if (pNumbering && pNumbering->GetLevel() < nFoundBound && pParaSilverBullet
&& (pParaSilverBullet->GetObjectID() != m_pSilverBullet->GetObjectID()
|| pNumbering->GetPosition() != nPosition))
{
nFoundBound = pNumbering->GetLevel();
}
}
}
}
// Don't bump the number if this bullet is skipped
if (m_xBullOver->IsSkip())
;
else if ( pParaSilverBullet
&& pParaSilverBullet->GetObjectID() == m_pSilverBullet->GetObjectID()
&& pNumbering && nPosition == pNumbering->GetPosition())
{
if (bLesser)
{
if (nFoundLevel != 0xffff)
{
if (nFoundLevel == pNumbering->GetLevel())
{
aPreBullStyleName = pPara->GetBulletStyleName();
nNum++;
}
}
else if (pNumbering->GetLevel() <= nLevel)
{
if (pNumbering->GetLevel() >= nFoundBound)
{
break;
}
nFoundLevel = pNumbering->GetLevel();
aPreBullStyleName = pPara->GetBulletStyleName();
nNum++;
}
}
else
{
aPreBullStyleName = pPara->GetBulletStyleName();
nNum++;
}
}
pPrePara = dynamic_cast<LwpPara*>(pPara->GetPrevious().obj(VO_PARA).get());
if (!pPrePara)
{
LwpStory* pStory = pPara->GetStory();
pPrePara = pStory ? pStory->GetLastParaOfPreviousStory() : nullptr;
if (!pPrePara)
{
break;
}
}
pPara = pPrePara;
if (aSeen.find(pPara) != aSeen.end())
throw std::runtime_error("loop in conversion");
}
nNum = nNum ? nNum : 1;
if (nNum > 1)
{
m_aBulletStyleName = aPreBullStyleName;
m_bBullContinue = true;
}
else
{
m_bBullContinue = false;
if (IsInCell())
{
XFListStyle* pOldStyle = static_cast<XFListStyle*>(pXFStyleManager->FindStyle(m_aBulletStyleName));
if (pOldStyle)
{
std::unique_ptr<XFListStyle> xNewStyle(new XFListStyle(*pOldStyle));
m_aBulletStyleName = pXFStyleManager->AddStyle(std::move(xNewStyle)).m_pStyle->GetStyleName();
}
}
}
LwpStory* pMyStory = GetStory();
if (pMyStory)
{
if (pMyStory->IsBullStyleUsedBefore(m_aBulletStyleName, m_xParaNumbering->GetPosition()))
{
//m_bBullContinue = sal_True;
}
else
{
pMyStory->AddBullStyleName2List(m_aBulletStyleName, m_xParaNumbering->GetPosition());
}
}
}
// end of test codes
}
}
}
if (noSpacing)
{
LwpPara* pPrePara = dynamic_cast<LwpPara*>(GetPrevious().obj().get());
if (pPrePara && pPrePara->GetBelowSpacing()!=0)
{
xOverStyle.reset(new XFParaStyle);
*xOverStyle = *GetXFParaStyle();
XFMargins* pMargin = &xOverStyle->GetMargins();
pMargin->SetTop(pMargin->GetTop()+pPrePara->GetBelowSpacing());
if (!m_ParentStyleName.isEmpty())
xOverStyle->SetParentStyleName(m_ParentStyleName);
m_StyleName = pXFStyleManager->AddStyle(std::move(xOverStyle)).m_pStyle->GetStyleName();
}
}
//register tab style
if(m_Fribs.HasFrib(FRIB_TAG_TAB))
{
std::unique_ptr<XFParaStyle> xNewParaStyle(new XFParaStyle);
*xNewParaStyle = *GetXFParaStyle();
//xOverStyle->SetStyleName("");
RegisterTabStyle(xNewParaStyle.get());
if (!m_ParentStyleName.isEmpty())
xNewParaStyle->SetParentStyleName(m_ParentStyleName);
m_StyleName = pXFStyleManager->AddStyle(std::move(xNewParaStyle)).m_pStyle->GetStyleName();
}
//register master page;
RegisterMasterPage(GetXFParaStyle());
// reg auto style,lay here for pagebreak need overridden para style
m_Fribs.SetPara(this);
m_Fribs.RegisterStyle();
if (m_bHasDropcap)
{
GatherDropcapInfo();
std::unique_ptr<XFParaStyle> xStyle(new XFParaStyle);
*xStyle = *GetXFParaStyle();
xStyle->SetDropCap(m_nChars-1,m_nLines);
if (!m_ParentStyleName.isEmpty())
xStyle->SetParentStyleName(m_ParentStyleName);
m_StyleName = pXFStyleManager->AddStyle(std::move(xStyle)).m_pStyle->GetStyleName();
}
// maybe useful for further version
// deleted because Leader of Table is not supported in this version
//AddTabStyleForTOC();
}
void LwpPara::RegisterNewSectionStyle(LwpPageLayout *pLayout)
{
if( !pLayout )
return;
std::unique_ptr<XFSectionStyle> xSectStyle(new XFSectionStyle);
XFColumns* pColumns = pLayout->GetXFColumns();
if(pColumns)
{
xSectStyle->SetColumns(pColumns);
}
XFStyleManager* pXFStyleManager = LwpGlobalMgr::GetInstance()->GetXFStyleManager();
m_SectionStyleName = pXFStyleManager->AddStyle(std::move(xSectStyle)).m_pStyle->GetStyleName();
}
rtl::Reference<XFSection> LwpPara::CreateXFSection()
{
rtl::Reference<XFSection> xXFSection(new XFSection);
xXFSection->SetStyleName(m_SectionStyleName);
m_SectionStyleName.clear();
return xXFSection;
}
/**************************************************************************
* @descr: register tab style
**************************************************************************/
void LwpPara::RegisterTabStyle(XFParaStyle* pXFParaStyle)
{
LwpTabOverride aFinaOverride;
LwpTabOverride* pBase = nullptr;
//get the tabrack from the current layout
LwpStory* pStory = dynamic_cast<LwpStory*>(m_Story.obj().get());
LwpMiddleLayout* pLayout = pStory ? pStory->GetTabLayout() : nullptr;
if(pLayout)
{
pBase = pLayout->GetTabOverride();
if(pBase)
{
pBase->Override(&aFinaOverride);
}
}
//get the tabrack from the base parastyle
LwpParaStyle* pParaStyle = GetParaStyle();
pBase = pParaStyle->GetTabOverride();
if(pBase)
{
pBase->Override(&aFinaOverride);
}
//get the tabrack from the local property
pBase = GetLocalTabOverride();
if(pBase)
{
pBase->Override(&aFinaOverride);
}
LwpParaStyle::ApplyTab(pXFParaStyle, &aFinaOverride);
}
/**
* @short parse dropcap text
*/
void LwpPara::ParseDropcapContent()
{
if (!GetFoundry())
return;
XFParagraph* pDropcap = GetFoundry()->GetDropcapMgr()->GetXFPara();
if (pDropcap)
{
m_Fribs.SetXFPara(pDropcap);
m_Fribs.XFConvert();
}
}
/**
* @short add paragraph break attribute
*/
void LwpPara::AddBreakBefore(XFContentContainer* pCont)
{
if (!m_pBreaks || !pCont)
return;
if (m_pBreaks->IsPageBreakBefore())
{
rtl::Reference<XFParagraph> xPara(new XFParagraph);
xPara->SetStyleName(m_BefPageBreakName);
pCont->Add(xPara.get());
}
else if (m_pBreaks->IsColumnBreakBefore())
{
rtl::Reference<XFParagraph> xPara(new XFParagraph);
xPara->SetStyleName(m_BefColumnBreakName);
pCont->Add(xPara.get());
}
}
void LwpPara::AddBreakAfter(XFContentContainer* pCont)
{
if (!m_pBreaks)
return;
if (m_pBreaks->IsPageBreakAfter())
{
rtl::Reference<XFParagraph> xPara(new XFParagraph);
xPara->SetStyleName(m_AftPageBreakName);
pCont->Add(xPara.get());
}
else if (m_pBreaks->IsColumnBreakAfter())
{
rtl::Reference<XFParagraph> xPara(new XFParagraph);
xPara->SetStyleName(m_AftColumnBreakName);
pCont->Add(xPara.get());
}
}
LwpBulletStyleMgr* LwpPara::GetBulletStyleMgr()
{
if (m_pFoundry)
{
return m_pFoundry->GetBulletStyleMgr();
}
return nullptr;
}
rtl::Reference<XFContentContainer> LwpPara::AddBulletList(XFContentContainer* pCont)
{
LwpBulletStyleMgr* pBulletStyleMgr = GetBulletStyleMgr();
if (!pBulletStyleMgr)
{
assert(false);
return rtl::Reference<XFContentContainer>();
}
sal_uInt16 nLevel = m_nLevel;
bool bOrdered = false;
/*LwpStory* pMyStory =*/ GetStory();
pBulletStyleMgr->SetContinueFlag(m_bBullContinue);
if (m_pSilverBullet->IsBulletOrdered())
{
bOrdered = true;
}
if (m_pSilverBullet->HasName())
{
nLevel = m_xParaNumbering->GetPosition();
m_nLevel = nLevel;//for get para level
}
return pBulletStyleMgr->AddBulletList(pCont, bOrdered, m_aBulletStyleName,
nLevel, m_xBullOver->IsSkip());
}
LwpNumberingOverride* LwpPara::GetParaNumbering()
{
return m_xParaNumbering.get();
}
void LwpForked3NotifyList::Read(LwpObjectStream* pObjStrm)
{
m_PersistentList.Read(pObjStrm);
}
void LwpNotifyListPersistent::Read(LwpObjectStream* pObjStrm)
{
m_Head.ReadIndexed(pObjStrm);
pObjStrm->SkipExtra();
}
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
↑ V560 A part of conditional expression is always true: pNumbering.
↑ V560 A part of conditional expression is always true: pParaSilverBullet.