xref: /AOO41X/main/sw/source/core/unocore/unocrsrhelper.cxx (revision 69a743679e823ad8f875be547552acb607b8ada5)

/**************************************************************
 *
 * 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 <svx/svxids.hrc>
#include <map>
#include <com/sun/star/text/XTextSection.hpp>
#include <cmdid.h>
#include <unocrsrhelper.hxx>
#include <unofootnote.hxx>
#include <unorefmark.hxx>
#include <unostyle.hxx>
#include <unoidx.hxx>
#include <unofield.hxx>
#include <unotbl.hxx>
#include <unosett.hxx>
#include <unoframe.hxx>
#include <unocrsr.hxx>
#include <doc.hxx>
#include <IDocumentUndoRedo.hxx>
#include <IDocumentRedlineAccess.hxx>
#include <fmtftn.hxx>
#include <fmtpdsc.hxx>
#include <charfmt.hxx>
#include <pagedesc.hxx>
#include <docstyle.hxx>
#include <ndtxt.hxx>
#include <txtrfmrk.hxx>
#include <fmtfld.hxx>
#include <txtfld.hxx>
#include <docsh.hxx>
#include <section.hxx>
#include <shellio.hxx>
#include <edimp.hxx>
#include <swundo.hxx>
#include <cntfrm.hxx>
#include <pagefrm.hxx>
#include <svl/eitem.hxx>
#include <tools/urlobj.hxx>
#include <docary.hxx>
#include <swtable.hxx>
#include <tox.hxx>
#include <doctxm.hxx>
#include <fchrfmt.hxx>
#include <editeng/flstitem.hxx>
#include <vcl/metric.hxx>
#include <svtools/ctrltool.hxx>
#define _SVSTDARR_USHORTS
#define _SVSTDARR_USHORTSSORT
#include <svl/svstdarr.hxx>
#include <sfx2/docfilt.hxx>
#include <sfx2/docfile.hxx>
#include <sfx2/fcontnr.hxx>
#include <svl/stritem.hxx>
#include <com/sun/star/beans/PropertyState.hpp>
#include <SwStyleNameMapper.hxx>
#include <redline.hxx>
#include <numrule.hxx>
#include <comphelper/storagehelper.hxx>
#include <comphelper/mediadescriptor.hxx>
#include <comphelper/sequenceashashmap.hxx>
#include <com/sun/star/embed/ElementModes.hpp>
#include <com/sun/star/embed/XStorage.hpp>
// --> OD 2008-11-26 #158694#
#include <SwNodeNum.hxx>
// <--
#include <fmtmeta.hxx>


using namespace ::com::sun::star;
using namespace ::com::sun::star::uno;
using namespace ::com::sun::star::beans;
using namespace ::com::sun::star::text;
using namespace ::com::sun::star::table;
using namespace ::com::sun::star::container;
using namespace ::com::sun::star::lang;
using ::rtl::OUString;


namespace SwUnoCursorHelper
{

uno::Reference<text::XTextContent>
GetNestedTextContent(SwTxtNode & rTextNode, xub_StrLen const nIndex,
        bool const bParent)
{
    // these should be unambiguous because of the dummy character
    SwTxtNode::GetTxtAttrMode const eMode( (bParent)
        ? SwTxtNode::PARENT : SwTxtNode::EXPAND );
    SwTxtAttr *const pMetaTxtAttr =
        rTextNode.GetTxtAttrAt(nIndex, RES_TXTATR_META, eMode);
    SwTxtAttr *const pMetaFieldTxtAttr =
        rTextNode.GetTxtAttrAt(nIndex, RES_TXTATR_METAFIELD, eMode);
    // which is innermost?
    SwTxtAttr *const pTxtAttr = (pMetaTxtAttr)
        ? ((pMetaFieldTxtAttr)
            ? ((*pMetaFieldTxtAttr->GetStart() >
                    *pMetaTxtAttr->GetStart())
                ? pMetaFieldTxtAttr : pMetaTxtAttr)
            : pMetaTxtAttr)
        : pMetaFieldTxtAttr;
    uno::Reference<XTextContent> xRet;
    if (pTxtAttr)
    {
        ::sw::Meta *const pMeta(
            static_cast<SwFmtMeta &>(pTxtAttr->GetAttr()).GetMeta());
        OSL_ASSERT(pMeta);
        xRet.set(pMeta->MakeUnoObject(), uno::UNO_QUERY);
    }
    return xRet;
}


/* -----------------16.09.98 12:27-------------------
* 	Lesen spezieller Properties am Cursor
 * --------------------------------------------------*/
