#120879# - import "Microsoft Word TOC bookmarks" as cross reference bookmarks

and suppress the import of unreferenced ones.

Review by: zhengfan

11 files changed, 232 insertions, 101 deletions

diff --git a/sw/inc/IDocumentMarkAccess.hxx b/sw/inc/IDocumentMarkAccess.hxx
index b1f3d0562d3b..8635a988d20a 100644
--- a/sw/inc/IDocumentMarkAccess.hxx
+++ b/sw/inc/IDocumentMarkAccess.hxx
@@ -240,6 +240,9 @@ class IDocumentMarkAccess
 
         // Returns the MarkType used to create the mark
         static MarkType SAL_DLLPUBLIC_EXPORT GetType(const ::sw::mark::IMark& rMark);
+
+        static const ::rtl::OUString SAL_DLLPUBLIC_EXPORT & GetCrossRefHeadingBookmarkNamePrefix();
+        static const bool SAL_DLLPUBLIC_EXPORT IsLegalPaMForCrossRefHeadingBookmark( const SwPaM& rPaM );
     protected:
         virtual ~IDocumentMarkAccess() {};
 };
diff --git a/sw/source/core/crsr/crossrefbookmark.cxx b/sw/source/core/crsr/crossrefbookmark.cxx
index 75d760b81e83..f0be0825f8b5 100644
--- a/sw/source/core/crsr/crossrefbookmark.cxx
+++ b/sw/source/core/crsr/crossrefbookmark.cxx
@@ -24,6 +24,7 @@
 // MARKER(update_precomp.py): autogen include statement, do not remove
 #include "precompiled_sw.hxx"
 
+#include <IDocumentMarkAccess.hxx>
 #include <crossrefbookmark.hxx>
 #include <ndtxt.hxx>
 
@@ -38,12 +39,9 @@ namespace sw { namespace mark
         const OUString& rPrefix)
         : Bookmark(rPaM, rCode, rName, rShortName)
     {
-        if(rPaM.HasMark())
-            OSL_ENSURE((rPaM.GetMark()->nNode == rPaM.GetPoint()->nNode &&
-                rPaM.Start()->nContent.GetIndex() == 0 &&
-                rPaM.End()->nContent.GetIndex() == rPaM.GetPoint()->nNode.GetNode().GetTxtNode()->Len()),
-                "<CrossRefBookmark::CrossRefBookmark(..)>"
-                "- creation of cross-reference bookmark with an expanded PaM that does not expand over exactly one whole paragraph.");
+        OSL_ENSURE( IDocumentMarkAccess::IsLegalPaMForCrossRefHeadingBookmark( rPaM ),
+                    "<CrossRefBookmark::CrossRefBookmark(..)>"
+                    "- creation of cross-reference bookmark with an illegal PaM that does not expand over exactly one whole paragraph.");
         SetMarkPos(*rPaM.Start());
         if(!rName.getLength())
             m_aName = MarkBase::GenerateNewName(rPrefix);
@@ -72,14 +70,12 @@ namespace sw { namespace mark
         const KeyCode& rCode,
         const OUString& rName,
         const OUString& rShortName)
-        : CrossRefBookmark(rPaM, rCode, rName, rShortName, our_sNamePrefix)
+        : CrossRefBookmark(rPaM, rCode, rName, rShortName, IDocumentMarkAccess::GetCrossRefHeadingBookmarkNamePrefix())
     { }
 
-    const ::rtl::OUString CrossRefHeadingBookmark::our_sNamePrefix = ::rtl::OUString::createFromAscii("__RefHeading__");
-
     bool CrossRefHeadingBookmark::IsLegalName(const ::rtl::OUString& rName)
     {
-        return rName.match(our_sNamePrefix);
+        return rName.match(IDocumentMarkAccess::GetCrossRefHeadingBookmarkNamePrefix());
     }
 
     CrossRefNumItemBookmark::CrossRefNumItemBookmark(const SwPaM& rPaM,
diff --git a/sw/source/core/doc/docbm.cxx b/sw/source/core/doc/docbm.cxx
index 05831972201b..5f70b4ccae99 100644
--- a/sw/source/core/doc/docbm.cxx
+++ b/sw/source/core/doc/docbm.cxx
@@ -295,6 +295,26 @@ IDocumentMarkAccess::MarkType IDocumentMarkAccess::GetType(const IMark& rBkmk)
     }
 }
 
