sc/source/ui/formdlg/dwfunctr.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 <comphelper/string.hxx>
  21 #include <editeng/editview.hxx>
  22 #include <sfx2/viewsh.hxx>
  23 #include <formula/funcvarargs.h>
  24 #include <unotools/charclass.hxx>
  25 #include <unotools/textsearch.hxx>
  26 #include <vcl/svapp.hxx>
  27 #include <vcl/help.hxx>
  28
  29 #include <global.hxx>
  30 #include <scmod.hxx>
  31 #include <inputhdl.hxx>
  32 #include <tabvwsh.hxx>
  33 #include <funcdesc.hxx>
  34 #include <compiler.hxx>
  35
  36 #include <dwfunctr.hxx>
  37
  38 /*************************************************************************
  39 #*  Member:     ScFunctionWin
  40 #*------------------------------------------------------------------------
  41 #*
  42 #*  Class:      ScFunctionWin
  43 #*
  44 #*  Function:   Constructor of ScFunctionWin Class
  45 #*
  46 #*  Input:      Sfx - links, window, resource
  47 #*
  48 #*  Output:     ---
  49 #*
  50 #************************************************************************/
  51
  52 ScFunctionWin::ScFunctionWin(weld::Widget* pParent)
  53     : PanelLayout(pParent, u"FunctionPanel"_ustr, u"modules/scalc/ui/functionpanel.ui"_ustr)
  54     , xCatBox(m_xBuilder->weld_combo_box(u"category"_ustr))
  55     , xFuncList(m_xBuilder->weld_tree_view(u"funclist"_ustr))
  56     , xScratchIter(xFuncList->make_iterator())
  57     , xInsertButton(m_xBuilder->weld_button(u"insert"_ustr))
  58     , xHelpButton(m_xBuilder->weld_button(u"help"_ustr))
  59     , xSimilaritySearch(m_xBuilder->weld_check_button(u"similaritysearch"_ustr))
  60     , xFiFuncDesc(m_xBuilder->weld_text_view(u"funcdesc"_ustr))
  61     , m_xSearchString(m_xBuilder->weld_entry(u"search"_ustr))
  62     , xConfigListener(new comphelper::ConfigurationListener(u"/org.openoffice.Office.Calc/Formula/Syntax"_ustr))
  63     , xConfigChange(std::make_unique<EnglishFunctionNameChange>(xConfigListener, this))
  64     , pFuncDesc(nullptr)
  65 {
  66     InitLRUList();
  67
  68     nArgs=0;
  69     m_aListHelpId = xFuncList->get_help_id();
  70     m_aSearchHelpId = m_xSearchString->get_help_id();
  71
  72     // Description box has a height of 8 lines of text
  73     xFiFuncDesc->set_size_request(-1, 8 * xFiFuncDesc->get_text_height());
  74
  75     m_xSearchString->connect_changed(LINK(this, ScFunctionWin, ModifyHdl));
  76     m_xSearchString->connect_key_press(LINK(this, ScFunctionWin, KeyInputHdl));
  77
  78     xCatBox->connect_changed(LINK( this, ScFunctionWin, SelComboHdl));
  79     xFuncList->connect_selection_changed(LINK(this, ScFunctionWin, SelTreeHdl));
  80
  81     xFuncList->connect_row_activated(LINK( this, ScFunctionWin, SetRowActivatedHdl));
  82     xInsertButton->connect_clicked(LINK( this, ScFunctionWin, SetSelectionClickHdl));
  83     xHelpButton->connect_clicked(LINK( this, ScFunctionWin, SetHelpClickHdl));
  84     xSimilaritySearch->connect_toggled(LINK(this, ScFunctionWin, SetSimilarityToggleHdl));
  85
  86     xCatBox->set_active(0);
  87
  88     SelComboHdl(*xCatBox);
  89 }
  90
  91 /*************************************************************************
  92 #*  Member:     ScFunctionWin
  93 #*------------------------------------------------------------------------
  94 #*
  95 #*  Class:      ScFunctionWin
  96 #*
  97 #*  Function:   Destructor of ScFunctionWin Class
  98 #*
  99 #*  Input:      ---
 100 #*
 101 #*  Output:     ---
 102 #*
 103 #************************************************************************/
 104
 105 ScFunctionWin::~ScFunctionWin()
 106 {
 107     xConfigChange.reset();
 108     xConfigListener->dispose();
 109     xConfigListener.clear();
 110
 111     xCatBox.reset();
 112     xFuncList.reset();
 113     xInsertButton.reset();
 114     xHelpButton.reset();
 115     xSimilaritySearch.reset();
 116     xFiFuncDesc.reset();
 117 }
 118
 119 /*************************************************************************
 120 #*  Member:     InitLRUList
 121 #*------------------------------------------------------------------------
 122 #*
 123 #*  Class:      ScFunctionWin
 124 #*
 125 #*  Function:   Updates the list of functions depending on the set category
 126 #*
 127 #*  Input:      ---
 128 #*
 129 #*  Output:     ---
 130 #*
 131 #************************************************************************/
 132
 133 void ScFunctionWin::InitLRUList()
 134 {
 135     ScFunctionMgr* pFuncMgr = ScGlobal::GetStarCalcFunctionMgr();
 136     pFuncMgr->fillLastRecentlyUsedFunctions(aLRUList);
 137
 138     sal_Int32 nSelPos  = xCatBox->get_active();
 139
 140     if (nSelPos == 0)
 141         UpdateFunctionList(u""_ustr);
 142 }
 143
 144
 145 /*************************************************************************
 146 #*  Member:     FillCategoriesMap
 147 #*------------------------------------------------------------------------
 148 #*
 149 #*  Class:      ScFunctionWin
 150 #*
 151 #*  Function:   Fills the categories map.
 152 #*
 153 #*  Input:      ---
 154 #*
 155 #*  Output:     ---
 156 #*
 157 #************************************************************************/
 158
 159 weld::TreeIter* ScFunctionWin::FillCategoriesMap(const OUString& aCategory, bool bFill)
 160 {
 161     if (!bFill)
 162         return nullptr;
 163
 164     if (mCategories.find(aCategory) == mCategories.end())
 165     {
 166         mCategories[aCategory] = xFuncList->make_iterator();
 167         xFuncList->insert(nullptr, -1, &aCategory, nullptr, nullptr, nullptr, false,
 168             mCategories[aCategory].get());
 169     }
 170     return mCategories[aCategory].get();
 171 }
 172
 173 /*************************************************************************
 174 #*  Member:     UpdateLRUList
 175 #*------------------------------------------------------------------------
 176 #*
 177 #*  Class:      ScFunctionWin
 178 #*
 179 #*  Function:   Updates the list of last used functions.
 180 #*
 181 #*  Input:      ---
 182 #*
 183 #*  Output:     ---
 184 #*
 185 #************************************************************************/
 186
 187 void ScFunctionWin::UpdateLRUList()
 188 {
 189     if (pFuncDesc && pFuncDesc->nFIndex!=0)
 190     {
 191         ScModule::get()->InsertEntryToLRUList(pFuncDesc->nFIndex);
 192     }
 193 }
 194
 195 void ScFunctionWin::SearchFunction(const OUString& rFuncName, const OUString& rSearchString,
 196                                    const ScFuncDesc* pDesc, const bool bSimilaritySearch)
 197 {
 198     std::pair<sal_Int32, sal_Int32> score = std::make_pair(0, 0);
 199     if (bSimilaritySearch && !utl::TextSearch::SimilaritySearch(rFuncName, rSearchString, score))
 200         return;
 201     if (!bSimilaritySearch && rFuncName.indexOf(rSearchString) < 0
 202         && rSearchString.indexOf(rFuncName) < 0)
 203         return;
 204
 205     sFuncScores.insert(std::make_pair(score, std::make_pair(rFuncName, pDesc)));
 206 }
 207
 208 /*************************************************************************
 209 #*  Member:     SetDescription
 210 #*------------------------------------------------------------------------
 211 #*
 212 #*  Class:      ScFunctionWin
 213 #*
 214 #*  Function:
 215 #*
 216 #*  Input:      ---
 217 #*
 218 #*  Output:     ---
 219 #*
 220 #************************************************************************/
 221
 222 void ScFunctionWin::SetDescription()
 223 {
 224     xFiFuncDesc->set_text(OUString());
 225     const ScFuncDesc* pDesc =
 226              weld::fromId<const ScFuncDesc*>(xFuncList->get_selected_id());
 227     if (pDesc)
 228     {
 229         pDesc->initArgumentInfo();      // full argument info is needed
 230
 231         OUString aBuf = xFuncList->get_selected_text() +
 232             ":\n\n" +
 233             pDesc->GetParamList() +
 234             "\n\n" +
 235             *pDesc->mxFuncDesc;
 236
 237         xFiFuncDesc->set_text(aBuf);
 238
 239         // Update help ID for the selected entry
 240         const OUString sHelpId = pDesc->getHelpId();
 241         if (!sHelpId.isEmpty())
 242             xFuncList->set_help_id(pDesc->getHelpId());
 243         else
 244             xFuncList->set_help_id(m_aListHelpId);
 245     }
 246 }
 247
 248 /*************************************************************************
 249 #*  Member:     UpdateFunctionList
 250 #*------------------------------------------------------------------------
 251 #*
 252 #*  Class:      ScFunctionWin
 253 #*
 254 #*  Function:   Updates the list of functions depending on the set category
 255 #*
 256 #*  Input:      Search string used to filter the list of functions
 257 #*
 258 #*  Output:     ---
 259 #*
 260 #************************************************************************/
 261
 262 void ScFunctionWin::UpdateFunctionList(const OUString& rSearchString)
 263 {
 264     sal_Int32  nSelPos   = xCatBox->get_active();
 265     sal_Int32  nCategory = ( -1 != nSelPos )
 266                             ? (nSelPos-1) : 0;
 267
 268     xFuncList->clear();
 269     xFuncList->freeze();
 270     mCategories.clear();
 271     sFuncScores.clear();
 272
 273     bool bCollapse = nCategory == 0;
 274     bool bFilter = !rSearchString.isEmpty();
 275     if ( nSelPos > 0 )
 276     {
 277         ScFunctionMgr* pFuncMgr = ScGlobal::GetStarCalcFunctionMgr();
 278
 279         // Use the corresponding CharClass for uppercase() depending on whether
 280         // English function names are used, or localized names.
 281         const CharClass* pCharClass = (ScGlobal::GetStarCalcFunctionList()->IsEnglishFunctionNames()
 282                 ? ScCompiler::GetCharClassEnglish()
 283                 : ScCompiler::GetCharClassLocalized());
 284
 285         const OUString aSearchStr(pCharClass->uppercase(rSearchString));
 286
 287         const ScFuncDesc* pDesc = pFuncMgr->First(nCategory);
 288         while (pDesc)
 289         {
 290             const OUString aCategory(pDesc->getCategory()->getName());
 291             const OUString aFunction(pCharClass->uppercase(pDesc->getFunctionName()));
 292             const OUString aFuncDescId(weld::toId(pDesc));
 293
 294             if (bFilter)
 295                 SearchFunction(aFunction, aSearchStr, pDesc, xSimilaritySearch->get_active());
 296             else
 297             {
 298                 weld::TreeIter* pCategory = FillCategoriesMap(aCategory, bCollapse);
 299                 xFuncList->insert(pCategory, -1, &aFunction, &aFuncDescId, nullptr, nullptr,
 300                             false, xScratchIter.get());
 301             }
 302             pDesc = pFuncMgr->Next();
 303         }
 304
 305         for (const auto& func : sFuncScores)
 306         {
 307             pDesc = func.second.second;
 308             const OUString aCategory(pDesc->getCategory()->getName());
 309             const OUString aFunction(func.second.first);
 310             const OUString aFuncDescId(weld::toId(pDesc));
 311             weld::TreeIter* pCategory = FillCategoriesMap(aCategory, bCollapse);
 312
 313             xFuncList->insert(pCategory, -1, &aFunction, &aFuncDescId, nullptr, nullptr, false,
 314                               xScratchIter.get());
 315         }
 316     }
 317     else // LRU list
 318     {
 319         for (const formula::IFunctionDescription* pDesc : aLRUList)
 320         {
 321             if (pDesc)
 322             {
 323                 OUString aFunction = pDesc->getFunctionName();
 324                 OUString aFuncDescId = weld::toId(pDesc);
 325
 326                 xFuncList->insert(nullptr, -1, &aFunction, &aFuncDescId, nullptr, nullptr,
 327                         false, xScratchIter.get());
 328             }
 329         }
 330     }
 331
 332     xFuncList->thaw();
 333
 334     if (bCollapse && bFilter)
 335     {
 336         for (const auto& category : mCategories)
 337             xFuncList->expand_row(*category.second);
 338     }
 339
 340     if (xFuncList->n_children() > 0)
 341     {
 342         xFuncList->set_sensitive(true);
 343         xFuncList->select(0);
 344     }
 345     else
 346     {
 347         xFuncList->set_sensitive(false);
 348     }
 349 }
 350
 351 /*************************************************************************
 352 #*  Member:     DoEnter
 353 #*------------------------------------------------------------------------
 354 #*
 355 #*  Class:      ScFunctionWin
 356 #*
 357 #*  Function:   Save input into document. Is called after clicking the
 358 #*              Apply button or a double-click on the function list.
 359 #*
 360 #*  Input:      Boolean to know if I double-clicked/press-enter or not
 361 #*
 362 #*  Output:     ---
 363 #*
 364 #************************************************************************/
 365
 366 void ScFunctionWin::DoEnter(bool bDoubleOrEnter)
 367 {
 368     OUString aString=xFuncList->get_selected_text();
 369     const bool isCategory = mCategories.find(aString) != mCategories.end();
 370     if (isCategory && !bDoubleOrEnter)
 371         return;
 372
 373     if (isCategory)
 374     {
 375         const auto& categoryRow = *(mCategories[aString]);
 376         if (xFuncList->get_row_expanded(categoryRow))
 377             xFuncList->collapse_row(categoryRow);
 378         else
 379             xFuncList->expand_row(categoryRow);
 380         return;
 381     }
 382
 383     OUStringBuffer aArgStr;
 384     SfxViewShell* pCurSh = SfxViewShell::Current();
 385     nArgs=0;
 386
 387     if(!aString.isEmpty())
 388     {
 389         OUString aFirstArgStr;
 390         ScModule* pScMod = ScModule::get();
 391         ScTabViewShell* pViewSh = dynamic_cast<ScTabViewShell*>( pCurSh );
 392         ScInputHandler* pHdl = pScMod->GetInputHdl( pViewSh );
 393         if(!pScMod->IsEditMode())
 394         {
 395             rtl::Reference<comphelper::ConfigurationListener> xDetectDisposed(xConfigListener);
 396             pScMod->SetInputMode(SC_INPUT_TABLE);
 397             // the above call can result in us being disposed
 398             if (xDetectDisposed->isDisposed())
 399                 return;
 400             aString = "=" + xFuncList->get_selected_text();
 401             if (pHdl)
 402                 pHdl->ClearText();
 403         }
 404         const ScFuncDesc* pDesc =
 405              weld::fromId<const ScFuncDesc*>(xFuncList->get_selected_id());
 406         if (pDesc)
 407         {
 408             pFuncDesc=pDesc;
 409             UpdateLRUList();
 410             nArgs = pDesc->nArgCount;
 411             if(nArgs>0)
 412             {
 413                 // NOTE: Theoretically the first parameter could have the
 414                 // suppress flag as well, but practically it doesn't.
 415                 aFirstArgStr = pDesc->maDefArgNames[0];
 416                 aFirstArgStr = comphelper::string::strip(aFirstArgStr, ' ');
 417                 aFirstArgStr = aFirstArgStr.replaceAll(" ", "_");
 418                 aArgStr = aFirstArgStr;
 419                 if ( nArgs != VAR_ARGS && nArgs != PAIRED_VAR_ARGS )
 420                 {   // no VarArgs or Fix plus VarArgs, but not VarArgs only
 421                     sal_uInt16 nFix;
 422                     if (nArgs >= PAIRED_VAR_ARGS)
 423                         nFix = nArgs - PAIRED_VAR_ARGS + 2;
 424                     else if (nArgs >= VAR_ARGS)
 425                         nFix = nArgs - VAR_ARGS + 1;
 426                     else
 427                         nFix = nArgs;
 428                     for ( sal_uInt16 nArg = 1;
 429                             nArg < nFix && !pDesc->pDefArgFlags[nArg].bOptional; nArg++ )
 430                     {
 431                         aArgStr.append("; ");
 432                         OUString sTmp = pDesc->maDefArgNames[nArg];
 433                         sTmp = comphelper::string::strip(sTmp, ' ');
 434                         sTmp = sTmp.replaceAll(" ", "_");
 435                         aArgStr.append(sTmp);
 436                     }
 437                 }
 438             }
 439         }
 440         if (pHdl)
 441         {
 442             if (pHdl->GetEditString().isEmpty())
 443             {
 444                 aString = "=" + xFuncList->get_selected_text();
 445             }
 446             EditView *pEdView=pHdl->GetActiveView();
 447             if(pEdView!=nullptr) // @ needed because of crash during setting a name
 448             {
 449                 if(nArgs>0)
 450                 {
 451                     pHdl->InsertFunction(aString);
 452                     pEdView->InsertText(aArgStr.makeStringAndClear(),true);
 453                     ESelection  aESel=pEdView->GetSelection();
 454                     aESel.end.nIndex = aESel.start.nIndex + aFirstArgStr.getLength();
 455                     pEdView->SetSelection(aESel);
 456                     pHdl->DataChanged();
 457                 }
 458                 else
 459                 {
 460                     aString += "()";
 461                     pEdView->InsertText(aString);
 462                     pHdl->DataChanged();
 463                 }
 464             }
 465         }
 466         InitLRUList();
 467     }
 468     if ( pCurSh )
 469     {
 470         vcl::Window* pShellWnd = pCurSh->GetWindow();
 471
 472         if ( pShellWnd )
 473             pShellWnd->GrabFocus();
 474     }
 475
 476 }
 477
 478 /*************************************************************************
 479 #*  Handle:     ModifyHdl
 480 #*------------------------------------------------------------------------
 481 #*
 482 #*  Class:      ScFunctionWin
 483 #*
 484 #*  Function:   Handles changes in the search text
 485 #*
 486 #************************************************************************/
 487
 488 IMPL_LINK_NOARG(ScFunctionWin, ModifyHdl, weld::Entry&, void)
 489 {
 490     if (xCatBox->get_active() == 0)
 491     {
 492         xCatBox->set_active(1);
 493         xHelpButton->set_sensitive(false);
 494     }
 495     OUString searchStr = m_xSearchString->get_text();
 496     UpdateFunctionList(searchStr);
 497     SetDescription();
 498 }
 499
 500 /*************************************************************************
 501 #*  Handle:     KeyInputHdl
 502 #*------------------------------------------------------------------------
 503 #*
 504 #*  Class:      ScFunctionWin
 505 #*
 506 #*  Function:   Processes key inputs when the search entry has focus
 507 #*
 508 #************************************************************************/
 509
 510 IMPL_LINK(ScFunctionWin, KeyInputHdl, const KeyEvent&, rEvent, bool)
 511 {
 512     bool bHandled = false;
 513
 514     switch (rEvent.GetKeyCode().GetCode())
 515     {
 516     case KEY_RETURN:
 517         {
 518             DoEnter(true);
 519             bHandled = true;
 520         }
 521         break;
 522     case KEY_DOWN:
 523         {
 524             int nNewIndex = std::min(xFuncList->get_selected_index() + 1, xFuncList->n_children() - 1);
 525             xFuncList->select(nNewIndex);
 526             SetDescription();
 527             bHandled = true;
 528         }
 529         break;
 530     case KEY_UP:
 531         {
 532             int nNewIndex = std::max(xFuncList->get_selected_index() - 1, 0);
 533             xFuncList->select(nNewIndex);
 534             SetDescription();
 535             bHandled = true;
 536         }
 537         break;
 538     case KEY_ESCAPE:
 539         {
 540             // Escape in an empty search field should move focus to the document,
 541             // adhering to Sidebar guidelines
 542             if (m_xSearchString->get_text().isEmpty())
 543             {
 544                 if (SfxViewShell* pCurSh = SfxViewShell::Current())
 545                 {
 546                     vcl::Window* pShellWnd = pCurSh->GetWindow();
 547
 548                     if (pShellWnd)
 549                         pShellWnd->GrabFocusToDocument();
 550                 }
 551                 bHandled = true;
 552                 break;
 553             }
 554             m_xSearchString->set_text(u""_ustr);
 555             UpdateFunctionList(u""_ustr);
 556             bHandled = true;
 557         }
 558         break;
 559     case KEY_F1:
 560         {
 561             const ScFuncDesc* pDesc = weld::fromId<const ScFuncDesc*>(xFuncList->get_selected_id());
 562             OUString sHelpId;
 563             if (pDesc)
 564                 sHelpId = pDesc->getHelpId();
 565
 566             if (!sHelpId.isEmpty())
 567                 m_xSearchString->set_help_id(sHelpId);
 568             else
 569                 m_xSearchString->set_help_id(m_aSearchHelpId);
 570             bHandled = false;
 571         }
 572         break;
 573     }
 574
 575     return bHandled;
 576 }
 577
 578 /*************************************************************************
 579 #*  Handle:     SelComboHdl
 580 #*------------------------------------------------------------------------
 581 #*
 582 #*  Class:      ScFunctionWin
 583 #*
 584 #*  Function:   A change of the category will update the list of functions.
 585 #*
 586 #*  Input:      ---
 587 #*
 588 #*  Output:     ---
 589 #*
 590 #************************************************************************/
 591
 592 IMPL_LINK_NOARG(ScFunctionWin, SelComboHdl, weld::ComboBox&, void)
 593 {
 594     if (xCatBox->get_active() == 0)
 595         m_xSearchString->set_text(u""_ustr);
 596     xHelpButton->set_sensitive(xCatBox->get_active() != 1);
 597     OUString searchStr = m_xSearchString->get_text();
 598     UpdateFunctionList(searchStr);
 599     SetDescription();
 600 }
 601
 602 IMPL_LINK_NOARG(ScFunctionWin, SelTreeHdl, weld::TreeView&, void)
 603 {
 604     bool bSensitivity = weld::fromId<const ScFuncDesc*>(xFuncList->get_selected_id());
 605     xHelpButton->set_sensitive(bSensitivity);
 606     SetDescription();
 607 }
 608
 609 /*************************************************************************
 610 #*  Handle:     SetSelectionClickHdl
 611 #*------------------------------------------------------------------------
 612 #*
 613 #*  Class:      ScFunctionWin
 614 #*
 615 #*  Function:   A change of the category will update the list of functions.
 616 #*
 617 #*  Input:      ---
 618 #*
 619 #*  Output:     ---
 620 #*
 621 #************************************************************************/
 622
 623 IMPL_LINK_NOARG( ScFunctionWin, SetSelectionClickHdl, weld::Button&, void )
 624 {
 625     DoEnter();          // saves the input
 626 }
 627
 628 /*************************************************************************
 629 #*  Handle:     SetHelpClickHdl
 630 #*------------------------------------------------------------------------
 631 #*
 632 #*  Class:      ScFunctionWin
 633 #*
 634 #*  Function:   Get selected function's official help.
 635 #*
 636 #*  Input:      ---
 637 #*
 638 #*  Output:     ---
 639 #*
 640 #************************************************************************/
 641
 642 IMPL_LINK_NOARG( ScFunctionWin, SetHelpClickHdl, weld::Button&, void )
 643 {
 644     if (const auto pDesc = weld::fromId<const ScFuncDesc*>(xFuncList->get_selected_id()))
 645     {
 646         if (Help* pHelp = Application::GetHelp())
 647         {
 648             const OUString sHelpId = pDesc->getHelpId();
 649             if (!sHelpId.isEmpty())
 650             {
 651                 pHelp->Start(sHelpId);
 652             }
 653         }
 654     }
 655 }
 656
 657 IMPL_LINK_NOARG(ScFunctionWin, SetSimilarityToggleHdl, weld::Toggleable&, void)
 658 {
 659     OUString searchStr = m_xSearchString->get_text();
 660     UpdateFunctionList(searchStr);
 661     SetDescription();
 662 }
 663
 664 IMPL_LINK_NOARG( ScFunctionWin, SetRowActivatedHdl, weld::TreeView&, bool )
 665 {
 666     DoEnter(true);      // saves the input
 667     return true;
 668 }
 669
 670 void EnglishFunctionNameChange::setProperty(const css::uno::Any &rProperty)
 671 {
 672     ConfigurationListenerProperty::setProperty(rProperty);
 673     m_pFunctionWin->InitLRUList();
 674     m_pFunctionWin->UpdateFunctionList(u""_ustr);
 675 }
 676
 677 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */