/* -*- 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
 ************************************************************************/
/*************************************************************************
 * Change History
 Jan 2005			Created
 ************************************************************************/

#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"

LwpPara::LwpPara(LwpObjectHeader& objHdr, LwpSvStream* pStrm)
    : LwpDLVList(objHdr, pStrm), m_pBreaks(NULL), m_pIndentOverride(NULL)
    , m_bHasBullet(sal_False), m_pSilverBullet(NULL)
    , /*m_pParaNumbering(NULL),*/ m_pBullOver(NULL)
    , m_bBullContinue(sal_False)
    , m_bHasDropcap(sal_False), m_nLines(0), m_nChars(0)
    , m_pDropcapLayout(NULL), m_BelowSpacing(0), m_pXFContainer(NULL)
{
    m_pProps = NULL;
    m_SectionStyleName = A2OUSTR("");
    m_AllText = A2OUSTR("");
}

LwpPara::~LwpPara()
{

    if (m_pBreaks)
    {
        delete m_pBreaks;
        m_pBreaks = NULL;
    }
/*	if (m_pParaNumbering)
    {
        delete m_pParaNumbering;
        m_pParaNumbering = NULL;
    }*/

    if (m_pBullOver)
    {
        delete m_pBullOver;
        m_pBullOver = NULL;
    }
    if(m_pIndentOverride)
    {
        delete m_pIndentOverride;
    }

    LwpParaProperty* pNextProp;
    while(m_pProps)
    {
        pNextProp = m_pProps->GetNext();
        delete m_pProps;
        m_pProps = pNextProp;
    }
}

void LwpPara::Read()
{
    LwpDLVList::Read();

    sal_Bool Simple;
    sal_Bool Notify = sal_False;
//	m_Fribs.SetPara(this);
//	LwpParaPropListProperty *PropList = NULL;
    if(LwpFileHeader::m_nFileRevision<0x0006)
        Simple = sal_False;
    else if(LwpFileHeader::m_nFileRevision<0x000B)
        m_pObjStrm->QuickRead(&Simple, sizeof(Simple));
    else
    {
        sal_uInt8 Flag;
        m_pObjStrm->QuickRead(&Flag, sizeof(Flag));

        const int DISK_SIMPLE = 1;
        const int DISK_NOTIFY = 2;

        Simple = (Flag & DISK_SIMPLE) ? sal_True : sal_False;
        Notify = (Flag & DISK_NOTIFY) ? sal_True : sal_False;
    }

    if(!Simple)
    {
        m_pObjStrm->QuickRead(&m_nOrdinal, sizeof(m_nOrdinal));
        if(LwpFileHeader::m_nFileRevision<0x000B)
        {
            // TODO: to process
            assert(false);
            /*pCForked3NotifyList Notify = new CForked3NotifyList(this);
            Notify->GetExtraList()->QuickRead(pFile);
            Notify->QuickRead(pFile);
            if(Notify->GetExtraList()->IsEmpty() &&
                Notify->IsEmpty())
                delete Notify;
            else
                cNotifyList = Notify;*/
        }
        else
        {
            if (Notify)
            {
                LwpForked3NotifyList* pNotifyList = new LwpForked3NotifyList();
                pNotifyList->GetExtraList()->Read(m_pObjStrm);
                pNotifyList->Read(m_pObjStrm);
                delete pNotifyList;
            }
        }
    }
    else
        m_nOrdinal = 0x0001;

    m_pObjStrm->QuickRead(&m_nFlags, sizeof(m_nFlags));
    m_ParaStyle.ReadIndexed(m_pObjStrm);

    if(!Simple)
    {
        m_Hint.Read(m_pObjStrm);
        if (IsBadHintsInFile())
        {
            // This hint is no good, so throw it away -- SDC 9/28/95
            m_Hint.Reset();
        }
    }

    m_Story.ReadIndexed(m_pObjStrm);
    if(!Simple)
    {
        if(LwpFileHeader::m_nFileRevision<0x000B)
        {
            // TODO: to process
            assert(false);
            /*PropList = new CParaPropListProperty(this);
            PropList->GetList()->QuickRead(pFile);
            if(PropList->GetList()->IsEmpty())
            {
                delete PropList;
                PropList = LNULL;
            }*/
        }
        m_pObjStrm->QuickRead(&m_nLevel, sizeof(m_nLevel));

        // test
        if (m_nLevel > 9)
        {
            m_nLevel = 9;
        }
        // test ends
    }
    else
        m_nLevel = 0x0001;

    m_Fribs.SetPara(this);//add by  2/1, for silver bullet
    m_Fribs.ReadPara(m_pObjStrm);

    m_pProps = LwpParaProperty::ReadPropertyList(m_pObjStrm,this);
}