+const ::rtl::OUString& IDocumentMarkAccess::GetCrossRefHeadingBookmarkNamePrefix()
+{
+    static const ::rtl::OUString CrossRefHeadingBookmarkNamePrefix = ::rtl::OUString::createFromAscii("__RefHeading__");
+
+    return CrossRefHeadingBookmarkNamePrefix;
+}
+
+const bool SAL_DLLPUBLIC_EXPORT IDocumentMarkAccess::IsLegalPaMForCrossRefHeadingBookmark( const SwPaM& rPaM )
+{
+    bool bRet( false );
+
+    bRet = rPaM.Start()->nNode.GetNode().IsTxtNode() &&
+           rPaM.Start()->nContent.GetIndex() == 0 &&
+           ( !rPaM.HasMark() ||
+             ( rPaM.GetMark()->nNode == rPaM.GetPoint()->nNode &&
+               rPaM.End()->nContent.GetIndex() == rPaM.End()->nNode.GetNode().GetTxtNode()->Len() ) );
+
+    return bRet;
+}
+
 namespace sw { namespace mark
 {
     MarkManager::MarkManager(SwDoc& rDoc)
diff --git a/sw/source/core/inc/crossrefbookmark.hxx b/sw/source/core/inc/crossrefbookmark.hxx
index c303c6b8cb81..dd5ef00d2b7c 100644
--- a/sw/source/core/inc/crossrefbookmark.hxx
+++ b/sw/source/core/inc/crossrefbookmark.hxx
@@ -75,7 +75,6 @@ namespace sw { namespace mark
                 const ::rtl::OUString& rShortName);
             static ::rtl::OUString GenerateNewName();
             static bool IsLegalName(const ::rtl::OUString& rName);
-            static const ::rtl::OUString our_sNamePrefix;
     };
 
     class CrossRefNumItemBookmark
diff --git a/sw/source/core/unocore/unobkm.cxx b/sw/source/core/unocore/unobkm.cxx
index 03c2a184f8fa..1ac63b5e8c40 100644
--- a/sw/source/core/unocore/unobkm.cxx
+++ b/sw/source/core/unocore/unobkm.cxx
@@ -241,7 +241,8 @@ throw (lang::IllegalArgumentException, uno::RuntimeException)
         eType = IDocumentMarkAccess::CROSSREF_NUMITEM_BOOKMARK;
     }
     else if ((eType == IDocumentMarkAccess::BOOKMARK) &&
-        ::sw::mark::CrossRefHeadingBookmark::IsLegalName(m_pImpl->m_sMarkName))
+        ::sw::mark::CrossRefHeadingBookmark::IsLegalName(m_pImpl->m_sMarkName) &&
+        IDocumentMarkAccess::IsLegalPaMForCrossRefHeadingBookmark( aPam ) )
     {
         eType = IDocumentMarkAccess::CROSSREF_HEADING_BOOKMARK;
     }