sal_Bool getCrsrPropertyValue(
    const SfxItemPropertySimpleEntry& rEntry,
    SwPaM& rPam,
    Any *pAny,
    PropertyState& eState,
    const SwTxtNode* pNode )
{
    PropertyState eNewState = PropertyState_DIRECT_VALUE;
    //    PropertyState_DEFAULT_VALUE
    //    PropertyState_AMBIGUOUS_VALUE
    sal_Bool bDone = sal_True;
    switch(rEntry.nWID)
    {
        case FN_UNO_PARA_CONT_PREV_SUBTREE:
            if (pAny)
            {
                const SwTxtNode * pTmpNode = pNode;

                if (!pTmpNode)
                    pTmpNode = rPam.GetNode()->GetTxtNode();

                bool bRet = false;

                if ( pTmpNode &&
                     pTmpNode->GetNum() &&
                     pTmpNode->GetNum()->IsContinueingPreviousSubTree() )
                {
                    bRet = true;
                }

                *pAny <<= bRet;
            }
        break;

        case FN_UNO_PARA_NUM_STRING:
            if (pAny)
            {
                const SwTxtNode * pTmpNode = pNode;

                if (!pTmpNode)
                    pTmpNode = rPam.GetNode()->GetTxtNode();

                String sRet;
                if ( pTmpNode && pTmpNode->GetNum() )
                {
                    sRet = pTmpNode->GetNumString();
                }

                *pAny <<= OUString(sRet);
            }
        break;

        case RES_PARATR_OUTLINELEVEL: //#outlinelevel added by zhaojianwei
            if (pAny)
            {
                const SwTxtNode * pTmpNode = pNode;

                if (!pTmpNode)
                    pTmpNode = rPam.GetNode()->GetTxtNode();

                sal_Int16 nRet = -1;
                if ( pTmpNode )
                    nRet = sal::static_int_cast< sal_Int16 >( pTmpNode->GetAttrOutlineLevel() );

                *pAny <<= nRet;
            }
        break; //<-end,zhaojianwei

        case FN_UNO_PARA_CONDITIONAL_STYLE_NAME:
        case FN_UNO_PARA_STYLE :
            {
            SwFmtColl* pFmt = 0;
            if(pNode)
                pFmt = FN_UNO_PARA_CONDITIONAL_STYLE_NAME == rEntry.nWID
                            ? pNode->GetFmtColl() : &pNode->GetAnyFmtColl();
            else
            {
                pFmt = SwUnoCursorHelper::GetCurTxtFmtColl(rPam,
                        FN_UNO_PARA_CONDITIONAL_STYLE_NAME == rEntry.nWID);
            }
			if(pFmt)
			{
				if( pAny )
				{
					String sVal;
					SwStyleNameMapper::FillProgName(pFmt->GetName(), sVal, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL, sal_True );
					*pAny <<= OUString(sVal);
				}
			}
			else
				eNewState = PropertyState_AMBIGUOUS_VALUE;
		}
		break;
		case FN_UNO_PAGE_STYLE :
		{
			String sVal;
			GetCurPageStyle(rPam, sVal);
			if( pAny )
				*pAny <<= OUString(sVal);
			if(!sVal.Len())
				eNewState = PropertyState_AMBIGUOUS_VALUE;
		}
		break;
		case FN_UNO_NUM_START_VALUE  :
			if( pAny )
			{
				sal_Int16 nValue = IsNodeNumStart(rPam, eNewState);
				*pAny <<= nValue;
			}
		break;

        case FN_UNO_NUM_LEVEL  :
        case FN_UNO_IS_NUMBER  :
        case FN_UNO_LIST_ID:
        case FN_NUMBER_NEWSTART:
            {
                // a multi selection is not considered
                const SwTxtNode* pTxtNd = rPam.GetNode()->GetTxtNode();
                if ( pTxtNd && pTxtNd->IsInList() )
                {
                    if( pAny )
                    {
                        if(rEntry.nWID == FN_UNO_NUM_LEVEL)
                            *pAny <<= (sal_Int16)(pTxtNd->GetActualListLevel());
                        else if(rEntry.nWID == FN_UNO_IS_NUMBER)
                        {
                            sal_Bool bIsNumber = pTxtNd->IsCountedInList();
                            pAny->setValue(&bIsNumber, ::getBooleanCppuType());
                        }
                        else if ( rEntry.nWID == FN_UNO_LIST_ID )
                        {
                            const String sListId = pTxtNd->GetListId();
                            *pAny <<= OUString(sListId);
                        }
                        else /*if(rEntry.nWID == UNO_NAME_PARA_IS_NUMBERING_RESTART)*/
                        {
                            sal_Bool bIsRestart = pTxtNd->IsListRestart();
                            pAny->setValue(&bIsRestart, ::getBooleanCppuType());
                        }
                    }
                }
                else
                {
                    eNewState = PropertyState_DEFAULT_VALUE;

                    if( pAny )
                    {
                        // #i30838# set default values for default properties
                        if(rEntry.nWID == FN_UNO_NUM_LEVEL)
                            *pAny <<= static_cast<sal_Int16>( 0 );
                        else if(rEntry.nWID == FN_UNO_IS_NUMBER)
                            *pAny <<= false;
                        // --> OD 2008-07-14 #i91601#
                        else if ( rEntry.nWID == FN_UNO_LIST_ID )
                        {
                            *pAny <<= OUString();
                        }
                        // <--
                        else /*if(rEntry.nWID == UNO_NAME_PARA_IS_NUMBERING_RESTART)*/
                            *pAny <<= false;
                    }
                }
                //PROPERTY_MAYBEVOID!
            }
            break;

        case FN_UNO_NUM_RULES  :
            if( pAny )
                getNumberingProperty(rPam, eNewState, pAny);
            else
            {
                if( !rPam.GetDoc()->GetCurrNumRule( *rPam.GetPoint() ) )
                    eNewState = PropertyState_DEFAULT_VALUE;
            }
            break;

        case FN_UNO_DOCUMENT_INDEX_MARK:
            {
                ::std::vector<SwTxtAttr *> const marks(
                    rPam.GetNode()->GetTxtNode()->GetTxtAttrsAt(
                    rPam.GetPoint()->nContent.GetIndex(), RES_TXTATR_TOXMARK));
                if (marks.size())
                {
                    if( pAny )
                    {   // hmm... can only return 1 here
                        SwTOXMark & rMark =
                            static_cast<SwTOXMark &>((*marks.begin())->GetAttr());
                        const uno::Reference< text::XDocumentIndexMark > xRef =
                            SwXDocumentIndexMark::CreateXDocumentIndexMark(
                            *rPam.GetDoc(),
                            *const_cast<SwTOXType*>(rMark.GetTOXType()), rMark);
                        (*pAny) <<= xRef;
                    }
                }
                else
                    //auch hier - nicht zu unterscheiden
                    eNewState = PropertyState_DEFAULT_VALUE;
            }
            break;

        case FN_UNO_DOCUMENT_INDEX:
            {
                const SwTOXBase* pBase = rPam.GetDoc()->GetCurTOX(
                    *rPam.Start() );
                if( pBase )
                {
                    if( pAny )
                    {
                        const uno::Reference< text::XDocumentIndex > xRef =
                            SwXDocumentIndex::CreateXDocumentIndex(*rPam.GetDoc(),
                            *static_cast<SwTOXBaseSection const*>(pBase));
                        (*pAny) <<= xRef;
                    }
                }
                else
                    eNewState = PropertyState_DEFAULT_VALUE;
            }
            break;

        case FN_UNO_TEXT_FIELD:
            {
                const SwPosition *pPos = rPam.Start();
                const SwTxtNode *pTxtNd =
                    rPam.GetDoc()->GetNodes()[pPos->nNode.GetIndex()]->GetTxtNode();
                const SwTxtAttr* pTxtAttr = (pTxtNd)
                    ? pTxtNd->GetFldTxtAttrAt( pPos->nContent.GetIndex(), true )
                    : 0;
                if ( pTxtAttr != NULL )
                {
                    if( pAny )
                    {
                        SwXTextField* pField =
                            SwXTextField::CreateSwXTextField( *rPam.GetDoc(),pTxtAttr->GetFmtFld() );
                        *pAny <<= uno::Reference< XTextField >( pField );
                    }
                }
                else
                    eNewState = PropertyState_DEFAULT_VALUE;
            }
            break;

        case FN_UNO_TEXT_TABLE:
        case FN_UNO_CELL:
            {
                SwStartNode* pSttNode = rPam.GetNode()->StartOfSectionNode();
                SwStartNodeType eType = pSttNode->GetStartNodeType();
                if(SwTableBoxStartNode == eType)
                {
                    if( pAny )
                    {
                        const SwTableNode* pTblNode = pSttNode->FindTableNode();
                        SwFrmFmt* pTableFmt = (SwFrmFmt*)pTblNode->GetTable().GetFrmFmt();
                        //SwTable& rTable = ((SwTableNode*)pSttNode)->GetTable();
                        if(FN_UNO_TEXT_TABLE == rEntry.nWID)
                        {
                            uno::Reference< XTextTable >  xTable = SwXTextTables::GetObject(*pTableFmt);
                            pAny->setValue(&xTable, ::getCppuType((uno::Reference<XTextTable>*)0));
                        }
                        else
                        {
                            SwTableBox* pBox = pSttNode->GetTblBox();
                            uno::Reference< XCell >  xCell = SwXCell::CreateXCell(pTableFmt, pBox);
                            pAny->setValue(&xCell, ::getCppuType((uno::Reference<XCell>*)0));
                        }
                    }
                }
                else
                    eNewState = PropertyState_DEFAULT_VALUE;
            }
            break;

        case FN_UNO_TEXT_FRAME:
            {
                SwStartNode* pSttNode = rPam.GetNode()->StartOfSectionNode();
                SwStartNodeType eType = pSttNode->GetStartNodeType();

                SwFrmFmt* pFmt;
                if(eType == SwFlyStartNode && 0 != (pFmt = pSttNode->GetFlyFmt()))
                {
                    if( pAny )
                    {
                        uno::Reference< XTextFrame >  xFrm = (SwXTextFrame*) SwXFrames::GetObject(*pFmt, FLYCNTTYPE_FRM);
                        pAny->setValue(&xFrm, ::getCppuType((uno::Reference<XTextFrame>*)0));
                    }
                }
                else
                    eNewState = PropertyState_DEFAULT_VALUE;
            }
            break;

        case FN_UNO_TEXT_SECTION:
            {
                SwSection* pSect = rPam.GetDoc()->GetCurrSection(*rPam.GetPoint());
                if(pSect)
                {
                    if( pAny )
                    {
                        uno::Reference< XTextSection >  xSect = SwXTextSections::GetObject( *pSect->GetFmt() );
                        pAny->setValue(&xSect, ::getCppuType((uno::Reference<XTextSection>*)0) );
                    }
                }
                else
                    eNewState = PropertyState_DEFAULT_VALUE;
            }
            break;

        case FN_UNO_ENDNOTE:
        case FN_UNO_FOOTNOTE:
            {
                SwTxtAttr *const pTxtAttr =
                    rPam.GetNode()->GetTxtNode()->GetTxtAttrForCharAt(
                    rPam.GetPoint()->nContent.GetIndex(), RES_TXTATR_FTN);
                if(pTxtAttr)
                {
                    const SwFmtFtn& rFtn = pTxtAttr->GetFtn();
                    if(rFtn.IsEndNote() == (FN_UNO_ENDNOTE == rEntry.nWID))
                    {
                        if( pAny )
                        {
                            const uno::Reference< text::XFootnote > xFootnote =
                                SwXFootnote::CreateXFootnote(*rPam.GetDoc(), rFtn);
                            *pAny <<= xFootnote;
                        }
                    }
                    else
                        eNewState = PropertyState_DEFAULT_VALUE;
                }
                else
                    eNewState = PropertyState_DEFAULT_VALUE;
            }
            break;

        case FN_UNO_REFERENCE_MARK:
            {
                ::std::vector<SwTxtAttr *> const marks(
                    rPam.GetNode()->GetTxtNode()->GetTxtAttrsAt(
                    rPam.GetPoint()->nContent.GetIndex(), RES_TXTATR_REFMARK));
                if (marks.size())
                {
                    if( pAny )
                    {   // hmm... can only return 1 here
                        const SwFmtRefMark& rRef = (*marks.begin())->GetRefMark();
                        uno::Reference< XTextContent >  xRef = SwXReferenceMarks::GetObject( rPam.GetDoc(), &rRef );
                        pAny->setValue(&xRef, ::getCppuType((uno::Reference<XTextContent>*)0));
                    }
                }
                else
                    eNewState = PropertyState_DEFAULT_VALUE;
            }
            break;

        case FN_UNO_NESTED_TEXT_CONTENT:
        {
            uno::Reference<XTextContent> const xRet(
                GetNestedTextContent(*rPam.GetNode()->GetTxtNode(),
                    rPam.GetPoint()->nContent.GetIndex(), false));
            if (xRet.is())
            {
                if (pAny)
                {
                    (*pAny) <<= xRet;
                }
            }
            else
            {
                eNewState = PropertyState_DEFAULT_VALUE;
            }
        }
        break;

        case FN_UNO_CHARFMT_SEQUENCE:
        {

            SwTxtNode* pTxtNode;
            if((pTxtNode = (SwTxtNode*)rPam.GetNode( sal_True )) == rPam.GetNode(sal_False) &&
                    pTxtNode->GetpSwpHints())
            {
                sal_uInt16 nPaMStart = rPam.GetPoint()->nContent.GetIndex();
                sal_uInt16 nPaMEnd = rPam.GetMark() ? rPam.GetMark()->nContent.GetIndex() : nPaMStart;
                if(nPaMStart > nPaMEnd)
                {
                    sal_uInt16 nTmp = nPaMStart;
                    nPaMStart = nPaMEnd;
                    nPaMEnd = nTmp;
                }
                Sequence< ::rtl::OUString> aCharStyles;
                SwpHints* pHints = pTxtNode->GetpSwpHints();
                for(sal_uInt16 nAttr = 0; nAttr < pHints->GetStartCount(); nAttr++ )
                {
                    SwTxtAttr* pAttr = pHints->GetStart( nAttr );
                    if(pAttr->Which() != RES_TXTATR_CHARFMT)
                        continue;
                    sal_uInt16 nAttrStart = *pAttr->GetStart();
                    sal_uInt16 nAttrEnd = *pAttr->GetEnd();
                    //check if the attribute touches the selection
                    if( ( nAttrEnd > nPaMStart && nAttrStart < nPaMEnd ) ||
                        ( !nAttrStart && !nAttrEnd && !nPaMStart && !nPaMEnd ) )
                    {
                        //check for overlapping
                        if(nAttrStart > nPaMStart ||
                                    nAttrEnd < nPaMEnd)
                        {
                            aCharStyles.realloc(0);
                            eNewState = PropertyState_AMBIGUOUS_VALUE;
                            break;
                        }
                        else
                        {
                            //now the attribute should start before or at the selection
                            //and it should end at the end of the selection or behind
                            DBG_ASSERT(nAttrStart <= nPaMStart && nAttrEnd >=nPaMEnd,
                                    "attribute overlaps or is outside");
                            //now the name of the style has to be added to the sequence
                            aCharStyles.realloc(aCharStyles.getLength() + 1);
                            DBG_ASSERT(pAttr->GetCharFmt().GetCharFmt(), "no character format set");
                            aCharStyles.getArray()[aCharStyles.getLength() - 1] =
                                        SwStyleNameMapper::GetProgName(
                                            pAttr->GetCharFmt().GetCharFmt()->GetName(), nsSwGetPoolIdFromName::GET_POOLID_CHRFMT);
                        }
                    }

                }
                eNewState =
                    aCharStyles.getLength() ?
                        PropertyState_DIRECT_VALUE : PropertyState_DEFAULT_VALUE;;
                if(pAny)
                    (*pAny) <<= aCharStyles;
            }
            else
                eNewState = PropertyState_DEFAULT_VALUE;
        }
        break;

        case RES_TXTATR_CHARFMT:
            // kein break hier!
        default: bDone = sal_False;
    }
    if( bDone )
        eState = eNewState;
    return bDone;
};
/* -----------------30.06.98 10:30-------------------
 *
 * --------------------------------------------------*/