void LwpPara::Parse(IXFStream* pOutputStream)
{
    m_pXFContainer = new XFContentContainer;
    XFConvert(m_pXFContainer);
    m_pXFContainer->ToXml(pOutputStream);
    m_pXFContainer->Reset();
    delete m_pXFContainer;
    m_pXFContainer = NULL;
}

void LwpPara::XFConvert(XFContentContainer* pCont)
{
    m_pXFContainer = pCont;

    if (static_cast<LwpStory*>(m_Story.obj())->GetDropcapFlag() == sal_True)
    {
        ParseDropcapContent();
        /*LwpObject* pNextPara = GetNext()->obj();
        if(pNextPara)
            pNextPara->XFConvert(pCont);*/
        return;
    }

    //Add the break before para
    if (m_pBreaks && m_nOrdinal!=0)
        AddBreakBefore(pCont);

    //Create an XFPara for this VO_PARA
    XFParagraph *pPara = new XFParagraph;
    pPara->SetStyleName(m_StyleName);

    if(m_SectionStyleName.getLength()>0)
    {
        XFSection* pSection = CreateXFSection();
        LwpStory* pStory = static_cast<LwpStory*> ( m_Story.obj() );
        pStory->AddXFContent(pSection);
        //pSection->Add(pPara);
        m_pXFContainer = pSection;
    }

    if (m_bHasBullet &&  m_pSilverBullet)
    {
        XFContentContainer* pListItem = AddBulletList(m_pXFContainer);
        if (pListItem)
        {
            pListItem->Add(pPara);
        }
    }
    else
    {
        LwpBulletStyleMgr* pBulletStyleMgr = this->GetBulletStyleMgr();
        if (pBulletStyleMgr)
        {
            pBulletStyleMgr->SetCurrentSilverBullet(LwpObjectID());
            pBulletStyleMgr->SetContinueFlag(sal_False);
        }
        m_pXFContainer->Add(pPara);
    }

    m_Fribs.SetXFPara(pPara);
    m_Fribs.XFConvert();

    if (m_pBreaks)
        AddBreakAfter(m_pXFContainer);

    // maybe useful for futer version
    // deleted by
    // AddTabStopForTOC();

    //Caller is responsible for calling the next para object
    /*LwpObject* pNextPara = GetNext()->obj();
    if(pNextPara)
        pNextPara->XFConvert( m_pXFContainer );*/
}