diff --git a/sw/source/filter/inc/fltshell.hxx b/sw/source/filter/inc/fltshell.hxx
index f2afb37ad68e..0044413163ef 100644
--- a/sw/source/filter/inc/fltshell.hxx
+++ b/sw/source/filter/inc/fltshell.hxx
@@ -237,28 +237,32 @@ public:
 
 class SW_DLLPUBLIC SwFltBookmark : public SfxPoolItem
 {
+private:
     friend class SwFltShell;    // darf aName und aVal uebersetzen
-    long nHandle;
-    String aName;
-    String aVal;
-    sal_Bool bOnlyRef;          // "FRAGE"-Feld, Ref/Seitenrf oder nichts
-    sal_Bool bRef;
-    sal_Bool bPgRef;
+
+    long mnHandle;
+    String maName;
+    String maVal;
+    bool mbIsTOCBookmark;
+
 public:
-    SwFltBookmark( const String& rNa, const String& rVa,
-                    long nHand, sal_Bool bOnlyR );
+    SwFltBookmark( const String& rNa,
+                   const String& rVa,
+                   long nHand,
+                   const bool bIsTOCBookmark = false );
     SwFltBookmark( const SwFltBookmark& );
+
     // "pure virtual Methoden" vom SfxPoolItem
     virtual int operator==(const SfxPoolItem&) const;
     virtual SfxPoolItem* Clone(SfxItemPool* = 0) const;
-    const String& GetName() const       { return aName; }
-    const String& GetValSys() const     { return aVal; }
-    sal_Bool IsOnlyRef() const              { return bOnlyRef; }
-    sal_Bool IsRef() const                  { return bRef; }
-    void SetRef(sal_Bool b = sal_True)          { bRef = b; }
-    sal_Bool IsPgRef() const                { return bPgRef; }
-    void SetPgRef(sal_Bool b = sal_True)        { bPgRef = b; }
-    long GetHandle() const              { return nHandle; }
+
+    long GetHandle() const              { return mnHandle; }
+    const String& GetName() const       { return maName; }
+    const String& GetValSys() const     { return maVal; }
+    const bool IsTOCBookmark() const
+    {
+        return mbIsTOCBookmark;
+    }
 };
 
 class SW_DLLPUBLIC SwFltTOX : public SfxPoolItem