sal_Int16 IsNodeNumStart(SwPaM& rPam, PropertyState& eState)
{
	const SwTxtNode* pTxtNd = rPam.GetNode()->GetTxtNode();
    // --> OD 2008-02-28 #refactorlists#
    // correction: check, if restart value is set at the text node and use
    // new method <SwTxtNode::GetAttrListRestartValue()> to retrieve the value
    if ( pTxtNd && pTxtNd->GetNumRule() && pTxtNd->IsListRestart() &&
         pTxtNd->HasAttrListRestartValue() )
	{
		eState = PropertyState_DIRECT_VALUE;
        sal_Int16 nTmp = sal::static_int_cast< sal_Int16 >(pTxtNd->GetAttrListRestartValue());
        return nTmp;
	}
    // <--
	eState = PropertyState_DEFAULT_VALUE;
	return -1;
}

/* -----------------25.05.98 11:41-------------------
 *
 * --------------------------------------------------*/
void setNumberingProperty(const Any& rValue, SwPaM& rPam)
{
    uno::Reference<XIndexReplace> xIndexReplace;
    if(rValue >>= xIndexReplace)
	{
		SwXNumberingRules* pSwNum = 0;

        uno::Reference<XUnoTunnel> xNumTunnel(xIndexReplace, UNO_QUERY);
		if(xNumTunnel.is())
		{
			pSwNum = reinterpret_cast< SwXNumberingRules * >(
				sal::static_int_cast< sal_IntPtr >( xNumTunnel->getSomething( SwXNumberingRules::getUnoTunnelId() )));
		}

		if(pSwNum)
		{
            SwDoc* pDoc = rPam.GetDoc();
			if(pSwNum->GetNumRule())
			{
				SwNumRule aRule(*pSwNum->GetNumRule());
				const String* pNewCharStyles =  pSwNum->GetNewCharStyleNames();
				const String* pBulletFontNames = pSwNum->GetBulletFontNames();
				for(sal_uInt16 i = 0; i < MAXLEVEL; i++)
				{
					SwNumFmt aFmt(aRule.Get( i ));
					if( pNewCharStyles[i].Len() &&
						pNewCharStyles[i] != SwXNumberingRules::GetInvalidStyle() &&
						(!aFmt.GetCharFmt() || pNewCharStyles[i] != aFmt.GetCharFmt()->GetName()))
					{
						if(!pNewCharStyles[i].Len())
							aFmt.SetCharFmt(0);
						else
						{

                            // CharStyle besorgen und an der Rule setzen
							sal_uInt16 nChCount = pDoc->GetCharFmts()->Count();
							SwCharFmt* pCharFmt = 0;
                            for(sal_uInt16 nCharFmt = 0; nCharFmt < nChCount; nCharFmt++)
							{
                                SwCharFmt& rChFmt = *((*(pDoc->GetCharFmts()))[nCharFmt]);;
								if(rChFmt.GetName() == pNewCharStyles[i])
								{
									pCharFmt = &rChFmt;
									break;
								}
							}

							if(!pCharFmt)
							{
								SfxStyleSheetBasePool* pPool = pDoc->GetDocShell()->GetStyleSheetPool();
								SfxStyleSheetBase* pBase;
								pBase = pPool->Find(pNewCharStyles[i], SFX_STYLE_FAMILY_CHAR);
							// soll das wirklich erzeugt werden?
								if(!pBase)
									pBase = &pPool->Make(pNewCharStyles[i], SFX_STYLE_FAMILY_PAGE);
								pCharFmt = ((SwDocStyleSheet*)pBase)->GetCharFmt();
							}
							if(pCharFmt)
								aFmt.SetCharFmt(pCharFmt);
						}
					}
					//jetzt nochmal fuer Fonts
					if(
					   pBulletFontNames[i] != SwXNumberingRules::GetInvalidStyle() &&
					   (
					    (pBulletFontNames[i].Len() && !aFmt.GetBulletFont()) ||
					    (pBulletFontNames[i].Len() &&
							aFmt.GetBulletFont()->GetName() != pBulletFontNames[i])
					   )
					  )
					{
						const SvxFontListItem* pFontListItem =
								(const SvxFontListItem* )pDoc->GetDocShell()
													->GetItem( SID_ATTR_CHAR_FONTLIST );
						const FontList*	 pList = pFontListItem->GetFontList();

						FontInfo aInfo = pList->Get(
							pBulletFontNames[i],WEIGHT_NORMAL, ITALIC_NONE);
						Font aFont(aInfo);
						aFmt.SetBulletFont(&aFont);
					}
					aRule.Set( i, aFmt );
				}
                UnoActionContext aAction(pDoc);

                if( rPam.GetNext() != &rPam )           // Mehrfachselektion ?
				{
                    pDoc->GetIDocumentUndoRedo().StartUndo( UNDO_START, NULL );
					SwPamRanges aRangeArr( rPam );
					SwPaM aPam( *rPam.GetPoint() );
					for( sal_uInt16 n = 0; n < aRangeArr.Count(); ++n )
                    {
                        // --> OD 2008-03-17 #refactorlists#
                        // no start of a new list
                        pDoc->SetNumRule( aRangeArr.SetPam( n, aPam ), aRule, false );
                        // <--
                    }
                    pDoc->GetIDocumentUndoRedo().EndUndo( UNDO_END, NULL );
                }
                else
                {
                    // --> OD 2008-03-17 #refactorlists#
                    // no start of a new list
                    pDoc->SetNumRule( rPam, aRule, false );
                    // <--
                }


			}
			else if(pSwNum->GetCreatedNumRuleName().Len())
			{
				UnoActionContext aAction(pDoc);
				SwNumRule* pRule = pDoc->FindNumRulePtr( pSwNum->GetCreatedNumRuleName() );
				if(!pRule)
					throw RuntimeException();
                // --> OD 2008-03-17 #refactorlists#
                // no start of a new list
                pDoc->SetNumRule( rPam, *pRule, false );
                // <--
			}
            // --> OD 2009-08-18 #i103817#
            // outline numbering
            else
            {
                UnoActionContext aAction(pDoc);
                SwNumRule* pRule = pDoc->GetOutlineNumRule();
                if(!pRule)
                    throw RuntimeException();
                pDoc->SetNumRule( rPam, *pRule, false );
            }
            // <--
		}
	}
    else if(rValue.getValueType() == ::getVoidCppuType())
    {
        rPam.GetDoc()->DelNumRules(rPam);
    }
}


