svx/source/tbxctrls/tbunosearchcontrollers.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 <sal/config.h>
  21
  22 #include <map>
  23 #include <utility>
  24 #include <vector>
  25
  26 #include <config_feature_desktop.h>
  27 #include <officecfg/Office/Common.hxx>
  28
  29 #include <svx/strings.hrc>
  30 #include <svx/dialmgr.hxx>
  31
  32 #include <comphelper/propertysequence.hxx>
  33 #include <cppuhelper/queryinterface.hxx>
  34 #include <cppuhelper/supportsservice.hxx>
  35 #include <cppuhelper/weak.hxx>
  36 #include <com/sun/star/beans/PropertyValue.hpp>
  37 #include <com/sun/star/beans/XPropertySet.hpp>
  38 #include <com/sun/star/frame/DispatchDescriptor.hpp>
  39 #include <com/sun/star/frame/XDispatch.hpp>
  40 #include <com/sun/star/frame/XDispatchProvider.hpp>
  41 #include <com/sun/star/frame/XLayoutManager.hpp>
  42 #include <com/sun/star/frame/XStatusListener.hpp>
  43 #include <com/sun/star/lang/XInitialization.hpp>
  44 #include <com/sun/star/lang/XServiceInfo.hpp>
  45 #include <com/sun/star/text/XTextRange.hpp>
  46 #include <com/sun/star/text/XTextViewCursorSupplier.hpp>
  47 #include <com/sun/star/ui/XUIElement.hpp>
  48 #include <com/sun/star/util/URL.hpp>
  49 #include <com/sun/star/util/URLTransformer.hpp>
  50 #include <com/sun/star/util/SearchAlgorithms.hpp>
  51 #include <com/sun/star/util/SearchAlgorithms2.hpp>
  52
  53 #include <vcl/InterimItemWindow.hxx>
  54 #include <svl/ctloptions.hxx>
  55 #include <svl/srchitem.hxx>
  56 #include <svtools/acceleratorexecute.hxx>
  57 #include <svtools/toolboxcontroller.hxx>
  58 #include <toolkit/helper/vclunohelper.hxx>
  59 #include <vcl/toolbox.hxx>
  60 #include <vcl/svapp.hxx>
  61 #include <svx/labelitemwindow.hxx>
  62 #include <svx/srchdlg.hxx>
  63 #include <vcl/event.hxx>
  64
  65 #include <findtextfield.hxx>
  66
  67 using namespace css;
  68
  69 namespace {
  70
  71 constexpr OUString COMMAND_FINDTEXT = u".uno:FindText"_ustr;
  72 constexpr OUString COMMAND_DOWNSEARCH = u".uno:DownSearch"_ustr;
  73 constexpr OUString COMMAND_UPSEARCH = u".uno:UpSearch"_ustr;
  74 constexpr OUStringLiteral COMMAND_FINDALL = u".uno:FindAll";
  75 constexpr OUString COMMAND_MATCHCASE = u".uno:MatchCase"_ustr;
  76 constexpr OUString COMMAND_SEARCHFORMATTED = u".uno:SearchFormattedDisplayString"_ustr;
  77
  78 class CheckButtonItemWindow final : public InterimItemWindow
  79 {
  80 public:
  81     CheckButtonItemWindow(vcl::Window* pParent, const OUString& rLabel)
  82         : InterimItemWindow(pParent, "svx/ui/checkbuttonbox.ui", "CheckButtonBox")
  83         , m_xWidget(m_xBuilder->weld_check_button("checkbutton"))
  84     {
  85         InitControlBase(m_xWidget.get());
  86
  87         m_xWidget->connect_key_press(LINK(this, CheckButtonItemWindow, KeyInputHdl));
  88         m_xWidget->set_label(rLabel);
  89         SetSizePixel(m_xWidget->get_preferred_size());
  90     }
  91
  92     bool get_active() const
  93     {
  94         return m_xWidget->get_active();
  95     }
  96
  97     virtual void dispose() override
  98     {
  99         m_xWidget.reset();
 100         InterimItemWindow::dispose();
 101     }
 102
 103     virtual ~CheckButtonItemWindow() override
 104     {
 105         disposeOnce();
 106     }
 107
 108 private:
 109     std::unique_ptr<weld::CheckButton> m_xWidget;
 110
 111     DECL_LINK(KeyInputHdl, const KeyEvent&, bool);
 112 };
 113
 114 IMPL_LINK(CheckButtonItemWindow, KeyInputHdl, const KeyEvent&, rKeyEvent, bool)
 115 {
 116     return ChildKeyInput(rKeyEvent);
 117 }
 118
 119 void impl_executeSearch( const css::uno::Reference< css::uno::XComponentContext >& rxContext,
 120                          const css::uno::Reference< css::frame::XFrame >& xFrame,
 121                          const ToolBox* pToolBox,
 122                          const bool aSearchBackwards,
 123                          const bool aFindAll = false )
 124 {
 125     css::uno::Reference< css::util::XURLTransformer > xURLTransformer( css::util::URLTransformer::create( rxContext ) );
 126     css::util::URL aURL;
 127     aURL.Complete = ".uno:ExecuteSearch";
 128     xURLTransformer->parseStrict(aURL);
 129
 130     OUString sFindText;
 131     bool aMatchCase = false;
 132     bool bSearchFormatted = false;
 133     if ( pToolBox )
 134     {
 135         ToolBox::ImplToolItems::size_type nItemCount = pToolBox->GetItemCount();
 136         for ( ToolBox::ImplToolItems::size_type i=0; i<nItemCount; ++i )
 137         {
 138             ToolBoxItemId id = pToolBox->GetItemId(i);
 139             OUString sItemCommand = pToolBox->GetItemCommand(id);
 140             if ( sItemCommand == COMMAND_FINDTEXT )
 141             {
 142                 FindTextFieldControl* pItemWin = static_cast<FindTextFieldControl*>(pToolBox->GetItemWindow(id));
 143                 if (pItemWin)
 144                 {
 145                     sFindText = pItemWin->get_active_text();
 146                     if (aFindAll && !pItemWin->ControlHasFocus())
 147                         pItemWin->GetFocus();
 148                 }
 149             } else if ( sItemCommand == COMMAND_MATCHCASE )
 150             {
 151                 CheckButtonItemWindow* pItemWin = static_cast<CheckButtonItemWindow*>(pToolBox->GetItemWindow(id));
 152                 if (pItemWin)
 153                     aMatchCase = pItemWin->get_active();
 154             } else if ( sItemCommand == COMMAND_SEARCHFORMATTED )
 155             {
 156                 CheckButtonItemWindow* pItemWin = static_cast<CheckButtonItemWindow*>(pToolBox->GetItemWindow(id));
 157                 if (pItemWin)
 158                     bSearchFormatted = pItemWin->get_active();
 159             }
 160         }
 161     }
 162
 163     TransliterationFlags nFlags = TransliterationFlags::NONE;
 164     if (!aMatchCase)
 165         nFlags |= TransliterationFlags::IGNORE_CASE;
 166     if (SvtCTLOptions::IsCTLFontEnabled())
 167         nFlags |= TransliterationFlags::IGNORE_DIACRITICS_CTL
 168                   | TransliterationFlags::IGNORE_KASHIDA_CTL;
 169
 170     auto aArgs( comphelper::InitPropertySequence( {
 171         { "SearchItem.SearchString", css::uno::Any( sFindText ) },
 172         // Related tdf#102506: make Find Bar Ctrl+F searching by value by default
 173         { "SearchItem.CellType", css::uno::Any( sal_Int16(SvxSearchCellType::VALUE) ) },
 174         { "SearchItem.Backward", css::uno::Any( aSearchBackwards ) },
 175         { "SearchItem.SearchFlags", css::uno::Any( sal_Int32(0) ) },
 176         { "SearchItem.TransliterateFlags", css::uno::Any( static_cast<sal_Int32>(nFlags) ) },
 177         { "SearchItem.Command", css::uno::Any( static_cast<sal_Int16>(aFindAll ?SvxSearchCmd::FIND_ALL : SvxSearchCmd::FIND ) ) },
 178         { "SearchItem.AlgorithmType", css::uno::Any( sal_Int16(css::util::SearchAlgorithms_ABSOLUTE) ) },
 179         { "SearchItem.AlgorithmType2", css::uno::Any( sal_Int16(css::util::SearchAlgorithms2::ABSOLUTE) ) },
 180         { "SearchItem.SearchFormatted", css::uno::Any( bSearchFormatted ) }
 181     } ) );
 182
 183     css::uno::Reference< css::frame::XDispatchProvider > xDispatchProvider(xFrame, css::uno::UNO_QUERY);
 184     if ( xDispatchProvider.is() )
 185     {
 186         css::uno::Reference< css::frame::XDispatch > xDispatch = xDispatchProvider->queryDispatch( aURL, OUString(), 0 );
 187         if ( xDispatch.is() && !aURL.Complete.isEmpty() )
 188             xDispatch->dispatch( aURL, aArgs );
 189     }
 190 }
 191
 192 }
 193
 194 // tdf#154818 - remember last search string
 195 OUString FindTextFieldControl::m_sRememberedSearchString;
 196
 197 FindTextFieldControl::FindTextFieldControl( vcl::Window* pParent,
 198     css::uno::Reference< css::frame::XFrame > xFrame,
 199     css::uno::Reference< css::uno::XComponentContext > xContext) :
 200     InterimItemWindow(pParent, "svx/ui/findbox.ui", "FindBox"),
 201     m_nAsyncGetFocusId(nullptr),
 202     m_xWidget(m_xBuilder->weld_combo_box("find")),
 203     m_xFrame(std::move(xFrame)),
 204     m_xContext(std::move(xContext)),
 205     m_pAcc(svt::AcceleratorExecute::createAcceleratorHelper())
 206 {
 207     InitControlBase(m_xWidget.get());
 208
 209     m_xWidget->set_entry_placeholder_text(SvxResId(RID_SVXSTR_FINDBAR_FIND));
 210     m_xWidget->set_entry_completion(true, true);
 211     m_pAcc->init(m_xContext, m_xFrame);
 212
 213     m_xWidget->connect_focus_in(LINK(this, FindTextFieldControl, FocusInHdl));
 214     m_xWidget->connect_key_press(LINK(this, FindTextFieldControl, KeyInputHdl));
 215     m_xWidget->connect_entry_activate(LINK(this, FindTextFieldControl, ActivateHdl));
 216
 217     m_xWidget->set_size_request(250, -1);
 218     SetSizePixel(m_xWidget->get_preferred_size());
 219
 220     // tdf#154269 - respect FindReplaceRememberedSearches expert option
 221     m_nRememberSize = officecfg::Office::Common::Misc::FindReplaceRememberedSearches::get();
 222     if (m_nRememberSize < 1)
 223         m_nRememberSize = 1;
 224 }
 225
 226 void FindTextFieldControl::Remember_Impl(const OUString& rStr)
 227 {
 228     if (rStr.isEmpty())
 229         return;
 230
 231     // tdf#154818 - rearrange the search items
 232     const auto nPos = m_xWidget->find_text(rStr);
 233     if (nPos != -1)
 234         m_xWidget->remove(nPos);
 235     else if (m_xWidget->get_count() >= m_nRememberSize)
 236         m_xWidget->remove(m_nRememberSize - 1);
 237     m_xWidget->insert_text(0, rStr);
 238 }
 239
 240 void FindTextFieldControl::SetTextToSelected_Impl()
 241 {
 242     OUString aString;
 243
 244     try
 245     {
 246         css::uno::Reference<css::frame::XController> xController(m_xFrame->getController(), css::uno::UNO_SET_THROW);
 247         uno::Reference<text::XTextViewCursorSupplier> const xTVCS(xController, uno::UNO_QUERY);
 248         if (xTVCS.is())
 249         {
 250             uno::Reference<text::XTextViewCursor> const xTVC(xTVCS->getViewCursor());
 251             aString = xTVC->getString();
 252         }
 253         else
 254         {
 255             uno::Reference<frame::XModel> xModel(xController->getModel(), uno::UNO_SET_THROW);
 256             uno::Reference<container::XIndexAccess> xIndexAccess(xModel->getCurrentSelection(), uno::UNO_QUERY_THROW);
 257             if (xIndexAccess->getCount() > 0)
 258             {
 259                 uno::Reference<text::XTextRange> xTextRange(xIndexAccess->getByIndex(0), uno::UNO_QUERY_THROW);
 260                 aString = xTextRange->getString();
 261             }
 262         }
 263     }
 264     catch ( ... )
 265     {
 266     }
 267
 268     if ( !aString.isEmpty() )
 269     {
 270         // If something is selected in the document, prepopulate with this
 271         m_xWidget->set_entry_text(aString);
 272         m_aChangeHdl.Call(*m_xWidget);
 273     }
 274     // tdf#154818 - reuse last search string
 275     else if (!m_sRememberedSearchString.isEmpty() || get_count() > 0)
 276     {
 277         // prepopulate with last search word (fdo#84256)
 278         m_xWidget->set_entry_text(m_sRememberedSearchString.isEmpty() ? m_xWidget->get_text(0)
 279                                                                       : m_sRememberedSearchString);
 280     }
 281 }
 282
 283 IMPL_LINK(FindTextFieldControl, KeyInputHdl, const KeyEvent&, rKeyEvent, bool)
 284 {
 285     if (isDisposed())
 286         return true;
 287
 288     bool bRet = false;
 289
 290     bool bShift = rKeyEvent.GetKeyCode().IsShift();
 291     bool bMod1 = rKeyEvent.GetKeyCode().IsMod1();
 292     sal_uInt16 nCode = rKeyEvent.GetKeyCode().GetCode();
 293
 294     // Close the search bar on Escape
 295     if ( KEY_ESCAPE == nCode )
 296     {
 297         bRet = true;
 298         GrabFocusToDocument();
 299
 300         // hide the findbar
 301         css::uno::Reference< css::beans::XPropertySet > xPropSet(m_xFrame, css::uno::UNO_QUERY);
 302         if (xPropSet.is())
 303         {
 304             css::uno::Reference< css::frame::XLayoutManager > xLayoutManager;
 305             css::uno::Any aValue = xPropSet->getPropertyValue("LayoutManager");
 306             aValue >>= xLayoutManager;
 307             if (xLayoutManager.is())
 308             {
 309                 static constexpr OUString sResourceURL( u"private:resource/toolbar/findbar"_ustr );
 310                 xLayoutManager->hideElement( sResourceURL );
 311                 xLayoutManager->destroyElement( sResourceURL );
 312             }
 313         }
 314     }
 315     else
 316     {
 317         auto awtKey = svt::AcceleratorExecute::st_VCLKey2AWTKey(rKeyEvent.GetKeyCode());
 318         const OUString aCommand(m_pAcc->findCommand(awtKey));
 319
 320         // Select text in the search box when Ctrl-F pressed
 321         if ( bMod1 && nCode == KEY_F )
 322             m_xWidget->select_entry_region(0, -1);
 323         // Execute the search when Ctrl-G, F3 and Shift-RETURN pressed (in addition to ActivateHdl condition which handles bare RETURN)
 324         else if ( (bMod1 && KEY_G == nCode) || (bShift && KEY_RETURN == nCode) || (KEY_F3 == nCode) )
 325         {
 326             ActivateFind(bShift);
 327             bRet = true;
 328         }
 329         else if (aCommand == ".uno:SearchDialog")
 330             bRet = m_pAcc->execute(awtKey);
 331
 332         // find-shortcut called with focus already in find
 333         if (aCommand == "vnd.sun.star.findbar:FocusToFindbar")
 334         {
 335             m_xWidget->call_attention_to();
 336             bRet = true;
 337         }
 338     }
 339
 340     return bRet || ChildKeyInput(rKeyEvent);
 341 }
 342
 343 void FindTextFieldControl::ActivateFind(bool bShift)
 344 {
 345     // tdf#154818 - remember last search string
 346     m_sRememberedSearchString = m_xWidget->get_active_text();
 347     Remember_Impl(m_sRememberedSearchString);
 348
 349     vcl::Window* pWindow = GetParent();
 350     ToolBox* pToolBox = static_cast<ToolBox*>(pWindow);
 351
 352     impl_executeSearch(m_xContext, m_xFrame, pToolBox, bShift);
 353
 354     m_xWidget->grab_focus();
 355 }
 356
 357 // Execute the search when activated, typically due to "Return"
 358 IMPL_LINK_NOARG(FindTextFieldControl, ActivateHdl, weld::ComboBox&, bool)
 359 {
 360     if (isDisposed())
 361         return true;
 362
 363     ActivateFind(false);
 364
 365     return true;
 366 }
 367
 368 IMPL_LINK_NOARG(FindTextFieldControl, OnAsyncGetFocus, void*, void)
 369 {
 370     m_nAsyncGetFocusId = nullptr;
 371     m_xWidget->select_entry_region(0, -1);
 372 }
 373
 374 void FindTextFieldControl::FocusIn()
 375 {
 376     if (m_nAsyncGetFocusId || !m_xWidget)
 377         return;
 378
 379     // do it async to defeat entry in combobox having its own ideas about the focus
 380     m_nAsyncGetFocusId = Application::PostUserEvent(LINK(this, FindTextFieldControl, OnAsyncGetFocus));
 381
 382     GrabFocus(); // tdf#137993 ensure the toplevel vcl::Window is activated so SfxViewFrame::Current is valid
 383 }
 384
 385 IMPL_LINK_NOARG(FindTextFieldControl, FocusInHdl, weld::Widget&, void)
 386 {
 387     FocusIn();
 388 }
 389
 390 void FindTextFieldControl::dispose()
 391 {
 392     if (m_nAsyncGetFocusId)
 393     {
 394         Application::RemoveUserEvent(m_nAsyncGetFocusId);
 395         m_nAsyncGetFocusId = nullptr;
 396     }
 397     m_xWidget.reset();
 398     InterimItemWindow::dispose();
 399 }
 400
 401 FindTextFieldControl::~FindTextFieldControl()
 402 {
 403     disposeOnce();
 404 }
 405
 406 void FindTextFieldControl::connect_changed(const Link<weld::ComboBox&, void>& rLink)
 407 {
 408     m_aChangeHdl = rLink;
 409     m_xWidget->connect_changed(rLink);
 410 }
 411
 412 int FindTextFieldControl::get_count() const
 413 {
 414     return m_xWidget->get_count();
 415 }
 416
 417 OUString FindTextFieldControl::get_text(int nIndex) const
 418 {
 419     return m_xWidget->get_text(nIndex);
 420 }
 421
 422 OUString FindTextFieldControl::get_active_text() const
 423 {
 424     return m_xWidget->get_active_text();
 425 }
 426
 427 void FindTextFieldControl::append_text(const OUString& rText)
 428 {
 429     m_xWidget->append_text(rText);
 430 }
 431
 432 namespace {
 433
 434 class SearchToolbarControllersManager
 435 {
 436 public:
 437
 438     SearchToolbarControllersManager();
 439
 440     static SearchToolbarControllersManager& createControllersManager();
 441
 442     void registryController( const css::uno::Reference< css::frame::XFrame >& xFrame, const css::uno::Reference< css::frame::XStatusListener >& xStatusListener, const OUString& sCommandURL );
 443     void freeController ( const css::uno::Reference< css::frame::XFrame >& xFrame, const OUString& sCommandURL );
 444     css::uno::Reference< css::frame::XStatusListener > findController( const css::uno::Reference< css::frame::XFrame >& xFrame, const OUString& sCommandURL );
 445
 446     void saveSearchHistory(const FindTextFieldControl* m_pFindTextFieldControl);
 447     void loadSearchHistory(FindTextFieldControl* m_pFindTextFieldControl);
 448
 449 private:
 450
 451     typedef ::std::vector< css::beans::PropertyValue > SearchToolbarControllersVec;
 452     typedef ::std::map< css::uno::Reference< css::frame::XFrame >, SearchToolbarControllersVec > SearchToolbarControllersMap;
 453     SearchToolbarControllersMap aSearchToolbarControllersMap;
 454     std::vector<OUString> m_aSearchStrings;
 455
 456 };
 457
 458 SearchToolbarControllersManager::SearchToolbarControllersManager()
 459 {
 460 }
 461
 462 SearchToolbarControllersManager& SearchToolbarControllersManager::createControllersManager()
 463 {
 464     static SearchToolbarControllersManager theSearchToolbarControllersManager;
 465     return theSearchToolbarControllersManager;
 466 }
 467
 468 void SearchToolbarControllersManager::saveSearchHistory(const FindTextFieldControl* pFindTextFieldControl)
 469 {
 470     const sal_Int32 nECount( pFindTextFieldControl->get_count() );
 471     m_aSearchStrings.resize( nECount );
 472     for( sal_Int32 i=0; i<nECount; ++i )
 473     {
 474         m_aSearchStrings[i] = pFindTextFieldControl->get_text(i);
 475     }
 476 }
 477
 478 void SearchToolbarControllersManager::loadSearchHistory(FindTextFieldControl* pFindTextFieldControl)
 479 {
 480     for( size_t i=0; i<m_aSearchStrings.size(); ++i )
 481     {
 482         pFindTextFieldControl->append_text(m_aSearchStrings[i]);
 483     }
 484 }
 485
 486 void SearchToolbarControllersManager::registryController( const css::uno::Reference< css::frame::XFrame >& xFrame, const css::uno::Reference< css::frame::XStatusListener >& xStatusListener, const OUString& sCommandURL )
 487 {
 488     SearchToolbarControllersMap::iterator pIt = aSearchToolbarControllersMap.find(xFrame);
 489     if (pIt == aSearchToolbarControllersMap.end())
 490     {
 491         SearchToolbarControllersVec lControllers(1);
 492         lControllers[0].Name = sCommandURL;
 493         lControllers[0].Value <<= xStatusListener;
 494         aSearchToolbarControllersMap.emplace(xFrame, lControllers);
 495     }
 496     else
 497     {
 498         sal_Int32 nSize = pIt->second.size();
 499         for (sal_Int32 i=0; i<nSize; ++i)
 500         {
 501             if (pIt->second[i].Name == sCommandURL)
 502                 return;
 503         }
 504
 505         pIt->second.resize(nSize+1);
 506         pIt->second[nSize].Name = sCommandURL;
 507         pIt->second[nSize].Value <<= xStatusListener;
 508     }
 509 }
 510
 511 void SearchToolbarControllersManager::freeController( const css::uno::Reference< css::frame::XFrame >& xFrame, const OUString& sCommandURL )
 512 {
 513     SearchToolbarControllersMap::iterator pIt = aSearchToolbarControllersMap.find(xFrame);
 514     if (pIt != aSearchToolbarControllersMap.end())
 515     {
 516         auto pItCtrl = std::find_if(pIt->second.begin(), pIt->second.end(),
 517             [&sCommandURL](const css::beans::PropertyValue& rCtrl) { return rCtrl.Name == sCommandURL; });
 518         if (pItCtrl != pIt->second.end())
 519             pIt->second.erase(pItCtrl);
 520
 521         if (pIt->second.empty())
 522             aSearchToolbarControllersMap.erase(pIt);
 523     }
 524 }
 525
 526 css::uno::Reference< css::frame::XStatusListener > SearchToolbarControllersManager::findController( const css::uno::Reference< css::frame::XFrame >& xFrame, const OUString& sCommandURL )
 527 {
 528     css::uno::Reference< css::frame::XStatusListener > xStatusListener;
 529
 530     SearchToolbarControllersMap::iterator pIt = aSearchToolbarControllersMap.find(xFrame);
 531     if (pIt != aSearchToolbarControllersMap.end())
 532     {
 533         auto pItCtrl = std::find_if(pIt->second.begin(), pIt->second.end(),
 534             [&sCommandURL](const css::beans::PropertyValue& rCtrl) { return rCtrl.Name == sCommandURL; });
 535         if (pItCtrl != pIt->second.end())
 536             pItCtrl->Value >>= xStatusListener;
 537     }
 538
 539     return xStatusListener;
 540 }
 541
 542 typedef cppu::ImplInheritanceHelper< ::svt::ToolboxController, css::lang::XServiceInfo> FindTextToolbarController_Base;
 543 class FindTextToolbarController : public FindTextToolbarController_Base
 544 {
 545 public:
 546
 547     FindTextToolbarController( const css::uno::Reference< css::uno::XComponentContext > & rxContext );
 548
 549     // XServiceInfo
 550     virtual OUString SAL_CALL getImplementationName() override;
 551     virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) override;
 552     virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override;
 553
 554     // XComponent
 555     virtual void SAL_CALL dispose() override;
 556
 557     // XInitialization
 558     virtual void SAL_CALL initialize( const css::uno::Sequence< css::uno::Any >& aArguments ) override;
 559
 560     // XToolbarController
 561     virtual css::uno::Reference< css::awt::XWindow > SAL_CALL createItemWindow( const css::uno::Reference< css::awt::XWindow >& Parent ) override;
 562
 563     // XStatusListener
 564     virtual void SAL_CALL statusChanged( const css::frame::FeatureStateEvent& Event ) override;
 565
 566     DECL_LINK(EditModifyHdl, weld::ComboBox&, void);
 567
 568 private:
 569
 570     void textfieldChanged();
 571
 572     VclPtr<FindTextFieldControl> m_pFindTextFieldControl;
 573
 574     ToolBoxItemId m_nDownSearchId;
 575     ToolBoxItemId m_nUpSearchId;
 576     ToolBoxItemId m_nFindAllId;
 577
 578 };
 579
 580 FindTextToolbarController::FindTextToolbarController( const css::uno::Reference< css::uno::XComponentContext >& rxContext )
 581     : FindTextToolbarController_Base(rxContext, css::uno::Reference< css::frame::XFrame >(), COMMAND_FINDTEXT)
 582     , m_pFindTextFieldControl(nullptr)
 583     , m_nDownSearchId(0)
 584     , m_nUpSearchId(0)
 585     , m_nFindAllId(0)
 586 {
 587 }
 588
 589 // XServiceInfo
 590 OUString SAL_CALL FindTextToolbarController::getImplementationName()
 591 {
 592     return "com.sun.star.svx.FindTextToolboxController";
 593 }
 594
 595 sal_Bool SAL_CALL FindTextToolbarController::supportsService( const OUString& ServiceName )
 596 {
 597     return cppu::supportsService(this, ServiceName);
 598 }
 599
 600 css::uno::Sequence< OUString > SAL_CALL FindTextToolbarController::getSupportedServiceNames()
 601 {
 602     return { "com.sun.star.frame.ToolbarController" };
 603 }
 604
 605 // XComponent
 606 void SAL_CALL FindTextToolbarController::dispose()
 607 {
 608     SolarMutexGuard aSolarMutexGuard;
 609
 610     SearchToolbarControllersManager::createControllersManager().freeController(m_xFrame, m_aCommandURL);
 611
 612     svt::ToolboxController::dispose();
 613     if (m_pFindTextFieldControl != nullptr) {
 614         SearchToolbarControllersManager::createControllersManager()
 615             .saveSearchHistory(m_pFindTextFieldControl);
 616         m_pFindTextFieldControl.disposeAndClear();
 617     }
 618 }
 619
 620 // XInitialization
 621 void SAL_CALL FindTextToolbarController::initialize( const css::uno::Sequence< css::uno::Any >& aArguments )
 622 {
 623     svt::ToolboxController::initialize(aArguments);
 624
 625     VclPtr<vcl::Window> pWindow = VCLUnoHelper::GetWindow( getParent() );
 626     ToolBox* pToolBox = static_cast<ToolBox*>(pWindow.get());
 627     if ( pToolBox )
 628     {
 629         m_nDownSearchId = pToolBox->GetItemId(COMMAND_DOWNSEARCH);
 630         m_nUpSearchId = pToolBox->GetItemId(COMMAND_UPSEARCH);
 631         m_nFindAllId = pToolBox->GetItemId(COMMAND_FINDALL);
 632     }
 633
 634     SearchToolbarControllersManager::createControllersManager().registryController(m_xFrame, css::uno::Reference< css::frame::XStatusListener >(this), m_aCommandURL);
 635 }
 636
 637 css::uno::Reference< css::awt::XWindow > SAL_CALL FindTextToolbarController::createItemWindow( const css::uno::Reference< css::awt::XWindow >& xParent )
 638 {
 639     css::uno::Reference< css::awt::XWindow > xItemWindow;
 640
 641     VclPtr<vcl::Window> pParent = VCLUnoHelper::GetWindow( xParent );
 642     if ( pParent )
 643     {
 644         ToolBox* pToolbar = static_cast<ToolBox*>(pParent.get());
 645         m_pFindTextFieldControl = VclPtr<FindTextFieldControl>::Create(pToolbar, m_xFrame, m_xContext);
 646
 647         m_pFindTextFieldControl->connect_changed(LINK(this, FindTextToolbarController, EditModifyHdl));
 648         SearchToolbarControllersManager::createControllersManager().loadSearchHistory(m_pFindTextFieldControl);
 649     }
 650     xItemWindow = VCLUnoHelper::GetInterface( m_pFindTextFieldControl );
 651
 652     return xItemWindow;
 653 }
 654
 655 // XStatusListener
 656 void SAL_CALL FindTextToolbarController::statusChanged( const css::frame::FeatureStateEvent& rEvent )
 657 {
 658     SolarMutexGuard aSolarMutexGuard;
 659     if ( m_bDisposed )
 660         return;
 661
 662     OUString aFeatureURL = rEvent.FeatureURL.Complete;
 663     if ( aFeatureURL == "AppendSearchHistory" )
 664     {
 665         m_pFindTextFieldControl->Remember_Impl(m_pFindTextFieldControl->get_active_text());
 666     }
 667     // enable up/down buttons in case there is already text (from the search history)
 668     textfieldChanged();
 669 }
 670
 671 IMPL_LINK_NOARG(FindTextToolbarController, EditModifyHdl, weld::ComboBox&, void)
 672 {
 673     // Clear SearchLabel when search string altered
 674     #if HAVE_FEATURE_DESKTOP
 675     SvxSearchDialogWrapper::SetSearchLabel(SearchLabel::Empty);
 676     #endif
 677
 678     textfieldChanged();
 679 }
 680
 681 void FindTextToolbarController::textfieldChanged() {
 682     // enable or disable item DownSearch/UpSearch/FindAll of findbar
 683     VclPtr<vcl::Window> pWindow = VCLUnoHelper::GetWindow( getParent() );
 684     ToolBox* pToolBox = static_cast<ToolBox*>(pWindow.get());
 685     if ( pToolBox && m_pFindTextFieldControl )
 686     {
 687         bool enableButtons = !m_pFindTextFieldControl->get_active_text().isEmpty();
 688         pToolBox->EnableItem(m_nDownSearchId, enableButtons);
 689         pToolBox->EnableItem(m_nUpSearchId, enableButtons);
 690         pToolBox->EnableItem(m_nFindAllId, enableButtons);
 691     }
 692 }
 693
 694 typedef cppu::ImplInheritanceHelper< ::svt::ToolboxController, css::lang::XServiceInfo> UpDownSearchToolboxController_Base;
 695 class UpDownSearchToolboxController : public UpDownSearchToolboxController_Base
 696 {
 697 public:
 698     enum Type { UP, DOWN };
 699
 700     UpDownSearchToolboxController( const css::uno::Reference< css::uno::XComponentContext >& rxContext, Type eType );
 701
 702     // XServiceInfo
 703     virtual OUString SAL_CALL getImplementationName() override;
 704     virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) override;
 705     virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override;
 706
 707     // XComponent
 708     virtual void SAL_CALL dispose() override;
 709
 710     // XInitialization
 711     virtual void SAL_CALL initialize( const css::uno::Sequence< css::uno::Any >& aArguments ) override;
 712
 713     // XToolbarController
 714     virtual void SAL_CALL execute( sal_Int16 KeyModifier ) override;
 715
 716     // XStatusListener
 717     virtual void SAL_CALL statusChanged( const css::frame::FeatureStateEvent& rEvent ) override;
 718
 719 private:
 720     Type meType;
 721 };
 722
 723 UpDownSearchToolboxController::UpDownSearchToolboxController( const css::uno::Reference< css::uno::XComponentContext > & rxContext, Type eType )
 724     : UpDownSearchToolboxController_Base( rxContext,
 725             css::uno::Reference< css::frame::XFrame >(),
 726             (eType == UP) ? COMMAND_UPSEARCH:  COMMAND_DOWNSEARCH ),
 727       meType( eType )
 728 {
 729 }
 730
 731 // XServiceInfo
 732 OUString SAL_CALL UpDownSearchToolboxController::getImplementationName()
 733 {
 734     return meType == UpDownSearchToolboxController::UP?
 735         OUString( "com.sun.star.svx.UpSearchToolboxController" ) :
 736         OUString( "com.sun.star.svx.DownSearchToolboxController" );
 737 }
 738
 739 sal_Bool SAL_CALL UpDownSearchToolboxController::supportsService( const OUString& ServiceName )
 740 {
 741     return cppu::supportsService(this, ServiceName);
 742 }
 743
 744 css::uno::Sequence< OUString > SAL_CALL UpDownSearchToolboxController::getSupportedServiceNames()
 745 {
 746     return { "com.sun.star.frame.ToolbarController" };
 747 }
 748
 749 // XComponent
 750 void SAL_CALL UpDownSearchToolboxController::dispose()
 751 {
 752     SolarMutexGuard aSolarMutexGuard;
 753
 754     SearchToolbarControllersManager::createControllersManager().freeController(m_xFrame, m_aCommandURL);
 755
 756     svt::ToolboxController::dispose();
 757 }
 758
 759 // XInitialization
 760 void SAL_CALL UpDownSearchToolboxController::initialize( const css::uno::Sequence< css::uno::Any >& aArguments )
 761 {
 762     svt::ToolboxController::initialize( aArguments );
 763     SearchToolbarControllersManager::createControllersManager().registryController(m_xFrame, css::uno::Reference< css::frame::XStatusListener >(this), m_aCommandURL);
 764 }
 765
 766 // XToolbarController
 767 void SAL_CALL UpDownSearchToolboxController::execute( sal_Int16 /*KeyModifier*/ )
 768 {
 769     if ( m_bDisposed )
 770         throw css::lang::DisposedException();
 771
 772     VclPtr<vcl::Window> pWindow = VCLUnoHelper::GetWindow( getParent() );
 773     ToolBox* pToolBox = static_cast<ToolBox*>(pWindow.get());
 774
 775     impl_executeSearch(m_xContext, m_xFrame, pToolBox, meType == UP );
 776
 777     css::frame::FeatureStateEvent aEvent;
 778     aEvent.FeatureURL.Complete = "AppendSearchHistory";
 779     css::uno::Reference< css::frame::XStatusListener > xStatusListener = SearchToolbarControllersManager::createControllersManager().findController(m_xFrame, COMMAND_FINDTEXT);
 780     if (xStatusListener.is())
 781         xStatusListener->statusChanged( aEvent );
 782 }
 783
 784 // XStatusListener
 785 void SAL_CALL UpDownSearchToolboxController::statusChanged( const css::frame::FeatureStateEvent& /*rEvent*/ )
 786 {
 787 }
 788
 789 typedef cppu::ImplInheritanceHelper< ::svt::ToolboxController, css::lang::XServiceInfo> MatchCaseToolboxController_Base;
 790 class MatchCaseToolboxController : public MatchCaseToolboxController_Base
 791 {
 792 public:
 793     MatchCaseToolboxController( const css::uno::Reference< css::uno::XComponentContext >& rxContext );
 794
 795     // XServiceInfo
 796     virtual OUString SAL_CALL getImplementationName() override;
 797     virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) override;
 798     virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override;
 799
 800     // XComponent
 801     virtual void SAL_CALL dispose() override;
 802
 803     // XInitialization
 804     virtual void SAL_CALL initialize( const css::uno::Sequence< css::uno::Any >& aArguments ) override;
 805
 806     // XToolbarController
 807     virtual css::uno::Reference< css::awt::XWindow > SAL_CALL createItemWindow( const css::uno::Reference< css::awt::XWindow >& Parent ) override;
 808
 809     // XStatusListener
 810     virtual void SAL_CALL statusChanged( const css::frame::FeatureStateEvent& rEvent ) override;
 811
 812 private:
 813     VclPtr<CheckButtonItemWindow> m_xMatchCaseControl;
 814 };
 815
 816 MatchCaseToolboxController::MatchCaseToolboxController( const css::uno::Reference< css::uno::XComponentContext >& rxContext )
 817     : MatchCaseToolboxController_Base( rxContext,
 818         css::uno::Reference< css::frame::XFrame >(),
 819         COMMAND_MATCHCASE )
 820     , m_xMatchCaseControl(nullptr)
 821 {
 822 }
 823
 824 // XServiceInfo
 825 OUString SAL_CALL MatchCaseToolboxController::getImplementationName()
 826 {
 827     return "com.sun.star.svx.MatchCaseToolboxController";
 828 }
 829
 830 sal_Bool SAL_CALL MatchCaseToolboxController::supportsService( const OUString& ServiceName )
 831 {
 832     return cppu::supportsService(this, ServiceName);
 833 }
 834
 835 css::uno::Sequence< OUString > SAL_CALL MatchCaseToolboxController::getSupportedServiceNames()
 836 {
 837     return { "com.sun.star.frame.ToolbarController" };
 838 }
 839
 840 // XComponent
 841 void SAL_CALL MatchCaseToolboxController::dispose()
 842 {
 843     SolarMutexGuard aSolarMutexGuard;
 844
 845     SearchToolbarControllersManager::createControllersManager().freeController(m_xFrame, m_aCommandURL);
 846
 847     svt::ToolboxController::dispose();
 848
 849     m_xMatchCaseControl.disposeAndClear();
 850 }
 851
 852 // XInitialization
 853 void SAL_CALL MatchCaseToolboxController::initialize( const css::uno::Sequence< css::uno::Any >& aArguments )
 854 {
 855     svt::ToolboxController::initialize(aArguments);
 856
 857     SearchToolbarControllersManager::createControllersManager().registryController(m_xFrame, css::uno::Reference< css::frame::XStatusListener >(this), m_aCommandURL);
 858 }
 859
 860 css::uno::Reference< css::awt::XWindow > SAL_CALL MatchCaseToolboxController::createItemWindow( const css::uno::Reference< css::awt::XWindow >& xParent )
 861 {
 862     css::uno::Reference< css::awt::XWindow > xItemWindow;
 863
 864     VclPtr<vcl::Window> pParent = VCLUnoHelper::GetWindow( xParent );
 865     if ( pParent )
 866     {
 867         ToolBox* pToolbar = static_cast<ToolBox*>(pParent.get());
 868         m_xMatchCaseControl = VclPtr<CheckButtonItemWindow>::Create(pToolbar, SvxResId(RID_SVXSTR_FINDBAR_MATCHCASE));
 869     }
 870     xItemWindow = VCLUnoHelper::GetInterface(m_xMatchCaseControl);
 871
 872     return xItemWindow;
 873 }
 874
 875 // XStatusListener
 876 void SAL_CALL MatchCaseToolboxController::statusChanged( const css::frame::FeatureStateEvent& )
 877 {
 878 }
 879
 880 typedef cppu::ImplInheritanceHelper< ::svt::ToolboxController, css::lang::XServiceInfo> SearchFormattedToolboxController_Base;
 881 class SearchFormattedToolboxController : public SearchFormattedToolboxController_Base
 882 {
 883 public:
 884     SearchFormattedToolboxController( const css::uno::Reference< css::uno::XComponentContext >& rxContext );
 885
 886     // XServiceInfo
 887     virtual OUString SAL_CALL getImplementationName() override;
 888     virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) override;
 889     virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override;
 890
 891     // XComponent
 892     virtual void SAL_CALL dispose() override;
 893
 894     // XInitialization
 895     virtual void SAL_CALL initialize( const css::uno::Sequence< css::uno::Any >& aArguments ) override;
 896
 897     // XToolbarController
 898     virtual css::uno::Reference< css::awt::XWindow > SAL_CALL createItemWindow( const css::uno::Reference< css::awt::XWindow >& Parent ) override;
 899
 900     // XStatusListener
 901     virtual void SAL_CALL statusChanged( const css::frame::FeatureStateEvent& rEvent ) override;
 902
 903 private:
 904     VclPtr<CheckButtonItemWindow> m_xSearchFormattedControl;
 905 };
 906
 907 SearchFormattedToolboxController::SearchFormattedToolboxController( const css::uno::Reference< css::uno::XComponentContext >& rxContext )
 908     : SearchFormattedToolboxController_Base( rxContext,
 909         css::uno::Reference< css::frame::XFrame >(),
 910         COMMAND_SEARCHFORMATTED )
 911     , m_xSearchFormattedControl(nullptr)
 912 {
 913 }
 914
 915 // XServiceInfo
 916 OUString SAL_CALL SearchFormattedToolboxController::getImplementationName()
 917 {
 918     return "com.sun.star.svx.SearchFormattedToolboxController";
 919 }
 920
 921 sal_Bool SAL_CALL SearchFormattedToolboxController::supportsService( const OUString& ServiceName )
 922 {
 923     return cppu::supportsService(this, ServiceName);
 924 }
 925
 926 css::uno::Sequence< OUString > SAL_CALL SearchFormattedToolboxController::getSupportedServiceNames()
 927 {
 928     return { "com.sun.star.frame.ToolbarController" };
 929 }
 930
 931 // XComponent
 932 void SAL_CALL SearchFormattedToolboxController::dispose()
 933 {
 934     SolarMutexGuard aSolarMutexGuard;
 935
 936     SearchToolbarControllersManager::createControllersManager().freeController(m_xFrame, m_aCommandURL);
 937
 938     svt::ToolboxController::dispose();
 939
 940     m_xSearchFormattedControl.disposeAndClear();
 941 }
 942
 943 // XInitialization
 944 void SAL_CALL SearchFormattedToolboxController::initialize( const css::uno::Sequence< css::uno::Any >& aArguments )
 945 {
 946     svt::ToolboxController::initialize(aArguments);
 947
 948     SearchToolbarControllersManager::createControllersManager().registryController(m_xFrame, css::uno::Reference< css::frame::XStatusListener >(this), m_aCommandURL);
 949 }
 950
 951 css::uno::Reference< css::awt::XWindow > SAL_CALL SearchFormattedToolboxController::createItemWindow( const css::uno::Reference< css::awt::XWindow >& xParent )
 952 {
 953     css::uno::Reference< css::awt::XWindow > xItemWindow;
 954
 955     VclPtr<vcl::Window> pParent = VCLUnoHelper::GetWindow( xParent );
 956     if ( pParent )
 957     {
 958         ToolBox* pToolbar = static_cast<ToolBox*>(pParent.get());
 959         m_xSearchFormattedControl = VclPtr<CheckButtonItemWindow>::Create(pToolbar, SvxResId(RID_SVXSTR_FINDBAR_SEARCHFORMATTED));
 960     }
 961     xItemWindow = VCLUnoHelper::GetInterface(m_xSearchFormattedControl);
 962
 963     return xItemWindow;
 964 }
 965
 966 // XStatusListener
 967 void SAL_CALL SearchFormattedToolboxController::statusChanged( const css::frame::FeatureStateEvent& )
 968 {
 969 }
 970
 971 typedef cppu::ImplInheritanceHelper< ::svt::ToolboxController, css::lang::XServiceInfo> FindAllToolboxController_Base;
 972 class FindAllToolboxController : public FindAllToolboxController_Base
 973 {
 974 public:
 975     FindAllToolboxController( const css::uno::Reference< css::uno::XComponentContext >& rxContext );
 976
 977     // XServiceInfo
 978     virtual OUString SAL_CALL getImplementationName() override;
 979     virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) override;
 980     virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override;
 981
 982     // XComponent
 983     virtual void SAL_CALL dispose() override;
 984
 985     // XInitialization
 986     virtual void SAL_CALL initialize( const css::uno::Sequence< css::uno::Any >& aArguments ) override;
 987
 988     // XToolbarController
 989     virtual void SAL_CALL execute( sal_Int16 KeyModifier ) override;
 990
 991     // XStatusListener
 992     virtual void SAL_CALL statusChanged( const css::frame::FeatureStateEvent& rEvent ) override;
 993 };
 994
 995 FindAllToolboxController::FindAllToolboxController( const css::uno::Reference< css::uno::XComponentContext > & rxContext )
 996     : FindAllToolboxController_Base( rxContext,
 997             css::uno::Reference< css::frame::XFrame >(),
 998             ".uno:FindAll" )
 999 {
1000 }
1001
1002 // XServiceInfo
1003 OUString SAL_CALL FindAllToolboxController::getImplementationName()
1004 {
1005     return "com.sun.star.svx.FindAllToolboxController";
1006 }
1007
1008
1009 sal_Bool SAL_CALL FindAllToolboxController::supportsService( const OUString& ServiceName )
1010 {
1011     return cppu::supportsService(this, ServiceName);
1012 }
1013
1014 css::uno::Sequence< OUString > SAL_CALL FindAllToolboxController::getSupportedServiceNames()
1015 {
1016     return { "com.sun.star.frame.ToolbarController" };
1017 }
1018
1019 // XComponent
1020 void SAL_CALL FindAllToolboxController::dispose()
1021 {
1022     SolarMutexGuard aSolarMutexGuard;
1023
1024     SearchToolbarControllersManager::createControllersManager().freeController(m_xFrame, m_aCommandURL);
1025
1026     svt::ToolboxController::dispose();
1027 }
1028
1029 // XInitialization
1030 void SAL_CALL FindAllToolboxController::initialize( const css::uno::Sequence< css::uno::Any >& aArguments )
1031 {
1032     svt::ToolboxController::initialize( aArguments );
1033     SearchToolbarControllersManager::createControllersManager().registryController(m_xFrame, css::uno::Reference< css::frame::XStatusListener >(this), m_aCommandURL);
1034 }
1035
1036 // XToolbarController
1037 void SAL_CALL FindAllToolboxController::execute( sal_Int16 /*KeyModifier*/ )
1038 {
1039     if ( m_bDisposed )
1040         throw css::lang::DisposedException();
1041
1042     VclPtr<vcl::Window> pWindow = VCLUnoHelper::GetWindow( getParent() );
1043     ToolBox* pToolBox = static_cast<ToolBox*>(pWindow.get());
1044
1045     impl_executeSearch(m_xContext, m_xFrame, pToolBox, false, true);
1046 }
1047
1048 // XStatusListener
1049 void SAL_CALL FindAllToolboxController::statusChanged( const css::frame::FeatureStateEvent& /*rEvent*/ )
1050 {
1051 }
1052
1053 typedef cppu::ImplInheritanceHelper< ::svt::ToolboxController, css::lang::XServiceInfo> ExitSearchToolboxController_Base;
1054 class ExitSearchToolboxController : public ExitSearchToolboxController_Base
1055 {
1056 public:
1057     ExitSearchToolboxController( const css::uno::Reference< css::uno::XComponentContext >& rxContext );
1058
1059     // XServiceInfo
1060     virtual OUString SAL_CALL getImplementationName() override;
1061     virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) override;
1062     virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override;
1063
1064     // XComponent
1065     virtual void SAL_CALL dispose() override;
1066
1067     // XInitialization
1068     virtual void SAL_CALL initialize( const css::uno::Sequence< css::uno::Any >& aArguments ) override;
1069
1070     // XToolbarController
1071     virtual void SAL_CALL execute( sal_Int16 KeyModifier ) override;
1072
1073     // XStatusListener
1074     virtual void SAL_CALL statusChanged( const css::frame::FeatureStateEvent& rEvent ) override;
1075 };
1076
1077 ExitSearchToolboxController::ExitSearchToolboxController( const css::uno::Reference< css::uno::XComponentContext > & rxContext )
1078     : ExitSearchToolboxController_Base( rxContext,
1079             css::uno::Reference< css::frame::XFrame >(),
1080             ".uno:ExitSearch" )
1081 {
1082 }
1083
1084 // XServiceInfo
1085 OUString SAL_CALL ExitSearchToolboxController::getImplementationName()
1086 {
1087     return "com.sun.star.svx.ExitFindbarToolboxController";
1088 }
1089
1090
1091 sal_Bool SAL_CALL ExitSearchToolboxController::supportsService( const OUString& ServiceName )
1092 {
1093     return cppu::supportsService(this, ServiceName);
1094 }
1095
1096 css::uno::Sequence< OUString > SAL_CALL ExitSearchToolboxController::getSupportedServiceNames()
1097 {
1098     return { "com.sun.star.frame.ToolbarController" };
1099 }
1100
1101 // XComponent
1102 void SAL_CALL ExitSearchToolboxController::dispose()
1103 {
1104     SolarMutexGuard aSolarMutexGuard;
1105
1106     SearchToolbarControllersManager::createControllersManager().freeController(m_xFrame, m_aCommandURL);
1107
1108     svt::ToolboxController::dispose();
1109 }
1110
1111 // XInitialization
1112 void SAL_CALL ExitSearchToolboxController::initialize( const css::uno::Sequence< css::uno::Any >& aArguments )
1113 {
1114     svt::ToolboxController::initialize( aArguments );
1115     SearchToolbarControllersManager::createControllersManager().registryController(m_xFrame, css::uno::Reference< css::frame::XStatusListener >(this), m_aCommandURL);
1116 }
1117
1118 // XToolbarController
1119 void SAL_CALL ExitSearchToolboxController::execute( sal_Int16 /*KeyModifier*/ )
1120 {
1121     vcl::Window *pFocusWindow = Application::GetFocusWindow();
1122     if ( pFocusWindow )
1123         pFocusWindow->GrabFocusToDocument();
1124
1125     // hide the findbar
1126     css::uno::Reference< css::beans::XPropertySet > xPropSet(m_xFrame, css::uno::UNO_QUERY);
1127     if (xPropSet.is())
1128     {
1129         css::uno::Reference< css::frame::XLayoutManager > xLayoutManager;
1130         css::uno::Any aValue = xPropSet->getPropertyValue("LayoutManager");
1131         aValue >>= xLayoutManager;
1132         if (xLayoutManager.is())
1133         {
1134             static constexpr OUString sResourceURL( u"private:resource/toolbar/findbar"_ustr );
1135             xLayoutManager->hideElement( sResourceURL );
1136             xLayoutManager->destroyElement( sResourceURL );
1137         }
1138     }
1139 }
1140
1141 // XStatusListener
1142 void SAL_CALL ExitSearchToolboxController::statusChanged( const css::frame::FeatureStateEvent& /*rEvent*/ )
1143 {
1144 }
1145
1146 typedef cppu::ImplInheritanceHelper< ::svt::ToolboxController, css::lang::XServiceInfo> SearchLabelToolboxController_Base;
1147 class SearchLabelToolboxController : public SearchLabelToolboxController_Base
1148 {
1149 public:
1150     SearchLabelToolboxController( const css::uno::Reference< css::uno::XComponentContext >& rxContext );
1151
1152     // XServiceInfo
1153     virtual OUString SAL_CALL getImplementationName() override;
1154     virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) override;
1155     virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override;
1156
1157     // XComponent
1158     virtual void SAL_CALL dispose() override;
1159
1160     // XInitialization
1161     virtual void SAL_CALL initialize( const css::uno::Sequence< css::uno::Any >& aArguments ) override;
1162
1163     // XToolbarController
1164     virtual css::uno::Reference< css::awt::XWindow > SAL_CALL createItemWindow( const css::uno::Reference< css::awt::XWindow >& Parent ) override;
1165
1166     // XStatusListener
1167     virtual void SAL_CALL statusChanged( const css::frame::FeatureStateEvent& rEvent ) override;
1168
1169 private:
1170     VclPtr<LabelItemWindow> m_xSL;
1171 };
1172
1173 SearchLabelToolboxController::SearchLabelToolboxController( const css::uno::Reference< css::uno::XComponentContext > & rxContext )
1174     : SearchLabelToolboxController_Base( rxContext,
1175             css::uno::Reference< css::frame::XFrame >(),
1176             ".uno:SearchLabel" )
1177 {
1178 }
1179
1180 // XServiceInfo
1181 OUString SAL_CALL SearchLabelToolboxController::getImplementationName()
1182 {
1183     return "com.sun.star.svx.SearchLabelToolboxController";
1184 }
1185
1186
1187 sal_Bool SAL_CALL SearchLabelToolboxController::supportsService( const OUString& ServiceName )
1188 {
1189     return cppu::supportsService(this, ServiceName);
1190 }
1191
1192 css::uno::Sequence< OUString > SAL_CALL SearchLabelToolboxController::getSupportedServiceNames()
1193 {
1194     return { "com.sun.star.frame.ToolbarController" };
1195 }
1196
1197 // XComponent
1198 void SAL_CALL SearchLabelToolboxController::dispose()
1199 {
1200     SolarMutexGuard aSolarMutexGuard;
1201
1202     SearchToolbarControllersManager::createControllersManager().freeController(m_xFrame, m_aCommandURL);
1203
1204     svt::ToolboxController::dispose();
1205     m_xSL.disposeAndClear();
1206 }
1207
1208 // XInitialization
1209 void SAL_CALL SearchLabelToolboxController::initialize( const css::uno::Sequence< css::uno::Any >& aArguments )
1210 {
1211     svt::ToolboxController::initialize( aArguments );
1212     SearchToolbarControllersManager::createControllersManager().registryController(m_xFrame, css::uno::Reference< css::frame::XStatusListener >(this), m_aCommandURL);
1213 }
1214
1215 // XStatusListener
1216 void SAL_CALL SearchLabelToolboxController::statusChanged( const css::frame::FeatureStateEvent& )
1217 {
1218     if (m_xSL)
1219     {
1220         OUString aStr = SvxSearchDialogWrapper::GetSearchLabel();
1221         m_xSL->set_label(aStr);
1222         m_xSL->SetOptimalSize();
1223         Size aSize(m_xSL->GetSizePixel());
1224         tools::Long nWidth = !aStr.isEmpty() ? aSize.getWidth() : 16;
1225         m_xSL->SetSizePixel(Size(nWidth, aSize.Height()));
1226     }
1227 }
1228
1229 css::uno::Reference< css::awt::XWindow > SAL_CALL SearchLabelToolboxController::createItemWindow( const css::uno::Reference< css::awt::XWindow >& Parent )
1230 {
1231     ToolBox* pToolBox = nullptr;
1232     ToolBoxItemId nId;
1233     if (getToolboxId(nId, &pToolBox))
1234         pToolBox->SetItemWindowNonInteractive(nId, true);
1235
1236     m_xSL = VclPtr<LabelItemWindow>::Create(VCLUnoHelper::GetWindow(Parent), "");
1237     m_xSL->SetSizePixel(Size(16, m_xSL->GetSizePixel().Height()));
1238     return VCLUnoHelper::GetInterface(m_xSL);
1239 }
1240
1241 // protocol handler for "vnd.sun.star.findbar:*" URLs
1242 // The dispatch object will be used for shortcut commands for findbar
1243 class FindbarDispatcher : public css::lang::XServiceInfo,
1244                           public css::lang::XInitialization,
1245                           public css::frame::XDispatchProvider,
1246                           public css::frame::XDispatch,
1247                           public ::cppu::OWeakObject
1248 {
1249 public:
1250
1251     FindbarDispatcher();
1252     virtual ~FindbarDispatcher() override;
1253
1254     // XInterface
1255     virtual css::uno::Any SAL_CALL queryInterface( const css::uno::Type& aType ) override;
1256     virtual void SAL_CALL acquire() noexcept override;
1257     virtual void SAL_CALL release() noexcept override;
1258
1259     // XServiceInfo
1260     virtual OUString SAL_CALL getImplementationName() override;
1261     virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) override;
1262     virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override;
1263
1264     // XInitialization
1265     virtual void SAL_CALL initialize( const css::uno::Sequence< css::uno::Any >& aArguments ) override;
1266
1267     // XDispatchProvider
1268     virtual css::uno::Reference< css::frame::XDispatch > SAL_CALL queryDispatch( const css::util::URL& aURL, const OUString& sTargetFrameName , sal_Int32 nSearchFlags ) override;
1269     virtual css::uno::Sequence< css::uno::Reference< css::frame::XDispatch > > SAL_CALL queryDispatches( const css::uno::Sequence< css::frame::DispatchDescriptor >& lDescriptions    ) override;
1270
1271     // XDispatch
1272     virtual void SAL_CALL dispatch( const css::util::URL& aURL, const css::uno::Sequence< css::beans::PropertyValue >& lArguments ) override;
1273     virtual void SAL_CALL addStatusListener( const css::uno::Reference< css::frame::XStatusListener >& xListener, const css::util::URL& aURL ) override;
1274     virtual void SAL_CALL removeStatusListener( const css::uno::Reference< css::frame::XStatusListener >& xListener, const css::util::URL& aURL ) override;
1275
1276 private:
1277
1278     css::uno::Reference< css::frame::XFrame > m_xFrame;
1279
1280 };
1281
1282 FindbarDispatcher::FindbarDispatcher()
1283 {
1284 }
1285
1286 FindbarDispatcher::~FindbarDispatcher()
1287 {
1288     m_xFrame = nullptr;
1289 }
1290
1291 // XInterface
1292 css::uno::Any SAL_CALL FindbarDispatcher::queryInterface( const css::uno::Type& aType )
1293 {
1294     css::uno::Any aReturn( ::cppu::queryInterface( aType,
1295         static_cast< css::lang::XServiceInfo* >(this),
1296         static_cast< css::lang::XInitialization* >(this),
1297         static_cast< css::frame::XDispatchProvider* >(this),
1298         static_cast< css::frame::XDispatch* >(this)) );
1299
1300     if ( aReturn.hasValue() )
1301         return aReturn;
1302
1303     return OWeakObject::queryInterface( aType );
1304 }
1305
1306 void SAL_CALL FindbarDispatcher::acquire() noexcept
1307 {
1308     OWeakObject::acquire();
1309 }
1310
1311 void SAL_CALL FindbarDispatcher::release() noexcept
1312 {
1313     OWeakObject::release();
1314 }
1315
1316 // XServiceInfo
1317 OUString SAL_CALL FindbarDispatcher::getImplementationName()
1318 {
1319     return "com.sun.star.comp.svx.Impl.FindbarDispatcher";
1320 }
1321
1322 sal_Bool SAL_CALL FindbarDispatcher::supportsService( const OUString& ServiceName )
1323 {
1324     return cppu::supportsService(this, ServiceName);
1325 }
1326
1327 css::uno::Sequence< OUString > SAL_CALL FindbarDispatcher::getSupportedServiceNames()
1328 {
1329     return { "com.sun.star.comp.svx.FindbarDispatcher", "com.sun.star.frame.ProtocolHandler" };
1330 }
1331
1332 // XInitialization
1333 void SAL_CALL FindbarDispatcher::initialize( const css::uno::Sequence< css::uno::Any >& aArguments )
1334 {
1335     if ( aArguments.hasElements() )
1336         aArguments[0] >>= m_xFrame;
1337 }
1338
1339 // XDispatchProvider
1340 css::uno::Reference< css::frame::XDispatch > SAL_CALL FindbarDispatcher::queryDispatch( const css::util::URL& aURL, const OUString& /*sTargetFrameName*/, sal_Int32 /*nSearchFlags*/ )
1341 {
1342     css::uno::Reference< css::frame::XDispatch > xDispatch;
1343
1344     if ( aURL.Protocol == "vnd.sun.star.findbar:" )
1345         xDispatch = this;
1346
1347     return xDispatch;
1348 }
1349
1350 css::uno::Sequence < css::uno::Reference< css::frame::XDispatch > > SAL_CALL FindbarDispatcher::queryDispatches( const css::uno::Sequence < css::frame::DispatchDescriptor >& seqDescripts )
1351 {
1352     sal_Int32 nCount = seqDescripts.getLength();
1353     css::uno::Sequence < css::uno::Reference < XDispatch > > lDispatcher( nCount );
1354
1355     std::transform(seqDescripts.begin(), seqDescripts.end(), lDispatcher.getArray(),
1356         [this](const css::frame::DispatchDescriptor& rDescript) -> css::uno::Reference < XDispatch > {
1357             return queryDispatch( rDescript.FeatureURL, rDescript.FrameName, rDescript.SearchFlags ); });
1358
1359     return lDispatcher;
1360 }
1361
1362 // XDispatch
1363 void SAL_CALL FindbarDispatcher::dispatch( const css::util::URL& aURL, const css::uno::Sequence < css::beans::PropertyValue >& /*lArgs*/ )
1364 {
1365     //vnd.sun.star.findbar:FocusToFindbar  - set cursor to the FindTextFieldControl of the findbar
1366     if ( aURL.Path != "FocusToFindbar" )
1367         return;
1368
1369     css::uno::Reference< css::beans::XPropertySet > xPropSet(m_xFrame, css::uno::UNO_QUERY);
1370     if(!xPropSet.is())
1371         return;
1372
1373     css::uno::Reference< css::frame::XLayoutManager > xLayoutManager;
1374     css::uno::Any aValue = xPropSet->getPropertyValue("LayoutManager");
1375     aValue >>= xLayoutManager;
1376     if (!xLayoutManager.is())
1377         return;
1378
1379     static constexpr OUString sResourceURL( u"private:resource/toolbar/findbar"_ustr );
1380     css::uno::Reference< css::ui::XUIElement > xUIElement = xLayoutManager->getElement(sResourceURL);
1381     if (!xUIElement.is())
1382     {
1383         // show the findbar if necessary
1384         xLayoutManager->createElement( sResourceURL );
1385         xLayoutManager->showElement( sResourceURL );
1386         xUIElement = xLayoutManager->getElement( sResourceURL );
1387         if ( !xUIElement.is() )
1388             return;
1389     }
1390
1391     css::uno::Reference< css::awt::XWindow > xWindow(xUIElement->getRealInterface(), css::uno::UNO_QUERY);
1392     VclPtr<vcl::Window> pWindow = VCLUnoHelper::GetWindow( xWindow );
1393     ToolBox* pToolBox = static_cast<ToolBox*>(pWindow.get());
1394     pToolBox->set_id("FindBar");
1395     if ( !pToolBox )
1396         return;
1397
1398     ToolBox::ImplToolItems::size_type nItemCount = pToolBox->GetItemCount();
1399     for ( ToolBox::ImplToolItems::size_type i=0; i<nItemCount; ++i )
1400     {
1401         ToolBoxItemId id = pToolBox->GetItemId(i);
1402         OUString sItemCommand = pToolBox->GetItemCommand(id);
1403         if ( sItemCommand == COMMAND_FINDTEXT )
1404         {
1405             vcl::Window* pItemWin = pToolBox->GetItemWindow( id );
1406             if ( pItemWin )
1407             {
1408                 SolarMutexGuard aSolarMutexGuard;
1409                 FindTextFieldControl* pFindTextFieldControl = dynamic_cast<FindTextFieldControl*>(pItemWin);
1410                 if ( pFindTextFieldControl )
1411                     pFindTextFieldControl->SetTextToSelected_Impl();
1412                 pItemWin->GrabFocus();
1413                 return;
1414             }
1415         }
1416     }
1417 }
1418
1419 void SAL_CALL FindbarDispatcher::addStatusListener( const css::uno::Reference< css::frame::XStatusListener >& /*xControl*/, const css::util::URL& /*aURL*/ )
1420 {
1421 }
1422
1423 void SAL_CALL FindbarDispatcher::removeStatusListener( const css::uno::Reference< css::frame::XStatusListener >& /*xControl*/, const css::util::URL& /*aURL*/ )
1424 {
1425 }
1426
1427 }
1428
1429 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
1430 com_sun_star_svx_FindTextToolboxController_get_implementation(
1431     css::uno::XComponentContext *context,
1432     css::uno::Sequence<css::uno::Any> const &)
1433 {
1434     return cppu::acquire(new FindTextToolbarController(context));
1435 }
1436
1437 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
1438 com_sun_star_svx_ExitFindbarToolboxController_get_implementation(
1439     css::uno::XComponentContext *context,
1440     css::uno::Sequence<css::uno::Any> const &)
1441 {
1442     return cppu::acquire(new ExitSearchToolboxController(context));
1443 }
1444
1445 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
1446 com_sun_star_svx_UpSearchToolboxController_get_implementation(
1447     css::uno::XComponentContext *context,
1448     css::uno::Sequence<css::uno::Any> const &)
1449 {
1450     return cppu::acquire(new UpDownSearchToolboxController(context, UpDownSearchToolboxController::UP));
1451 }
1452
1453 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
1454 com_sun_star_svx_DownSearchToolboxController_get_implementation(
1455     css::uno::XComponentContext *context,
1456     css::uno::Sequence<css::uno::Any> const &)
1457 {
1458     return cppu::acquire(new UpDownSearchToolboxController(context, UpDownSearchToolboxController::DOWN));
1459 }
1460
1461 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
1462 com_sun_star_svx_MatchCaseToolboxController_get_implementation(
1463     css::uno::XComponentContext *context,
1464     css::uno::Sequence<css::uno::Any> const &)
1465 {
1466     return cppu::acquire(new MatchCaseToolboxController(context));
1467 }
1468
1469 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
1470 com_sun_star_svx_SearchFormattedToolboxController_get_implementation(
1471     css::uno::XComponentContext *context,
1472     css::uno::Sequence<css::uno::Any> const &)
1473 {
1474     return cppu::acquire(new SearchFormattedToolboxController(context));
1475 }
1476
1477 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
1478 com_sun_star_svx_FindAllToolboxController_get_implementation(
1479     css::uno::XComponentContext *context,
1480     css::uno::Sequence<css::uno::Any> const &)
1481 {
1482     return cppu::acquire(new FindAllToolboxController(context));
1483 }
1484
1485 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
1486 com_sun_star_svx_SearchLabelToolboxController_get_implementation(
1487     css::uno::XComponentContext *context,
1488     css::uno::Sequence<css::uno::Any> const &)
1489 {
1490     return cppu::acquire(new SearchLabelToolboxController(context));
1491 }
1492
1493 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
1494 com_sun_star_comp_svx_Impl_FindbarDispatcher_get_implementation(
1495     SAL_UNUSED_PARAMETER css::uno::XComponentContext *,
1496     css::uno::Sequence<css::uno::Any> const &)
1497 {
1498     return cppu::acquire(new FindbarDispatcher);
1499 }
1500
1501 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */