LCOV - code coverage report
Current view: top level - sw/source/uibase/index - toxmgr.cxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 1 270 0.4 %
Date: 2015-06-13 12:38:46 Functions: 2 17 11.8 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : #include <wrtsh.hxx>
      21             : #include <shellres.hxx>
      22             : #include <swwait.hxx>
      23             : #include <view.hxx>
      24             : #include <toxmgr.hxx>
      25             : #include <crsskip.hxx>
      26             : #include <doc.hxx>
      27             : #include <IDocumentUndoRedo.hxx>
      28             : #include <swundo.hxx>
      29             : #include <globals.hrc>
      30             : 
      31             : // handle indexes with TOXMgr
      32           0 : SwTOXMgr::SwTOXMgr(SwWrtShell* pShell):
      33           0 :     pSh(pShell)
      34             : {
      35           0 :     GetTOXMarks();
      36           0 :     SetCurTOXMark(0);
      37           0 : }
      38             : 
      39             : // handle current TOXMarks
      40           0 : sal_uInt16 SwTOXMgr::GetTOXMarks()
      41             : {
      42           0 :     return pSh->GetCurTOXMarks(aCurMarks);
      43             : }
      44             : 
      45           0 : SwTOXMark* SwTOXMgr::GetTOXMark(sal_uInt16 nId)
      46             : {
      47           0 :     if(!aCurMarks.empty())
      48           0 :         return aCurMarks[nId];
      49           0 :     return 0;
      50             : }
      51             : 
      52           0 : void SwTOXMgr::DeleteTOXMark()
      53             : {
      54           0 :     SwTOXMark* pNext = 0;
      55           0 :     if( pCurTOXMark )
      56             :     {
      57           0 :         pNext = const_cast<SwTOXMark*>(&pSh->GotoTOXMark( *pCurTOXMark, TOX_NXT ));
      58           0 :         if( pNext == pCurTOXMark )
      59           0 :             pNext = 0;
      60             : 
      61           0 :         pSh->DeleteTOXMark( pCurTOXMark );
      62           0 :         pSh->SetModified();
      63             :     }
      64             :     // go to next one
      65           0 :     pCurTOXMark = pNext;
      66           0 : }
      67             : 
      68           0 : void    SwTOXMgr::InsertTOXMark(const SwTOXMarkDescription& rDesc)
      69             : {
      70           0 :     SwTOXMark* pMark = 0;
      71           0 :     switch(rDesc.GetTOXType())
      72             :     {
      73             :         case  TOX_CONTENT:
      74             :         {
      75             :             OSL_ENSURE(rDesc.GetLevel() > 0 && rDesc.GetLevel() <= MAXLEVEL,
      76             :                        "invalid InsertTOCMark level");
      77           0 :             pMark = new SwTOXMark(pSh->GetTOXType(TOX_CONTENT, 0));
      78           0 :             pMark->SetLevel( static_cast< sal_uInt16 >(rDesc.GetLevel()) );
      79             : 
      80           0 :             if(rDesc.GetAltStr())
      81           0 :                 pMark->SetAlternativeText(*rDesc.GetAltStr());
      82             :         }
      83           0 :         break;
      84             :         case  TOX_INDEX:
      85             :         {
      86           0 :             pMark = new SwTOXMark(pSh->GetTOXType(TOX_INDEX, 0));
      87             : 
      88           0 :             if( rDesc.GetPrimKey() && !rDesc.GetPrimKey()->isEmpty() )
      89             :             {
      90           0 :                 pMark->SetPrimaryKey( *rDesc.GetPrimKey() );
      91           0 :                 if(rDesc.GetPhoneticReadingOfPrimKey())
      92           0 :                     pMark->SetPrimaryKeyReading( *rDesc.GetPhoneticReadingOfPrimKey() );
      93             : 
      94           0 :                 if( rDesc.GetSecKey() && !rDesc.GetSecKey()->isEmpty() )
      95             :                 {
      96           0 :                     pMark->SetSecondaryKey( *rDesc.GetSecKey() );
      97           0 :                     if(rDesc.GetPhoneticReadingOfSecKey())
      98           0 :                         pMark->SetSecondaryKeyReading( *rDesc.GetPhoneticReadingOfSecKey() );
      99             :                 }
     100             :             }
     101           0 :             if(rDesc.GetAltStr())
     102           0 :                 pMark->SetAlternativeText(*rDesc.GetAltStr());
     103           0 :             if(rDesc.GetPhoneticReadingOfAltStr())
     104           0 :                 pMark->SetTextReading( *rDesc.GetPhoneticReadingOfAltStr() );
     105           0 :             pMark->SetMainEntry(rDesc.IsMainEntry());
     106             :         }
     107           0 :         break;
     108             :         case  TOX_USER:
     109             :         {
     110             :             OSL_ENSURE(rDesc.GetLevel() > 0 && rDesc.GetLevel() <= MAXLEVEL,
     111             :                        "invalid InsertTOCMark level");
     112           0 :             sal_uInt16 nId = rDesc.GetTOUName() ?
     113           0 :                 GetUserTypeID(*rDesc.GetTOUName()) : 0;
     114           0 :             pMark = new SwTOXMark(pSh->GetTOXType(TOX_USER, nId));
     115           0 :             pMark->SetLevel( static_cast< sal_uInt16 >(rDesc.GetLevel()) );
     116             : 
     117           0 :             if(rDesc.GetAltStr())
     118           0 :                 pMark->SetAlternativeText(*rDesc.GetAltStr());
     119             :         }
     120           0 :         break;
     121             :         case  TOX_BIBLIOGRAPHY:
     122             :         {
     123           0 :             pMark = new SwTOXMark(pSh->GetTOXType(TOX_BIBLIOGRAPHY, 0));
     124             : 
     125           0 :             if( rDesc.GetPrimKey() && !rDesc.GetPrimKey()->isEmpty() )
     126             :             {
     127           0 :                 pMark->SetPrimaryKey( *rDesc.GetPrimKey() );
     128           0 :                 if(rDesc.GetPhoneticReadingOfPrimKey())
     129           0 :                     pMark->SetPrimaryKeyReading( *rDesc.GetPhoneticReadingOfPrimKey() );
     130             : 
     131           0 :                 if( rDesc.GetSecKey() && !rDesc.GetSecKey()->isEmpty() )
     132             :                 {
     133           0 :                     pMark->SetSecondaryKey( *rDesc.GetSecKey() );
     134           0 :                     if(rDesc.GetPhoneticReadingOfSecKey())
     135           0 :                         pMark->SetSecondaryKeyReading( *rDesc.GetPhoneticReadingOfSecKey() );
     136             :                 }
     137             :             }
     138           0 :             if(rDesc.GetAltStr())
     139           0 :                 pMark->SetAlternativeText(*rDesc.GetAltStr());
     140           0 :             if(rDesc.GetPhoneticReadingOfAltStr())
     141           0 :                 pMark->SetTextReading( *rDesc.GetPhoneticReadingOfAltStr() );
     142           0 :             pMark->SetMainEntry(rDesc.IsMainEntry());
     143             :         }
     144           0 :         break;
     145             :         default:; //prevent warning
     146             :     }
     147             : 
     148           0 :     if (!pMark)
     149           0 :         return;
     150             : 
     151           0 :     pSh->StartAllAction();
     152           0 :     pSh->SwEditShell::Insert(*pMark);
     153           0 :     pSh->EndAllAction();
     154             : }
     155             : 
     156             : // Update of TOXMarks
     157           0 : void SwTOXMgr::UpdateTOXMark(const SwTOXMarkDescription& rDesc)
     158             : {
     159             :     assert(pCurTOXMark && "no current TOXMark");
     160           0 :     pSh->StartAllAction();
     161           0 :     if(pCurTOXMark->GetTOXType()->GetType() == TOX_INDEX)
     162             :     {
     163           0 :         if(rDesc.GetPrimKey() && !rDesc.GetPrimKey()->isEmpty() )
     164             :         {
     165           0 :             pCurTOXMark->SetPrimaryKey( *rDesc.GetPrimKey() );
     166           0 :             if(rDesc.GetPhoneticReadingOfPrimKey())
     167           0 :                 pCurTOXMark->SetPrimaryKeyReading( *rDesc.GetPhoneticReadingOfPrimKey() );
     168             :             else
     169           0 :                 pCurTOXMark->SetPrimaryKeyReading( aEmptyOUStr );
     170             : 
     171           0 :             if( rDesc.GetSecKey() && !rDesc.GetSecKey()->isEmpty() )
     172             :             {
     173           0 :                 pCurTOXMark->SetSecondaryKey( *rDesc.GetSecKey() );
     174           0 :                 if(rDesc.GetPhoneticReadingOfSecKey())
     175           0 :                     pCurTOXMark->SetSecondaryKeyReading( *rDesc.GetPhoneticReadingOfSecKey() );
     176             :                 else
     177           0 :                     pCurTOXMark->SetSecondaryKeyReading( aEmptyOUStr );
     178             :             }
     179             :             else
     180             :             {
     181           0 :                 pCurTOXMark->SetSecondaryKey( aEmptyOUStr );
     182           0 :                 pCurTOXMark->SetSecondaryKeyReading( aEmptyOUStr );
     183             :             }
     184             :         }
     185             :         else
     186             :         {
     187           0 :             pCurTOXMark->SetPrimaryKey( aEmptyOUStr );
     188           0 :             pCurTOXMark->SetPrimaryKeyReading( aEmptyOUStr );
     189           0 :             pCurTOXMark->SetSecondaryKey( aEmptyOUStr );
     190           0 :             pCurTOXMark->SetSecondaryKeyReading( aEmptyOUStr );
     191             :         }
     192           0 :         if(rDesc.GetPhoneticReadingOfAltStr())
     193           0 :             pCurTOXMark->SetTextReading( *rDesc.GetPhoneticReadingOfAltStr() );
     194             :         else
     195           0 :             pCurTOXMark->SetTextReading( aEmptyOUStr );
     196           0 :         pCurTOXMark->SetMainEntry(rDesc.IsMainEntry());
     197             :     }
     198             :     else
     199           0 :         pCurTOXMark->SetLevel( static_cast< sal_uInt16 >(rDesc.GetLevel()) );
     200             : 
     201           0 :     if(rDesc.GetAltStr())
     202             :     {
     203             :         // JP 26.08.96: Bug 30344 - either the text of a Doc or an alternative test,
     204             :         //                          not both!
     205           0 :         bool bReplace = pCurTOXMark->IsAlternativeText();
     206           0 :         if( bReplace )
     207           0 :             pCurTOXMark->SetAlternativeText( *rDesc.GetAltStr() );
     208             :         else
     209             :         {
     210           0 :             SwTOXMark aCpy( *pCurTOXMark );
     211           0 :             aCurMarks.clear();
     212           0 :             pSh->DeleteTOXMark(pCurTOXMark);
     213           0 :             aCpy.SetAlternativeText( *rDesc.GetAltStr() );
     214           0 :             pSh->SwEditShell::Insert( aCpy );
     215           0 :             pCurTOXMark = 0;
     216             :         }
     217             :     }
     218           0 :     pSh->SetModified();
     219           0 :     pSh->EndAllAction();
     220             :     // Bug 36207 pCurTOXMark points nowhere here!
     221           0 :     if(!pCurTOXMark)
     222             :     {
     223           0 :         pSh->Left(CRSR_SKIP_CHARS, false, 1, false );
     224           0 :         pSh->GetCurTOXMarks(aCurMarks);
     225           0 :         SetCurTOXMark(0);
     226             :     }
     227           0 : }
     228             : 
     229             : // determine UserTypeID
     230           0 : sal_uInt16 SwTOXMgr::GetUserTypeID(const OUString& rStr)
     231             : {
     232           0 :     sal_uInt16 nSize = pSh->GetTOXTypeCount(TOX_USER);
     233           0 :     for(sal_uInt16 i=0; i < nSize; ++i)
     234             :     {
     235           0 :         const SwTOXType* pTmp = pSh->GetTOXType(TOX_USER, i);
     236           0 :         if(pTmp && pTmp->GetTypeName() == rStr)
     237           0 :             return i;
     238             :     }
     239           0 :     SwTOXType aUserType(TOX_USER, rStr);
     240           0 :     pSh->InsertTOXType(aUserType);
     241           0 :     return nSize;
     242             : }
     243             : 
     244             : // traveling between TOXMarks
     245           0 : void SwTOXMgr::NextTOXMark(bool bSame)
     246             : {
     247             :     OSL_ENSURE(pCurTOXMark, "no current TOXMark");
     248           0 :     if( pCurTOXMark )
     249             :     {
     250           0 :         SwTOXSearch eDir = bSame ? TOX_SAME_NXT : TOX_NXT;
     251           0 :         pCurTOXMark = const_cast<SwTOXMark*>(&pSh->GotoTOXMark( *pCurTOXMark, eDir ));
     252             :     }
     253           0 : }
     254             : 
     255           0 : void SwTOXMgr::PrevTOXMark(bool bSame)
     256             : {
     257             :     OSL_ENSURE(pCurTOXMark, "no current TOXMark");
     258           0 :     if( pCurTOXMark )
     259             :     {
     260           0 :         SwTOXSearch eDir = bSame ? TOX_SAME_PRV : TOX_PRV;
     261           0 :         pCurTOXMark = const_cast<SwTOXMark*>(&pSh->GotoTOXMark(*pCurTOXMark, eDir ));
     262             :     }
     263           0 : }
     264             : 
     265             : // insert keyword index
     266           0 : const SwTOXBase* SwTOXMgr::GetCurTOX()
     267             : {
     268           0 :     return pSh->GetCurTOX();
     269             : }
     270           0 : const SwTOXType* SwTOXMgr::GetTOXType(TOXTypes eTyp, sal_uInt16 nId) const
     271             : {
     272           0 :     return pSh->GetTOXType(eTyp, nId);
     273             : }
     274             : 
     275           0 : void SwTOXMgr::SetCurTOXMark(sal_uInt16 nId)
     276             : {
     277           0 :     pCurTOXMark = (nId < aCurMarks.size()) ? aCurMarks[nId] : 0;
     278           0 : }
     279             : 
     280           0 : bool SwTOXMgr::UpdateOrInsertTOX(const SwTOXDescription& rDesc,
     281             :                                     SwTOXBase** ppBase,
     282             :                                     const SfxItemSet* pSet)
     283             : {
     284           0 :     SwWait aWait( *pSh->GetView().GetDocShell(), true );
     285           0 :     bool bRet = true;
     286           0 :     const SwTOXBase* pCurTOX = ppBase && *ppBase ? *ppBase : GetCurTOX();
     287           0 :     SwTOXBase* pTOX = const_cast<SwTOXBase*>(pCurTOX);
     288             : 
     289           0 :     SwTOXBase * pNewTOX = NULL;
     290             : 
     291           0 :     if (pTOX)
     292           0 :         pNewTOX = new SwTOXBase(*pTOX);
     293             : 
     294           0 :     TOXTypes eCurTOXType = rDesc.GetTOXType();
     295           0 :     if(pCurTOX && !ppBase && pSh->HasSelection())
     296           0 :         pSh->EnterStdMode();
     297             : 
     298           0 :     switch(eCurTOXType)
     299             :     {
     300             :         case TOX_INDEX :
     301             :         {
     302           0 :             if(!pCurTOX || (ppBase && !(*ppBase)))
     303             :             {
     304           0 :                 const SwTOXType* pType = pSh->GetTOXType(eCurTOXType, 0);
     305           0 :                 SwForm aForm(eCurTOXType);
     306           0 :                 pNewTOX = new SwTOXBase(pType, aForm, nsSwTOXElement::TOX_MARK, pType->GetTypeName());
     307             :             }
     308           0 :             pNewTOX->SetOptions(rDesc.GetIndexOptions());
     309           0 :             pNewTOX->SetMainEntryCharStyle(rDesc.GetMainEntryCharStyle());
     310           0 :             pSh->SetTOIAutoMarkURL(rDesc.GetAutoMarkURL());
     311           0 :             pSh->ApplyAutoMark();
     312             :         }
     313           0 :         break;
     314             :         case TOX_CONTENT :
     315             :         {
     316           0 :             if(!pCurTOX || (ppBase && !(*ppBase)))
     317             :             {
     318           0 :                 const SwTOXType* pType = pSh->GetTOXType(eCurTOXType, 0);
     319           0 :                 SwForm aForm(eCurTOXType);
     320           0 :                 pNewTOX = new SwTOXBase(pType, aForm, rDesc.GetContentOptions(), pType->GetTypeName());
     321             :             }
     322           0 :             pNewTOX->SetCreate(rDesc.GetContentOptions());
     323           0 :             pNewTOX->SetLevel(rDesc.GetLevel());
     324             :         }
     325           0 :         break;
     326             :         case TOX_USER :
     327             :         {
     328           0 :             if(!pCurTOX || (ppBase && !(*ppBase)))
     329             :             {
     330           0 :                 sal_uInt16 nPos  = 0;
     331           0 :                 sal_uInt16 nSize = pSh->GetTOXTypeCount(eCurTOXType);
     332           0 :                 for(sal_uInt16 i=0; rDesc.GetTOUName() && i < nSize; ++i)
     333           0 :                 {   const SwTOXType* pType = pSh->GetTOXType(TOX_USER, i);
     334           0 :                     if(pType->GetTypeName() == *rDesc.GetTOUName())
     335           0 :                     {   nPos = i;
     336           0 :                         break;
     337             :                     }
     338             :                 }
     339           0 :                 const SwTOXType* pType = pSh->GetTOXType(eCurTOXType, nPos);
     340             : 
     341           0 :                 SwForm aForm(eCurTOXType);
     342           0 :                 pNewTOX = new SwTOXBase(pType, aForm, rDesc.GetContentOptions(), pType->GetTypeName());
     343             : 
     344             :             }
     345             :             else
     346             :             {
     347           0 :                 const_cast<SwTOXBase*>( pCurTOX )->SetCreate(rDesc.GetContentOptions());
     348             :             }
     349           0 :             pNewTOX->SetLevelFromChapter(rDesc.IsLevelFromChapter());
     350             :         }
     351           0 :         break;
     352           0 :         case TOX_CITATION: /** TODO */break;
     353             :         case TOX_OBJECTS:
     354             :         case TOX_TABLES:
     355             :         case TOX_AUTHORITIES:
     356             :         case TOX_BIBLIOGRAPHY:
     357             :         case TOX_ILLUSTRATIONS:
     358             :         {
     359             :             //Special handling for TOX_AUTHORITY
     360           0 :             if(TOX_AUTHORITIES == eCurTOXType)
     361             :             {
     362             :                 SwAuthorityFieldType* pFType = static_cast<SwAuthorityFieldType*>(
     363           0 :                                                 pSh->GetFieldType(RES_AUTHORITY, aEmptyOUStr));
     364           0 :                 if (!pFType)
     365             :                 {
     366           0 :                     SwAuthorityFieldType const type(pSh->GetDoc());
     367             :                     pFType = static_cast<SwAuthorityFieldType*>(
     368           0 :                                 pSh->InsertFieldType(type));
     369             :                 }
     370           0 :                 pFType->SetPreSuffix(rDesc.GetAuthBrackets()[0],
     371           0 :                     rDesc.GetAuthBrackets()[1]);
     372           0 :                 pFType->SetSequence(rDesc.IsAuthSequence());
     373           0 :                 SwTOXSortKey rArr[3];
     374           0 :                 rArr[0] = rDesc.GetSortKey1();
     375           0 :                 rArr[1] = rDesc.GetSortKey2();
     376           0 :                 rArr[2] = rDesc.GetSortKey3();
     377           0 :                 pFType->SetSortKeys(3, rArr);
     378           0 :                 pFType->SetSortByDocument(rDesc.IsSortByDocument());
     379           0 :                 pFType->SetLanguage(rDesc.GetLanguage());
     380           0 :                 pFType->SetSortAlgorithm(rDesc.GetSortAlgorithm());
     381             : 
     382           0 :                 pFType->UpdateFields();
     383             :             }
     384             :             // TODO: consider properties of the current TOXType
     385           0 :             if(!pCurTOX || (ppBase && !(*ppBase)))
     386             :             {
     387           0 :                 const SwTOXType* pType = pSh->GetTOXType(eCurTOXType, 0);
     388           0 :                 SwForm aForm(eCurTOXType);
     389             :                 pNewTOX = new SwTOXBase(
     390             :                     pType, aForm,
     391           0 :                     TOX_AUTHORITIES == eCurTOXType ? nsSwTOXElement::TOX_MARK : 0, pType->GetTypeName());
     392             :             }
     393             :             else
     394             :             {
     395           0 :                 if((!ppBase || !(*ppBase)) && pSh->HasSelection())
     396           0 :                     pSh->DelRight();
     397           0 :                 pNewTOX = const_cast<SwTOXBase*>(pCurTOX);
     398             :             }
     399           0 :             pNewTOX->SetFromObjectNames(rDesc.IsCreateFromObjectNames());
     400           0 :             pNewTOX->SetOLEOptions(rDesc.GetOLEOptions());
     401             :         }
     402           0 :         break;
     403             :     }
     404             : 
     405             :     OSL_ENSURE(pNewTOX, "no TOXBase created!" );
     406           0 :     if(!pNewTOX)
     407           0 :         return false;
     408             : 
     409           0 :     pNewTOX->SetFromChapter(rDesc.IsFromChapter());
     410           0 :     pNewTOX->SetSequenceName(rDesc.GetSequenceName());
     411           0 :     pNewTOX->SetCaptionDisplay(rDesc.GetCaptionDisplay());
     412           0 :     pNewTOX->SetProtected(rDesc.IsReadonly());
     413             : 
     414           0 :     for(sal_uInt16 nLevel = 0; nLevel < MAXLEVEL; nLevel++)
     415           0 :         pNewTOX->SetStyleNames(rDesc.GetStyleNames(nLevel), nLevel);
     416             : 
     417           0 :     if(rDesc.GetTitle())
     418           0 :         pNewTOX->SetTitle(*rDesc.GetTitle());
     419           0 :     if(rDesc.GetForm())
     420           0 :         pNewTOX->SetTOXForm(*rDesc.GetForm());
     421           0 :     pNewTOX->SetLanguage(rDesc.GetLanguage());
     422           0 :     pNewTOX->SetSortAlgorithm(rDesc.GetSortAlgorithm());
     423             : 
     424           0 :     if(!pCurTOX || (ppBase && !(*ppBase)) )
     425             :     {
     426             :         // when ppBase is passed over, TOXBase is only created here
     427             :         // and then inserted in a global document by the dialog
     428           0 :         if(ppBase)
     429           0 :             (*ppBase) = pNewTOX;
     430             :         else
     431             :         {
     432           0 :             pSh->InsertTableOf(*pNewTOX, pSet);
     433           0 :             delete pNewTOX;
     434             :         }
     435             :     }
     436             :     else
     437             :     {
     438           0 :         SwDoc * pDoc = pSh->GetDoc();
     439             : 
     440           0 :         if (pDoc->GetIDocumentUndoRedo().DoesUndo())
     441             :         {
     442           0 :             pDoc->GetIDocumentUndoRedo().DelAllUndoObj();
     443           0 :             pDoc->GetIDocumentUndoRedo().StartUndo(UNDO_TOXCHANGE, NULL);
     444             :         }
     445             : 
     446           0 :         pDoc->ChgTOX(*pTOX, *pNewTOX);
     447             : 
     448           0 :         pTOX->DisableKeepExpression();
     449           0 :         bRet = pSh->UpdateTableOf(*pTOX, pSet);
     450           0 :         pTOX->EnableKeepExpression();
     451             : 
     452           0 :         if (pDoc->GetIDocumentUndoRedo().DoesUndo())
     453             :         {
     454           0 :             pDoc->GetIDocumentUndoRedo().EndUndo(UNDO_TOXCHANGE, NULL);
     455             :         }
     456             :     }
     457             : 
     458           0 :     return bRet;
     459             : }
     460             : 
     461           0 : void SwTOXDescription::SetSortKeys(SwTOXSortKey eKey1,
     462             :                         SwTOXSortKey eKey2,
     463             :                             SwTOXSortKey eKey3)
     464             : {
     465           0 :     SwTOXSortKey aArr[3];
     466           0 :     sal_uInt16 nPos = 0;
     467           0 :     if(AUTH_FIELD_END > eKey1.eField)
     468           0 :         aArr[nPos++] = eKey1;
     469           0 :     if(AUTH_FIELD_END > eKey2.eField)
     470           0 :         aArr[nPos++] = eKey2;
     471           0 :     if(AUTH_FIELD_END > eKey3.eField)
     472           0 :         aArr[nPos++] = eKey3;
     473             : 
     474           0 :     eSortKey1 = aArr[0];
     475           0 :     eSortKey2 = aArr[1];
     476           0 :     eSortKey3 = aArr[2];
     477           0 : }
     478             : 
     479           0 : void SwTOXDescription::ApplyTo(SwTOXBase& rTOXBase)
     480             : {
     481           0 :     for(sal_uInt16 i = 0; i < MAXLEVEL; i++)
     482           0 :         rTOXBase.SetStyleNames(GetStyleNames(i), i);
     483           0 :     rTOXBase.SetTitle(GetTitle() ? *GetTitle() : OUString());
     484           0 :     rTOXBase.SetCreate(GetContentOptions());
     485             : 
     486           0 :     if(GetTOXType() == TOX_INDEX)
     487           0 :         rTOXBase.SetOptions(GetIndexOptions());
     488           0 :     if(GetTOXType() != TOX_INDEX)
     489           0 :         rTOXBase.SetLevel(GetLevel());
     490           0 :     rTOXBase.SetFromObjectNames(IsCreateFromObjectNames());
     491           0 :     rTOXBase.SetSequenceName(GetSequenceName());
     492           0 :     rTOXBase.SetCaptionDisplay(GetCaptionDisplay());
     493           0 :     rTOXBase.SetFromChapter(IsFromChapter());
     494           0 :     rTOXBase.SetProtected(IsReadonly());
     495           0 :     rTOXBase.SetOLEOptions(GetOLEOptions());
     496           0 :     rTOXBase.SetLevelFromChapter(IsLevelFromChapter());
     497           0 :     rTOXBase.SetLanguage(eLanguage);
     498           0 :     rTOXBase.SetSortAlgorithm(sSortAlgorithm);
     499             : 
     500         177 : }
     501             : 
     502             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.11