/* -----------------25.05.98 11:40-------------------
 *
 * --------------------------------------------------*/
void  getNumberingProperty(SwPaM& rPam, PropertyState& eState, Any * pAny )
{
	const SwNumRule* pNumRule = rPam.GetDoc()->GetCurrNumRule( *rPam.GetPoint() );
	if(pNumRule)
	{
		uno::Reference< XIndexReplace >  xNum = new SwXNumberingRules(*pNumRule);
		if ( pAny )
			pAny->setValue(&xNum, ::getCppuType((const uno::Reference<XIndexReplace>*)0));
		eState = PropertyState_DIRECT_VALUE;
	}
	else
		eState = PropertyState_DEFAULT_VALUE;
}
/* -----------------04.07.98 15:15-------------------
 *
 * --------------------------------------------------*/
void GetCurPageStyle(SwPaM& rPaM, String &rString)
{
	const SwPageFrm* pPage = rPaM.GetCntntNode()->getLayoutFrm(rPaM.GetDoc()->GetCurrentLayout())->FindPageFrm();
	if(pPage)
		SwStyleNameMapper::FillProgName( pPage->GetPageDesc()->GetName(), rString, nsSwGetPoolIdFromName::GET_POOLID_PAGEDESC, sal_True );
}
/* -----------------30.03.99 10:52-------------------
 * spezielle Properties am Cursor zuruecksetzen
 * --------------------------------------------------*/
