sw/source/ui/index/swuiidxmrk.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 <swuiidxmrk.hxx>
  21 #include <hintids.hxx>
  22 #include <helpids.h>
  23 #include <com/sun/star/ui/dialogs/TemplateDescription.hpp>
  24 #include <comphelper/processfactory.hxx>
  25 #include <com/sun/star/beans/PropertyValue.hpp>
  26 #include <com/sun/star/beans/XPropertySet.hpp>
  27 #include <com/sun/star/frame/Bibliography.hpp>
  28 #include <com/sun/star/i18n/IndexEntrySupplier.hpp>
  29 #include <com/sun/star/util/SearchAlgorithms2.hpp>
  30 #include <com/sun/star/util/SearchFlags.hpp>
  31 #include <com/sun/star/uri/UriReferenceFactory.hpp>
  32 #include <rtl/ustrbuf.hxx>
  33 #include <i18nutil/searchopt.hxx>
  34 #include <utility>
  35 #include <vcl/svapp.hxx>
  36 #include <vcl/weld.hxx>
  37 #include <sfx2/dispatch.hxx>
  38 #include <sfx2/viewfrm.hxx>
  39 #include <svl/itemset.hxx>
  40 #include <editeng/langitem.hxx>
  41 #include <osl/diagnose.h>
  42 #include <o3tl/string_view.hxx>
  43 #include <swtypes.hxx>
  44 #include <toxmgr.hxx>
  45 #include <txttxmrk.hxx>
  46 #include <wrtsh.hxx>
  47 #include <view.hxx>
  48 #include <swundo.hxx>
  49 #include <cmdid.h>
  50 #include <swmodule.hxx>
  51 #include <fldmgr.hxx>
  52 #include <fldbas.hxx>
  53 #include <strings.hrc>
  54 #include <svl/cjkoptions.hxx>
  55 #include <sfx2/filedlghelper.hxx>
  56 #include <ndtxt.hxx>
  57 #include <SwRewriter.hxx>
  58 #include <doc.hxx>
  59 #include <docsh.hxx>
  60
  61 #define POS_CONTENT 0
  62 #define POS_INDEX   1
  63
  64 static sal_Int32  nTypePos = 1; // TOX_INDEX as standard
  65 static sal_uInt16 nKey1Pos = USHRT_MAX;
  66
  67 static sal_uInt16 nKey2Pos = USHRT_MAX;
  68
  69 using namespace com::sun::star;
  70 using namespace com::sun::star::i18n;
  71 using namespace com::sun::star::lang;
  72 using namespace com::sun::star::util;
  73 using namespace ::comphelper;
  74
  75 namespace
  76 {
  77 bool SplitUrlAndPage(const OUString& rText, OUString& rUrl, int& nPageNumber)
  78 {
  79     uno::Reference<uri::XUriReferenceFactory> xUriReferenceFactory
  80         = uri::UriReferenceFactory::create(comphelper::getProcessComponentContext());
  81     uno::Reference<uri::XUriReference> xUriRef;
  82     try
  83     {
  84         xUriRef = xUriReferenceFactory->parse(rText);
  85     }
  86     catch (const uno::Exception& rException)
  87     {
  88         SAL_WARN("sw.ui", "SplitUrlAndPage: failed to parse url: " << rException.Message);
  89         return false;
  90     }
  91
  92     OUString aPagePrefix("page=");
  93     if (!xUriRef->getFragment().startsWith(aPagePrefix))
  94     {
  95         return false;
  96     }
  97
  98     nPageNumber = o3tl::toInt32(xUriRef->getFragment().subView(aPagePrefix.getLength()));
  99     xUriRef->clearFragment();
 100     rUrl = xUriRef->getUriReference();
 101     return true;
 102 }
 103
 104 OUString MergeUrlAndPage(const OUString& rUrl, const std::unique_ptr<weld::SpinButton>& xPageSB)
 105 {
 106     if (!xPageSB->get_sensitive())
 107     {
 108         return rUrl;
 109     }
 110
 111     uno::Reference<uri::XUriReferenceFactory> xUriReferenceFactory
 112         = uri::UriReferenceFactory::create(comphelper::getProcessComponentContext());
 113     uno::Reference<uri::XUriReference> xUriRef;
 114     try
 115     {
 116         xUriRef = xUriReferenceFactory->parse(rUrl);
 117     }
 118     catch (const uno::Exception& rException)
 119     {
 120         SAL_WARN("sw.ui", "MergeUrlAndPage: failed to parse url: " << rException.Message);
 121         return rUrl;
 122     }
 123
 124     OUString aFragment("page=" + OUString::number(xPageSB->get_value()));
 125     xUriRef->setFragment(aFragment);
 126     return xUriRef->getUriReference();
 127 }
 128 }
 129
 130 // dialog to insert a directory selection
 131 SwIndexMarkPane::SwIndexMarkPane(std::shared_ptr<weld::Dialog> xDialog, weld::Builder& rBuilder, bool bNewDlg,
 132     SwWrtShell* pWrtShell)
 133     : m_xDialog(std::move(xDialog))
 134     , m_bDel(false)
 135     , m_bNewMark(bNewDlg)
 136     , m_bSelected(false)
 137     , m_bPhoneticED0_ChangedByUser(false)
 138     , m_bPhoneticED1_ChangedByUser(false)
 139     , m_bPhoneticED2_ChangedByUser(false)
 140     , m_nLangForPhoneticReading(LANGUAGE_CHINESE_SIMPLIFIED)
 141     , m_bIsPhoneticReadingEnabled(false)
 142     , m_pSh(pWrtShell)
 143     , m_xTypeFT(rBuilder.weld_label("typeft"))
 144     , m_xTypeDCB(rBuilder.weld_combo_box("typecb"))
 145     , m_xNewBT(rBuilder.weld_button("new"))
 146     , m_xEntryED(rBuilder.weld_entry("entryed"))
 147     , m_xSyncED(rBuilder.weld_button("sync"))
 148     , m_xPhoneticFT0(rBuilder.weld_label("phonetic0ft"))
 149     , m_xPhoneticED0(rBuilder.weld_entry("phonetic0ed"))
 150     , m_xKey1FT(rBuilder.weld_label("key1ft"))
 151     , m_xKey1DCB(rBuilder.weld_combo_box("key1cb"))
 152     , m_xPhoneticFT1(rBuilder.weld_label("phonetic1ft"))
 153     , m_xPhoneticED1(rBuilder.weld_entry("phonetic1ed"))
 154     , m_xKey2FT(rBuilder.weld_label("key2ft"))
 155     , m_xKey2DCB(rBuilder.weld_combo_box("key2cb"))
 156     , m_xPhoneticFT2(rBuilder.weld_label("phonetic2ft"))
 157     , m_xPhoneticED2(rBuilder.weld_entry("phonetic2ed"))
 158     , m_xLevelFT(rBuilder.weld_label("levelft"))
 159     , m_xLevelNF(rBuilder.weld_spin_button("levelnf"))
 160     , m_xMainEntryCB(rBuilder.weld_check_button("mainentrycb"))
 161     , m_xApplyToAllCB(rBuilder.weld_check_button("applytoallcb"))
 162     , m_xSearchCaseSensitiveCB(rBuilder.weld_check_button("searchcasesensitivecb"))
 163     , m_xSearchCaseWordOnlyCB(rBuilder.weld_check_button("searchcasewordonlycb"))
 164     , m_xOKBT(bNewDlg ? rBuilder.weld_button("insert") : rBuilder.weld_button("ok"))
 165     , m_xCloseBT(rBuilder.weld_button("close"))
 166     , m_xDelBT(rBuilder.weld_button("delete"))
 167     , m_xPrevSameBT(rBuilder.weld_button("first"))
 168     , m_xNextSameBT(rBuilder.weld_button("last"))
 169     , m_xPrevBT(rBuilder.weld_button("previous"))
 170     , m_xNextBT(rBuilder.weld_button("next"))
 171     , m_xForSelectedEntry(rBuilder.weld_label("selectedentrytitle"))
 172 {
 173     m_xSyncED->show();
 174
 175     if (SvtCJKOptions::IsCJKFontEnabled())
 176     {
 177         uno::Reference< uno::XComponentContext > xContext = getProcessComponentContext();
 178
 179         m_xExtendedIndexEntrySupplier = i18n::IndexEntrySupplier::create(xContext);
 180
 181         m_xPhoneticFT0->show();
 182         m_xPhoneticED0->show();
 183         m_xPhoneticFT1->show();
 184         m_xPhoneticED1->show();
 185         m_xPhoneticFT2->show();
 186         m_xPhoneticED2->show();
 187     }
 188
 189     // tdf#129726 there are two help pages for this dialog, one for each mode,
 190     // where a widget/dialog appears in both, use -insert/-edit to disambiguate
 191     if (m_bNewMark)
 192     {
 193         m_xDialog->set_title(SwResId(STR_IDXMRK_INSERT));
 194         m_xDialog->set_help_id(m_xDialog->get_help_id() + "-insert");
 195         m_xTypeDCB->set_help_id(m_xTypeDCB->get_help_id() + "-insert");
 196     }
 197     else
 198     {
 199         m_xDialog->set_title(SwResId(STR_IDXMRK_EDIT));
 200         m_xDialog->set_help_id(m_xDialog->get_help_id() + "-edit");
 201         m_xTypeDCB->set_help_id(m_xTypeDCB->get_help_id() + "-edit");
 202     }
 203
 204     m_xDelBT->connect_clicked(LINK(this,SwIndexMarkPane,        DelHdl));
 205     m_xPrevBT->connect_clicked(LINK(this,SwIndexMarkPane,       PrevHdl));
 206     m_xPrevSameBT->connect_clicked(LINK(this,SwIndexMarkPane,   PrevSameHdl));
 207     m_xNextBT->connect_clicked(LINK(this,SwIndexMarkPane,       NextHdl));
 208     m_xNextSameBT->connect_clicked(LINK(this,SwIndexMarkPane,   NextSameHdl));
 209     m_xTypeDCB->connect_changed(LINK(this,SwIndexMarkPane,     ModifyListBoxHdl));
 210     m_xKey1DCB->connect_changed(LINK(this,SwIndexMarkPane,      KeyDCBModifyHdl));
 211     m_xKey2DCB->connect_changed(LINK(this,SwIndexMarkPane,     KeyDCBModifyHdl));
 212     m_xCloseBT->connect_clicked(LINK(this,SwIndexMarkPane,      CloseHdl));
 213     m_xEntryED->connect_changed(LINK(this,SwIndexMarkPane,     ModifyEditHdl));
 214     m_xNewBT->connect_clicked(LINK(this, SwIndexMarkPane,       NewUserIdxHdl));
 215     m_xApplyToAllCB->connect_toggled(LINK(this, SwIndexMarkPane, SearchTypeHdl));
 216     m_xPhoneticED0->connect_changed(LINK(this,SwIndexMarkPane, PhoneticEDModifyHdl));
 217     m_xPhoneticED1->connect_changed(LINK(this,SwIndexMarkPane, PhoneticEDModifyHdl));
 218     m_xPhoneticED2->connect_changed(LINK(this,SwIndexMarkPane, PhoneticEDModifyHdl));
 219     m_xSyncED->connect_clicked(LINK(this, SwIndexMarkPane, SyncSelectionHdl));
 220
 221     if (m_bNewMark)
 222         m_xDelBT->hide();
 223     else
 224         m_xNewBT->hide();
 225     m_xOKBT->show();
 226     m_xOKBT->connect_clicked(LINK(this, SwIndexMarkPane, InsertHdl));
 227
 228     m_xEntryED->grab_focus();
 229 }
 230
 231 // Newly initialise controls with the new selection
 232 void SwIndexMarkPane::InitControls()
 233 {
 234     assert(m_pSh && m_pTOXMgr && "no shell?");
 235     // contents index
 236     const SwTOXType* pType = m_pTOXMgr->GetTOXType(TOX_CONTENT);
 237     assert(pType && "No directory type !!");
 238     OUString sTmpTypeSelection;
 239     if (m_xTypeDCB->get_active() != -1)
 240         sTmpTypeSelection = m_xTypeDCB->get_active_text();
 241     m_xTypeDCB->clear();
 242     m_xTypeDCB->append_text(pType->GetTypeName());
 243
 244     // keyword index
 245     pType = m_pTOXMgr->GetTOXType(TOX_INDEX);
 246     assert(pType && "No directory type !!");
 247     m_xTypeDCB->append_text(pType->GetTypeName());
 248
 249     // user index
 250     sal_uInt16 nCount = m_pSh->GetTOXTypeCount(TOX_USER);
 251     for (sal_uInt16 i = 0; i < nCount; ++i)
 252         m_xTypeDCB->append_text(m_pSh->GetTOXType(TOX_USER, i)->GetTypeName());
 253
 254     // read keywords primary
 255     {
 256         std::vector<OUString> aArr;
 257         m_pSh->GetTOIKeys(TOI_PRIMARY, aArr);
 258         std::sort(aArr.begin(), aArr.end());
 259         auto last = std::unique(aArr.begin(), aArr.end());
 260         for (auto it = aArr.begin(); it != last; ++it)
 261             m_xKey1DCB->append_text(*it);
 262     }
 263
 264     // read keywords secondary
 265     {
 266         std::vector<OUString> aArr;
 267         m_pSh->GetTOIKeys( TOI_SECONDARY, aArr );
 268         std::sort(aArr.begin(), aArr.end());
 269         auto last = std::unique(aArr.begin(), aArr.end());
 270         for (auto it = aArr.begin(); it != last; ++it)
 271             m_xKey2DCB->append_text(*it);
 272     }
 273
 274     UpdateLanguageDependenciesForPhoneticReading();
 275
 276     // current entry
 277     const SwTOXMark* pMark = m_pTOXMgr->GetCurTOXMark();
 278     if( pMark && !m_bNewMark)
 279     {
 280         // Controls-Handling
 281
 282         // only if there are more than one
 283         // if equal it lands at the same entry
 284         m_pSh->SttCursorMove();
 285
 286         const SwTOXMark* pMoveMark;
 287         bool bShow = false;
 288
 289         pMoveMark = &m_pSh->GotoTOXMark( *pMark, TOX_PRV );
 290         if( pMoveMark != pMark )
 291         {
 292             m_pSh->GotoTOXMark( *pMoveMark, TOX_NXT );
 293             bShow = true;
 294         }
 295         m_xPrevBT->set_sensitive(pMoveMark != pMark);
 296         pMoveMark = &m_pSh->GotoTOXMark( *pMark, TOX_NXT );
 297         if( pMoveMark != pMark )
 298         {
 299             m_pSh->GotoTOXMark( *pMoveMark, TOX_PRV );
 300             bShow = true;
 301         }
 302         m_xNextBT->set_sensitive(pMoveMark != pMark);
 303         if( bShow )
 304         {
 305             m_xPrevBT->show();
 306             m_xNextBT->show();
 307             bShow = false;
 308         }
 309
 310         pMoveMark = &m_pSh->GotoTOXMark( *pMark, TOX_SAME_PRV );
 311         if( pMoveMark != pMark )
 312         {
 313             m_pSh->GotoTOXMark( *pMoveMark, TOX_SAME_NXT );
 314             bShow = true;
 315         }
 316         m_xPrevSameBT->set_sensitive(pMoveMark != pMark);
 317         pMoveMark = &m_pSh->GotoTOXMark( *pMark, TOX_SAME_NXT );
 318         if( pMoveMark != pMark )
 319         {
 320             m_pSh->GotoTOXMark( *pMoveMark, TOX_SAME_PRV );
 321             bShow = true;
 322         }
 323         m_xNextSameBT->set_sensitive(pMoveMark != pMark);
 324         if( bShow )
 325         {
 326             m_xNextSameBT->show();
 327             m_xPrevSameBT->show();
 328         }
 329         m_pSh->EndCursorMove();
 330
 331         m_xTypeFT->show();
 332
 333         m_xTypeDCB->set_sensitive(false);
 334         m_xTypeFT->set_sensitive(false);
 335
 336         UpdateDialog();
 337     }
 338     else
 339     {   // display current selection (first element) ????
 340         if (m_pSh->GetCursorCnt() < 2)
 341         {
 342             m_bSelected = !m_pSh->HasSelection();
 343             m_aOrgStr = m_pSh->GetView().GetSelectionTextParam(true, false);
 344             m_xEntryED->set_text(m_aOrgStr);
 345
 346             //to include all equal entries may only be allowed in the body and even there
 347             //only when a simple selection exists
 348             const FrameTypeFlags nFrameType = m_pSh->GetFrameType(nullptr,true);
 349             m_xForSelectedEntry->show();
 350             m_xApplyToAllCB->show();
 351             m_xSearchCaseSensitiveCB->show();
 352             m_xSearchCaseWordOnlyCB->show();
 353             m_xApplyToAllCB->set_sensitive(!m_aOrgStr.isEmpty() &&
 354                 !(nFrameType & ( FrameTypeFlags::HEADER | FrameTypeFlags::FOOTER | FrameTypeFlags::FLY_ANY )));
 355             SearchTypeHdl(*m_xApplyToAllCB);
 356         }
 357
 358         // index type is default
 359         if (!sTmpTypeSelection.isEmpty() && m_xTypeDCB->find_text(sTmpTypeSelection) != -1)
 360             m_xTypeDCB->set_active_text(sTmpTypeSelection);
 361         else
 362             m_xTypeDCB->set_active_text(m_xTypeDCB->get_text(nTypePos));
 363         ModifyHdl(*m_xTypeDCB);
 364     }
 365 }
 366
 367 void    SwIndexMarkPane::UpdateLanguageDependenciesForPhoneticReading()
 368 {
 369     //no phonetic reading if no global cjk support
 370     if( !m_xExtendedIndexEntrySupplier.is() )
 371     {
 372         m_bIsPhoneticReadingEnabled = false;
 373         return;
 374     }
 375     m_bIsPhoneticReadingEnabled = true;
 376
 377     //get the current language
 378     if(!m_bNewMark) //if dialog is opened to iterate existing marks
 379     {
 380         OSL_ENSURE(m_pTOXMgr, "need TOXMgr");
 381         if(!m_pTOXMgr)
 382             return;
 383         SwTOXMark* pMark = m_pTOXMgr->GetCurTOXMark();
 384         OSL_ENSURE(pMark, "need current SwTOXMark");
 385         if(!pMark)
 386             return;
 387         SwTextTOXMark* pTextTOXMark = pMark->GetTextTOXMark();
 388         OSL_ENSURE(pTextTOXMark, "need current SwTextTOXMark");
 389         if(!pTextTOXMark)
 390             return;
 391         const SwTextNode* pTextNode = pTextTOXMark->GetpTextNd();
 392         OSL_ENSURE(pTextNode, "need current SwTextNode");
 393         if(!pTextNode)
 394             return;
 395         sal_Int32 nTextIndex = pTextTOXMark->GetStart();
 396         m_nLangForPhoneticReading = pTextNode->GetLang( nTextIndex );
 397     }
 398     else //if dialog is opened to create a new mark
 399     {
 400         sal_uInt16 nWhich;
 401         switch(m_pSh->GetScriptType())
 402         {
 403             case SvtScriptType::ASIAN: nWhich = RES_CHRATR_CJK_LANGUAGE; break;
 404             case SvtScriptType::COMPLEX:nWhich = RES_CHRATR_CTL_LANGUAGE; break;
 405             default:nWhich = RES_CHRATR_LANGUAGE; break;
 406         }
 407         SfxItemSet aLangSet(m_pSh->GetAttrPool(), nWhich, nWhich);
 408         m_pSh->GetCurAttr(aLangSet);
 409         m_nLangForPhoneticReading = static_cast<const SvxLanguageItem&>(aLangSet.Get(nWhich)).GetLanguage();
 410     }
 411
 412 }
 413
 414 OUString SwIndexMarkPane::GetDefaultPhoneticReading( const OUString& rText )
 415 {
 416     if( !m_bIsPhoneticReadingEnabled )
 417         return OUString();
 418
 419     return m_xExtendedIndexEntrySupplier->getPhoneticCandidate(rText, LanguageTag::convertToLocale( m_nLangForPhoneticReading ));
 420 }
 421
 422 void    SwIndexMarkPane::Activate()
 423 {
 424     // display current selection (first element) ????
 425     if (m_bNewMark)
 426     {
 427         m_xSyncED->set_sensitive(m_pSh->GetCursorCnt() < 2);
 428     }
 429 }
 430
 431 IMPL_LINK_NOARG(SwIndexMarkPane, SyncSelectionHdl, weld::Button&, void)
 432 {
 433     m_bSelected = !m_pSh->HasSelection();
 434     m_aOrgStr = m_pSh->GetView().GetSelectionTextParam(true, false);
 435     m_xEntryED->set_text(m_aOrgStr);
 436
 437     //to include all equal entries may only be allowed in the body and even there
 438     //only when a simple selection exists
 439     const FrameTypeFlags nFrameType = m_pSh->GetFrameType(nullptr,true);
 440     m_xApplyToAllCB->show();
 441     m_xSearchCaseSensitiveCB->show();
 442     m_xSearchCaseWordOnlyCB->show();
 443     m_xApplyToAllCB->set_sensitive(!m_aOrgStr.isEmpty() &&
 444         !(nFrameType & ( FrameTypeFlags::HEADER | FrameTypeFlags::FOOTER | FrameTypeFlags::FLY_ANY )));
 445     SearchTypeHdl(*m_xApplyToAllCB);
 446     ModifyHdl(*m_xEntryED);
 447 }
 448
 449 // evaluate Ok-Button
 450 void SwIndexMarkPane::Apply()
 451 {
 452     InsertUpdate();
 453     if(m_bSelected)
 454         m_pSh->ResetSelect(nullptr, false);
 455 }
 456
 457 // apply changes
 458 void SwIndexMarkPane::InsertUpdate()
 459 {
 460     m_pSh->StartUndo(m_bDel ? SwUndoId::INDEX_ENTRY_DELETE : SwUndoId::INDEX_ENTRY_INSERT);
 461     m_pSh->StartAllAction();
 462     SwRewriter aRewriter;
 463
 464     if( m_bNewMark )
 465     {
 466         InsertMark();
 467
 468         if ( m_pTOXMgr->GetCurTOXMark())
 469             aRewriter.AddRule(UndoArg1,
 470                     m_pTOXMgr->GetCurTOXMark()->GetText(m_pSh->GetLayout()));
 471     }
 472     else if( !m_pSh->HasReadonlySel() )
 473     {
 474         if ( m_pTOXMgr->GetCurTOXMark())
 475             aRewriter.AddRule(UndoArg1,
 476                     m_pTOXMgr->GetCurTOXMark()->GetText(m_pSh->GetLayout()));
 477
 478         if( m_bDel )
 479             m_pTOXMgr->DeleteTOXMark();
 480         else if( m_pTOXMgr->GetCurTOXMark() )
 481             UpdateMark();
 482     }
 483
 484     m_pSh->EndAllAction();
 485     m_pSh->EndUndo(m_bDel ? SwUndoId::INDEX_ENTRY_DELETE : SwUndoId::INDEX_ENTRY_INSERT);
 486
 487     nTypePos = m_xTypeDCB->find_text(m_xTypeDCB->get_active_text());
 488     if(nTypePos == -1)
 489         nTypePos = 0;
 490
 491     nKey1Pos = m_xKey1DCB->find_text(m_xKey1DCB->get_active_text());
 492     nKey2Pos = m_xKey2DCB->find_text(m_xKey2DCB->get_active_text());
 493 }
 494
 495 // insert mark
 496 static void lcl_SelectSameStrings(SwWrtShell& rSh, bool bWordOnly, bool bCaseSensitive)
 497 {
 498     rSh.Push();
 499
 500     i18nutil::SearchOptions2 aSearchOpt(
 501                         SearchAlgorithms_ABSOLUTE,
 502                         ( bWordOnly ? SearchFlags::NORM_WORD_ONLY : 0 ),
 503                         rSh.GetSelText(), OUString(),
 504                         GetAppLanguageTag().getLocale(),
 505                         0, 0, 0,
 506                         (bCaseSensitive
 507                             ? TransliterationFlags::NONE
 508                             : TransliterationFlags::IGNORE_CASE),
 509                         SearchAlgorithms2::ABSOLUTE,
 510                         '\\' );
 511
 512     rSh.ClearMark();
 513     bool bCancel;
 514
 515     //todo/mba: assuming that notes should not be searched
 516     rSh.Find_Text(aSearchOpt, false/*bSearchInNotes*/, SwDocPositions::Start, SwDocPositions::End, bCancel,
 517               FindRanges::InSelAll | FindRanges::InBodyOnly );
 518 }
 519
 520 void SwIndexMarkPane::InsertMark()
 521 {
 522     auto nPos = m_xTypeDCB->find_text(m_xTypeDCB->get_active_text());
 523     TOXTypes eType = nPos == POS_CONTENT ? TOX_CONTENT :
 524                         nPos == POS_INDEX ? TOX_INDEX : TOX_USER;
 525
 526     SwTOXMarkDescription aDesc(eType);
 527
 528     const int nLevel = m_xLevelNF->denormalize(m_xLevelNF->get_value());
 529     switch( nPos)
 530     {
 531         case POS_CONTENT : break;
 532         case POS_INDEX:     // keyword index mark
 533         {
 534             UpdateKeyBoxes();
 535             aDesc.SetPrimKey(m_xKey1DCB->get_active_text());
 536             aDesc.SetSecKey(m_xKey2DCB->get_active_text());
 537             aDesc.SetMainEntry(m_xMainEntryCB->get_active());
 538             aDesc.SetPhoneticReadingOfAltStr(m_xPhoneticED0->get_text());
 539             aDesc.SetPhoneticReadingOfPrimKey(m_xPhoneticED1->get_text());
 540             aDesc.SetPhoneticReadingOfSecKey(m_xPhoneticED2->get_text());
 541         }
 542         break;
 543         default:            // Userdefined index mark
 544         {
 545             aDesc.SetTOUName(m_xTypeDCB->get_active_text());
 546         }
 547     }
 548     if (m_aOrgStr != m_xEntryED->get_text())
 549         aDesc.SetAltStr(m_xEntryED->get_text());
 550     bool bApplyAll = m_xApplyToAllCB->get_active();
 551     bool bWordOnly = m_xSearchCaseWordOnlyCB->get_active();
 552     bool bCaseSensitive = m_xSearchCaseSensitiveCB->get_active();
 553
 554     m_pSh->StartAllAction();
 555     // all equal strings have to be selected here so that the
 556     // entry is applied to all equal strings
 557     if(bApplyAll)
 558     {
 559         lcl_SelectSameStrings(*m_pSh, bWordOnly, bCaseSensitive);
 560     }
 561     aDesc.SetLevel(nLevel);
 562     SwTOXMgr aMgr(m_pSh);
 563     aMgr.InsertTOXMark(aDesc);
 564     if(bApplyAll)
 565         m_pSh->Pop(SwCursorShell::PopMode::DeleteCurrent);
 566
 567     m_pSh->EndAllAction();
 568 }
 569
 570 // update mark
 571 void SwIndexMarkPane::UpdateMark()
 572 {
 573     OUString  aAltText(m_xEntryED->get_text());
 574     OUString* pAltText = m_aOrgStr != m_xEntryED->get_text() ? &aAltText : nullptr;
 575     //empty alternative texts are not allowed
 576     if(pAltText && pAltText->isEmpty())
 577         return;
 578
 579     UpdateKeyBoxes();
 580
 581     auto nPos = m_xTypeDCB->find_text(m_xTypeDCB->get_active_text());
 582     TOXTypes eType = TOX_USER;
 583     if(POS_CONTENT == nPos)
 584         eType = TOX_CONTENT;
 585     else if(POS_INDEX == nPos)
 586         eType = TOX_INDEX;
 587
 588     SwTOXMarkDescription aDesc(eType);
 589     aDesc.SetLevel(m_xLevelNF->get_value());
 590     if(pAltText)
 591         aDesc.SetAltStr(*pAltText);
 592
 593     OUString  aPrim(m_xKey1DCB->get_active_text());
 594     if(!aPrim.isEmpty())
 595         aDesc.SetPrimKey(aPrim);
 596     OUString  aSec(m_xKey2DCB->get_active_text());
 597     if(!aSec.isEmpty())
 598         aDesc.SetSecKey(aSec);
 599
 600     if(eType == TOX_INDEX)
 601     {
 602         aDesc.SetPhoneticReadingOfAltStr(m_xPhoneticED0->get_text());
 603         aDesc.SetPhoneticReadingOfPrimKey(m_xPhoneticED1->get_text());
 604         aDesc.SetPhoneticReadingOfSecKey(m_xPhoneticED2->get_text());
 605     }
 606     aDesc.SetMainEntry(m_xMainEntryCB->get_visible() && m_xMainEntryCB->get_active());
 607     m_pTOXMgr->UpdateTOXMark(aDesc);
 608 }
 609
 610 // insert new keys
 611 void SwIndexMarkPane::UpdateKeyBoxes()
 612 {
 613     OUString aKey(m_xKey1DCB->get_active_text());
 614     auto nPos = m_xKey1DCB->find_text(aKey);
 615     if(nPos == -1 && !aKey.isEmpty())
 616     {   // create new key
 617         m_xKey1DCB->append_text(aKey);
 618     }
 619
 620     aKey = m_xKey2DCB->get_active_text();
 621     nPos = m_xKey2DCB->find_text(aKey);
 622
 623     if(nPos == -1 && !aKey.isEmpty())
 624     {   // create new key
 625         m_xKey2DCB->append_text(aKey);
 626     }
 627 }
 628
 629 namespace {
 630
 631 class SwNewUserIdxDlg : public weld::GenericDialogController
 632 {
 633     SwIndexMarkPane* m_pDlg;
 634
 635     std::unique_ptr<weld::Button> m_xOKPB;
 636     std::unique_ptr<weld::Entry> m_xNameED;
 637
 638     DECL_LINK(ModifyHdl, weld::Entry&, void);
 639
 640 public:
 641     explicit SwNewUserIdxDlg(SwIndexMarkPane* pPane, weld::Window* pParent)
 642         : GenericDialogController(pParent, "modules/swriter/ui/newuserindexdialog.ui", "NewUserIndexDialog")
 643         , m_pDlg(pPane)
 644         , m_xOKPB(m_xBuilder->weld_button("ok"))
 645         , m_xNameED(m_xBuilder->weld_entry("entry"))
 646     {
 647         m_xNameED->connect_changed(LINK(this, SwNewUserIdxDlg, ModifyHdl));
 648         m_xOKPB->set_sensitive(false);
 649         m_xNameED->grab_focus();
 650     }
 651     OUString GetName() const { return m_xNameED->get_text(); }
 652 };
 653
 654 }
 655
 656 IMPL_LINK( SwNewUserIdxDlg, ModifyHdl, weld::Entry&, rEdit, void)
 657 {
 658     m_xOKPB->set_sensitive(!rEdit.get_text().isEmpty() && !m_pDlg->IsTOXType(rEdit.get_text()));
 659 }
 660
 661 IMPL_LINK_NOARG(SwIndexMarkPane, NewUserIdxHdl, weld::Button&, void)
 662 {
 663     SwNewUserIdxDlg aDlg(this, m_xDialog.get());
 664     if (aDlg.run() == RET_OK)
 665     {
 666         OUString sNewName(aDlg.GetName());
 667         m_xTypeDCB->append_text(sNewName);
 668         m_xTypeDCB->set_active_text(sNewName);
 669     }
 670 }
 671
 672 IMPL_LINK( SwIndexMarkPane, SearchTypeHdl, weld::Toggleable&, rBox, void)
 673 {
 674     const bool bEnable = rBox.get_active() && rBox.get_sensitive();
 675     m_xSearchCaseWordOnlyCB->set_sensitive(bEnable);
 676     m_xSearchCaseSensitiveCB->set_sensitive(bEnable);
 677 }
 678
 679 IMPL_LINK(SwIndexMarkPane, InsertHdl, weld::Button&, rButton, void)
 680 {
 681     Apply();
 682     //close the dialog if only one entry is available
 683     if(!m_bNewMark && !m_xPrevBT->get_visible() && !m_xNextBT->get_visible())
 684         CloseHdl(rButton);
 685 }
 686
 687 IMPL_LINK_NOARG(SwIndexMarkPane, CloseHdl, weld::Button&, void)
 688 {
 689     if (m_bNewMark)
 690     {
 691         if (SfxViewFrame* pViewFrm = SfxViewFrame::Current())
 692         {
 693             pViewFrm->GetDispatcher()->Execute(FN_INSERT_IDX_ENTRY_DLG,
 694                         SfxCallMode::ASYNCHRON|SfxCallMode::RECORD);
 695         }
 696     }
 697     else
 698     {
 699         m_xDialog->response(RET_CLOSE);
 700     }
 701 }
 702
 703 // select index type only when inserting
 704 IMPL_LINK(SwIndexMarkPane, ModifyListBoxHdl, weld::ComboBox&, rBox, void)
 705 {
 706     ModifyHdl(rBox);
 707 }
 708
 709 IMPL_LINK(SwIndexMarkPane, ModifyEditHdl, weld::Entry&, rEdit, void)
 710 {
 711     ModifyHdl(rEdit);
 712 }
 713
 714 void SwIndexMarkPane::ModifyHdl(const weld::Widget& rBox)
 715 {
 716     if (m_xTypeDCB.get() == &rBox)
 717     {
 718         // set index type
 719         auto nPos = m_xTypeDCB->find_text(m_xTypeDCB->get_active_text());
 720         bool bLevelEnable = false,
 721              bKeyEnable   = false,
 722              bSetKey2     = false,
 723              bKey2Enable  = false,
 724              bEntryHasText   = false,
 725              bKey1HasText    = false,
 726              bKey2HasText    = false;
 727         if(nPos == POS_INDEX)
 728         {
 729             if (!m_xEntryED->get_text().isEmpty())
 730                 bEntryHasText = true;
 731             m_xPhoneticED0->set_text(GetDefaultPhoneticReading(m_xEntryED->get_text()));
 732
 733             bKeyEnable = true;
 734             m_xKey1DCB->set_active_text(m_xKey1DCB->get_text(nKey1Pos));
 735             m_xPhoneticED1->set_text(GetDefaultPhoneticReading(m_xKey1DCB->get_active_text()));
 736             if (!m_xKey1DCB->get_active_text().isEmpty())
 737             {
 738                 bKey1HasText = bSetKey2 = bKey2Enable = true;
 739                 m_xKey2DCB->set_active_text(m_xKey2DCB->get_text(nKey2Pos));
 740                 m_xPhoneticED2->set_text(GetDefaultPhoneticReading(m_xKey2DCB->get_active_text()));
 741                 if(!m_xKey2DCB->get_active_text().isEmpty())
 742                     bKey2HasText = true;
 743             }
 744         }
 745         else
 746         {
 747             bLevelEnable = true;
 748             m_xLevelNF->set_max(MAXLEVEL);
 749             m_xLevelNF->set_value(m_xLevelNF->normalize(0));
 750             bSetKey2 = true;
 751         }
 752         m_xLevelFT->set_visible(bLevelEnable);
 753         m_xLevelNF->set_visible(bLevelEnable);
 754         m_xMainEntryCB->set_visible(nPos == POS_INDEX);
 755
 756         m_xKey1FT->set_sensitive(bKeyEnable);
 757         m_xKey1DCB->set_sensitive(bKeyEnable);
 758         if ( bSetKey2 )
 759         {
 760             m_xKey2DCB->set_sensitive(bKey2Enable);
 761             m_xKey2FT->set_sensitive(bKey2Enable);
 762         }
 763         m_xPhoneticFT0->set_sensitive(bKeyEnable&&bEntryHasText&&m_bIsPhoneticReadingEnabled);
 764         m_xPhoneticED0->set_sensitive(bKeyEnable&&bEntryHasText&&m_bIsPhoneticReadingEnabled);
 765         m_xPhoneticFT1->set_sensitive(bKeyEnable&&bKey1HasText&&m_bIsPhoneticReadingEnabled);
 766         m_xPhoneticED1->set_sensitive(bKeyEnable&&bKey1HasText&&m_bIsPhoneticReadingEnabled);
 767         m_xPhoneticFT2->set_sensitive(bKeyEnable&&bKey2HasText&&m_bIsPhoneticReadingEnabled);
 768         m_xPhoneticED2->set_sensitive(bKeyEnable&&bKey2HasText&&m_bIsPhoneticReadingEnabled);
 769     }
 770     else //m_xEntryED  !!m_xEntryED is not a ListBox but an Edit
 771     {
 772         bool bHasText = !m_xEntryED->get_text().isEmpty();
 773         if(!bHasText)
 774         {
 775             m_xPhoneticED0->set_text(OUString());
 776             m_bPhoneticED0_ChangedByUser = false;
 777         }
 778         else if(!m_bPhoneticED0_ChangedByUser)
 779             m_xPhoneticED0->set_text(GetDefaultPhoneticReading(m_xEntryED->get_text()));
 780
 781         m_xPhoneticFT0->set_sensitive(bHasText&&m_bIsPhoneticReadingEnabled);
 782         m_xPhoneticED0->set_sensitive(bHasText&&m_bIsPhoneticReadingEnabled);
 783     }
 784     m_xOKBT->set_sensitive(!m_pSh->HasReadonlySel() &&
 785         (!m_xEntryED->get_text().isEmpty() || m_pSh->GetCursorCnt(false)));
 786 }
 787
 788 IMPL_LINK_NOARG(SwIndexMarkPane, NextHdl, weld::Button&, void)
 789 {
 790     InsertUpdate();
 791     m_pTOXMgr->NextTOXMark();
 792     UpdateDialog();
 793 }
 794
 795 IMPL_LINK_NOARG(SwIndexMarkPane, NextSameHdl, weld::Button&, void)
 796 {
 797     InsertUpdate();
 798     m_pTOXMgr->NextTOXMark(true);
 799     UpdateDialog();
 800 }
 801
 802 IMPL_LINK_NOARG(SwIndexMarkPane, PrevHdl, weld::Button&, void)
 803 {
 804     InsertUpdate();
 805     m_pTOXMgr->PrevTOXMark();
 806     UpdateDialog();
 807 }
 808
 809 IMPL_LINK_NOARG(SwIndexMarkPane, PrevSameHdl, weld::Button&, void)
 810 {
 811     InsertUpdate();
 812     m_pTOXMgr->PrevTOXMark(true);
 813     UpdateDialog();
 814 }
 815
 816 IMPL_LINK_NOARG(SwIndexMarkPane, DelHdl, weld::Button&, void)
 817 {
 818     m_bDel = true;
 819     InsertUpdate();
 820     m_bDel = false;
 821
 822     if(m_pTOXMgr->GetCurTOXMark())
 823         UpdateDialog();
 824     else
 825     {
 826         CloseHdl(*m_xCloseBT);
 827         if (SfxViewFrame* pViewFrm = SfxViewFrame::Current())
 828             pViewFrm->GetBindings().Invalidate(FN_EDIT_IDX_ENTRY_DLG);
 829     }
 830 }
 831
 832 // renew dialog view
 833 void SwIndexMarkPane::UpdateDialog()
 834 {
 835     OSL_ENSURE(m_pSh && m_pTOXMgr, "no shell?");
 836     SwTOXMark* pMark = m_pTOXMgr->GetCurTOXMark();
 837     OSL_ENSURE(pMark, "no current marker");
 838     if(!pMark)
 839         return;
 840
 841     SwViewShell::SetCareDialog(m_xDialog);
 842
 843     m_aOrgStr = pMark->GetText(m_pSh->GetLayout());
 844     m_xEntryED->set_text(m_aOrgStr);
 845
 846     // set index type
 847     bool bLevelEnable = true,
 848          bKeyEnable   = false,
 849          bKey2Enable  = false,
 850          bEntryHasText  = false,
 851          bKey1HasText   = false,
 852          bKey2HasText   = false;
 853
 854     TOXTypes eCurType = pMark->GetTOXType()->GetType();
 855     if(TOX_INDEX == eCurType)
 856     {
 857         bLevelEnable = false;
 858         bKeyEnable = true;
 859         bKey1HasText = bKey2Enable = !pMark->GetPrimaryKey().isEmpty();
 860         bKey2HasText = !pMark->GetSecondaryKey().isEmpty();
 861         bEntryHasText = !pMark->GetText(m_pSh->GetLayout()).isEmpty();
 862         m_xKey1DCB->set_entry_text( pMark->GetPrimaryKey() );
 863         m_xKey2DCB->set_entry_text( pMark->GetSecondaryKey() );
 864         m_xPhoneticED0->set_text( pMark->GetTextReading() );
 865         m_xPhoneticED1->set_text( pMark->GetPrimaryKeyReading() );
 866         m_xPhoneticED2->set_text( pMark->GetSecondaryKeyReading() );
 867         m_xMainEntryCB->set_active(pMark->IsMainEntry());
 868     }
 869     else if(TOX_CONTENT == eCurType || TOX_USER == eCurType)
 870     {
 871         m_xLevelNF->set_value(m_xLevelNF->normalize(pMark->GetLevel()));
 872     }
 873     m_xKey1FT->set_sensitive(bKeyEnable);
 874     m_xKey1DCB->set_sensitive(bKeyEnable);
 875     m_xLevelNF->set_max(MAXLEVEL);
 876     m_xLevelFT->set_visible(bLevelEnable);
 877     m_xLevelNF->set_visible(bLevelEnable);
 878     m_xMainEntryCB->set_visible(!bLevelEnable);
 879     m_xKey2FT->set_sensitive(bKey2Enable);
 880     m_xKey2DCB->set_sensitive(bKey2Enable);
 881
 882     UpdateLanguageDependenciesForPhoneticReading();
 883     m_xPhoneticFT0->set_sensitive(bKeyEnable&&bEntryHasText&&m_bIsPhoneticReadingEnabled);
 884     m_xPhoneticED0->set_sensitive(bKeyEnable&&bEntryHasText&&m_bIsPhoneticReadingEnabled);
 885     m_xPhoneticFT1->set_sensitive(bKeyEnable&&bKey1HasText&&m_bIsPhoneticReadingEnabled);
 886     m_xPhoneticED1->set_sensitive(bKeyEnable&&bKey1HasText&&m_bIsPhoneticReadingEnabled);
 887     m_xPhoneticFT2->set_sensitive(bKeyEnable&&bKey2HasText&&m_bIsPhoneticReadingEnabled);
 888     m_xPhoneticED2->set_sensitive(bKeyEnable&&bKey2HasText&&m_bIsPhoneticReadingEnabled);
 889
 890     // set index type
 891     m_xTypeDCB->set_active_text(pMark->GetTOXType()->GetTypeName());
 892
 893     // set Next - Prev - Buttons
 894     m_pSh->SttCursorMove();
 895     if( m_xPrevBT->get_visible() )
 896     {
 897         const SwTOXMark* pMoveMark = &m_pSh->GotoTOXMark( *pMark, TOX_PRV );
 898         if( pMoveMark != pMark )
 899             m_pSh->GotoTOXMark( *pMoveMark, TOX_NXT );
 900         m_xPrevBT->set_sensitive( pMoveMark != pMark );
 901         pMoveMark = &m_pSh->GotoTOXMark( *pMark, TOX_NXT );
 902         if( pMoveMark != pMark )
 903             m_pSh->GotoTOXMark( *pMoveMark, TOX_PRV );
 904         m_xNextBT->set_sensitive( pMoveMark != pMark );
 905     }
 906
 907     if (m_xPrevSameBT->get_visible())
 908     {
 909         const SwTOXMark* pMoveMark = &m_pSh->GotoTOXMark( *pMark, TOX_SAME_PRV );
 910         if( pMoveMark != pMark )
 911             m_pSh->GotoTOXMark( *pMoveMark, TOX_SAME_NXT );
 912         m_xPrevSameBT->set_sensitive( pMoveMark != pMark );
 913         pMoveMark = &m_pSh->GotoTOXMark( *pMark, TOX_SAME_NXT );
 914         if( pMoveMark != pMark )
 915             m_pSh->GotoTOXMark( *pMoveMark, TOX_SAME_PRV );
 916         m_xNextSameBT->set_sensitive( pMoveMark != pMark );
 917     }
 918
 919     const bool bEnable = !m_pSh->HasReadonlySel();
 920     m_xOKBT->set_sensitive(bEnable);
 921     m_xDelBT->set_sensitive(bEnable);
 922     m_xEntryED->set_sensitive(bEnable);
 923     m_xLevelNF->set_sensitive(bEnable);
 924     m_xKey1DCB->set_sensitive(bEnable);
 925     m_xKey2DCB->set_sensitive(bEnable);
 926
 927     m_pSh->SelectTextAttr( RES_TXTATR_TOXMARK, pMark->GetTextTOXMark() );
 928     // we need the point at the start of the attribute
 929     m_pSh->SwapPam();
 930
 931     m_pSh->EndCursorMove();
 932 }
 933
 934 // Remind whether the edit boxes for Phonetic reading are changed manually
 935 IMPL_LINK(SwIndexMarkPane, PhoneticEDModifyHdl, weld::Entry&, rEdit, void)
 936 {
 937     if (m_xPhoneticED0.get() == &rEdit)
 938     {
 939         m_bPhoneticED0_ChangedByUser = !rEdit.get_text().isEmpty();
 940     }
 941     else if (m_xPhoneticED1.get() == &rEdit)
 942     {
 943         m_bPhoneticED1_ChangedByUser = !rEdit.get_text().isEmpty();
 944     }
 945     else if (m_xPhoneticED2.get() == &rEdit)
 946     {
 947         m_bPhoneticED2_ChangedByUser = !rEdit.get_text().isEmpty();
 948     }
 949 }
 950
 951 // Enable Disable of the 2nd key
 952 IMPL_LINK( SwIndexMarkPane, KeyDCBModifyHdl, weld::ComboBox&, rBox, void )
 953 {
 954     if (m_xKey1DCB.get() == &rBox)
 955     {
 956         bool bEnable = !rBox.get_active_text().isEmpty();
 957         if(!bEnable)
 958         {
 959             m_xKey2DCB->set_entry_text(OUString());
 960             m_xPhoneticED1->set_text(OUString());
 961             m_xPhoneticED2->set_text(OUString());
 962             m_bPhoneticED1_ChangedByUser = false;
 963             m_bPhoneticED2_ChangedByUser = false;
 964         }
 965         else
 966         {
 967             if (rBox.get_popup_shown())
 968             {
 969                 //reset bPhoneticED1_ChangedByUser if a completely new string is selected
 970                 m_bPhoneticED1_ChangedByUser = false;
 971             }
 972             if (!m_bPhoneticED1_ChangedByUser)
 973                 m_xPhoneticED1->set_text(GetDefaultPhoneticReading(rBox.get_active_text()));
 974         }
 975         m_xKey2DCB->set_sensitive(bEnable);
 976         m_xKey2FT->set_sensitive(bEnable);
 977     }
 978     else if (m_xKey2DCB.get() == &rBox)
 979     {
 980         if (rBox.get_active_text().isEmpty())
 981         {
 982             m_xPhoneticED2->set_text(OUString());
 983             m_bPhoneticED2_ChangedByUser = false;
 984         }
 985         else
 986         {
 987             if (rBox.get_popup_shown())
 988             {
 989                 //reset bPhoneticED1_ChangedByUser if a completely new string is selected
 990                 m_bPhoneticED2_ChangedByUser = false;
 991             }
 992             if(!m_bPhoneticED2_ChangedByUser)
 993                 m_xPhoneticED2->set_text(GetDefaultPhoneticReading(rBox.get_active_text()));
 994         }
 995     }
 996
 997     bool bKey1HasText = !m_xKey1DCB->get_active_text().isEmpty();
 998     bool bKey2HasText = !m_xKey2DCB->get_active_text().isEmpty();
 999
1000     m_xPhoneticFT1->set_sensitive(bKey1HasText && m_bIsPhoneticReadingEnabled);
1001     m_xPhoneticED1->set_sensitive(bKey1HasText && m_bIsPhoneticReadingEnabled);
1002     m_xPhoneticFT2->set_sensitive(bKey2HasText && m_bIsPhoneticReadingEnabled);
1003     m_xPhoneticED2->set_sensitive(bKey2HasText && m_bIsPhoneticReadingEnabled);
1004 }
1005
1006 SwIndexMarkPane::~SwIndexMarkPane()
1007 {
1008 }
1009
1010 void SwIndexMarkPane::ReInitDlg(SwWrtShell& rWrtShell, SwTOXMark const * pCurTOXMark)
1011 {
1012     m_pSh = &rWrtShell;
1013     m_pTOXMgr.reset( new SwTOXMgr(m_pSh) );
1014     if(pCurTOXMark)
1015     {
1016         for(sal_uInt16 i = 0; i < m_pTOXMgr->GetTOXMarkCount(); i++)
1017             if(m_pTOXMgr->GetTOXMark(i) == pCurTOXMark)
1018             {
1019                 m_pTOXMgr->SetCurTOXMark(i);
1020                 break;
1021             }
1022     }
1023     InitControls();
1024 }
1025
1026 SwIndexMarkFloatDlg::SwIndexMarkFloatDlg(SfxBindings* _pBindings,
1027     SfxChildWindow* pChild, weld::Window *pParent,
1028     SfxChildWinInfo const * pInfo, bool bNew)
1029     : SfxModelessDialogController(_pBindings, pChild, pParent,
1030         "modules/swriter/ui/indexentry.ui", "IndexEntryDialog")
1031     , m_aContent(m_xDialog, *m_xBuilder, bNew, ::GetActiveWrtShell())
1032 {
1033     if (SwWrtShell* pWrtShell = ::GetActiveWrtShell())
1034         m_aContent.ReInitDlg(*pWrtShell);
1035     Initialize(pInfo);
1036 }
1037
1038 void SwIndexMarkFloatDlg::Activate()
1039 {
1040     SfxModelessDialogController::Activate();
1041     m_aContent.Activate();
1042 }
1043
1044 void SwIndexMarkFloatDlg::ReInitDlg(SwWrtShell& rWrtShell)
1045 {
1046     m_aContent.ReInitDlg( rWrtShell );
1047 }
1048
1049 SwIndexMarkModalDlg::SwIndexMarkModalDlg(weld::Window *pParent, SwWrtShell& rSh, SwTOXMark const * pCurTOXMark)
1050     : SfxDialogController(pParent, "modules/swriter/ui/indexentry.ui",
1051                           "IndexEntryDialog")
1052     , m_aContent(m_xDialog, *m_xBuilder, false, &rSh)
1053 {
1054     m_aContent.ReInitDlg(rSh, pCurTOXMark);
1055 }
1056
1057 SwIndexMarkModalDlg::~SwIndexMarkModalDlg()
1058 {
1059     SwViewShell::SetCareDialog(nullptr);
1060 }
1061
1062 short SwIndexMarkModalDlg::run()
1063 {
1064     short nRet = SfxDialogController::run();
1065     if (RET_OK == nRet)
1066         m_aContent.Apply();
1067     return nRet;
1068 }
1069
1070 namespace {
1071
1072 class SwCreateAuthEntryDlg_Impl : public weld::GenericDialogController
1073 {
1074     std::vector<std::unique_ptr<weld::Builder>> m_aBuilders;
1075
1076     Link<weld::Entry&,bool>       m_aShortNameCheckLink;
1077
1078     SwWrtShell&     m_rWrtSh;
1079
1080     bool            m_bNewEntryMode;
1081     bool            m_bNameAllowed;
1082
1083     std::vector<std::unique_ptr<weld::Container>> m_aOrigContainers;
1084     std::vector<std::unique_ptr<weld::Label>> m_aFixedTexts;
1085     std::unique_ptr<weld::Box> m_pBoxes[AUTH_FIELD_END];
1086     std::unique_ptr<weld::Entry> m_pEdits[AUTH_FIELD_END];
1087     std::unique_ptr<weld::Button> m_xOKBT;
1088     std::unique_ptr<weld::Container> m_xBox;
1089     std::unique_ptr<weld::Container> m_xLeft;
1090     std::unique_ptr<weld::Container> m_xRight;
1091     std::unique_ptr<weld::ComboBox> m_xTypeListBox;
1092     std::unique_ptr<weld::ComboBox> m_xIdentifierBox;
1093     std::unique_ptr<weld::Button> m_xLocalBrowseButton;
1094     std::unique_ptr<weld::CheckButton> m_xLocalPageCB;
1095     std::unique_ptr<weld::SpinButton> m_xLocalPageSB;
1096     std::unique_ptr<weld::ComboBox> m_xTargetTypeListBox;
1097     weld::Entry* m_pTargetURLField;
1098
1099     DECL_LINK(IdentifierHdl, weld::ComboBox&, void);
1100     DECL_LINK(ShortNameHdl, weld::Entry&, void);
1101     DECL_LINK(EnableHdl, weld::ComboBox&, void);
1102     DECL_LINK(BrowseHdl, weld::Button&, void);
1103     DECL_LINK(PageNumHdl, weld::Toggleable&, void);
1104     DECL_LINK(TargetTypeHdl, weld::ComboBox&, void);
1105
1106 public:
1107     SwCreateAuthEntryDlg_Impl(weld::Window* pParent,
1108                               const OUString pFields[],
1109                               SwWrtShell& rSh,
1110                               bool bNewEntry,
1111                               bool bCreate);
1112
1113     OUString        GetEntryText(ToxAuthorityField eField) const;
1114
1115     void            SetCheckNameHdl(const Link<weld::Entry&,bool>& rLink) {m_aShortNameCheckLink = rLink;}
1116
1117 };
1118
1119 struct TextInfo
1120 {
1121     ToxAuthorityField nToxField;
1122     const OUString pHelpId;
1123 };
1124
1125 }
1126
1127 const TextInfo aTextInfoArr[] =
1128 {
1129     {AUTH_FIELD_IDENTIFIER,      HID_AUTH_FIELD_IDENTIFIER      },
1130     {AUTH_FIELD_AUTHORITY_TYPE,  HID_AUTH_FIELD_AUTHORITY_TYPE  },
1131     {AUTH_FIELD_AUTHOR,          HID_AUTH_FIELD_AUTHOR          },
1132     {AUTH_FIELD_TITLE,           HID_AUTH_FIELD_TITLE           },
1133     {AUTH_FIELD_YEAR,            HID_AUTH_FIELD_YEAR            },
1134     {AUTH_FIELD_PUBLISHER,       HID_AUTH_FIELD_PUBLISHER       },
1135     {AUTH_FIELD_ADDRESS,         HID_AUTH_FIELD_ADDRESS         },
1136     {AUTH_FIELD_ISBN,            HID_AUTH_FIELD_ISBN            },
1137     {AUTH_FIELD_CHAPTER,         HID_AUTH_FIELD_CHAPTER         },
1138     {AUTH_FIELD_PAGES,           HID_AUTH_FIELD_PAGES           },
1139     {AUTH_FIELD_EDITOR,          HID_AUTH_FIELD_EDITOR          },
1140     {AUTH_FIELD_EDITION,         HID_AUTH_FIELD_EDITION         },
1141     {AUTH_FIELD_BOOKTITLE,       HID_AUTH_FIELD_BOOKTITLE       },
1142     {AUTH_FIELD_VOLUME,          HID_AUTH_FIELD_VOLUME          },
1143     {AUTH_FIELD_HOWPUBLISHED,    HID_AUTH_FIELD_HOWPUBLISHED    },
1144     {AUTH_FIELD_ORGANIZATIONS,   HID_AUTH_FIELD_ORGANIZATIONS   },
1145     {AUTH_FIELD_INSTITUTION,     HID_AUTH_FIELD_INSTITUTION     },
1146     {AUTH_FIELD_SCHOOL,          HID_AUTH_FIELD_SCHOOL          },
1147     {AUTH_FIELD_REPORT_TYPE,     HID_AUTH_FIELD_REPORT_TYPE     },
1148     {AUTH_FIELD_MONTH,           HID_AUTH_FIELD_MONTH           },
1149     {AUTH_FIELD_JOURNAL,         HID_AUTH_FIELD_JOURNAL         },
1150     {AUTH_FIELD_NUMBER,          HID_AUTH_FIELD_NUMBER          },
1151     {AUTH_FIELD_SERIES,          HID_AUTH_FIELD_SERIES          },
1152     {AUTH_FIELD_ANNOTE,          HID_AUTH_FIELD_ANNOTE          },
1153     {AUTH_FIELD_NOTE,            HID_AUTH_FIELD_NOTE            },
1154     {AUTH_FIELD_URL,             HID_AUTH_FIELD_URL             },
1155     {AUTH_FIELD_TARGET_TYPE,     HID_AUTH_FIELD_TARGET_TYPE     },
1156     {AUTH_FIELD_TARGET_URL,      HID_AUTH_FIELD_TARGET_URL      },
1157     {AUTH_FIELD_LOCAL_URL,       HID_AUTH_FIELD_LOCAL_URL       },
1158     {AUTH_FIELD_CUSTOM1,         HID_AUTH_FIELD_CUSTOM1         },
1159     {AUTH_FIELD_CUSTOM2,         HID_AUTH_FIELD_CUSTOM2         },
1160     {AUTH_FIELD_CUSTOM3,         HID_AUTH_FIELD_CUSTOM3         },
1161     {AUTH_FIELD_CUSTOM4,         HID_AUTH_FIELD_CUSTOM4         },
1162     {AUTH_FIELD_CUSTOM5,         HID_AUTH_FIELD_CUSTOM5         }
1163 };
1164
1165 static OUString lcl_FindColumnEntry(const uno::Sequence<beans::PropertyValue>& rFields, std::u16string_view rColumnTitle)
1166 {
1167     for(const auto& rField : rFields)
1168     {
1169         OUString sRet;
1170         if(rField.Name == rColumnTitle &&
1171             (rField.Value >>= sRet))
1172         {
1173             return sRet;
1174         }
1175     }
1176     return OUString();
1177 }
1178
1179 bool SwAuthorMarkPane::s_bIsFromComponent = true;
1180
1181 SwAuthorMarkPane::SwAuthorMarkPane(weld::DialogController &rDialog, weld::Builder& rBuilder, bool bNewDlg)
1182     : m_rDialog(rDialog)
1183     , m_bNewEntry(bNewDlg)
1184     , m_bBibAccessInitialized(false)
1185     , m_pSh(nullptr)
1186     , m_xFromComponentRB(rBuilder.weld_radio_button("frombibliography"))
1187     , m_xFromDocContentRB(rBuilder.weld_radio_button("fromdocument"))
1188     , m_xAuthorFI(rBuilder.weld_label("author"))
1189     , m_xTitleFI(rBuilder.weld_label("title"))
1190     , m_xEntryED(rBuilder.weld_entry("entryed"))
1191     , m_xEntryLB(rBuilder.weld_combo_box("entrylb"))
1192     , m_xActionBT(rBuilder.weld_button(m_bNewEntry ? OUString("insert") : OUString("modify")))
1193     , m_xCloseBT(rBuilder.weld_button("close"))
1194     , m_xCreateEntryPB(rBuilder.weld_button("new"))
1195     , m_xEditEntryPB(rBuilder.weld_button("edit"))
1196 {
1197     m_xActionBT->show();
1198     m_xFromComponentRB->set_visible(m_bNewEntry);
1199     m_xFromDocContentRB->set_visible(m_bNewEntry);
1200     m_xFromComponentRB->set_active(s_bIsFromComponent);
1201     m_xFromDocContentRB->set_active(!s_bIsFromComponent);
1202
1203     m_xActionBT->connect_clicked(LINK(this,SwAuthorMarkPane, InsertHdl));
1204     m_xCloseBT->connect_clicked(LINK(this,SwAuthorMarkPane, CloseHdl));
1205     m_xCreateEntryPB->connect_clicked(LINK(this,SwAuthorMarkPane, CreateEntryHdl));
1206     m_xEditEntryPB->connect_clicked(LINK(this,SwAuthorMarkPane, CreateEntryHdl));
1207     m_xFromComponentRB->connect_toggled(LINK(this,SwAuthorMarkPane, ChangeSourceHdl));
1208     m_xFromDocContentRB->connect_toggled(LINK(this,SwAuthorMarkPane, ChangeSourceHdl));
1209     m_xEntryED->connect_changed(LINK(this,SwAuthorMarkPane, EditModifyHdl));
1210
1211     m_rDialog.set_title(SwResId(
1212                     m_bNewEntry ? STR_AUTHMRK_INSERT : STR_AUTHMRK_EDIT));
1213
1214     m_xEntryED->set_visible(!m_bNewEntry);
1215     m_xEntryLB->set_visible(m_bNewEntry);
1216     // tdf#90641 - sort bibliography entries by identifier
1217     m_xEntryLB->make_sorted();
1218     if (m_bNewEntry)
1219     {
1220         m_xEntryLB->connect_changed(LINK(this, SwAuthorMarkPane, CompEntryHdl));
1221     }
1222 }
1223
1224 void SwAuthorMarkPane::ReInitDlg(SwWrtShell& rWrtShell)
1225 {
1226     m_pSh = &rWrtShell;
1227     InitControls();
1228 }
1229
1230 IMPL_LINK_NOARG(SwAuthorMarkPane, CloseHdl, weld::Button&, void)
1231 {
1232     if(m_bNewEntry)
1233     {
1234         if (SfxViewFrame* pViewFrm = SfxViewFrame::Current())
1235         {
1236             pViewFrm->GetDispatcher()->Execute(FN_INSERT_AUTH_ENTRY_DLG,
1237                     SfxCallMode::ASYNCHRON|SfxCallMode::RECORD);
1238         }
1239     }
1240     else
1241     {
1242         m_rDialog.response(RET_CANCEL);
1243     }
1244 }
1245
1246 IMPL_LINK( SwAuthorMarkPane, CompEntryHdl, weld::ComboBox&, rBox, void)
1247 {
1248     const OUString sEntry(rBox.get_active_text());
1249     if(s_bIsFromComponent)
1250     {
1251         if(m_xBibAccess.is() && !sEntry.isEmpty())
1252         {
1253             if(m_xBibAccess->hasByName(sEntry))
1254             {
1255                 uno::Any aEntry(m_xBibAccess->getByName(sEntry));
1256                 uno::Sequence<beans::PropertyValue> aFieldProps;
1257                 if(aEntry >>= aFieldProps)
1258                 {
1259                     auto nSize = std::min(static_cast<sal_Int32>(AUTH_FIELD_END), aFieldProps.getLength());
1260                     for(sal_Int32 i = 0; i < nSize; i++)
1261                     {
1262                         m_sFields[i] = lcl_FindColumnEntry(aFieldProps, m_sColumnTitles[i]);
1263                     }
1264                 }
1265             }
1266         }
1267     }
1268     else
1269     {
1270         if(!sEntry.isEmpty())
1271         {
1272             const SwAuthorityFieldType* pFType = static_cast<const SwAuthorityFieldType*>(
1273                                         m_pSh->GetFieldType(SwFieldIds::TableOfAuthorities, OUString()));
1274             const SwAuthEntry*  pEntry = pFType ? pFType->GetEntryByIdentifier(sEntry) : nullptr;
1275             for(int i = 0; i < AUTH_FIELD_END; i++)
1276                 m_sFields[i] = pEntry ?
1277                             pEntry->GetAuthorField(static_cast<ToxAuthorityField>(i)) : OUString();
1278         }
1279     }
1280     if (rBox.get_active_text().isEmpty())
1281     {
1282         for(OUString & s : m_sFields)
1283             s.clear();
1284     }
1285     m_xAuthorFI->set_label(m_sFields[AUTH_FIELD_AUTHOR]);
1286     m_xTitleFI->set_label(m_sFields[AUTH_FIELD_TITLE]);
1287 }
1288
1289 IMPL_LINK_NOARG(SwAuthorMarkPane, InsertHdl, weld::Button&, void)
1290 {
1291     //insert or update the SwAuthorityField...
1292     if(m_pSh)
1293     {
1294         bool bDifferent = false;
1295         OSL_ENSURE(!m_sFields[AUTH_FIELD_IDENTIFIER].isEmpty() , "No Id is set!");
1296         OSL_ENSURE(!m_sFields[AUTH_FIELD_AUTHORITY_TYPE].isEmpty() , "No authority type is set!");
1297         //check if the entry already exists with different content
1298         const SwAuthorityFieldType* pFType = static_cast<const SwAuthorityFieldType*>(
1299                                         m_pSh->GetFieldType(SwFieldIds::TableOfAuthorities, OUString()));
1300         const SwAuthEntry*  pEntry = pFType ?
1301                 pFType->GetEntryByIdentifier( m_sFields[AUTH_FIELD_IDENTIFIER])
1302                 : nullptr;
1303         if(pEntry)
1304         {
1305             for(int i = 0; i < AUTH_FIELD_END && !bDifferent; i++)
1306                 bDifferent |= m_sFields[i] != pEntry->GetAuthorField(static_cast<ToxAuthorityField>(i));
1307             if(bDifferent)
1308             {
1309                 std::unique_ptr<weld::MessageDialog> xQuery(Application::CreateMessageDialog(m_rDialog.getDialog(),
1310                                                             VclMessageType::Question, VclButtonsType::YesNo,
1311                                                             SwResId(STR_QUERY_CHANGE_AUTH_ENTRY)));
1312                 if (RET_YES != xQuery->run())
1313                     return;
1314             }
1315         }
1316
1317         SwFieldMgr aMgr(m_pSh);
1318         OUStringBuffer sFields;
1319         for(OUString & s : m_sFields)
1320         {
1321             sFields.append(s + OUStringChar(TOX_STYLE_DELIMITER));
1322         }
1323         if(m_bNewEntry)
1324         {
1325             if(bDifferent)
1326             {
1327                 rtl::Reference<SwAuthEntry> xNewData(new SwAuthEntry);
1328                 for(int i = 0; i < AUTH_FIELD_END; i++)
1329                     xNewData->SetAuthorField(static_cast<ToxAuthorityField>(i), m_sFields[i]);
1330                 m_pSh->ChangeAuthorityData(xNewData.get());
1331             }
1332             SwInsertField_Data aData(SwFieldTypesEnum::Authority, 0, sFields.makeStringAndClear(), OUString(), 0 );
1333             aMgr.InsertField( aData );
1334         }
1335         else if(aMgr.GetCurField())
1336         {
1337             aMgr.UpdateCurField(0, sFields.makeStringAndClear(), OUString());
1338         }
1339     }
1340     if(!m_bNewEntry)
1341         CloseHdl(*m_xCloseBT);
1342 }
1343
1344 IMPL_LINK(SwAuthorMarkPane, CreateEntryHdl, weld::Button&, rButton, void)
1345 {
1346     bool bCreate = &rButton == m_xCreateEntryPB.get();
1347     OUString sOldId = m_sCreatedEntry[0];
1348     for(int i = 0; i < AUTH_FIELD_END; i++)
1349         m_sCreatedEntry[i] = bCreate ? OUString() : m_sFields[i];
1350     SwCreateAuthEntryDlg_Impl aDlg(m_rDialog.getDialog(),
1351                 bCreate ? m_sCreatedEntry : m_sFields,
1352                 *m_pSh, m_bNewEntry, bCreate);
1353     if(m_bNewEntry)
1354     {
1355         aDlg.SetCheckNameHdl(LINK(this, SwAuthorMarkPane, IsEntryAllowedHdl));
1356     }
1357     if(RET_OK != aDlg.run())
1358         return;
1359
1360     if(bCreate && !sOldId.isEmpty())
1361     {
1362         m_xEntryLB->remove_text(sOldId);
1363     }
1364     for(int i = 0; i < AUTH_FIELD_END; i++)
1365     {
1366         m_sFields[i] = aDlg.GetEntryText(static_cast<ToxAuthorityField>(i));
1367         m_sCreatedEntry[i] = m_sFields[i];
1368     }
1369     if(m_bNewEntry && !m_xFromDocContentRB->get_active())
1370     {
1371         m_xFromDocContentRB->set_active(true);
1372         ChangeSourceHdl(*m_xFromDocContentRB);
1373     }
1374     if(bCreate)
1375     {
1376         OSL_ENSURE(m_xEntryLB->find_text(m_sFields[AUTH_FIELD_IDENTIFIER]) == -1,
1377                     "entry exists!");
1378         m_xEntryLB->append_text(m_sFields[AUTH_FIELD_IDENTIFIER]);
1379         m_xEntryLB->set_active_text(m_sFields[AUTH_FIELD_IDENTIFIER]);
1380     }
1381     m_xEntryED->set_text(m_sFields[AUTH_FIELD_IDENTIFIER]);
1382     m_xAuthorFI->set_label(m_sFields[AUTH_FIELD_AUTHOR]);
1383     m_xTitleFI->set_label(m_sFields[AUTH_FIELD_TITLE]);
1384     m_xActionBT->set_sensitive(true);
1385
1386     if (!m_bNewEntry)
1387     {
1388         // When in edit mode, automatically apply the changed entry to update the field in the doc
1389         // model.
1390         InsertHdl(*m_xActionBT);
1391     }
1392 }
1393
1394 IMPL_LINK_NOARG(SwAuthorMarkPane, ChangeSourceHdl, weld::Toggleable&, void)
1395 {
1396     bool bFromComp = m_xFromComponentRB->get_active();
1397     s_bIsFromComponent = bFromComp;
1398     m_xCreateEntryPB->set_sensitive(!s_bIsFromComponent);
1399     m_xEntryLB->clear();
1400     if(s_bIsFromComponent)
1401     {
1402         if(!m_bBibAccessInitialized)
1403         {
1404             uno::Reference< uno::XComponentContext > xContext = getProcessComponentContext();
1405             m_xBibAccess = frame::Bibliography::create( xContext );
1406             uno::Reference< beans::XPropertySet >  xPropSet(m_xBibAccess, uno::UNO_QUERY);
1407             OUString uPropName("BibliographyDataFieldNames");
1408             if(xPropSet.is() && xPropSet->getPropertySetInfo()->hasPropertyByName(uPropName))
1409             {
1410                 uno::Any aNames = xPropSet->getPropertyValue(uPropName);
1411                 uno::Sequence<beans::PropertyValue> aSeq;
1412                 if( aNames >>= aSeq)
1413                 {
1414                     for(const beans::PropertyValue& rProp : std::as_const(aSeq))
1415                     {
1416                         sal_Int16 nField = 0;
1417                         rProp.Value >>= nField;
1418                         if(nField >= 0 && nField < AUTH_FIELD_END)
1419                             m_sColumnTitles[nField] = rProp.Name;
1420                     }
1421                 }
1422             }
1423             m_bBibAccessInitialized = true;
1424         }
1425         if(m_xBibAccess.is())
1426         {
1427             const uno::Sequence<OUString> aIdentifiers = m_xBibAccess->getElementNames();
1428             for(const OUString& rName : aIdentifiers)
1429                 m_xEntryLB->append_text(rName);
1430         }
1431     }
1432     else
1433     {
1434         const SwAuthorityFieldType* pFType = static_cast<const SwAuthorityFieldType*>(
1435                                     m_pSh->GetFieldType(SwFieldIds::TableOfAuthorities, OUString()));
1436         if(pFType)
1437         {
1438             std::vector<OUString> aIds;
1439             pFType->GetAllEntryIdentifiers( aIds );
1440             for(const OUString & i : aIds)
1441                 m_xEntryLB->append_text(i);
1442         }
1443         if(!m_sCreatedEntry[AUTH_FIELD_IDENTIFIER].isEmpty())
1444             m_xEntryLB->append_text(m_sCreatedEntry[AUTH_FIELD_IDENTIFIER]);
1445     }
1446     m_xEntryLB->set_active(0);
1447     CompEntryHdl(*m_xEntryLB);
1448 }
1449
1450 IMPL_LINK(SwAuthorMarkPane, EditModifyHdl, weld::Entry&, rEdit, void)
1451 {
1452     Link<weld::Entry&,bool> aAllowed = LINK(this, SwAuthorMarkPane, IsEditAllowedHdl);
1453     bool bResult = aAllowed.Call(rEdit);
1454     m_xActionBT->set_sensitive(bResult);
1455     if(bResult)
1456     {
1457         OUString sEntry(rEdit.get_text());
1458         m_sFields[AUTH_FIELD_IDENTIFIER] = sEntry;
1459         m_sCreatedEntry[AUTH_FIELD_IDENTIFIER] = sEntry;
1460     }
1461 };
1462
1463 IMPL_LINK(SwAuthorMarkPane, IsEntryAllowedHdl, weld::Entry&, rEdit, bool)
1464 {
1465     OUString sEntry = rEdit.get_text();
1466     bool bAllowed = false;
1467     if(!sEntry.isEmpty())
1468     {
1469         if (m_xEntryLB->find_text(sEntry) != -1)
1470             return false;
1471         else if(s_bIsFromComponent)
1472         {
1473             const SwAuthorityFieldType* pFType = static_cast<const SwAuthorityFieldType*>(
1474                                         m_pSh->GetFieldType(SwFieldIds::TableOfAuthorities, OUString()));
1475             bAllowed = !pFType || !pFType->GetEntryByIdentifier(sEntry);
1476         }
1477         else
1478         {
1479             bAllowed = !m_xBibAccess.is() || !m_xBibAccess->hasByName(sEntry);
1480         }
1481     }
1482     return bAllowed;
1483 }
1484
1485 IMPL_LINK(SwAuthorMarkPane, IsEditAllowedHdl, weld::Entry&, rEdit, bool)
1486 {
1487     OUString sEntry = rEdit.get_text();
1488     bool bAllowed = false;
1489     if(!sEntry.isEmpty())
1490     {
1491         if (m_xEntryLB->find_text(sEntry) != -1)
1492             return false;
1493         else if(s_bIsFromComponent)
1494         {
1495             const SwAuthorityFieldType* pFType = static_cast<const SwAuthorityFieldType*>(
1496                                         m_pSh->GetFieldType(SwFieldIds::TableOfAuthorities, OUString()));
1497             bAllowed = !pFType || !pFType->GetEntryByIdentifier(sEntry);
1498         }
1499         else
1500         {
1501             bAllowed = !m_xBibAccess.is() || !m_xBibAccess->hasByName(sEntry);
1502         }
1503     }
1504     return bAllowed;
1505 }
1506
1507 void SwAuthorMarkPane::InitControls()
1508 {
1509     OSL_ENSURE(m_pSh, "no shell?");
1510     SwField* pField = m_pSh->GetCurField();
1511     OSL_ENSURE(m_bNewEntry || pField, "no current marker");
1512     if(m_bNewEntry)
1513     {
1514         ChangeSourceHdl(m_xFromComponentRB->get_active() ? *m_xFromComponentRB : *m_xFromDocContentRB);
1515         m_xCreateEntryPB->set_sensitive(!m_xFromComponentRB->get_active());
1516         if(!m_xFromComponentRB->get_active() && !m_sCreatedEntry[0].isEmpty())
1517             for(int i = 0; i < AUTH_FIELD_END; i++)
1518                 m_sFields[i] = m_sCreatedEntry[i];
1519     }
1520     if(m_bNewEntry || !pField || pField->GetTyp()->Which() != SwFieldIds::TableOfAuthorities)
1521         return;
1522
1523     const SwAuthEntry* pEntry = static_cast<SwAuthorityField*>(pField)->GetAuthEntry();
1524
1525     OSL_ENSURE(pEntry, "No authority entry found");
1526     if(!pEntry)
1527         return;
1528     for(int i = 0; i < AUTH_FIELD_END; i++)
1529         m_sFields[i] = pEntry->GetAuthorField(static_cast<ToxAuthorityField>(i));
1530
1531     m_xEntryED->set_text(pEntry->GetAuthorField(AUTH_FIELD_IDENTIFIER));
1532     m_xAuthorFI->set_label(pEntry->GetAuthorField(AUTH_FIELD_AUTHOR));
1533     m_xTitleFI->set_label(pEntry->GetAuthorField(AUTH_FIELD_TITLE));
1534 }
1535
1536 void SwAuthorMarkPane::Activate()
1537 {
1538     m_xActionBT->set_sensitive(!m_pSh->HasReadonlySel());
1539 }
1540
1541 namespace
1542 {
1543     const TranslateId STR_AUTH_FIELD_ARY[] =
1544     {
1545         STR_AUTH_FIELD_IDENTIFIER,
1546         STR_AUTH_FIELD_AUTHORITY_TYPE,
1547         STR_AUTH_FIELD_ADDRESS,
1548         STR_AUTH_FIELD_ANNOTE,
1549         STR_AUTH_FIELD_AUTHOR,
1550         STR_AUTH_FIELD_BOOKTITLE,
1551         STR_AUTH_FIELD_CHAPTER,
1552         STR_AUTH_FIELD_EDITION,
1553         STR_AUTH_FIELD_EDITOR,
1554         STR_AUTH_FIELD_HOWPUBLISHED,
1555         STR_AUTH_FIELD_INSTITUTION,
1556         STR_AUTH_FIELD_JOURNAL,
1557         STR_AUTH_FIELD_MONTH,
1558         STR_AUTH_FIELD_NOTE,
1559         STR_AUTH_FIELD_NUMBER,
1560         STR_AUTH_FIELD_ORGANIZATIONS,
1561         STR_AUTH_FIELD_PAGES,
1562         STR_AUTH_FIELD_PUBLISHER,
1563         STR_AUTH_FIELD_SCHOOL,
1564         STR_AUTH_FIELD_SERIES,
1565         STR_AUTH_FIELD_TITLE,
1566         STR_AUTH_FIELD_TYPE,
1567         STR_AUTH_FIELD_VOLUME,
1568         STR_AUTH_FIELD_YEAR,
1569         STR_AUTH_FIELD_URL,
1570         STR_AUTH_FIELD_CUSTOM1,
1571         STR_AUTH_FIELD_CUSTOM2,
1572         STR_AUTH_FIELD_CUSTOM3,
1573         STR_AUTH_FIELD_CUSTOM4,
1574         STR_AUTH_FIELD_CUSTOM5,
1575         STR_AUTH_FIELD_ISBN,
1576         STR_AUTH_FIELD_LOCAL_URL,
1577         STR_AUTH_FIELD_TARGET_TYPE,
1578         STR_AUTH_FIELD_TARGET_URL,
1579     };
1580 }
1581
1582 SwCreateAuthEntryDlg_Impl::SwCreateAuthEntryDlg_Impl(weld::Window* pParent,
1583         const OUString pFields[],
1584         SwWrtShell& rSh,
1585         bool bNewEntry,
1586         bool bCreate)
1587     : GenericDialogController(pParent, "modules/swriter/ui/createauthorentry.ui", "CreateAuthorEntryDialog")
1588     , m_rWrtSh(rSh)
1589     , m_bNewEntryMode(bNewEntry)
1590     , m_bNameAllowed(true)
1591     , m_xOKBT(m_xBuilder->weld_button("ok"))
1592     , m_xBox(m_xBuilder->weld_container("box"))
1593     , m_xLeft(m_xBuilder->weld_container("leftgrid"))
1594     , m_xRight(m_xBuilder->weld_container("rightgrid"))
1595     , m_pTargetURLField(nullptr)
1596 {
1597     bool bLeft = true;
1598     sal_Int32 nLeftRow(0), nRightRow(0);
1599     for(int nIndex = 0; nIndex < AUTH_FIELD_END; nIndex++)
1600     {
1601         //m_xBox parent just to have some parent during setup, added contents are not directly visible under m_xBox
1602         m_aBuilders.emplace_back(Application::CreateBuilder(m_xBox.get(), "modules/swriter/ui/bibliofragment.ui"));
1603         const TextInfo aCurInfo = aTextInfoArr[nIndex];
1604
1605         m_aOrigContainers.emplace_back(m_aBuilders.back()->weld_container("biblioentry"));
1606         m_aFixedTexts.emplace_back(m_aBuilders.back()->weld_label("label"));
1607         if (bLeft)
1608             m_aOrigContainers.back()->move(m_aFixedTexts.back().get(), m_xLeft.get());
1609         else
1610             m_aOrigContainers.back()->move(m_aFixedTexts.back().get(), m_xRight.get());
1611         m_aFixedTexts.back()->set_grid_left_attach(0);
1612         m_aFixedTexts.back()->set_grid_top_attach(bLeft ? nLeftRow : nRightRow);
1613         m_aFixedTexts.back()->set_label(SwResId(STR_AUTH_FIELD_ARY[aCurInfo.nToxField]));
1614         m_aFixedTexts.back()->show();
1615         if( AUTH_FIELD_AUTHORITY_TYPE == aCurInfo.nToxField )
1616         {
1617             m_xTypeListBox = m_aBuilders.back()->weld_combo_box("listbox");
1618             if (bLeft)
1619                 m_aOrigContainers.back()->move(m_xTypeListBox.get(), m_xLeft.get());
1620             else
1621                 m_aOrigContainers.back()->move(m_xTypeListBox.get(), m_xRight.get());
1622
1623             for (int j = 0; j < AUTH_TYPE_END; j++)
1624             {
1625                 m_xTypeListBox->append_text(
1626                     SwAuthorityFieldType::GetAuthTypeName(static_cast<ToxAuthorityType>(j)));
1627             }
1628             if(!pFields[aCurInfo.nToxField].isEmpty())
1629             {
1630                 m_xTypeListBox->set_active(pFields[aCurInfo.nToxField].toInt32());
1631             }
1632             m_xTypeListBox->set_grid_left_attach(1);
1633             m_xTypeListBox->set_grid_top_attach(bLeft ? nLeftRow : nRightRow);
1634             m_xTypeListBox->set_hexpand(true);
1635             m_xTypeListBox->show();
1636             m_xTypeListBox->connect_changed(LINK(this, SwCreateAuthEntryDlg_Impl, EnableHdl));
1637             m_xTypeListBox->set_help_id(aCurInfo.pHelpId);
1638             m_aFixedTexts.back()->set_mnemonic_widget(m_xTypeListBox.get());
1639         }
1640         else if(AUTH_FIELD_IDENTIFIER == aCurInfo.nToxField && !m_bNewEntryMode)
1641         {
1642             m_xIdentifierBox = m_aBuilders.back()->weld_combo_box("combobox");
1643             if (bLeft)
1644                 m_aOrigContainers.back()->move(m_xIdentifierBox.get(), m_xLeft.get());
1645             else
1646                 m_aOrigContainers.back()->move(m_xIdentifierBox.get(), m_xRight.get());
1647
1648             m_xIdentifierBox->connect_changed(LINK(this,
1649                                     SwCreateAuthEntryDlg_Impl, IdentifierHdl));
1650
1651             const SwAuthorityFieldType* pFType = static_cast<const SwAuthorityFieldType*>(
1652                                         rSh.GetFieldType(SwFieldIds::TableOfAuthorities, OUString()));
1653             if(pFType)
1654             {
1655                 std::vector<OUString> aIds;
1656                 pFType->GetAllEntryIdentifiers( aIds );
1657                 for (const OUString& a : aIds)
1658                     m_xIdentifierBox->append_text(a);
1659             }
1660             m_xIdentifierBox->set_entry_text(pFields[aCurInfo.nToxField]);
1661             m_xIdentifierBox->set_grid_left_attach(1);
1662             m_xIdentifierBox->set_grid_top_attach(bLeft ? nLeftRow : nRightRow);
1663             m_xIdentifierBox->set_hexpand(true);
1664             m_xIdentifierBox->show();
1665             m_xIdentifierBox->set_help_id(aCurInfo.pHelpId);
1666             m_aFixedTexts.back()->set_mnemonic_widget(m_xIdentifierBox.get());
1667         }
1668         else if (AUTH_FIELD_TARGET_TYPE == aCurInfo.nToxField)
1669         {
1670             m_xTargetTypeListBox = m_aBuilders.back()->weld_combo_box("listbox-target-type");
1671             if (bLeft)
1672                 m_aOrigContainers.back()->move(m_xTargetTypeListBox.get(), m_xLeft.get());
1673             else
1674                 m_aOrigContainers.back()->move(m_xTargetTypeListBox.get(), m_xRight.get());
1675
1676             if(!pFields[aCurInfo.nToxField].isEmpty())
1677             {
1678                 m_xTargetTypeListBox->set_active(pFields[aCurInfo.nToxField].toInt32());
1679             }
1680             else if(m_bNewEntryMode)
1681             {
1682                 // For new documents, set value to "BibliographyTableRow"
1683                 m_xTargetTypeListBox->set_active(SwAuthorityField::TargetType::BibliographyTableRow);
1684             }
1685             m_xTargetTypeListBox->set_grid_left_attach(1);
1686             m_xTargetTypeListBox->set_grid_top_attach(bLeft ? nLeftRow : nRightRow);
1687             m_xTargetTypeListBox->set_hexpand(true);
1688             m_xTargetTypeListBox->show();
1689             m_xTargetTypeListBox->connect_changed(LINK(this, SwCreateAuthEntryDlg_Impl, TargetTypeHdl));
1690             m_xTargetTypeListBox->set_help_id(aCurInfo.pHelpId);
1691             m_aFixedTexts.back()->set_mnemonic_widget(m_xTargetTypeListBox.get());
1692         }
1693         else
1694         {
1695             m_pBoxes[nIndex] = m_aBuilders.back()->weld_box("vbox");
1696             m_pEdits[nIndex] = m_aBuilders.back()->weld_entry("entry");
1697
1698             if (AUTH_FIELD_TARGET_URL == aCurInfo.nToxField)
1699             {
1700                 m_pTargetURLField = m_pEdits[nIndex].get();
1701                 assert(m_xTargetTypeListBox);
1702                 m_pTargetURLField->set_sensitive(
1703                     m_xTargetTypeListBox->get_active() == SwAuthorityField::TargetType::UseTargetURL);
1704             }
1705
1706             if (bLeft)
1707                 m_aOrigContainers.back()->move(m_pBoxes[nIndex].get(), m_xLeft.get());
1708             else
1709                 m_aOrigContainers.back()->move(m_pBoxes[nIndex].get(), m_xRight.get());
1710
1711             m_pBoxes[nIndex]->set_grid_left_attach(1);
1712             m_pBoxes[nIndex]->set_grid_top_attach(bLeft ? nLeftRow : nRightRow);
1713             m_pBoxes[nIndex]->set_hexpand(true);
1714             if (aCurInfo.nToxField == AUTH_FIELD_LOCAL_URL)
1715             {
1716                 m_xLocalBrowseButton = m_aBuilders.back()->weld_button("browse");
1717                 m_xLocalBrowseButton->connect_clicked(
1718                     LINK(this, SwCreateAuthEntryDlg_Impl, BrowseHdl));
1719                 m_xLocalPageCB = m_aBuilders.back()->weld_check_button("pagecb");
1720                 // Distinguish different instances of this for ui-testing.
1721                 m_xLocalPageCB->set_buildable_name(m_xLocalPageCB->get_buildable_name()
1722                                                    + "-local-visible");
1723                 m_xLocalPageSB = m_aBuilders.back()->weld_spin_button("pagesb");
1724             }
1725
1726             // Now that both pEdits[nIndex] and m_xPageSB is initialized, set their values.
1727             OUString aText = pFields[aCurInfo.nToxField];
1728             if (aCurInfo.nToxField == AUTH_FIELD_LOCAL_URL)
1729             {
1730                 OUString aUrl;
1731                 int nPageNumber;
1732                 if (SplitUrlAndPage(aText, aUrl, nPageNumber))
1733                 {
1734                     m_pEdits[nIndex]->set_text(aUrl);
1735                     m_xLocalPageCB->set_active(true);
1736                     m_xLocalPageSB->set_sensitive(true);
1737                     m_xLocalPageSB->set_value(nPageNumber);
1738                 }
1739                 else
1740                 {
1741                     m_pEdits[nIndex]->set_text(aText);
1742                 }
1743             }
1744             else
1745             {
1746                 m_pEdits[nIndex]->set_text(aText);
1747             }
1748             m_pEdits[nIndex]->show();
1749             m_pEdits[nIndex]->set_help_id(aCurInfo.pHelpId);
1750
1751             if(AUTH_FIELD_IDENTIFIER == aCurInfo.nToxField)
1752             {
1753                 m_pEdits[nIndex]->connect_changed(LINK(this, SwCreateAuthEntryDlg_Impl, ShortNameHdl));
1754                 m_bNameAllowed = !pFields[nIndex].isEmpty();
1755                 if(!bCreate)
1756                 {
1757                     m_aFixedTexts.back()->set_sensitive(false);
1758                     m_pEdits[nIndex]->set_sensitive(false);
1759                 }
1760             }
1761             else if (aCurInfo.nToxField == AUTH_FIELD_LOCAL_URL)
1762             {
1763                 m_xLocalPageCB->show();
1764                 m_xLocalPageCB->connect_toggled(LINK(this, SwCreateAuthEntryDlg_Impl, PageNumHdl));
1765                 m_xLocalPageSB->show();
1766             }
1767
1768             m_aFixedTexts.back()->set_mnemonic_widget(m_pEdits[nIndex].get());
1769         }
1770         if(bLeft)
1771             ++nLeftRow;
1772         else
1773             ++nRightRow;
1774         bLeft = !bLeft;
1775     }
1776     assert(m_xTypeListBox && "this will exist after the loop");
1777     EnableHdl(*m_xTypeListBox);
1778 }
1779
1780 OUString  SwCreateAuthEntryDlg_Impl::GetEntryText(ToxAuthorityField eField) const
1781 {
1782     if( AUTH_FIELD_AUTHORITY_TYPE == eField )
1783     {
1784         assert(m_xTypeListBox && "No ListBox");
1785         return OUString::number(m_xTypeListBox->get_active());
1786     }
1787
1788     if( AUTH_FIELD_IDENTIFIER == eField && !m_bNewEntryMode)
1789     {
1790         assert(m_xIdentifierBox && "No ComboBox");
1791         return m_xIdentifierBox->get_active_text();
1792     }
1793
1794     if (AUTH_FIELD_TARGET_TYPE == eField)
1795     {
1796         assert(m_xTargetTypeListBox && "No TargetType ListBox");
1797         return OUString::number(m_xTargetTypeListBox->get_active());
1798     }
1799
1800     for(int nIndex = 0; nIndex < AUTH_FIELD_END; nIndex++)
1801     {
1802         const TextInfo aCurInfo = aTextInfoArr[nIndex];
1803         if(aCurInfo.nToxField == eField)
1804         {
1805             if (aCurInfo.nToxField == AUTH_FIELD_LOCAL_URL)
1806             {
1807                 return MergeUrlAndPage(m_pEdits[nIndex]->get_text(), m_xLocalPageSB);
1808             }
1809             else
1810             {
1811                 return m_pEdits[nIndex]->get_text();
1812             }
1813         }
1814     }
1815
1816     return OUString();
1817 }
1818
1819 IMPL_LINK(SwCreateAuthEntryDlg_Impl, IdentifierHdl, weld::ComboBox&, rBox, void)
1820 {
1821     const SwAuthorityFieldType* pFType = static_cast<const SwAuthorityFieldType*>(
1822                                 m_rWrtSh.GetFieldType(SwFieldIds::TableOfAuthorities, OUString()));
1823     if(!pFType)
1824         return;
1825
1826     const SwAuthEntry* pEntry = pFType->GetEntryByIdentifier(
1827                                                     rBox.get_active_text());
1828     if(!pEntry)
1829         return;
1830
1831     for(int i = 0; i < AUTH_FIELD_END; i++)
1832     {
1833         const TextInfo aCurInfo = aTextInfoArr[i];
1834         if(AUTH_FIELD_IDENTIFIER == aCurInfo.nToxField)
1835             continue;
1836         if(AUTH_FIELD_AUTHORITY_TYPE == aCurInfo.nToxField)
1837             m_xTypeListBox->set_active_text(
1838                         pEntry->GetAuthorField(aCurInfo.nToxField));
1839         else
1840             m_pEdits[i]->set_text(
1841                         pEntry->GetAuthorField(aCurInfo.nToxField));
1842     }
1843 }
1844
1845 IMPL_LINK(SwCreateAuthEntryDlg_Impl, ShortNameHdl, weld::Entry&, rEdit, void)
1846 {
1847     if (m_aShortNameCheckLink.IsSet())
1848     {
1849         bool bEnable = m_aShortNameCheckLink.Call(rEdit);
1850         m_bNameAllowed |= bEnable;
1851         m_xOKBT->set_sensitive(m_xTypeListBox->get_active() != -1 && bEnable);
1852     }
1853 }
1854
1855 IMPL_LINK(SwCreateAuthEntryDlg_Impl, EnableHdl, weld::ComboBox&, rBox, void)
1856 {
1857     m_xOKBT->set_sensitive(m_bNameAllowed && rBox.get_active() != -1);
1858     m_xLocalBrowseButton->show();
1859 };
1860
1861 IMPL_LINK(SwCreateAuthEntryDlg_Impl, TargetTypeHdl, weld::ComboBox&, rBox, void)
1862 {
1863     assert(m_pTargetURLField);
1864     m_pTargetURLField->set_sensitive(rBox.get_active() == SwAuthorityField::TargetType::UseTargetURL);
1865 }
1866
1867 IMPL_LINK(SwCreateAuthEntryDlg_Impl, BrowseHdl, weld::Button&, rButton, void)
1868 {
1869     sfx2::FileDialogHelper aFileDlg(ui::dialogs::TemplateDescription::FILEOPEN_SIMPLE,
1870                                     FileDialogFlags::NONE, getDialog());
1871     OUString aPath;
1872     if (&rButton == m_xLocalBrowseButton.get())
1873     {
1874         aPath = GetEntryText(AUTH_FIELD_LOCAL_URL);
1875     }
1876     if (!aPath.isEmpty())
1877     {
1878         aFileDlg.SetDisplayDirectory(aPath);
1879     }
1880     else
1881     {
1882         OUString aBaseURL = m_rWrtSh.GetDoc()->GetDocShell()->getDocumentBaseURL();
1883         if (!aBaseURL.isEmpty())
1884         {
1885             aFileDlg.SetDisplayDirectory(aBaseURL);
1886         }
1887     }
1888
1889     if (aFileDlg.Execute() != ERRCODE_NONE)
1890     {
1891         return;
1892     }
1893
1894     aPath = aFileDlg.GetPath();
1895
1896     for (int nIndex = 0; nIndex < AUTH_FIELD_END; nIndex++)
1897     {
1898         const TextInfo& rCurInfo = aTextInfoArr[nIndex];
1899         if (rCurInfo.nToxField == AUTH_FIELD_LOCAL_URL && &rButton == m_xLocalBrowseButton.get())
1900         {
1901             m_pEdits[nIndex]->set_text(aPath);
1902             break;
1903         }
1904     }
1905 };
1906
1907 IMPL_LINK(SwCreateAuthEntryDlg_Impl, PageNumHdl, weld::Toggleable&, rPageCB, void)
1908 {
1909     if (rPageCB.get_active())
1910     {
1911         m_xLocalPageSB->set_sensitive(true);
1912         m_xLocalPageSB->set_value(1);
1913     }
1914     else
1915     {
1916         m_xLocalPageSB->set_sensitive(false);
1917     }
1918 }
1919
1920 SwAuthMarkFloatDlg::SwAuthMarkFloatDlg(SfxBindings* _pBindings,
1921                                        SfxChildWindow* pChild,
1922                                        weld::Window *pParent,
1923                                        SfxChildWinInfo const * pInfo,
1924                                        bool bNew)
1925     : SfxModelessDialogController(_pBindings, pChild, pParent,
1926         "modules/swriter/ui/bibliographyentry.ui", "BibliographyEntryDialog")
1927     , m_aContent(*this, *m_xBuilder, bNew)
1928 {
1929     Initialize(pInfo);
1930     if (SwWrtShell* pWrtShell = ::GetActiveWrtShell())
1931         m_aContent.ReInitDlg(*pWrtShell);
1932 }
1933
1934 void SwAuthMarkFloatDlg::Activate()
1935 {
1936     SfxModelessDialogController::Activate();
1937     m_aContent.Activate();
1938 }
1939
1940 void SwAuthMarkFloatDlg::ReInitDlg(SwWrtShell& rWrtShell)
1941 {
1942     m_aContent.ReInitDlg( rWrtShell );
1943 }
1944
1945 SwAuthMarkModalDlg::SwAuthMarkModalDlg(weld::Window *pParent, SwWrtShell& rSh)
1946     : SfxDialogController(pParent, "modules/swriter/ui/bibliographyentry.ui",
1947                           "BibliographyEntryDialog")
1948     , m_aContent(*this, *m_xBuilder, false)
1949 {
1950     m_aContent.ReInitDlg(rSh);
1951 }
1952
1953 short SwAuthMarkModalDlg::run()
1954 {
1955     short ret = SfxDialogController::run();
1956     if (ret == RET_OK)
1957         Apply();
1958     return ret;
1959 }
1960
1961 void SwAuthMarkModalDlg::Apply()
1962 {
1963     m_aContent.InsertHdl(*m_aContent.m_xActionBT);
1964 }
1965
1966 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */