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