void resetCrsrPropertyValue(const SfxItemPropertySimpleEntry& rEntry, SwPaM& rPam)
{
	SwDoc* pDoc = rPam.GetDoc();
    switch(rEntry.nWID)
	{
		case FN_UNO_PARA_STYLE :
//			lcl_SetTxtFmtColl(aValue, pUnoCrsr);
		break;
		case FN_UNO_PAGE_STYLE :
		break;
		case FN_UNO_NUM_START_VALUE  :
		{
			UnoActionContext aAction(pDoc);

			if( rPam.GetNext() != &rPam )			// Mehrfachselektion ?
            {
                pDoc->GetIDocumentUndoRedo().StartUndo( UNDO_START, NULL );
				SwPamRanges aRangeArr( rPam );
				SwPaM aPam( *rPam.GetPoint() );
				for( sal_uInt16 n = 0; n < aRangeArr.Count(); ++n )
					pDoc->SetNodeNumStart( *aRangeArr.SetPam( n, aPam ).GetPoint(), 1 );
                pDoc->GetIDocumentUndoRedo().EndUndo( UNDO_END, NULL );
            }
            else
				pDoc->SetNodeNumStart( *rPam.GetPoint(), 0 );
		}

		break;
		case FN_UNO_NUM_LEVEL  :
		break;
		case FN_UNO_NUM_RULES:
//    		lcl_setNumberingProperty(aValue, pUnoCrsr);
		break;
        case FN_UNO_CHARFMT_SEQUENCE:
        {
            SvUShortsSort aWhichIds;
            aWhichIds.Insert(RES_TXTATR_CHARFMT);
            pDoc->ResetAttrs(rPam, sal_True, &aWhichIds);
        }
        break;
    }
}
/* -----------------21.07.98 11:36-------------------
 *
 * --------------------------------------------------*/