diff --git a/sw/source/filter/ww1/fltshell.cxx b/sw/source/filter/ww1/fltshell.cxx
index 08371198e34c..dd0b66b2cdcb 100644
--- a/sw/source/filter/ww1/fltshell.cxx
+++ b/sw/source/filter/ww1/fltshell.cxx
@@ -539,40 +539,36 @@ void SwFltControlStack::SetAttrInDoc(const SwPosition& rTmpPos, SwFltStackEntry*
         break;
     case RES_FLTR_NUMRULE_NUM:
         break;
-    case RES_FLTR_BOOKMARK:         // eigentlich nur fuer den Ende-Stack
+    case RES_FLTR_BOOKMARK:
         {
             SwFltBookmark* pB = (SwFltBookmark*)pEntry->pAttr;
             const String& rName = ((SwFltBookmark*)pEntry->pAttr)->GetName();
 
             if (IsFlagSet(BOOK_TO_VAR_REF))
             {
-                if (pB->IsPgRef() && !pB->IsRef())
-                {
-                            // XRefs und Bookmarks sind bereits geUpcased
-                    MakeBookRegionOrPoint(pEntry, pDoc, aRegion, sal_True);
-                    pDoc->InsertPoolItem(aRegion, SwFmtRefMark(rName), 0);
-                }
-                else if( !pB->IsOnlyRef() )
+                SwFieldType* pFT = pDoc->GetFldType(RES_SETEXPFLD, rName, false);
+                if (!pFT)
                 {
-                    SwFieldType* pFT = pDoc->GetFldType(RES_SETEXPFLD, rName, false);
-                    if (!pFT)
-                    {                       // FieldType anlegen
-                        SwSetExpFieldType aS(pDoc, rName, nsSwGetSetExpType::GSE_STRING);
-                        pFT = pDoc->InsertFldType(aS);
-                    }
-                    SwSetExpField aFld((SwSetExpFieldType*)pFT,
-                                        pB->GetValSys());
-                    aFld.SetSubType( nsSwExtendedSubType::SUB_INVISIBLE );
-                    MakePoint(pEntry, pDoc, aRegion);
-                    pDoc->InsertPoolItem(aRegion, SwFmtFld(aFld), 0);
-                    MoveAttrs( *(aRegion.GetPoint()) );
+                    SwSetExpFieldType aS(pDoc, rName, nsSwGetSetExpType::GSE_STRING);
+                    pFT = pDoc->InsertFldType(aS);
                 }
+                SwSetExpField aFld((SwSetExpFieldType*)pFT, pB->GetValSys());
+                aFld.SetSubType( nsSwExtendedSubType::SUB_INVISIBLE );
+                MakePoint(pEntry, pDoc, aRegion);
+                pDoc->InsertPoolItem(aRegion, SwFmtFld(aFld), 0);
+                MoveAttrs( *(aRegion.GetPoint()) );
             }
-            if( !pB->IsOnlyRef() &&
-                ( !IsFlagSet(HYPO) || IsFlagSet(BOOK_AND_REF) ) && !pEntry->bConsumedByField)
+            if ( ( !IsFlagSet(HYPO) || IsFlagSet(BOOK_AND_REF) ) &&
+                 !pEntry->bConsumedByField )
             {
                 MakeBookRegionOrPoint(pEntry, pDoc, aRegion, sal_True);
-                pDoc->getIDocumentMarkAccess()->makeMark( aRegion, rName, IDocumentMarkAccess::BOOKMARK);
+                // #120879# - create a cross reference heading bookmark if appropriate.
+                const IDocumentMarkAccess::MarkType eBookmarkType =
+                    ( pB->IsTOCBookmark() &&
+                      IDocumentMarkAccess::IsLegalPaMForCrossRefHeadingBookmark( aRegion ) )
+                    ? IDocumentMarkAccess::CROSSREF_HEADING_BOOKMARK
+                    : IDocumentMarkAccess::BOOKMARK;
+                pDoc->getIDocumentMarkAccess()->makeMark( aRegion, rName, eBookmarkType );
             }
         }
         break;
@@ -916,32 +912,39 @@ SfxPoolItem* SwFltRedline::Clone( SfxItemPool* ) const
 
 //------ hier stehen die Methoden von SwFltBookmark -----------
 SwFltBookmark::SwFltBookmark( const String& rNa, const String& rVa,
-                                long nHand, sal_Bool bOnlyR )
-    : SfxPoolItem(RES_FLTR_BOOKMARK), nHandle(nHand), aName(rNa), aVal(rVa),
-    bOnlyRef(bOnlyR), bRef(sal_False), bPgRef(sal_False)
-{
-        // eSrc: CHARSET_DONTKNOW fuer keine UEbersetzung bei operator <<
-        // Upcase wird immer gemacht.
-        // bei XXXStack.NewAttr(...) wird nie eine UEbersetzung vorgenommen.
-        // ansonsten: uebergebener Src-Charset fuer aName
-        // im Filter eingestellter Src-Charset fuer aVal ( Text )
+                              long nHand, const bool bIsTOCBookmark )
+    : SfxPoolItem( RES_FLTR_BOOKMARK )
+    , mnHandle( nHand )
+    , maName( rNa )
+    , maVal( rVa )
+    , mbIsTOCBookmark( bIsTOCBookmark )
+{
+    // eSrc: CHARSET_DONTKNOW fuer keine UEbersetzung bei operator <<
+    // Upcase wird immer gemacht.
+    // bei XXXStack.NewAttr(...) wird nie eine UEbersetzung vorgenommen.
+    // ansonsten: uebergebener Src-Charset fuer aName
+    // im Filter eingestellter Src-Charset fuer aVal ( Text )
+
+    if ( IsTOCBookmark() )
+    {
+        maName = IDocumentMarkAccess::GetCrossRefHeadingBookmarkNamePrefix();
+        maName += rNa;
+    }
 }
 
 SwFltBookmark::SwFltBookmark(const SwFltBookmark& rCpy)
-    : SfxPoolItem(RES_FLTR_BOOKMARK),
-    nHandle(rCpy.nHandle),
-    aName(rCpy.aName),
-    aVal(rCpy.aVal),
-    bOnlyRef(rCpy.bOnlyRef),
-    bRef(rCpy.bRef),
-    bPgRef(rCpy.bPgRef)
+    : SfxPoolItem( RES_FLTR_BOOKMARK )
+    , mnHandle( rCpy.mnHandle )
+    , maName( rCpy.maName )
+    , maVal( rCpy.maVal )
+    , mbIsTOCBookmark( rCpy.mbIsTOCBookmark )
 {
 }
 
 int SwFltBookmark::operator==(const SfxPoolItem& rItem) const
 {
-    return (aName == ((SwFltBookmark&)rItem).aName)
-            && (nHandle == ((SwFltBookmark&)rItem).nHandle);
+    return ( maName == ((SwFltBookmark&)rItem).maName)
+            && (mnHandle == ((SwFltBookmark&)rItem).mnHandle);
 }
 
 SfxPoolItem* SwFltBookmark::Clone(SfxItemPool*) const
@@ -1249,8 +1252,8 @@ SwFltShell& SwFltShell::SetStyle( sal_uInt16 nStyle )
 
 SwFltShell& SwFltShell::operator << (SwFltBookmark& aBook)
 {
-    ConvertUStr( aBook.aName );
-    aBook.aVal = QuoteStr(aBook.aVal);
+    ConvertUStr( aBook.maName );
+    aBook.maVal = QuoteStr(aBook.maVal);
     aEndStack.NewAttr(*pPaM->GetPoint(), aBook);
     return *this;
 }
diff --git a/sw/source/filter/ww1/w1filter.cxx b/sw/source/filter/ww1/w1filter.cxx
index 63115f95b05a..6bbbfdda0edb 100644
--- a/sw/source/filter/ww1/w1filter.cxx
+++ b/sw/source/filter/ww1/w1filter.cxx
@@ -351,7 +351,7 @@ void Ww1Bookmarks::Out(Ww1Shell& rOut, Ww1Manager& rMan, sal_uInt16)
     String aVal( rMan.GetText().GetText( Where(), nLen ) );
 
     // in 2 Schritten, da OS/2 zu doof ist
-    SwFltBookmark aBook( rName, aVal, GetHandle(), sal_False );
+    SwFltBookmark aBook( rName, aVal, GetHandle() );
     rOut << aBook;
 }
 