sal_Bool LwpPara::RegisterMasterPage(XFParaStyle* pBaseStyle)
{
    sal_Bool bSuccess = sal_False;
    //get story
    LwpStory* pStory = static_cast<LwpStory*>(m_Story.obj());
    //if pagelayout is modified, register the pagelayout
    if(pStory->IsPMModified())
    {
        sal_Bool bNewSection = sal_False;
        bNewSection = pStory->IsNeedSection();
        LwpPageLayout* pLayout = pStory->GetCurrentLayout();
        if(bNewSection)
        {
            RegisterNewSectionStyle(pLayout);
        }

        bSuccess = sal_True;
        //register master page style
        XFParaStyle* pOverStyle = new XFParaStyle();
        *pOverStyle = *pBaseStyle;
        pOverStyle->SetStyleName( A2OUSTR(""));
        pOverStyle->SetMasterPage(pLayout->GetStyleName());
        if (m_ParentStyleName.getLength())
                    pOverStyle->SetParentStyleName(m_ParentStyleName); //Add by  2005/12/12
        XFStyleManager* pXFStyleManager = LwpGlobalMgr::GetInstance()->GetXFStyleManager();
        m_StyleName = pXFStyleManager->AddStyle(pOverStyle)->GetStyleName();
    }
    return bSuccess;
}
/**
 * @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 = static_cast<XFParaStyle*>(m_pFoundry->GetStyleManager()->GetStyle(m_ParaStyle));
    if (pBaseStyle == NULL) return;
    m_StyleName = pBaseStyle->GetStyleName();//such intf to be added
    m_ParentStyleName = m_StyleName;//Add by ,2005/12/12
    XFStyleManager* pXFStyleManager = LwpGlobalMgr::GetInstance()->GetXFStyleManager();

    if (GetParaStyle()->GetIndent())
    {
        m_pIndentOverride = new LwpIndentOverride;
        *m_pIndentOverride = *(GetParaStyle()->GetIndent()); //add by  2-6,for indent hierachy
    }
//	else
//		m_pIndentOverride = NULL;

    XFParaStyle* pOverStyle = NULL;
    sal_Bool noSpacing = sal_True;
    sal_Bool noIndent = sal_True;
    LwpParaProperty* pBulletProps = NULL, *pNumberingProps = NULL;

    if (m_pProps != NULL)
    {
        pOverStyle = new XFParaStyle;
        *pOverStyle = *pBaseStyle;
        pOverStyle->SetStyleName(A2OUSTR(""));
        LwpParaProperty* pProps = m_pProps;
        sal_uInt32 PropType;
        LwpParaStyle* pParaStyle = static_cast<LwpParaStyle*>(m_ParaStyle.obj());
        while(pProps)
        {
            PropType = pProps->GetType();
            switch(PropType)
            {
            case PP_LOCAL_ALIGN:
            {
                LwpAlignmentOverride aAlign;
                if (!pParaStyle->GetAlignment())
                    OverrideAlignment(NULL,static_cast<LwpParaAlignProperty*>(pProps)->GetAlignment(),pOverStyle);
                else
                {
                    aAlign = *(pParaStyle->GetAlignment());
                    OverrideAlignment(&aAlign,static_cast<LwpParaAlignProperty*>(pProps)->GetAlignment(),pOverStyle);
                }
            }
                break;
            case PP_LOCAL_INDENT:
            {
                noIndent = sal_False;
                if (!pParaStyle->GetIndent())
                    OverrideIndent(NULL,static_cast<LwpParaIndentProperty*>(pProps)->GetIndent(),pOverStyle);

                else
                {
                    OverrideIndent(m_pIndentOverride,static_cast<LwpParaIndentProperty*>(pProps)->GetIndent(),pOverStyle);
                }
            }
                break;
            case PP_LOCAL_SPACING:
            {
                LwpSpacingOverride aSpacing;
                noSpacing = sal_False;
                if (!pParaStyle->GetSpacing())
                    OverrideSpacing(NULL,static_cast<LwpParaSpacingProperty*>(pProps)->GetSpacing(),pOverStyle);
                else
                {
                    aSpacing = *(pParaStyle->GetSpacing());
                    OverrideSpacing(&aSpacing,static_cast<LwpParaSpacingProperty*>(pProps)->GetSpacing(),pOverStyle);
                }
            }
                break;
        // 01/25/2005
        case PP_LOCAL_BORDER:
        {
            OverrideParaBorder(pProps, pOverStyle);
            break;
        }
        case PP_LOCAL_BREAKS:
        {
            OverrideParaBreaks(pProps, pOverStyle);
            break;
        }
        case PP_LOCAL_BULLET:
        {
            pBulletProps = pProps;
//			OverrideParaBullet(pProps);
            break;
        }
        case PP_LOCAL_NUMBERING:
        {
            pNumberingProps = pProps;
//			OverrideParaNumbering(pProps);
            break;
        }
        //end
        case PP_LOCAL_TABRACK:
        {
            //, 01/28/05
            /*LwpTabOverride* pTabOverride=pParaStyle->GetTabOverride();
            if(!pTabOverride)
            {
                OverrideTab(NULL,static_cast<LwpParaTabRackProperty*>(pProps)->GetTab(),pOverStyle);
            }
            else
            {
                OverrideTab(pTabOverride,static_cast<LwpParaTabRackProperty*>(pProps)->GetTab(),pOverStyle);
            }*/
            break;
        }
        case PP_LOCAL_BACKGROUND:
        {
/*			LwpBackgroundOverride aBackground;
            if (!pParaStyle->GetBackground())
                OverrideBackground(NULL,static_cast<LwpParaBackGroundProperty*>(pProps)->GetBackground(),pOverStyle);
            else
            {
                aBackground = *(pParaStyle->GetaBackground());
                OverrideBackground(&aBackground,static_cast<LwpParaBackGroundProperty*>(pProps)->GetBackground(),pOverStyle);
            }
*/
            // modified by , 06/03/2005
            LwpBackgroundOverride* pBGOver = static_cast<LwpParaBackGroundProperty*>(pProps)->GetBackground();
            if (pBGOver)
            {
                LwpBackgroundStuff* pBGStuff = pBGOver->GetBGStuff();
                if (pBGStuff && !pBGStuff->IsTransparent() )
                {
                    if (pBGStuff->IsPatternFill())
                    {
                        XFBGImage* pXFBGImage = pBGStuff->GetFillPattern();
                        pOverStyle->SetBackImage(pXFBGImage);
                    }
                    else
                    {
                        LwpColor* pColor = pBGStuff->GetFillColor();
                        if (pColor && pColor->IsValidColor())
                        {
                            XFColor aXFColor( pColor->To24Color());
                            pOverStyle->SetBackColor( aXFColor );
                        }
                    }
                }
            }
            // end modified
                    break;
        }
                default:
                    break;
                }
            pProps = pProps->GetNext();
        }

        if (noIndent && m_pIndentOverride)
            {
                if (m_pIndentOverride->IsUseRelative() && GetParent())
                {
                OverrideIndent(NULL,m_pIndentOverride,pOverStyle);
                }
            }
            if (m_ParentStyleName.getLength())
                pOverStyle->SetParentStyleName(m_ParentStyleName); //Add by  2005/12/12
            m_StyleName = pXFStyleManager->AddStyle(pOverStyle)->GetStyleName();

    }
    else //use named style
    {
        if (m_pIndentOverride)
            {
                if (m_pIndentOverride->IsUseRelative() && GetParent())
                {
                    pOverStyle = new XFParaStyle;
                    *pOverStyle = *pBaseStyle;
                    OverrideIndent(NULL,m_pIndentOverride,pOverStyle);
                    if (m_ParentStyleName.getLength())
                        pOverStyle->SetParentStyleName(m_ParentStyleName); //Add by  2005/12/12
                    m_StyleName = pXFStyleManager->AddStyle(pOverStyle)->GetStyleName();
                }
            }
    }

    if (IsInCell())
    {
        XFParaStyle* pOldStyle = pXFStyleManager->FindParaStyle(m_StyleName);
        if (pOldStyle->GetNumberRight())
        {
            pOverStyle = new XFParaStyle;
            *pOverStyle = *pOldStyle;
            pOverStyle->SetAlignType(enumXFAlignStart);
            if (m_ParentStyleName.getLength())
                pOverStyle->SetParentStyleName(m_ParentStyleName); //Add by  2005/12/12
            m_StyleName = pXFStyleManager->AddStyle(pOverStyle)->GetStyleName();
        }
    }

    // override bullet and numbering
    OverrideParaBullet(pBulletProps);
    OverrideParaNumbering(pNumberingProps);

    //add by
    //register bullet style
    LwpBulletStyleMgr* pBulletStyleMgr = this->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_pBullOver->IsEditable())
                {
                    m_aBulletStyleName = pBulletStyleMgr->RegisterBulletStyle(this, m_pBullOver, m_pIndentOverride);
                }

                // test codes
                if (m_pSilverBullet->IsBulletOrdered())
                {
                    rtl::OUString aPreBullStyleName;
                    LwpNumberingOverride* pNumbering = this->GetParaNumbering();
                    sal_uInt16 nPosition = pNumbering->GetPosition();
                    sal_Bool bLesser = m_pSilverBullet->IsLesserLevel(nPosition);
                    /*sal_Bool bResetSection =*/ m_pSilverBullet->IsNewSection(nPosition);
                    sal_Bool bHeading;
                    LwpPara* pPara = this;
                    LwpPara* pPrePara = NULL;
                    LwpSilverBullet* pParaSilverBullet = NULL;
                    sal_uInt16 nNum = 0, nLevel = 0, nFoundLevel = 0xffff, nFoundBound = 0;

                    nFoundBound = nLevel = pNumbering->GetLevel();
                    if (nPosition == pNumbering->GetPosition())
                    {
                        nFoundBound++;
                    }
                    bHeading = pNumbering->IsHeading();

                    while(sal_True)
                    {
                        /*// When we hit the hint paragraph, we can stop and check the hint.
                        if (qNumberHint && (qPara == qNumberHint->GetPara()) &&
                            qNumberHint->Lookup(qSilverBullet, Level, Position, &Offset))
                        {
                            Num += Offset;
                            break;
                        }*/

                        pParaSilverBullet = pPara->GetSilverBullet();
                        pNumbering = pPara->GetParaNumbering();

                        if (*(pPara->GetObjectID()) != *(this->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() : sal_True))
                            {
                                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();
                                    }
                                }
                            }

                            /*if (qSpecificStyle
                            && qSpecificStyle == qPara->GetParaStyle(LTRUE))
                                break;

                            // See if we crossed a section boundary
                            if (ResetSection)
                            {
                                CurrPos.SetPara(qPara);
                                if (CurrPos <= SectionPos)
                                    break;
                            }*/
                        }

                        // Don't bump the number if this bullet is skipped
                        if (m_pBullOver->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++;
                            }
                        }

                        if (pPara && pPara->GetPrevious())
                            pPrePara = static_cast<LwpPara*>(pPara->GetPrevious()->obj(VO_PARA));
                        else
                            pPrePara=NULL;

                        if (!pPrePara)
                        {
                            LwpStory* pStory = pPara->GetStory();
                            pPrePara = pStory->GetLastParaOfPreviousStory();

                            if (!pPrePara)
                            {
                                break;
                            }
                        }
                        pPara = pPrePara;
                    }
                    nNum = nNum ? nNum : 1;

                    if (nNum > 1)
                    {
                        m_aBulletStyleName = aPreBullStyleName;
                        m_bBullContinue = sal_True;
                    }
                    else
                    {
                        m_bBullContinue = sal_False;
                        if (this->IsInCell())
                        {
                            XFListStyle* pOldStyle = static_cast<XFListStyle*>(pXFStyleManager->FindStyle(m_aBulletStyleName));
                            if (pOldStyle)
                            {
                                XFListStyle* pNewStyle = new XFListStyle(*pOldStyle);
                                m_aBulletStyleName = pXFStyleManager->AddStyle(pNewStyle)->GetStyleName();
                            }
                        }
                    }

                    LwpStory* pMyStory = this->GetStory();
                    if (pMyStory)
                    {
                        if (pMyStory->IsBullStyleUsedBefore(m_aBulletStyleName, m_aParaNumbering.GetPosition()))
                        {
                            //m_bBullContinue = sal_True;
                        }
                        else
                        {
                            pMyStory->AddBullStyleName2List(m_aBulletStyleName, m_aParaNumbering.GetPosition());
                        }
                    }

                }
                // end of test codes
            }
        }
    }
    //end add

    if (noSpacing && GetPrevious())
    {
        LwpPara* pPrePara = static_cast<LwpPara*>(GetPrevious()->obj());
        if (pPrePara && pPrePara->GetBelowSpacing()!=0)
        {
            pOverStyle = new XFParaStyle;
            *pOverStyle = *GetXFParaStyle();
            XFMargins* pMargin = &pOverStyle->GetMargins();
            pMargin->SetTop(pMargin->GetTop()+pPrePara->GetBelowSpacing());
            if (m_ParentStyleName.getLength())
                    pOverStyle->SetParentStyleName(m_ParentStyleName); //Add by  2005/12/12
            m_StyleName = pXFStyleManager->AddStyle(pOverStyle)->GetStyleName();
        }
    }

    //register tab style
    if(m_Fribs.HasFrib(FRIB_TAG_TAB))
    {
        XFParaStyle* pParaStyle = new XFParaStyle;
        *pParaStyle = *GetXFParaStyle();
        //pOverStyle->SetStyleName(A2OUSTR(""));
        this->RegisterTabStyle(pParaStyle);
        if (m_ParentStyleName.getLength())
                    pParaStyle->SetParentStyleName(m_ParentStyleName); //Add by  2005/12/12
        m_StyleName = pXFStyleManager->AddStyle(pParaStyle)->GetStyleName();
    }

    //register master page;
    RegisterMasterPage(GetXFParaStyle());

    // reg auto style,lay here for pagebreak need overrided para style
    m_Fribs.SetPara(this);
    m_Fribs.RegisterStyle();

    if (m_bHasDropcap == sal_True)
    {
        GatherDropcapInfo();
        XFParaStyle* pStyle = new XFParaStyle;
        *pStyle = *GetXFParaStyle();
        pStyle->SetDropCap(m_nChars-1,m_nLines);
        if (m_ParentStyleName.getLength())
                    pStyle->SetParentStyleName(m_ParentStyleName); //Add by  2005/12/12
        m_StyleName = pXFStyleManager->AddStyle(pStyle)->GetStyleName();
    }
    // maybe useful for futer version
    // deleted because Leader of Table is not supported in this version
    //AddTabStyleForTOC();
}