void InsertFile(SwUnoCrsr* pUnoCrsr,
    const String& rURL,
    const uno::Sequence< beans::PropertyValue >& rOptions
    ) throw( lang::IllegalArgumentException, io::IOException, uno::RuntimeException )
{
	SfxMedium* pMed = 0;
	SwDoc* pDoc = pUnoCrsr->GetDoc();
	SwDocShell* pDocSh = pDoc->GetDocShell();
    comphelper::MediaDescriptor aMediaDescriptor( rOptions );
    ::rtl::OUString sFileName = rURL;
    ::rtl::OUString sFilterName, sFilterOptions, sPassword, sBaseURL;
    uno::Reference < io::XStream > xStream;
    uno::Reference < io::XInputStream > xInputStream;

    if( !sFileName.getLength() )
        aMediaDescriptor[comphelper::MediaDescriptor::PROP_URL()] >>= sFileName;
    if( !sFileName.getLength() )
        aMediaDescriptor[comphelper::MediaDescriptor::PROP_FILENAME()] >>= sFileName;
    aMediaDescriptor[comphelper::MediaDescriptor::PROP_INPUTSTREAM()] >>= xInputStream;
    aMediaDescriptor[comphelper::MediaDescriptor::PROP_STREAM()] >>= xStream;
    aMediaDescriptor[comphelper::MediaDescriptor::PROP_INPUTSTREAM()] >>= xInputStream;
    aMediaDescriptor[comphelper::MediaDescriptor::PROP_FILTERNAME()] >>= sFilterName;
    aMediaDescriptor[comphelper::MediaDescriptor::PROP_FILTEROPTIONS()] >>= sFilterOptions;
    aMediaDescriptor[comphelper::MediaDescriptor::PROP_PASSWORD()] >>= sPassword;
    aMediaDescriptor[comphelper::MediaDescriptor::PROP_DOCUMENTBASEURL() ] >>= sBaseURL;
    if ( !xInputStream.is() && xStream.is() )
        xInputStream = xStream->getInputStream();

    if(!pDocSh || (!sFileName.getLength() && !xInputStream.is()))
		return;

    SfxObjectFactory& rFact = pDocSh->GetFactory();
    const SfxFilter* pFilter = rFact.GetFilterContainer()->GetFilter4FilterName( sFilterName );
    uno::Reference < embed::XStorage > xReadStorage;
    if( xInputStream.is() )
    {
        uno::Sequence< uno::Any > aArgs( 2 );
        aArgs[0] <<= xInputStream;
        aArgs[1] <<= embed::ElementModes::READ;
        try
        {
            xReadStorage = uno::Reference< embed::XStorage >(
                            ::comphelper::OStorageHelper::GetStorageFactory()->createInstanceWithArguments( aArgs ),
                            uno::UNO_QUERY );
        }
        catch( const io::IOException& rEx)
        {
            (void)rEx;
        }
    }
    if ( !pFilter )
	{
        if( xInputStream.is() && !xReadStorage.is())
        {
            pMed = new SfxMedium;
            pMed->setStreamToLoadFrom(xInputStream, sal_True );
        }
        else
            pMed = xReadStorage.is() ?
                new SfxMedium(xReadStorage, sBaseURL, 0 ) :
                new SfxMedium(sFileName, STREAM_READ, sal_True, 0, 0 );
        if( sBaseURL.getLength() )
            pMed->GetItemSet()->Put( SfxStringItem( SID_DOC_BASEURL, sBaseURL ) );

		SfxFilterMatcher aMatcher( rFact.GetFilterContainer()->GetName() );
		ErrCode nErr = aMatcher.GuessFilter( *pMed, &pFilter, sal_False );
		if ( nErr || !pFilter)
			DELETEZ(pMed);
		else
			pMed->SetFilter( pFilter );
	}
	else
	{
        if(!pMed)
        {
            if( xInputStream.is() && !xReadStorage.is())
            {
                pMed = new SfxMedium;
                pMed->setStreamToLoadFrom(xInputStream, sal_True );
                pMed->SetFilter( pFilter );
            }
            else
            {
                if( xReadStorage.is() )
                {
                    pMed = new SfxMedium(xReadStorage, sBaseURL, 0 );
                    pMed->SetFilter( pFilter );
                }
                else
                    pMed = new SfxMedium(sFileName, STREAM_READ, sal_True, pFilter, 0);
            }
        }
        if(sFilterOptions.getLength())
            pMed->GetItemSet()->Put( SfxStringItem( SID_FILE_FILTEROPTIONS, sFilterOptions ) );
        if( sBaseURL.getLength())
            pMed->GetItemSet()->Put( SfxStringItem( SID_DOC_BASEURL, sBaseURL ) );
	}

	if( !pMed )
		return;

    // this sourcecode is not responsible for the lifetime of the shell, SfxObjectShellLock should not be used
	SfxObjectShellRef aRef( pDocSh );

	pDocSh->RegisterTransfer( *pMed );
	pMed->DownLoad();	// ggfs. den DownLoad anstossen
	if( aRef.Is() && 1 < aRef->GetRefCount() )	// noch gueltige Ref?
	{
		SwReader* pRdr;
		SfxItemSet* pSet = 	pMed->GetItemSet();
		pSet->Put(SfxBoolItem(FN_API_CALL, sal_True));
        if(sPassword.getLength())
            pSet->Put(SfxStringItem(SID_PASSWORD, sPassword));
		Reader *pRead = pDocSh->StartConvertFrom( *pMed, &pRdr, 0, pUnoCrsr);
		if( pRead )
		{

			UnoActionContext aContext(pDoc);

			if(pUnoCrsr->HasMark())
				pDoc->DeleteAndJoin(*pUnoCrsr);

			SwNodeIndex aSave(  pUnoCrsr->GetPoint()->nNode, -1 );
			xub_StrLen nCntnt = pUnoCrsr->GetPoint()->nContent.GetIndex();

            sal_uInt32 nErrno = pRdr->Read( *pRead );   // und Dokument einfuegen

			if(!nErrno)
			{
				aSave++;
				pUnoCrsr->SetMark();
				pUnoCrsr->GetMark()->nNode = aSave;

				SwCntntNode* pCntNode = aSave.GetNode().GetCntntNode();
				if( !pCntNode )
					nCntnt = 0;
				pUnoCrsr->GetMark()->nContent.Assign( pCntNode, nCntnt );
			}

			delete pRdr;

			// ggfs. alle Verzeichnisse updaten:
/*			if( pWrtShell->IsUpdateTOX() )
			{
				SfxRequest aReq( *this, FN_UPDATE_TOX );
				Execute( aReq );
				pWrtShell->SetUpdateTOX( sal_False );		// wieder zurueck setzen
			}*/

		}
	}
	delete pMed;
}

