sw/source/uibase/index/toxmgr.cxx

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