diff --git a/sw/source/filter/ww8/ww8par.cxx b/sw/source/filter/ww8/ww8par.cxx
index 0d5d763ca111..5437513799f6 100644
--- a/sw/source/filter/ww8/ww8par.cxx
+++ b/sw/source/filter/ww8/ww8par.cxx
@@ -926,6 +926,41 @@ bool SwWW8FltControlStack::CheckSdOD(sal_Int32 nStart,sal_Int32 nEnd)
     return rReader.IsParaEndInCPs(nStart,nEnd);
 }
 //End
+
+void SwWW8ReferencedFltEndStack::SetAttrInDoc( const SwPosition& rTmpPos,
+                                               SwFltStackEntry* pEntry )
+{
+    switch( pEntry->pAttr->Which() )
+    {
+    case RES_FLTR_BOOKMARK:
+        {
+            // suppress insertion of bookmark, which is recognized as an internal bookmark used for table-of-content
+            // and which is not referenced.
+            bool bInsertBookmarkIntoDoc = true;
+
+            SwFltBookmark* pFltBookmark = dynamic_cast<SwFltBookmark*>(pEntry->pAttr);
+            if ( pFltBookmark != 0 && pFltBookmark->IsTOCBookmark() )
+            {
+                const String& rName = pFltBookmark->GetName();
+                ::std::set< String, SwWW8::ltstr >::const_iterator aResult = aReferencedTOCBookmarks.find(rName);
+                if ( aResult == aReferencedTOCBookmarks.end() )
+                {
+                    bInsertBookmarkIntoDoc = false;
+                }
+            }
+            if ( bInsertBookmarkIntoDoc )
+            {
+                SwFltEndStack::SetAttrInDoc( rTmpPos, pEntry );
+            }
+            break;
+        }
+    default:
+        SwFltEndStack::SetAttrInDoc( rTmpPos, pEntry );
+        break;
+    }
+
+}
+
 void SwWW8FltControlStack::SetAttrInDoc(const SwPosition& rTmpPos,
     SwFltStackEntry* pEntry)
 {
@@ -3982,7 +4017,7 @@ sal_uLong SwWW8ImplReader::CoreLoad(WW8Glossary *pGloss, const SwPosition &rPos)
         RefFldStck: Keeps track of bookmarks which may be inserted as
         variables intstead.
     */
-    pReffedStck = new SwFltEndStack(&rDoc, nFieldFlags);
+    pReffedStck = new SwWW8ReferencedFltEndStack(&rDoc, nFieldFlags);
     pReffingStck = new SwWW8FltRefStack(&rDoc, nFieldFlags);
 
     pAnchorStck = new SwWW8FltAnchorStack(&rDoc, nFieldFlags);
diff --git a/sw/source/filter/ww8/ww8par.hxx b/sw/source/filter/ww8/ww8par.hxx
index 6551a8c4877a..034b3e6d8b49 100644
--- a/sw/source/filter/ww8/ww8par.hxx
+++ b/sw/source/filter/ww8/ww8par.hxx
@@ -313,14 +313,8 @@ private:
     Position& operator=(const Position&);
 };
 