/* -----------------14.07.04 ------------------------
 *
 * --------------------------------------------------*/

// insert text and scan for CR characters in order to insert
// paragraph breaks at those positions by calling SplitNode
sal_Bool DocInsertStringSplitCR(
        SwDoc &rDoc,
        const SwPaM &rNewCursor, const String &rText,
        const bool bForceExpandHints )
{
    sal_Bool bOK = sal_True;

        const enum IDocumentContentOperations::InsertFlags nInsertFlags =
            (bForceExpandHints)
            ? static_cast<IDocumentContentOperations::InsertFlags>(
                    IDocumentContentOperations::INS_FORCEHINTEXPAND |
                    IDocumentContentOperations::INS_EMPTYEXPAND)
            : IDocumentContentOperations::INS_EMPTYEXPAND;

    // grouping done in InsertString is intended for typing, not API calls
    ::sw::GroupUndoGuard const undoGuard(rDoc.GetIDocumentUndoRedo());
    OUString aTxt;
    xub_StrLen nStartIdx = 0;
    SwTxtNode* const pTxtNd =
        rNewCursor.GetPoint()->nNode.GetNode().GetTxtNode();
    const xub_StrLen nMaxLength = ( pTxtNd )
        ? STRING_LEN - pTxtNd->GetTxt().Len()
        : STRING_LEN;
    xub_StrLen nIdx = rText.Search( '\r', nStartIdx );
    if( ( nIdx == STRING_NOTFOUND && nMaxLength < rText.Len() ) ||
        ( nIdx != STRING_NOTFOUND && nMaxLength < nIdx ) )
    {
        nIdx = nMaxLength;
    }
    while (nIdx != STRING_NOTFOUND )
    {
        DBG_ASSERT( nIdx - nStartIdx >= 0, "index negative!" );
        aTxt = rText.Copy( nStartIdx, nIdx - nStartIdx );
        if (aTxt.getLength() &&
            !rDoc.InsertString( rNewCursor, aTxt, nInsertFlags ))
        {
            DBG_ERROR( "Doc->Insert(Str) failed." );
            bOK = sal_False;
        }
        if (!rDoc.SplitNode( *rNewCursor.GetPoint(), false ) )
        {
            DBG_ERROR( "SplitNode failed" );
            bOK = sal_False;
        }
        nStartIdx = nIdx + 1;
        nIdx = rText.Search( '\r', nStartIdx );
    }
    aTxt = rText.Copy( nStartIdx );
    if (aTxt.getLength() &&
        !rDoc.InsertString( rNewCursor, aTxt, nInsertFlags ))
    {
        DBG_ERROR( "Doc->Insert(Str) failed." );
        bOK = sal_False;
    }

    return bOK;
}
/*-- 10.03.2008 09:58:47---------------------------------------------------

  -----------------------------------------------------------------------*/