void LwpPara::RegisterNewSectionStyle(LwpPageLayout *pLayout)
{
    if( !pLayout )
        return;

    XFSectionStyle* pSectStyle= new XFSectionStyle();
    XFColumns* pColumns = pLayout->GetXFColumns();
    if(pColumns)
    {
        pSectStyle->SetColumns(pColumns);
    }
    XFStyleManager* pXFStyleManager = LwpGlobalMgr::GetInstance()->GetXFStyleManager();
    m_SectionStyleName = pXFStyleManager->AddStyle(pSectStyle)->GetStyleName();
}

XFSection* LwpPara::CreateXFSection()
{
    XFSection* pXFSection = new XFSection();
    pXFSection->SetStyleName(m_SectionStyleName);
    m_SectionStyleName = A2OUSTR("");
    return pXFSection;
}

/**************************************************************************
 * @descr:  register tab style
 * @param:
 * @param:
 * @return:
**************************************************************************/
void LwpPara::RegisterTabStyle(XFParaStyle* pXFParaStyle)
{
    LwpTabOverride aFinaOverride;
    LwpTabOverride* pBase = NULL;
    //get the tabrack from the current layout
    LwpStory* pStory = static_cast<LwpStory*>(m_Story.obj());
    LwpMiddleLayout* pLayout = pStory->GetTabLayout();
    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)
        return;
    if (m_pBreaks->IsPageBreakBefore())
    {
        XFParagraph *pPara = new XFParagraph();
        pPara->SetStyleName(m_BefPageBreakName);
        pCont->Add(pPara);
    }
    else if (m_pBreaks->IsColumnBreakBefore())
    {
        XFParagraph *pPara = new XFParagraph();
        pPara->SetStyleName(m_BefColumnBreakName);
        pCont->Add(pPara);
    }
}