-class SwWW8FltRefStack : public SwFltEndStack
+namespace SwWW8
 {
-public:
-    SwWW8FltRefStack(SwDoc* pDo, sal_uLong nFieldFl)
-        : SwFltEndStack( pDo, nFieldFl )
-    {}
-    bool IsFtnEdnBkmField(const SwFmtFld& rFmtFld, sal_uInt16& rBkmNo);
-
     struct ltstr
     {
         bool operator()(const String &r1, const String &r2) const
@@ -328,10 +322,37 @@ public:
             return r1.CompareIgnoreCaseToAscii(r2) == COMPARE_LESS;
         }
     };
+};
+
+class SwWW8ReferencedFltEndStack : public SwFltEndStack
+{
+public:
+    SwWW8ReferencedFltEndStack( SwDoc* pDo, sal_uLong nFieldFl )
+        : SwFltEndStack( pDo, nFieldFl )
+        , aReferencedTOCBookmarks()
+    {}
+
+    // Keep track of referenced TOC bookmarks in order to suppress the import
+    // of unreferenced ones.
+    std::set<String, SwWW8::ltstr> aReferencedTOCBookmarks;
+protected:
+    virtual void SetAttrInDoc( const SwPosition& rTmpPos,
+                               SwFltStackEntry* pEntry );
+};
+
+class SwWW8FltRefStack : public SwFltEndStack
+{
+public:
+    SwWW8FltRefStack(SwDoc* pDo, sal_uLong nFieldFl)
+        : SwFltEndStack( pDo, nFieldFl )
+        , aFieldVarNames()
+    {}
+    bool IsFtnEdnBkmField(const SwFmtFld& rFmtFld, sal_uInt16& rBkmNo);
+
     //Keep track of variable names created with fields, and the bookmark
     //mapped to their position, hopefully the same, but very possibly
     //an additional pseudo bookmark
-    std::map<String, String, ltstr> aFieldVarNames;
+    std::map<String, String, SwWW8::ltstr> aFieldVarNames;
 protected:
     SwFltStackEntry *RefToVar(const SwField* pFld,SwFltStackEntry *pEntry);
     virtual void SetAttrInDoc(const SwPosition& rTmpPos,
@@ -843,11 +864,11 @@ private:
     sw::util::RedlineStack *mpRedlineStack;
 
     /*
-    This stack is for fields that get referneced later, e.g. BookMarks and TOX.
+    This stack is for fields that get referenced later, e.g. BookMarks and TOX.
     They get inserted at the end of the document, it is the same stack for
     headers/footers/main text/textboxes/tables etc...
     */
-    SwFltEndStack *pReffedStck;
+    SwWW8ReferencedFltEndStack *pReffedStck;
 
     /*
     This stack is for fields whose true conversion cannot be determined until
diff --git a/sw/source/filter/ww8/ww8par5.cxx b/sw/source/filter/ww8/ww8par5.cxx
index a3d7155dfe69..d6c1278a25df 100644
--- a/sw/source/filter/ww8/ww8par5.cxx
+++ b/sw/source/filter/ww8/ww8par5.cxx
@@ -294,6 +294,17 @@ bool _ReadFieldParams::GetTokenSttFromTo(sal_uInt16* pFrom, sal_uInt16* pTo, sal
 //              Bookmarks
 //----------------------------------------
 
+namespace
+{
+    // #120879# - helper method to identify a bookmark name to match the internal TOC bookmark naming convention
+    bool IsTOCBookmarkName( const ::rtl::OUString& rName )
+    {
+        static const ::rtl::OUString cTOCBookmarkNamePrefix = ::rtl::OUString::createFromAscii("_Toc");
+
+        return rName.match(cTOCBookmarkNamePrefix);
+    }
+}
+
 long SwWW8ImplReader::Read_Book(WW8PLCFManResult*)
 {
     // muesste auch ueber pRes.nCo2OrIdx gehen
@@ -404,8 +415,9 @@ long SwWW8ImplReader::Read_Book(WW8PLCFManResult*)
         aStart = rTest.maStartPos;
     }
 
-    pReffedStck->NewAttr(aStart, SwFltBookmark(BookmarkToWriter(*pName), aVal,
-        pB->GetHandle(), 0));
+    const String sOrigName = BookmarkToWriter(*pName);
+    pReffedStck->NewAttr( aStart,
+                          SwFltBookmark( sOrigName, aVal, pB->GetHandle(), IsTOCBookmarkName( sOrigName ) ));
     return 0;
 }
 
@@ -1314,7 +1326,7 @@ long SwWW8ImplReader::MapBookmarkVariables(const WW8FieldDesc* pF,
         nNo += pPlcxMan->GetBook()->GetIMax();
     }
     pReffedStck->NewAttr(*pPaM->GetPoint(),
-        SwFltBookmark(BookmarkToWriter(sName), rData, nNo, 0));
+        SwFltBookmark( BookmarkToWriter(sName), rData, nNo ));
     pReffingStck->aFieldVarNames[rOrigName] = sName;
     return nNo;
 }
@@ -1337,7 +1349,7 @@ SwFltStackEntry *SwWW8FltRefStack::RefToVar(const SwField* pFld,
     {
         //Get the name of the ref field, and see if actually a variable
         const String &rName = pFld->GetPar1();
-        ::std::map<String,String,SwWW8FltRefStack::ltstr>::const_iterator
+        ::std::map<String,String,SwWW8::ltstr>::const_iterator
             aResult = aFieldVarNames.find(rName);
 
         if (aResult != aFieldVarNames.end())
@@ -1361,7 +1373,7 @@ String SwWW8ImplReader::GetMappedBookmark(const String &rOrigName)
 
     //See if there has been a variable set with this name, if so get
     //the pseudo bookmark name that was set with it.
-    ::std::map<String,String,SwWW8FltRefStack::ltstr>::const_iterator aResult =
+    ::std::map<String,String,SwWW8::ltstr>::const_iterator aResult =
             pReffingStck->aFieldVarNames.find(sName);
 
     const String &rBkmName = (aResult == pReffingStck->aFieldVarNames.end())
@@ -2156,18 +2168,32 @@ eF_ResT SwWW8ImplReader::Read_F_PgRef( WW8FieldDesc*, String& rStr )
         }
     }
 
-    String sName(GetMappedBookmark(sOrigName));
+    const String sName(GetMappedBookmark(sOrigName));
 
-    //loading page reference field in TOC
+    // loading page reference field in TOC
     if (mbLoadingTOCCache )
     {
-        //Step 1. Insert page ref representation as plain text
-        //Step 2. If there is no hyperlink settings for current toc, assign link to current ref area
-        if ( !mbLoadingTOCHyperlink)
+        // insert page ref representation as plain text --> return FLD_TEXT
+        // if there is no hyperlink settings for current toc and referenced bookmark is available,
+        // assign link to current ref area
+        if ( !mbLoadingTOCHyperlink && sName.Len() > 0 )
         {
-            String sURL,sTarget;
-            if( sName.Len() )
-                ( sURL += INET_MARK_TOKEN ) += sName;
+            // #120879# add cross reference bookmark name prefix, if it matches internal TOC bookmark naming convention
+            String sBookmarkName;
+            if ( IsTOCBookmarkName( sName ) )
+            {
+                sBookmarkName = String( IDocumentMarkAccess::GetCrossRefHeadingBookmarkNamePrefix() );
+                sBookmarkName += sName;
+                // track <sBookmarkName> as referenced TOC bookmark.
+                pReffedStck->aReferencedTOCBookmarks.insert( sBookmarkName );
+            }
+            else
+            {
+                sBookmarkName = sName;
+            }
+            String sURL = INET_MARK_TOKEN;
+            sURL += sBookmarkName;
+            const String sTarget;
             SwFmtINetFmt aURL( sURL, sTarget );
             String sLinkStyle = String::CreateFromAscii("Index Link");
             sal_uInt16 nPoolId =
@@ -2181,11 +2207,23 @@ eF_ResT SwWW8ImplReader::Read_F_PgRef( WW8FieldDesc*, String& rStr )
         return FLD_TEXT;
     }
 
-    SwGetRefField aFld(
-        (SwGetRefFieldType*)rDoc.GetSysFldType( RES_GETREFFLD ), sName,
-        REF_BOOKMARK, 0, REF_PAGE );
-
+    // #120879# add cross reference bookmark name prefix, if it matches internal TOC bookmark naming convention
+    String sPageRefBookmarkName;
+    if ( IsTOCBookmarkName( sName ) )
+    {
+        sPageRefBookmarkName = IDocumentMarkAccess::GetCrossRefHeadingBookmarkNamePrefix();
+        sPageRefBookmarkName += sName;
+        // track <sPageRefBookmarkName> as referenced TOC bookmark.
+        pReffedStck->aReferencedTOCBookmarks.insert( sPageRefBookmarkName );
+    }
+    else
+    {
+        sPageRefBookmarkName = sName;
+    }
+    SwGetRefField aFld( (SwGetRefFieldType*)rDoc.GetSysFldType( RES_GETREFFLD ),
+                        sPageRefBookmarkName, REF_BOOKMARK, 0, REF_PAGE );
     rDoc.InsertPoolItem( *pPaM, SwFmtFld( aFld ), 0 );
+
     return FLD_OK;
 }
 //helper function
@@ -3572,8 +3610,19 @@ eF_ResT SwWW8ImplReader::Read_F_Hyperlink( WW8FieldDesc* /*pF*/, String& rStr )
                     if( -2 == nRet )
                     {
                         sMark = aReadParam.GetResult();
-                        if( sMark.Len() && '"' == sMark.GetChar( sMark.Len()-1 ))
+                        if( sMark.Len() > 0 && '"' == sMark.GetChar( sMark.Len()-1 ) )
+                        {
                             sMark.Erase( sMark.Len() - 1 );
+                        }
+                        // #120879# add cross reference bookmark name prefix, if it matches internal TOC bookmark naming convention
+                        if ( IsTOCBookmarkName( sMark ) )
+                        {
+                            String sTmp = IDocumentMarkAccess::GetCrossRefHeadingBookmarkNamePrefix();
+                            sTmp += sMark;
+                            sMark = sTmp;
+                            // track <sMark> as referenced TOC bookmark.
+                            pReffedStck->aReferencedTOCBookmarks.insert( sMark );
+                        }
 
                         if (mbLoadingTOCCache)
                         {