void makeRedline( SwPaM& rPaM,
    const ::rtl::OUString& rRedlineType,
    const uno::Sequence< beans::PropertyValue >& rRedlineProperties )
        throw (lang::IllegalArgumentException, uno::RuntimeException)
{
    IDocumentRedlineAccess* pRedlineAccess = rPaM.GetDoc();

    RedlineType_t eType = nsRedlineType_t::REDLINE_INSERT;
    if( rRedlineType.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM ( "Delete" ) ))
        eType = nsRedlineType_t::REDLINE_DELETE;
    else if( rRedlineType.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM ( "Format" ) ))
        eType = nsRedlineType_t::REDLINE_FORMAT;
    else if( rRedlineType.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM ( "TextTable" ) ))
        eType = nsRedlineType_t::REDLINE_TABLE;
    else if( !rRedlineType.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM ( "Insert" ) ))
        throw lang::IllegalArgumentException();

    //todo: what about REDLINE_FMTCOLL?
    comphelper::SequenceAsHashMap aPropMap( rRedlineProperties );
    uno::Any aAuthorValue;
    aAuthorValue = aPropMap.getUnpackedValueOrDefault( ::rtl::OUString::createFromAscii("RedlineAuthor"), aAuthorValue);
    sal_uInt16 nAuthor = 0;
    ::rtl::OUString sAuthor;
    if( aAuthorValue >>= sAuthor )
        nAuthor = pRedlineAccess->InsertRedlineAuthor(sAuthor);

    ::rtl::OUString sComment;
    uno::Any aCommentValue;
    aCommentValue = aPropMap.getUnpackedValueOrDefault( ::rtl::OUString::createFromAscii("RedlineComment"), aCommentValue);

    SwRedlineData aRedlineData( eType, nAuthor );
    if( aCommentValue >>= sComment )
        aRedlineData.SetComment( sComment );

    ::util::DateTime aStamp;
    uno::Any aDateTimeValue;
    aDateTimeValue = aPropMap.getUnpackedValueOrDefault( ::rtl::OUString::createFromAscii("RedlineDateTime"), aDateTimeValue);
    if( aDateTimeValue >>= aStamp )
    {
       aRedlineData.SetTimeStamp(
        DateTime( Date( aStamp.Day, aStamp.Month, aStamp.Year ), Time( aStamp.Hours, aStamp.Minutes, aStamp.Seconds ) ) );
    }

    SwRedline* pRedline = new SwRedline( aRedlineData, rPaM );
    RedlineMode_t nPrevMode = pRedlineAccess->GetRedlineMode( );

    pRedlineAccess->SetRedlineMode_intern(nsRedlineMode_t::REDLINE_ON);
    bool bRet = pRedlineAccess->AppendRedline( pRedline, false );
    pRedlineAccess->SetRedlineMode_intern( nPrevMode );
    if( !bRet )
        throw lang::IllegalArgumentException();
}

/*-- 19.02.2009 09:27:26---------------------------------------------------

  -----------------------------------------------------------------------*/
SwAnyMapHelper::~SwAnyMapHelper()
{
    AnyMapHelper_t::iterator aIt = begin();
    while( aIt != end() )
    {
        delete ( aIt->second );
        ++aIt;
    }
}
/*-- 19.02.2009 09:27:26---------------------------------------------------

  -----------------------------------------------------------------------*/
void SwAnyMapHelper::SetValue( sal_uInt16 nWhichId, sal_uInt16 nMemberId, const uno::Any& rAny )
{
    sal_uInt32 nKey = (nWhichId << 16) + nMemberId;
    AnyMapHelper_t::iterator aIt = find( nKey );
    if( aIt != end() )
    {
        *(aIt->second) = rAny;
    }
    else
        insert( value_type(nKey, new uno::Any( rAny )) );
}
/*-- 19.02.2009 09:27:26---------------------------------------------------

  -----------------------------------------------------------------------*/
bool    SwAnyMapHelper::FillValue( sal_uInt16 nWhichId, sal_uInt16 nMemberId, const uno::Any*& pAny )
{
    bool bRet = false;
    sal_uInt32 nKey = (nWhichId << 16) + nMemberId;
    AnyMapHelper_t::iterator aIt = find( nKey );
    if( aIt != end() )
    {
        pAny = aIt->second;
        bRet = true;
    }
    return bRet;
}

}//namespace SwUnoCursorHelper