void LwpPara::AddBreakAfter(XFContentContainer* pCont)
{
    if (!m_pBreaks)
        return;
    if (m_pBreaks->IsPageBreakAfter())
    {
        XFParagraph *pPara = new XFParagraph();
        pPara->SetStyleName(m_AftPageBreakName);
        pCont->Add(pPara);
    }
    else if (m_pBreaks->IsColumnBreakAfter())
    {
        XFParagraph *pPara = new XFParagraph();
        pPara->SetStyleName(m_AftColumnBreakName);
        pCont->Add(pPara);
    }
}

LwpVirtualLayout* LwpPara::GetLayoutWithMyStory()
{
    LwpStory* pMyStory = NULL;
    if (!m_Story.IsNull())
    {
        pMyStory = static_cast<LwpStory*>(m_Story.obj(VO_STORY));
        if (!pMyStory)
        {
            return NULL;
        }

        return pMyStory->GetLayout(NULL);
    }

    return NULL;
}

LwpBulletStyleMgr* LwpPara::GetBulletStyleMgr()
{
    if (m_pFoundry)
    {
        return m_pFoundry->GetBulletStyleMgr();
    }

    return NULL;
}

XFContentContainer* LwpPara::AddBulletList(XFContentContainer* pCont)
{
    LwpBulletStyleMgr* pBulletStyleMgr = GetBulletStyleMgr();
    if (!pBulletStyleMgr)
    {
        assert(false);
        return NULL;
    }

    sal_uInt16 nLevel = m_nLevel;
    sal_Bool bOrdered = sal_False;
    /*LwpStory* pMyStory =*/ GetStory();

    pBulletStyleMgr->SetContinueFlag(m_bBullContinue);

    if (m_pSilverBullet->IsBulletOrdered())
    {
        bOrdered = sal_True;
    }
    if (m_pSilverBullet->HasName())
    {
//		nLevel = m_pParaNumbering->GetPosition();
        nLevel = m_aParaNumbering.GetPosition();
        m_nLevel = nLevel;//add by ,for get para level
//		m_aBulletStyleName = m_pSilverBullet->GetBulletStyleName();
    }

    return ( pBulletStyleMgr->AddBulletList(pCont, bOrdered, m_aBulletStyleName,
            nLevel, m_pBullOver->IsSkip()) );
}

LwpNumberingOverride* LwpPara::GetParaNumbering()
{
    return &m_aParaNumbering;
}

void LwpForked3NotifyList::Read(LwpObjectStream* pObjStrm)
{
    m_PersistentList.Read(pObjStrm);
}

void LwpNotifyListPersistent::Read(LwpObjectStream* pObjStrm)
{
    m_Head.ReadIndexed(pObjStrm);
    pObjStrm->SkipExtra();
}

void LwpPara::Release()
{}

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
