svx/source/form/filtnav.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 <memory>
  21 #include <filtnav.hxx>
  22 #include <fmexch.hxx>
  23 #include <helpids.h>
  24 #include <fmprop.hxx>
  25 #include <svx/strings.hrc>
  26
  27 #include <com/sun/star/awt/XControl.hpp>
  28 #include <com/sun/star/form/runtime/XFormController.hpp>
  29 #include <com/sun/star/util/NumberFormatter.hpp>
  30 #include <com/sun/star/sdb/SQLContext.hpp>
  31
  32 #include <comphelper/processfactory.hxx>
  33 #include <comphelper/string.hxx>
  34 #include <connectivity/dbtools.hxx>
  35 #include <connectivity/sqlnode.hxx>
  36 #include <cppuhelper/implbase.hxx>
  37 #include <i18nlangtag/languagetag.hxx>
  38 #include <fmshimp.hxx>
  39 #include <o3tl/safeint.hxx>
  40 #include <sfx2/objitem.hxx>
  41 #include <svx/dialmgr.hxx>
  42 #include <svx/fmshell.hxx>
  43 #include <svx/fmtools.hxx>
  44 #include <svx/svxids.hrc>
  45 #include <toolkit/helper/vclunohelper.hxx>
  46 #include <comphelper/diagnose_ex.hxx>
  47 #include <utility>
  48 #include <vcl/commandevent.hxx>
  49 #include <vcl/event.hxx>
  50 #include <vcl/settings.hxx>
  51 #include <vcl/svapp.hxx>
  52
  53 #include <bitmaps.hlst>
  54
  55 #include <functional>
  56
  57 using namespace ::svxform;
  58 using namespace ::connectivity;
  59 using namespace ::dbtools;
  60
  61 namespace svxform
  62 {
  63     using ::com::sun::star::uno::Reference;
  64     using ::com::sun::star::container::XIndexAccess;
  65     using ::com::sun::star::uno::UNO_QUERY;
  66     using ::com::sun::star::beans::XPropertySet;
  67     using ::com::sun::star::form::runtime::XFormController;
  68     using ::com::sun::star::form::runtime::XFilterController;
  69     using ::com::sun::star::form::runtime::XFilterControllerListener;
  70     using ::com::sun::star::form::runtime::FilterEvent;
  71     using ::com::sun::star::lang::EventObject;
  72     using ::com::sun::star::form::XForm;
  73     using ::com::sun::star::container::XChild;
  74     using ::com::sun::star::awt::XControl;
  75     using ::com::sun::star::sdbc::XConnection;
  76     using ::com::sun::star::util::XNumberFormatsSupplier;
  77     using ::com::sun::star::util::XNumberFormatter;
  78     using ::com::sun::star::util::NumberFormatter;
  79     using ::com::sun::star::sdbc::XRowSet;
  80     using ::com::sun::star::lang::Locale;
  81     using ::com::sun::star::sdb::SQLContext;
  82     using ::com::sun::star::uno::XInterface;
  83     using ::com::sun::star::uno::UNO_QUERY_THROW;
  84     using ::com::sun::star::uno::UNO_SET_THROW;
  85     using ::com::sun::star::uno::Exception;
  86     using ::com::sun::star::uno::Sequence;
  87
  88
  89 OFilterItemExchange::OFilterItemExchange()
  90     : m_pFormItem(nullptr)
  91 {
  92 }
  93
  94 void OFilterItemExchange::AddSupportedFormats()
  95 {
  96     AddFormat(getFormatId());
  97 }
  98
  99 SotClipboardFormatId OFilterItemExchange::getFormatId()
 100 {
 101     static SotClipboardFormatId s_nFormat =
 102          SotExchange::RegisterFormatName("application/x-openoffice;windows_formatname=\"form.FilterControlExchange\"");
 103     DBG_ASSERT(static_cast<SotClipboardFormatId>(-1) != s_nFormat, "OFilterExchangeHelper::getFormatId: bad exchange id!");
 104     return s_nFormat;
 105 }
 106
 107 rtl::Reference<OLocalExchange> OFilterExchangeHelper::createExchange() const
 108 {
 109     return new OFilterItemExchange;
 110 }
 111
 112 OUString FmFilterData::GetImage() const
 113 {
 114     return OUString();
 115 }
 116
 117 FmParentData::~FmParentData()
 118 {
 119 }
 120
 121 OUString FmFormItem::GetImage() const
 122 {
 123     return RID_SVXBMP_FORM;
 124 }
 125
 126 FmFilterItem* FmFilterItems::Find( const ::sal_Int32 _nFilterComponentIndex ) const
 127 {
 128     for ( auto & pData : m_aChildren )
 129     {
 130         FmFilterItem& rCondition = dynamic_cast<FmFilterItem&>(*pData);
 131         if ( _nFilterComponentIndex == rCondition.GetComponentIndex() )
 132             return &rCondition;
 133     }
 134     return nullptr;
 135 }
 136
 137 OUString FmFilterItems::GetImage() const
 138 {
 139     return RID_SVXBMP_FILTER;
 140 }
 141
 142 FmFilterItem::FmFilterItem( FmFilterItems* pParent,
 143                             OUString aFieldName,
 144                             const OUString& aText,
 145                             const sal_Int32 _nComponentIndex )
 146           :FmFilterData(pParent, aText)
 147           ,m_aFieldName(std::move(aFieldName))
 148           ,m_nComponentIndex( _nComponentIndex )
 149 {
 150 }
 151
 152 OUString FmFilterItem::GetImage() const
 153 {
 154     return RID_SVXBMP_FIELD;
 155 }
 156
 157 // Hints for communication between model and view
 158
 159 namespace {
 160
 161 class FmFilterHint : public SfxHint
 162 {
 163     FmFilterData*   m_pData;
 164
 165 public:
 166     explicit FmFilterHint(FmFilterData* pData):m_pData(pData){}
 167     FmFilterData* GetData() const { return m_pData; }
 168 };
 169
 170 class FmFilterInsertedHint : public FmFilterHint
 171 {
 172     size_t m_nPos;   // Position relative to the parent of the data
 173
 174 public:
 175     FmFilterInsertedHint(FmFilterData* pData, size_t nRelPos)
 176         :FmFilterHint(pData)
 177         ,m_nPos(nRelPos){}
 178
 179     size_t GetPos() const { return m_nPos; }
 180 };
 181
 182 class FmFilterRemovedHint : public FmFilterHint
 183 {
 184 public:
 185     explicit FmFilterRemovedHint(FmFilterData* pData)
 186         :FmFilterHint(pData){}
 187 };
 188
 189
 190 class FmFilterTextChangedHint : public FmFilterHint
 191 {
 192 public:
 193     explicit FmFilterTextChangedHint(FmFilterData* pData)
 194         :FmFilterHint(pData){}
 195 };
 196
 197 class FilterClearingHint : public SfxHint
 198 {
 199 public:
 200     FilterClearingHint(){}
 201 };
 202
 203 class FmFilterCurrentChangedHint : public SfxHint
 204 {
 205 public:
 206     FmFilterCurrentChangedHint(){}
 207 };
 208
 209 }
 210
 211 // class FmFilterAdapter, listener at the FilterControls
 212 class FmFilterAdapter : public ::cppu::WeakImplHelper< XFilterControllerListener >
 213 {
 214     FmFilterModel*              m_pModel;
 215     Reference< XIndexAccess >   m_xControllers;
 216
 217 public:
 218     FmFilterAdapter(FmFilterModel* pModel, const Reference< XIndexAccess >& xControllers);
 219
 220 // XEventListener
 221     virtual void SAL_CALL disposing(const EventObject& Source) override;
 222
 223 // XFilterControllerListener
 224     virtual void SAL_CALL predicateExpressionChanged( const FilterEvent& Event ) override;
 225     virtual void SAL_CALL disjunctiveTermRemoved( const FilterEvent& Event ) override;
 226     virtual void SAL_CALL disjunctiveTermAdded( const FilterEvent& Event ) override;
 227
 228 // helpers
 229     /// @throws RuntimeException
 230     void dispose();
 231
 232     void AddOrRemoveListener( const Reference< XIndexAccess >& _rxControllers, const bool _bAdd );
 233
 234     static void setText(sal_Int32 nPos,
 235         const FmFilterItem* pFilterItem,
 236         const OUString& rText);
 237 };
 238
 239
 240 FmFilterAdapter::FmFilterAdapter(FmFilterModel* pModel, const Reference< XIndexAccess >& xControllers)
 241     :m_pModel( pModel )
 242     ,m_xControllers( xControllers )
 243 {
 244     AddOrRemoveListener( m_xControllers, true );
 245 }
 246
 247
 248 void FmFilterAdapter::dispose()
 249 {
 250     AddOrRemoveListener( m_xControllers, false );
 251 }
 252
 253
 254 void FmFilterAdapter::AddOrRemoveListener( const Reference< XIndexAccess >& _rxControllers, const bool _bAdd )
 255 {
 256     for (sal_Int32 i = 0, nLen = _rxControllers->getCount(); i < nLen; ++i)
 257     {
 258         Reference< XIndexAccess > xElement( _rxControllers->getByIndex(i), UNO_QUERY );
 259
 260         // step down
 261         AddOrRemoveListener( xElement, _bAdd );
 262
 263         // handle this particular controller
 264         Reference< XFilterController > xController( xElement, UNO_QUERY );
 265         OSL_ENSURE( xController.is(), "FmFilterAdapter::InsertElements: no XFilterController, cannot sync data!" );
 266         if ( xController.is() )
 267         {
 268             if ( _bAdd )
 269                 xController->addFilterControllerListener( this );
 270             else
 271                 xController->removeFilterControllerListener( this );
 272         }
 273     }
 274 }
 275
 276
 277 void FmFilterAdapter::setText(sal_Int32 nRowPos,
 278                               const FmFilterItem* pFilterItem,
 279                               const OUString& rText)
 280 {
 281     FmFormItem* pFormItem = dynamic_cast<FmFormItem*>( pFilterItem->GetParent()->GetParent()  );
 282     assert(pFormItem);
 283     try
 284     {
 285         Reference< XFilterController > xController( pFormItem->GetController(), UNO_QUERY_THROW );
 286         xController->setPredicateExpression( pFilterItem->GetComponentIndex(), nRowPos, rText );
 287     }
 288     catch( const Exception& )
 289     {
 290         DBG_UNHANDLED_EXCEPTION("svx");
 291     }
 292 }
 293
 294
 295 // XEventListener
 296
 297 void SAL_CALL FmFilterAdapter::disposing(const EventObject& /*e*/)
 298 {
 299 }
 300
 301
 302 namespace
 303 {
 304     OUString lcl_getLabelName_nothrow( const Reference< XControl >& _rxControl )
 305     {
 306         OUString sLabelName;
 307         try
 308         {
 309             Reference< XPropertySet > xModel( _rxControl->getModel(), UNO_QUERY_THROW );
 310             sLabelName = getLabelName( xModel );
 311         }
 312         catch( const Exception& )
 313         {
 314             DBG_UNHANDLED_EXCEPTION("svx");
 315         }
 316         return sLabelName;
 317     }
 318
 319     Reference< XPropertySet > lcl_getBoundField_nothrow( const Reference< XControl >& _rxControl )
 320     {
 321         Reference< XPropertySet > xField;
 322         try
 323         {
 324             Reference< XPropertySet > xModelProps( _rxControl->getModel(), UNO_QUERY_THROW );
 325             xField.set( xModelProps->getPropertyValue( FM_PROP_BOUNDFIELD ), UNO_QUERY_THROW );
 326         }
 327         catch( const Exception& )
 328         {
 329             DBG_UNHANDLED_EXCEPTION("svx");
 330         }
 331         return xField;
 332     }
 333 }
 334
 335 // XFilterControllerListener
 336 void FmFilterAdapter::predicateExpressionChanged( const FilterEvent& Event )
 337 {
 338     SolarMutexGuard aGuard;
 339
 340     if ( !m_pModel )
 341         return;
 342
 343     // the controller which sent the event
 344     Reference< XFormController > xController( Event.Source, UNO_QUERY_THROW );
 345     Reference< XFilterController > xFilterController( Event.Source, UNO_QUERY_THROW );
 346     Reference< XForm > xForm( xController->getModel(), UNO_QUERY_THROW );
 347
 348     FmFormItem* pFormItem = m_pModel->Find( m_pModel->m_aChildren, xForm );
 349     OSL_ENSURE( pFormItem, "FmFilterAdapter::predicateExpressionChanged: don't know this form!" );
 350     if ( !pFormItem )
 351         return;
 352
 353     const sal_Int32 nActiveTerm( xFilterController->getActiveTerm() );
 354
 355     FmFilterData* pData = pFormItem->GetChildren()[nActiveTerm].get();
 356     FmFilterItems& rFilter = dynamic_cast<FmFilterItems&>(*pData);
 357     FmFilterItem* pFilterItem = rFilter.Find( Event.FilterComponent );
 358     if ( pFilterItem )
 359     {
 360         if ( !Event.PredicateExpression.isEmpty())
 361         {
 362             pFilterItem->SetText( Event.PredicateExpression );
 363             // notify the UI
 364             FmFilterTextChangedHint aChangeHint(pFilterItem);
 365             m_pModel->Broadcast( aChangeHint );
 366         }
 367         else
 368         {
 369             // no text anymore so remove the condition
 370             m_pModel->Remove(pFilterItem);
 371         }
 372     }
 373     else
 374     {
 375         // searching the component by field name
 376         OUString aFieldName( lcl_getLabelName_nothrow( xFilterController->getFilterComponent( Event.FilterComponent ) ) );
 377
 378         std::unique_ptr<FmFilterItem> pNewFilterItem(new FmFilterItem(&rFilter, aFieldName, Event.PredicateExpression, Event.FilterComponent));
 379         m_pModel->Insert(rFilter.GetChildren().end(), std::move(pNewFilterItem));
 380     }
 381
 382     // ensure there's one empty term in the filter, just in case the active term was previously empty
 383     m_pModel->EnsureEmptyFilterRows( *pFormItem );
 384 }
 385
 386
 387 void SAL_CALL FmFilterAdapter::disjunctiveTermRemoved( const FilterEvent& Event )
 388 {
 389     SolarMutexGuard aGuard;
 390
 391     Reference< XFormController > xController( Event.Source, UNO_QUERY_THROW );
 392     Reference< XFilterController > xFilterController( Event.Source, UNO_QUERY_THROW );
 393     Reference< XForm > xForm( xController->getModel(), UNO_QUERY_THROW );
 394
 395     FmFormItem* pFormItem = m_pModel->Find( m_pModel->m_aChildren, xForm );
 396     OSL_ENSURE( pFormItem, "FmFilterAdapter::disjunctiveTermRemoved: don't know this form!" );
 397     if ( !pFormItem )
 398         return;
 399
 400     auto& rTermItems = pFormItem->GetChildren();
 401     const bool bValidIndex = ( Event.DisjunctiveTerm >= 0 ) && ( o3tl::make_unsigned(Event.DisjunctiveTerm) < rTermItems.size() );
 402     OSL_ENSURE( bValidIndex, "FmFilterAdapter::disjunctiveTermRemoved: invalid term index!" );
 403     if ( !bValidIndex )
 404         return;
 405
 406     // if the first term was removed, then the to-be first term needs its text updated
 407     if ( Event.DisjunctiveTerm == 0 )
 408     {
 409         rTermItems[1]->SetText( SvxResId(RID_STR_FILTER_FILTER_FOR));
 410         FmFilterTextChangedHint aChangeHint( rTermItems[1].get() );
 411         m_pModel->Broadcast( aChangeHint );
 412     }
 413
 414     // finally remove the entry from the model
 415     m_pModel->Remove( rTermItems.begin() + Event.DisjunctiveTerm );
 416
 417     // ensure there's one empty term in the filter, just in case the currently removed one was the last empty one
 418     m_pModel->EnsureEmptyFilterRows( *pFormItem );
 419 }
 420
 421
 422 void SAL_CALL FmFilterAdapter::disjunctiveTermAdded( const FilterEvent& Event )
 423 {
 424     SolarMutexGuard aGuard;
 425
 426     Reference< XFormController > xController( Event.Source, UNO_QUERY_THROW );
 427     Reference< XFilterController > xFilterController( Event.Source, UNO_QUERY_THROW );
 428     Reference< XForm > xForm( xController->getModel(), UNO_QUERY_THROW );
 429
 430     FmFormItem* pFormItem = m_pModel->Find( m_pModel->m_aChildren, xForm );
 431     OSL_ENSURE( pFormItem, "FmFilterAdapter::disjunctiveTermAdded: don't know this form!" );
 432     if ( !pFormItem )
 433         return;
 434
 435     const sal_Int32 nInsertPos = Event.DisjunctiveTerm;
 436     bool bValidIndex = ( nInsertPos >= 0 ) && ( o3tl::make_unsigned(nInsertPos) <= pFormItem->GetChildren().size() );
 437     if ( !bValidIndex )
 438     {
 439         OSL_FAIL( "FmFilterAdapter::disjunctiveTermAdded: invalid index!" );
 440         return;
 441     }
 442
 443     auto insertPos = pFormItem->GetChildren().begin() + nInsertPos;
 444
 445     // "Filter for" for first position, "Or" for the other positions
 446     std::unique_ptr<FmFilterItems> pFilterItems(new FmFilterItems(pFormItem, (nInsertPos?SvxResId(RID_STR_FILTER_FILTER_OR):SvxResId(RID_STR_FILTER_FILTER_FOR))));
 447     m_pModel->Insert( insertPos, std::move(pFilterItems) );
 448 }
 449
 450
 451 FmFilterModel::FmFilterModel()
 452               :FmParentData(nullptr, OUString())
 453               ,OSQLParserClient(comphelper::getProcessComponentContext())
 454               ,m_pCurrentItems(nullptr)
 455 {
 456 }
 457
 458
 459 FmFilterModel::~FmFilterModel()
 460 {
 461     Clear();
 462 }
 463
 464
 465 void FmFilterModel::Clear()
 466 {
 467     // notify
 468     FilterClearingHint aClearedHint;
 469     Broadcast( aClearedHint );
 470
 471     // lose endings
 472     if (m_pAdapter.is())
 473     {
 474         m_pAdapter->dispose();
 475         m_pAdapter.clear();
 476     }
 477
 478     m_pCurrentItems  = nullptr;
 479     m_xController    = nullptr;
 480     m_xControllers   = nullptr;
 481
 482     m_aChildren.clear();
 483 }
 484
 485
 486 void FmFilterModel::Update(const Reference< XIndexAccess > & xControllers, const Reference< XFormController > & xCurrent)
 487 {
 488     if ( xCurrent == m_xController )
 489         return;
 490
 491     if (!xControllers.is())
 492     {
 493         Clear();
 494         return;
 495     }
 496
 497     // there is only a new current controller
 498     if ( m_xControllers != xControllers )
 499     {
 500         Clear();
 501
 502         m_xControllers = xControllers;
 503         Update(m_xControllers, this);
 504
 505         DBG_ASSERT(xCurrent.is(), "FmFilterModel::Update(...) no current controller");
 506
 507         // Listening for TextChanges
 508         m_pAdapter = new FmFilterAdapter(this, xControllers);
 509
 510         SetCurrentController(xCurrent);
 511         EnsureEmptyFilterRows( *this );
 512     }
 513     else
 514         SetCurrentController(xCurrent);
 515 }
 516
 517
 518 void FmFilterModel::Update(const Reference< XIndexAccess > & xControllers, FmParentData* pParent)
 519 {
 520     try
 521     {
 522         sal_Int32 nCount = xControllers->getCount();
 523         for ( sal_Int32 i = 0; i < nCount; ++i )
 524         {
 525             Reference< XFormController > xController( xControllers->getByIndex(i), UNO_QUERY_THROW );
 526
 527             Reference< XPropertySet > xFormProperties( xController->getModel(), UNO_QUERY_THROW );
 528             OUString aName;
 529             OSL_VERIFY( xFormProperties->getPropertyValue( FM_PROP_NAME ) >>= aName );
 530
 531             // Insert a new item for the form
 532             FmFormItem* pFormItem = new FmFormItem( pParent, xController, aName );
 533             Insert( pParent->GetChildren().end(), std::unique_ptr<FmFilterData>(pFormItem) );
 534
 535             Reference< XFilterController > xFilterController( pFormItem->GetFilterController(), UNO_SET_THROW );
 536
 537             // insert the existing filters for the form
 538             OUString aTitle(SvxResId(RID_STR_FILTER_FILTER_FOR));
 539
 540             const Sequence< Sequence< OUString > > aExpressions = xFilterController->getPredicateExpressions();
 541             for ( auto const & conjunctionTerm : aExpressions )
 542             {
 543                 // we always display one row, even if there's no term to be displayed
 544                 FmFilterItems* pFilterItems = new FmFilterItems( pFormItem, aTitle );
 545                 Insert( pFormItem->GetChildren().end(), std::unique_ptr<FmFilterData>(pFilterItems) );
 546
 547                 const Sequence< OUString >& rDisjunction( conjunctionTerm );
 548                 sal_Int32 nComponentIndex = -1;
 549                 for ( const OUString& rDisjunctiveTerm : rDisjunction )
 550                 {
 551                     ++nComponentIndex;
 552
 553                     if ( rDisjunctiveTerm.isEmpty() )
 554                         // no condition for this particular component in this particular conjunction term
 555                         continue;
 556
 557                     // determine the display name of the control
 558                     const Reference< XControl > xFilterControl( xFilterController->getFilterComponent( nComponentIndex ) );
 559                     const OUString sDisplayName( lcl_getLabelName_nothrow( xFilterControl ) );
 560
 561                     // insert a new entry
 562                     std::unique_ptr<FmFilterItem> pANDCondition(new FmFilterItem( pFilterItems, sDisplayName, rDisjunctiveTerm, nComponentIndex ));
 563                     Insert( pFilterItems->GetChildren().end(), std::move(pANDCondition) );
 564                 }
 565
 566                 // title for the next conditions
 567                 aTitle = SvxResId( RID_STR_FILTER_FILTER_OR );
 568             }
 569
 570             // now add dependent controllers
 571             Update( xController, pFormItem );
 572         }
 573     }
 574     catch( const Exception& )
 575     {
 576         DBG_UNHANDLED_EXCEPTION("svx");
 577     }
 578 }
 579
 580
 581 FmFormItem* FmFilterModel::Find(const ::std::vector<std::unique_ptr<FmFilterData>>& rItems, const Reference< XFormController > & xController) const
 582 {
 583     for (const auto& rItem : rItems)
 584     {
 585         FmFormItem* pForm = dynamic_cast<FmFormItem*>( rItem.get() );
 586         if (pForm)
 587         {
 588             if ( xController == pForm->GetController() )
 589                 return pForm;
 590             else
 591             {
 592                 pForm = Find(pForm->GetChildren(), xController);
 593                 if (pForm)
 594                     return pForm;
 595             }
 596         }
 597     }
 598     return nullptr;
 599 }
 600
 601
 602 FmFormItem* FmFilterModel::Find(const ::std::vector<std::unique_ptr<FmFilterData>>& rItems, const Reference< XForm >& xForm) const
 603 {
 604     for (const auto& rItem : rItems)
 605     {
 606         FmFormItem* pForm = dynamic_cast<FmFormItem*>( rItem.get() );
 607         if (pForm)
 608         {
 609             if (xForm == pForm->GetController()->getModel())
 610                 return pForm;
 611             else
 612             {
 613                 pForm = Find(pForm->GetChildren(), xForm);
 614                 if (pForm)
 615                     return pForm;
 616             }
 617         }
 618     }
 619     return nullptr;
 620 }
 621
 622 void FmFilterModel::SetCurrentController(const Reference< XFormController > & xCurrent)
 623 {
 624     if ( xCurrent == m_xController )
 625         return;
 626
 627     m_xController = xCurrent;
 628
 629     FmFormItem* pItem = Find( m_aChildren, xCurrent );
 630     if ( !pItem )
 631         return;
 632
 633     try
 634     {
 635         Reference< XFilterController > xFilterController( m_xController, UNO_QUERY_THROW );
 636         const sal_Int32 nActiveTerm( xFilterController->getActiveTerm() );
 637         if (nActiveTerm != -1 && pItem->GetChildren().size() > o3tl::make_unsigned(nActiveTerm))
 638         {
 639             SetCurrentItems( static_cast< FmFilterItems* >( pItem->GetChildren()[ nActiveTerm ].get() ) );
 640         }
 641     }
 642     catch( const Exception& )
 643     {
 644         DBG_UNHANDLED_EXCEPTION("svx");
 645     }
 646 }
 647
 648 void FmFilterModel::AppendFilterItems( FmFormItem& _rFormItem )
 649 {
 650     // insert the condition behind the last filter items
 651     auto iter = std::find_if(_rFormItem.GetChildren().rbegin(), _rFormItem.GetChildren().rend(),
 652         [](const std::unique_ptr<FmFilterData>& rChild) { return dynamic_cast<const FmFilterItems*>(rChild.get()) != nullptr; });
 653
 654     sal_Int32 nInsertPos = iter.base() - _rFormItem.GetChildren().begin();
 655     // delegate this to the FilterController, it will notify us, which will let us update our model
 656     try
 657     {
 658         Reference< XFilterController > xFilterController( _rFormItem.GetFilterController(), UNO_SET_THROW );
 659         if ( nInsertPos >= xFilterController->getDisjunctiveTerms() )
 660             xFilterController->appendEmptyDisjunctiveTerm();
 661     }
 662     catch( const Exception& )
 663     {
 664         DBG_UNHANDLED_EXCEPTION("svx");
 665     }
 666 }
 667
 668 void FmFilterModel::Insert(const ::std::vector<std::unique_ptr<FmFilterData>>::iterator& rPos, std::unique_ptr<FmFilterData> pData)
 669 {
 670     auto pTemp = pData.get();
 671     size_t nPos;
 672     ::std::vector<std::unique_ptr<FmFilterData>>& rItems = pData->GetParent()->GetChildren();
 673     if (rPos == rItems.end())
 674     {
 675         nPos = rItems.size();
 676         rItems.push_back(std::move(pData));
 677     }
 678     else
 679     {
 680         nPos = rPos - rItems.begin();
 681         rItems.insert(rPos, std::move(pData));
 682     }
 683
 684     // notify the UI
 685     FmFilterInsertedHint aInsertedHint(pTemp, nPos);
 686     Broadcast( aInsertedHint );
 687 }
 688
 689 void FmFilterModel::Remove(FmFilterData* pData)
 690 {
 691     FmParentData* pParent = pData->GetParent();
 692     ::std::vector<std::unique_ptr<FmFilterData>>& rItems = pParent->GetChildren();
 693
 694     // erase the item from the model
 695     auto i = ::std::find_if(rItems.begin(), rItems.end(),
 696             [&](const std::unique_ptr<FmFilterData>& p) { return p.get() == pData; } );
 697     DBG_ASSERT(i != rItems.end(), "FmFilterModel::Remove(): unknown Item");
 698     // position within the parent
 699     sal_Int32 nPos = i - rItems.begin();
 700     if (auto pFilterItems = dynamic_cast<FmFilterItems*>( pData))
 701     {
 702         FmFormItem* pFormItem = static_cast<FmFormItem*>(pParent);
 703
 704         try
 705         {
 706             Reference< XFilterController > xFilterController( pFormItem->GetFilterController(), UNO_SET_THROW );
 707
 708             bool bEmptyLastTerm = ( ( nPos == 0 ) && xFilterController->getDisjunctiveTerms() == 1 );
 709             if ( bEmptyLastTerm )
 710             {
 711                 // remove all children (by setting an empty predicate expression)
 712                 ::std::vector< std::unique_ptr<FmFilterData> >& rChildren = pFilterItems->GetChildren();
 713                 while ( !rChildren.empty() )
 714                 {
 715                     auto removePos = rChildren.end() - 1;
 716                     if (FmFilterItem* pFilterItem = dynamic_cast<FmFilterItem*>( removePos->get() ))
 717                     {
 718                         FmFilterAdapter::setText( nPos, pFilterItem, OUString() );
 719                     }
 720                     Remove( removePos );
 721                 }
 722             }
 723             else
 724             {
 725                 xFilterController->removeDisjunctiveTerm( nPos );
 726             }
 727         }
 728         catch( const Exception& )
 729         {
 730             DBG_UNHANDLED_EXCEPTION("svx");
 731         }
 732     }
 733     else // FormItems can not be deleted
 734     {
 735         FmFilterItem& rFilterItem = dynamic_cast<FmFilterItem&>(*pData);
 736
 737         // if it's the last condition remove the parent
 738         if (rItems.size() == 1)
 739             Remove(rFilterItem.GetParent());
 740         else
 741         {
 742             // find the position of the father within his father
 743             ::std::vector<std::unique_ptr<FmFilterData>>& rParentParentItems = pData->GetParent()->GetParent()->GetChildren();
 744             auto j = ::std::find_if(rParentParentItems.begin(), rParentParentItems.end(),
 745                 [&](const std::unique_ptr<FmFilterData>& p) { return p.get() == rFilterItem.GetParent(); });
 746             DBG_ASSERT(j != rParentParentItems.end(), "FmFilterModel::Remove(): unknown Item");
 747             sal_Int32 nParentPos = j - rParentParentItems.begin();
 748
 749             // EmptyText removes the filter
 750             FmFilterAdapter::setText(nParentPos, &rFilterItem, OUString());
 751             Remove( i );
 752         }
 753     }
 754 }
 755
 756 void FmFilterModel::Remove( const ::std::vector<std::unique_ptr<FmFilterData>>::iterator& rPos )
 757 {
 758     // remove from parent's child list
 759     std::unique_ptr<FmFilterData> pData = std::move(*rPos);
 760     pData->GetParent()->GetChildren().erase( rPos );
 761
 762     // notify the view, this will remove the actual SvTreeListEntry
 763     FmFilterRemovedHint aRemoveHint( pData.get() );
 764     Broadcast( aRemoveHint );
 765 }
 766
 767
 768 bool FmFilterModel::ValidateText(FmFilterItem const * pItem, OUString& rText, OUString& rErrorMsg) const
 769 {
 770     FmFormItem* pFormItem = dynamic_cast<FmFormItem*>( pItem->GetParent()->GetParent()  );
 771     assert(pFormItem);
 772     try
 773     {
 774         Reference< XFormController > xFormController( pFormItem->GetController() );
 775         // obtain the connection of the form belonging to the controller
 776         Reference< XRowSet > xRowSet( xFormController->getModel(), UNO_QUERY_THROW );
 777         Reference< XConnection > xConnection( getConnection( xRowSet ) );
 778
 779         // obtain a number formatter for this connection
 780         // TODO: shouldn't this be cached?
 781         Reference< XNumberFormatsSupplier > xFormatSupplier = getNumberFormats( xConnection, true );
 782         Reference< XNumberFormatter > xFormatter( NumberFormatter::create( comphelper::getProcessComponentContext() ), UNO_QUERY_THROW );
 783         xFormatter->attachNumberFormatsSupplier( xFormatSupplier );
 784
 785         // get the field (database column) which the item is responsible for
 786         Reference< XFilterController > xFilterController( xFormController, UNO_QUERY_THROW );
 787         Reference< XPropertySet > xField( lcl_getBoundField_nothrow( xFilterController->getFilterComponent( pItem->GetComponentIndex() ) ), UNO_SET_THROW );
 788
 789         // parse the given text as filter predicate
 790         OUString aErr, aTxt( rText );
 791         std::unique_ptr< OSQLParseNode > pParseNode = predicateTree( aErr, aTxt, xFormatter, xField );
 792         rErrorMsg = aErr;
 793         rText = aTxt;
 794         if ( pParseNode != nullptr )
 795         {
 796             OUString aPreparedText;
 797             Locale aAppLocale = Application::GetSettings().GetUILanguageTag().getLocale();
 798             pParseNode->parseNodeToPredicateStr(
 799                 aPreparedText, xConnection, xFormatter, xField, OUString(), aAppLocale, OUString("."), getParseContext() );
 800             rText = aPreparedText;
 801             return true;
 802         }
 803     }
 804     catch( const Exception& )
 805     {
 806         DBG_UNHANDLED_EXCEPTION("svx");
 807     }
 808
 809     return false;
 810 }
 811
 812
 813 void FmFilterModel::Append(FmFilterItems* pItems, std::unique_ptr<FmFilterItem> pFilterItem)
 814 {
 815     Insert(pItems->GetChildren().end(), std::move(pFilterItem));
 816 }
 817
 818
 819 void FmFilterModel::SetTextForItem(FmFilterItem* pItem, const OUString& rText)
 820 {
 821     ::std::vector<std::unique_ptr<FmFilterData>>& rItems = pItem->GetParent()->GetParent()->GetChildren();
 822     auto i = ::std::find_if(rItems.begin(), rItems.end(),
 823                 [&](const std::unique_ptr<FmFilterData>& p) { return p.get() == pItem->GetParent(); });
 824     sal_Int32 nParentPos = i - rItems.begin();
 825
 826     FmFilterAdapter::setText(nParentPos, pItem, rText);
 827
 828     if (rText.isEmpty())
 829         Remove(pItem);
 830     else
 831     {
 832         // Change the text
 833         pItem->SetText(rText);
 834         FmFilterTextChangedHint aChangeHint(pItem);
 835         Broadcast( aChangeHint );
 836     }
 837 }
 838
 839
 840 void FmFilterModel::SetCurrentItems(FmFilterItems* pCurrent)
 841 {
 842     if (m_pCurrentItems == pCurrent)
 843         return;
 844
 845     // search for the condition
 846     if (pCurrent)
 847     {
 848         FmFormItem* pFormItem = static_cast<FmFormItem*>(pCurrent->GetParent());
 849         ::std::vector<std::unique_ptr<FmFilterData>>& rItems = pFormItem->GetChildren();
 850         auto i = ::std::find_if(rItems.begin(), rItems.end(),
 851                     [&](const std::unique_ptr<FmFilterData>& p) { return p.get() == pCurrent; });
 852
 853         if (i != rItems.end())
 854         {
 855             // determine the filter position
 856             sal_Int32 nPos = i - rItems.begin();
 857             try
 858             {
 859                 Reference< XFilterController > xFilterController( pFormItem->GetFilterController(), UNO_SET_THROW );
 860                 xFilterController->setActiveTerm( nPos );
 861             }
 862             catch( const Exception& )
 863             {
 864                 DBG_UNHANDLED_EXCEPTION("svx");
 865             }
 866
 867             if ( m_xController != pFormItem->GetController() )
 868                 // calls SetCurrentItems again
 869                 SetCurrentController( pFormItem->GetController() );
 870             else
 871                 m_pCurrentItems = pCurrent;
 872         }
 873         else
 874             m_pCurrentItems = nullptr;
 875     }
 876     else
 877         m_pCurrentItems = nullptr;
 878
 879
 880     // notify the UI
 881     FmFilterCurrentChangedHint aHint;
 882     Broadcast( aHint );
 883 }
 884
 885
 886 void FmFilterModel::EnsureEmptyFilterRows( FmParentData& _rItem )
 887 {
 888     // checks whether for each form there's one free level for input
 889     ::std::vector< std::unique_ptr<FmFilterData> >& rChildren = _rItem.GetChildren();
 890     bool bAppendLevel = dynamic_cast<const FmFormItem*>(&_rItem) !=  nullptr;
 891
 892     for ( const auto& rpChild : rChildren )
 893     {
 894         FmFilterItems* pItems = dynamic_cast<FmFilterItems*>( rpChild.get() );
 895         if ( pItems && pItems->GetChildren().empty() )
 896         {
 897             bAppendLevel = false;
 898             break;
 899         }
 900
 901         FmFormItem* pFormItem = dynamic_cast<FmFormItem*>( rpChild.get() );
 902         if (pFormItem)
 903         {
 904             EnsureEmptyFilterRows( *pFormItem );
 905             continue;
 906         }
 907     }
 908
 909     if ( bAppendLevel )
 910     {
 911         FmFormItem* pFormItem = dynamic_cast<FmFormItem*>( &_rItem  );
 912         OSL_ENSURE( pFormItem, "FmFilterModel::EnsureEmptyFilterRows: no FmFormItem, but a FmFilterItems child?" );
 913         if ( pFormItem )
 914             AppendFilterItems( *pFormItem );
 915     }
 916 }
 917
 918 const int nxD = 4;
 919 const int nxDBmp = 12;
 920
 921 IMPL_STATIC_LINK(FmFilterNavigator, CustomGetSizeHdl, weld::TreeView::get_size_args, aPayload, Size)
 922 {
 923     vcl::RenderContext& rRenderContext = aPayload.first;
 924     const OUString& rId = aPayload.second;
 925
 926     Size aSize;
 927
 928     FmFilterData* pData = weld::fromId<FmFilterData*>(rId);
 929     OUString sText = pData->GetText();
 930
 931     if (FmFilterItem* pItem = dynamic_cast<FmFilterItem*>(pData))
 932     {
 933         rRenderContext.Push(vcl::PushFlags::FONT);
 934         vcl::Font aFont(rRenderContext.GetFont());
 935         aFont.SetWeight(WEIGHT_BOLD);
 936         rRenderContext.SetFont(aFont);
 937
 938         OUString sName = pItem->GetFieldName() + ": ";
 939         aSize = Size(rRenderContext.GetTextWidth(sName), rRenderContext.GetTextHeight());
 940
 941         rRenderContext.Pop();
 942
 943         aSize.AdjustWidth(rRenderContext.GetTextWidth(sText) + nxD);
 944     }
 945     else
 946     {
 947         aSize = Size(rRenderContext.GetTextWidth(sText), rRenderContext.GetTextHeight());
 948         if (dynamic_cast<FmFilterItems*>(pData))
 949             aSize.AdjustWidth(nxDBmp);
 950     }
 951
 952     return aSize;
 953 }
 954
 955 IMPL_STATIC_LINK(FmFilterNavigator, CustomRenderHdl, weld::TreeView::render_args, aPayload, void)
 956 {
 957     vcl::RenderContext& rRenderContext = std::get<0>(aPayload);
 958     const ::tools::Rectangle& rRect = std::get<1>(aPayload);
 959     ::tools::Rectangle aRect(rRect.TopLeft(), Size(rRenderContext.GetOutputSize().Width() - rRect.Left(), rRect.GetHeight()));
 960     bool bSelected = std::get<2>(aPayload);
 961     const OUString& rId = std::get<3>(aPayload);
 962
 963     rRenderContext.Push(vcl::PushFlags::TEXTCOLOR);
 964     const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();
 965     if (bSelected)
 966         rRenderContext.SetTextColor(rStyleSettings.GetHighlightTextColor());
 967     else
 968         rRenderContext.SetTextColor(rStyleSettings.GetDialogTextColor());
 969
 970     FmFilterData* pData = weld::fromId<FmFilterData*>(rId);
 971     OUString sText = pData->GetText();
 972     Point aPos(aRect.TopLeft());
 973
 974     if (FmFilterItem* pFilter = dynamic_cast<FmFilterItem*>(pData))
 975     {
 976         vcl::Font aFont(rRenderContext.GetFont());
 977         aFont.SetWeight(WEIGHT_BOLD);
 978
 979         rRenderContext.Push(vcl::PushFlags::FONT);
 980         rRenderContext.SetFont(aFont);
 981
 982         OUString sName = pFilter->GetFieldName() + ": ";
 983         rRenderContext.DrawText(aPos, sName);
 984
 985         // position for the second text
 986         aPos.AdjustX(rRenderContext.GetTextWidth(sName) + nxD);
 987         rRenderContext.Pop();
 988
 989         rRenderContext.DrawText(aPos, sText);
 990     }
 991     else if (FmFilterItems* pRow = dynamic_cast<FmFilterItems*>(pData))
 992     {
 993         FmFormItem* pForm = static_cast<FmFormItem*>(pRow->GetParent());
 994
 995         // current filter is significant painted
 996         const bool bIsCurrentFilter = pForm->GetChildren()[ pForm->GetFilterController()->getActiveTerm() ].get() == pRow;
 997         if (bIsCurrentFilter)
 998         {
 999             rRenderContext.Push(vcl::PushFlags::LINECOLOR);
1000             rRenderContext.SetLineColor(rRenderContext.GetTextColor());
1001
1002             Point aFirst(aPos.X(), aRect.Bottom() - 6);
1003             Point aSecond(aFirst .X() + 2, aFirst.Y() + 3);
1004
1005             rRenderContext.DrawLine(aFirst, aSecond);
1006
1007             aFirst = aSecond;
1008             aFirst.AdjustX(1);
1009             aSecond.AdjustX(6);
1010             aSecond.AdjustY(-5);
1011
1012             rRenderContext.DrawLine(aFirst, aSecond);
1013             rRenderContext.Pop();
1014         }
1015
1016         rRenderContext.DrawText(Point(aPos.X() + nxDBmp, aPos.Y()), sText);
1017     }
1018     else
1019         rRenderContext.DrawText(aPos, sText);
1020
1021     rRenderContext.Pop();
1022 }
1023
1024 FmFilterNavigatorDropTarget::FmFilterNavigatorDropTarget(FmFilterNavigator& rTreeView)
1025     : DropTargetHelper(rTreeView.get_widget().get_drop_target())
1026     , m_rTreeView(rTreeView)
1027 {
1028 }
1029
1030 sal_Int8 FmFilterNavigatorDropTarget::AcceptDrop(const AcceptDropEvent& rEvt)
1031 {
1032     sal_Int8 nAccept = m_rTreeView.AcceptDrop(rEvt);
1033
1034     if (nAccept != DND_ACTION_NONE)
1035     {
1036         // to enable the autoscroll when we're close to the edges
1037         weld::TreeView& rWidget = m_rTreeView.get_widget();
1038         rWidget.get_dest_row_at_pos(rEvt.maPosPixel, nullptr, true);
1039     }
1040
1041     return nAccept;
1042 }
1043
1044 sal_Int8 FmFilterNavigatorDropTarget::ExecuteDrop(const ExecuteDropEvent& rEvt)
1045 {
1046     return m_rTreeView.ExecuteDrop(rEvt);
1047 }
1048
1049 FmFilterNavigator::FmFilterNavigator(vcl::Window* pTopLevel, std::unique_ptr<weld::TreeView> xTreeView)
1050     : m_xTopLevel(pTopLevel)
1051     , m_xTreeView(std::move(xTreeView))
1052     , m_aDropTargetHelper(*this)
1053     , m_nAsyncRemoveEvent(nullptr)
1054 {
1055     m_xTreeView->set_help_id(HID_FILTER_NAVIGATOR);
1056
1057     m_xTreeView->set_selection_mode(SelectionMode::Multiple);
1058
1059     m_pModel.reset( new FmFilterModel() );
1060     StartListening( *m_pModel );
1061
1062     m_xTreeView->connect_custom_get_size(LINK(this, FmFilterNavigator, CustomGetSizeHdl));
1063     m_xTreeView->connect_custom_render(LINK(this, FmFilterNavigator, CustomRenderHdl));
1064     m_xTreeView->set_column_custom_renderer(0, true);
1065
1066     m_xTreeView->connect_changed(LINK(this, FmFilterNavigator, SelectHdl));
1067     m_xTreeView->connect_key_press(LINK(this, FmFilterNavigator, KeyInputHdl));
1068     m_xTreeView->connect_popup_menu(LINK(this, FmFilterNavigator, PopupMenuHdl));
1069     m_xTreeView->connect_editing(LINK(this, FmFilterNavigator, EditingEntryHdl),
1070                                  LINK(this, FmFilterNavigator, EditedEntryHdl));
1071     m_xTreeView->connect_drag_begin(LINK(this, FmFilterNavigator, DragBeginHdl));
1072 }
1073
1074 FmFilterNavigator::~FmFilterNavigator()
1075 {
1076     if (m_nAsyncRemoveEvent)
1077         Application::RemoveUserEvent(m_nAsyncRemoveEvent);
1078     EndListening(*m_pModel);
1079     m_pModel.reset();
1080 }
1081
1082 void FmFilterNavigator::UpdateContent(const Reference< XIndexAccess > & xControllers, const Reference< XFormController > & xCurrent)
1083 {
1084     if (xCurrent == m_pModel->GetCurrentController())
1085         return;
1086
1087     m_pModel->Update(xControllers, xCurrent);
1088
1089     // expand the filters for the current controller
1090     std::unique_ptr<weld::TreeIter> xEntry = FindEntry(m_pModel->GetCurrentForm());
1091     if (!xEntry || m_xTreeView->get_row_expanded(*xEntry))
1092         return;
1093
1094     m_xTreeView->unselect_all();
1095
1096     m_xTreeView->expand_row(*xEntry);
1097
1098     xEntry = FindEntry(m_pModel->GetCurrentItems());
1099     if (xEntry)
1100     {
1101         if (!m_xTreeView->get_row_expanded(*xEntry))
1102             m_xTreeView->expand_row(*xEntry);
1103         m_xTreeView->select(*xEntry);
1104         SelectHdl(*m_xTreeView);
1105     }
1106 }
1107
1108 IMPL_LINK(FmFilterNavigator, EditingEntryHdl, const weld::TreeIter&, rIter, bool)
1109 {
1110     // returns true to allow editing
1111     if (dynamic_cast<const FmFilterItem*>(weld::fromId<FmFilterData*>(m_xTreeView->get_id(rIter))))
1112     {
1113         m_xEditingCurrently = m_xTreeView->make_iterator(&rIter);
1114         return true;
1115     }
1116     m_xEditingCurrently.reset();
1117     return false;
1118 }
1119
1120 IMPL_LINK(FmFilterNavigator, EditedEntryHdl, const IterString&, rIterString, bool)
1121 {
1122     const weld::TreeIter& rIter = rIterString.first;
1123     const OUString& rNewText = rIterString.second;
1124
1125     assert(m_xEditingCurrently && m_xTreeView->iter_compare(rIter, *m_xEditingCurrently) == 0 &&
1126                "FmFilterNavigator::EditedEntry: suspicious entry!");
1127     m_xEditingCurrently.reset();
1128
1129     FmFilterData* pData = weld::fromId<FmFilterData*>(m_xTreeView->get_id(rIter));
1130
1131     DBG_ASSERT(dynamic_cast<const FmFilterItem*>(pData) != nullptr,
1132                     "FmFilterNavigator::EditedEntry() wrong entry");
1133
1134     OUString aText(comphelper::string::strip(rNewText, ' '));
1135     if (aText.isEmpty())
1136     {
1137         // deleting the entry asynchron
1138         m_nAsyncRemoveEvent = Application::PostUserEvent(LINK(this, FmFilterNavigator, OnRemove), pData);
1139     }
1140     else
1141     {
1142         OUString aErrorMsg;
1143
1144         if (m_pModel->ValidateText(static_cast<FmFilterItem*>(pData), aText, aErrorMsg))
1145         {
1146             // this will set the text at the FmFilterItem, as well as update any filter controls
1147             // which are connected to this particular entry
1148             m_pModel->SetTextForItem(static_cast<FmFilterItem*>(pData), aText);
1149             m_xTreeView->set_text(rIter, aText);
1150         }
1151         else
1152         {
1153             // display the error and return sal_False
1154             SQLContext aError;
1155             aError.Message = SvxResId(RID_STR_SYNTAXERROR);
1156             aError.Details = aErrorMsg;
1157             displayException(aError, VCLUnoHelper::GetInterface(m_xTopLevel));
1158
1159             return false;
1160         }
1161     }
1162     return true;
1163 }
1164
1165 IMPL_LINK( FmFilterNavigator, OnRemove, void*, p, void )
1166 {
1167     m_nAsyncRemoveEvent = nullptr;
1168     // now remove the entry
1169     m_pModel->Remove(static_cast<FmFilterData*>(p));
1170 }
1171
1172 sal_Int8 FmFilterNavigator::AcceptDrop( const AcceptDropEvent& rEvt )
1173 {
1174     if (!m_aControlExchange.isDragSource())
1175         return DND_ACTION_NONE;
1176
1177     if (!OFilterItemExchange::hasFormat(m_aDropTargetHelper.GetDataFlavorExVector()))
1178         return DND_ACTION_NONE;
1179
1180     // do we contain the formitem?
1181     if (!FindEntry(m_aControlExchange->getFormItem()))
1182         return DND_ACTION_NONE;
1183
1184     Point aDropPos = rEvt.maPosPixel;
1185     std::unique_ptr<weld::TreeIter> xDropTarget(m_xTreeView->make_iterator());
1186     // get_dest_row_at_pos with false cause we must drop exactly "on" a node to paste a condition into it
1187     if (!m_xTreeView->get_dest_row_at_pos(aDropPos, xDropTarget.get(), false))
1188         xDropTarget.reset();
1189
1190     if (!xDropTarget)
1191         return DND_ACTION_NONE;
1192
1193     FmFilterData* pData = weld::fromId<FmFilterData*>(m_xTreeView->get_id(*xDropTarget));
1194     FmFormItem* pForm = nullptr;
1195     if (dynamic_cast<const FmFilterItem*>(pData) !=  nullptr)
1196     {
1197         pForm = dynamic_cast<FmFormItem*>( pData->GetParent()->GetParent() );
1198         if (pForm != m_aControlExchange->getFormItem())
1199             return DND_ACTION_NONE;
1200     }
1201     else if (dynamic_cast<const FmFilterItems*>( pData) !=  nullptr)
1202     {
1203         pForm = dynamic_cast<FmFormItem*>( pData->GetParent() );
1204         if (pForm != m_aControlExchange->getFormItem())
1205             return DND_ACTION_NONE;
1206     }
1207     else
1208         return DND_ACTION_NONE;
1209
1210     return rEvt.mnAction;
1211 }
1212
1213 namespace
1214 {
1215     FmFilterItems* getTargetItems(const weld::TreeView& rTreeView, const weld::TreeIter& rTarget)
1216     {
1217         FmFilterData* pData = weld::fromId<FmFilterData*>(rTreeView.get_id(rTarget));
1218         FmFilterItems*  pTargetItems = dynamic_cast<FmFilterItems*>(pData);
1219         if (!pTargetItems)
1220             pTargetItems = dynamic_cast<FmFilterItems*>(pData->GetParent());
1221         return pTargetItems;
1222     }
1223 }
1224
1225 sal_Int8 FmFilterNavigator::ExecuteDrop( const ExecuteDropEvent& rEvt )
1226 {
1227     if (!m_aControlExchange.isDragSource())
1228         return DND_ACTION_NONE;
1229
1230     Point aDropPos = rEvt.maPosPixel;
1231     std::unique_ptr<weld::TreeIter> xDropTarget(m_xTreeView->make_iterator());
1232     // get_dest_row_at_pos with false cause we must drop exactly "on" a node to paste a condition into it
1233     if (!m_xTreeView->get_dest_row_at_pos(aDropPos, xDropTarget.get(), false))
1234         xDropTarget.reset();
1235     if (!xDropTarget)
1236         return DND_ACTION_NONE;
1237
1238     // search the container where to add the items
1239     FmFilterItems* pTargetItems = getTargetItems(*m_xTreeView, *xDropTarget);
1240     m_xTreeView->unselect_all();
1241     std::unique_ptr<weld::TreeIter> xEntry = FindEntry(pTargetItems);
1242     if (xEntry)
1243     {
1244         m_xTreeView->select(*xEntry);
1245         m_xTreeView->set_cursor(*xEntry);
1246     }
1247
1248     insertFilterItem(m_aControlExchange->getDraggedEntries(),pTargetItems,DND_ACTION_COPY == rEvt.mnAction);
1249
1250     return DND_ACTION_COPY;
1251 }
1252
1253 IMPL_LINK_NOARG(FmFilterNavigator, SelectHdl, weld::TreeView&, void)
1254 {
1255     std::unique_ptr<weld::TreeIter> xIter(m_xTreeView->make_iterator());
1256     if (!m_xTreeView->get_selected(xIter.get()))
1257         return;
1258
1259     FmFilterData* pData = weld::fromId<FmFilterData*>(m_xTreeView->get_id(*xIter));
1260
1261     FmFormItem* pFormItem = nullptr;
1262     if (FmFilterItem* pItem = dynamic_cast<FmFilterItem*>(pData))
1263         pFormItem = static_cast<FmFormItem*>(pItem->GetParent()->GetParent());
1264     else if (FmFilterItems* pItems = dynamic_cast<FmFilterItems*>(pData))
1265         pFormItem = static_cast<FmFormItem*>(pItems->GetParent()->GetParent());
1266     else
1267         pFormItem = dynamic_cast<FmFormItem*>(pData);
1268
1269     if (pFormItem)
1270     {
1271         // will the controller be exchanged?
1272         if (FmFilterItem* pItem = dynamic_cast<FmFilterItem*>(pData))
1273             m_pModel->SetCurrentItems(static_cast<FmFilterItems*>(pItem->GetParent()));
1274         else if (FmFilterItems* pItems = dynamic_cast<FmFilterItems*>(pData))
1275             m_pModel->SetCurrentItems(pItems);
1276         else
1277             m_pModel->SetCurrentController(pFormItem->GetController());
1278     }
1279 }
1280
1281 void FmFilterNavigator::Notify( SfxBroadcaster& /*rBC*/, const SfxHint& rHint )
1282 {
1283     if (const FmFilterInsertedHint* pInsertHint = dynamic_cast<const FmFilterInsertedHint*>(&rHint))
1284     {
1285         Insert(pInsertHint->GetData(), pInsertHint->GetPos());
1286     }
1287     else if( dynamic_cast<const FilterClearingHint*>(&rHint) )
1288     {
1289         m_xTreeView->clear();
1290     }
1291     else if (const FmFilterRemovedHint* pRemoveHint = dynamic_cast<const FmFilterRemovedHint*>(&rHint))
1292     {
1293         Remove(pRemoveHint->GetData());
1294     }
1295     else if (const FmFilterTextChangedHint *pChangeHint = dynamic_cast<const FmFilterTextChangedHint*>(&rHint))
1296     {
1297         std::unique_ptr<weld::TreeIter> xEntry = FindEntry(pChangeHint->GetData());
1298         if (xEntry)
1299             m_xTreeView->set_text(*xEntry, pChangeHint->GetData()->GetText());
1300     }
1301     else if( dynamic_cast<const FmFilterCurrentChangedHint*>(&rHint) )
1302     {
1303         m_xTreeView->queue_draw();
1304     }
1305 }
1306
1307 std::unique_ptr<weld::TreeIter> FmFilterNavigator::FindEntry(const FmFilterData* pItem) const
1308 {
1309     if (!pItem)
1310         return nullptr;
1311     std::unique_ptr<weld::TreeIter> xEntry = m_xTreeView->make_iterator();
1312     if (!m_xTreeView->get_iter_first(*xEntry))
1313         return nullptr;
1314     do
1315     {
1316         FmFilterData* pEntryItem = weld::fromId<FmFilterData*>(m_xTreeView->get_id(*xEntry));
1317         if (pEntryItem == pItem)
1318             return xEntry;
1319     }
1320     while (m_xTreeView->iter_next(*xEntry));
1321
1322     return nullptr;
1323 }
1324
1325 void FmFilterNavigator::Insert(const FmFilterData* pItem, int nPos)
1326 {
1327     const FmParentData* pParent = pItem->GetParent() ? pItem->GetParent() : m_pModel.get();
1328
1329     // insert the item
1330     std::unique_ptr<weld::TreeIter> xParentEntry = FindEntry(pParent);
1331
1332     OUString sId(weld::toId(pItem));
1333     std::unique_ptr<weld::TreeIter> xRet(m_xTreeView->make_iterator());
1334     m_xTreeView->insert(xParentEntry.get(), nPos, &pItem->GetText(), &sId,
1335                         nullptr, nullptr, false, xRet.get());
1336     m_xTreeView->set_image(*xRet, pItem->GetImage());
1337
1338     if (!xParentEntry)
1339         return;
1340     m_xTreeView->expand_row(*xParentEntry);
1341 }
1342
1343 void FmFilterNavigator::EndEditing()
1344 {
1345     if (m_xEditingCurrently)
1346     {
1347         // end editing
1348         m_xTreeView->end_editing();
1349         m_xEditingCurrently.reset();
1350     }
1351 }
1352
1353 void FmFilterNavigator::Remove(FmFilterData const * pItem)
1354 {
1355     // the entry for the data
1356     std::unique_ptr<weld::TreeIter> xEntry = FindEntry(pItem);
1357     if (!xEntry)
1358         return;
1359
1360     if (m_xEditingCurrently && m_xTreeView->iter_compare(*xEntry, *m_xEditingCurrently) == 0)
1361         EndEditing();
1362
1363     m_xTreeView->remove(*xEntry);
1364 }
1365
1366 FmFormItem* FmFilterNavigator::getSelectedFilterItems(::std::vector<FmFilterItem*>& _rItemList)
1367 {
1368     // be sure that the data is only used within only one form!
1369     FmFormItem* pFirstItem = nullptr;
1370
1371     bool bHandled = true;
1372     bool bFoundSomething = false;
1373
1374     m_xTreeView->selected_foreach([this, &bHandled, &bFoundSomething, &pFirstItem, &_rItemList](weld::TreeIter& rEntry) {
1375         FmFilterData* pFilterEntry = weld::fromId<FmFilterData*>(m_xTreeView->get_id(rEntry));
1376         FmFilterItem* pFilter = dynamic_cast<FmFilterItem*>(pFilterEntry);
1377         if (pFilter)
1378         {
1379             FmFormItem* pForm = dynamic_cast<FmFormItem*>( pFilter->GetParent()->GetParent() );
1380             if (!pForm)
1381                 bHandled = false;
1382             else if (!pFirstItem)
1383                 pFirstItem = pForm;
1384             else if (pFirstItem != pForm)
1385                 bHandled = false;
1386
1387             if (bHandled)
1388             {
1389                 _rItemList.push_back(pFilter);
1390                 bFoundSomething = true;
1391             }
1392         }
1393         return !bHandled;
1394     });
1395
1396     if ( !bHandled || !bFoundSomething )
1397         pFirstItem = nullptr;
1398     return pFirstItem;
1399 }
1400
1401 void FmFilterNavigator::insertFilterItem(const ::std::vector<FmFilterItem*>& _rFilterList,FmFilterItems* _pTargetItems,bool _bCopy)
1402 {
1403     for (FmFilterItem* pLookupItem : _rFilterList)
1404     {
1405         if ( pLookupItem->GetParent() == _pTargetItems )
1406             continue;
1407
1408         FmFilterItem* pFilterItem = _pTargetItems->Find( pLookupItem->GetComponentIndex() );
1409         OUString aText = pLookupItem->GetText();
1410         if ( !pFilterItem )
1411         {
1412             pFilterItem = new FmFilterItem( _pTargetItems, pLookupItem->GetFieldName(), aText, pLookupItem->GetComponentIndex() );
1413             m_pModel->Append( _pTargetItems, std::unique_ptr<FmFilterItem>(pFilterItem) );
1414         }
1415
1416         if ( !_bCopy )
1417             m_pModel->Remove( pLookupItem );
1418
1419         // now set the text for the new dragged item
1420         m_pModel->SetTextForItem( pFilterItem, aText );
1421     }
1422
1423     m_pModel->EnsureEmptyFilterRows( *_pTargetItems->GetParent() );
1424 }
1425
1426 IMPL_LINK(FmFilterNavigator, DragBeginHdl, bool&, rUnsetDragIcon, bool)
1427 {
1428     rUnsetDragIcon = false;
1429
1430     // be sure that the data is only used within an only one form!
1431     m_aControlExchange.prepareDrag();
1432
1433     ::std::vector<FmFilterItem*> aItemList;
1434     if (FmFormItem* pFirstItem = getSelectedFilterItems(aItemList))
1435     {
1436         m_aControlExchange->setDraggedEntries(std::move(aItemList));
1437         m_aControlExchange->setFormItem(pFirstItem);
1438
1439         OFilterItemExchange& rExchange = *m_aControlExchange;
1440         rtl::Reference<TransferDataContainer> xHelper(&rExchange);
1441         m_xTreeView->enable_drag_source(xHelper, DND_ACTION_COPYMOVE);
1442         rExchange.setDragging(true);
1443
1444         return false;
1445     }
1446     return true;
1447 }
1448
1449 IMPL_LINK(FmFilterNavigator, PopupMenuHdl, const CommandEvent&, rEvt, bool)
1450 {
1451     bool bHandled = false;
1452     switch (rEvt.GetCommand())
1453     {
1454         case CommandEventId::ContextMenu:
1455         {
1456             // the place where it was clicked
1457             Point aWhere;
1458             std::unique_ptr<weld::TreeIter> xClicked(m_xTreeView->make_iterator());
1459             if (rEvt.IsMouseEvent())
1460             {
1461                 aWhere = rEvt.GetMousePosPixel();
1462                 if (!m_xTreeView->get_dest_row_at_pos(aWhere, xClicked.get(), false))
1463                     break;
1464
1465                 if (!m_xTreeView->is_selected(*xClicked))
1466                 {
1467                     m_xTreeView->unselect_all();
1468                     m_xTreeView->select(*xClicked);
1469                     m_xTreeView->set_cursor(*xClicked);
1470                 }
1471             }
1472             else
1473             {
1474                 if (!m_xTreeView->get_cursor(xClicked.get()))
1475                     break;
1476                 aWhere = m_xTreeView->get_row_area(*xClicked).Center();
1477             }
1478
1479             ::std::vector<FmFilterData*> aSelectList;
1480             m_xTreeView->selected_foreach([this, &aSelectList](weld::TreeIter& rEntry) {
1481                 FmFilterData* pFilterEntry = weld::fromId<FmFilterData*>(m_xTreeView->get_id(rEntry));
1482
1483                 // don't delete forms
1484                 FmFormItem* pForm = dynamic_cast<FmFormItem*>(pFilterEntry);
1485                 if (!pForm)
1486                     aSelectList.push_back(pFilterEntry);
1487
1488                 return false;
1489             });
1490
1491             if (aSelectList.size() == 1)
1492             {
1493                 // don't delete the only empty row of a form
1494                 FmFilterItems* pFilterItems = dynamic_cast<FmFilterItems*>( aSelectList[0] );
1495                 if (pFilterItems && pFilterItems->GetChildren().empty()
1496                     && pFilterItems->GetParent()->GetChildren().size() == 1)
1497                     aSelectList.clear();
1498             }
1499
1500             std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(m_xTreeView.get(), "svx/ui/filtermenu.ui"));
1501             std::unique_ptr<weld::Menu> xContextMenu(xBuilder->weld_menu("menu"));
1502
1503             // every condition could be deleted except the first one if it's the only one
1504             bool bNoDelete = false;
1505             if (aSelectList.empty())
1506             {
1507                 bNoDelete = true;
1508                 xContextMenu->remove("delete");
1509             }
1510
1511             FmFilterData* pFilterEntry = weld::fromId<FmFilterData*>(m_xTreeView->get_id(*xClicked));
1512             auto pFilterItem = dynamic_cast<FmFilterItem*>(pFilterEntry);
1513             bool bEdit = pFilterItem &&
1514                 m_xTreeView->is_selected(*xClicked) && m_xTreeView->count_selected_rows() == 1;
1515
1516             if (bNoDelete && !bEdit)
1517             {
1518                 // nothing is in the menu, don't bother
1519                 return true;
1520             }
1521
1522             if (!bEdit)
1523             {
1524                 xContextMenu->remove("edit");
1525                 xContextMenu->remove("isnull");
1526                 xContextMenu->remove("isnotnull");
1527             }
1528
1529             OUString sIdent = xContextMenu->popup_at_rect(m_xTreeView.get(), tools::Rectangle(aWhere, ::Size(1, 1)));
1530             if (sIdent == "edit")
1531             {
1532                 m_xTreeView->start_editing(*xClicked);
1533             }
1534             else if (sIdent == "isnull")
1535             {
1536                 OUString aErrorMsg;
1537                 OUString aText = "IS NULL";
1538                 assert(pFilterItem && "if item is null this menu entry was removed and unavailable");
1539                 m_pModel->ValidateText(pFilterItem, aText, aErrorMsg);
1540                 m_pModel->SetTextForItem(pFilterItem, aText);
1541             }
1542             else if (sIdent == "isnotnull")
1543             {
1544                 OUString aErrorMsg;
1545                 OUString aText = "IS NOT NULL";
1546
1547                 assert(pFilterItem && "if item is null this menu entry was removed and unavailable");
1548                 m_pModel->ValidateText(pFilterItem, aText, aErrorMsg);
1549                 m_pModel->SetTextForItem(pFilterItem, aText);
1550             }
1551             else if (sIdent == "delete")
1552             {
1553                 DeleteSelection();
1554             }
1555             bHandled = true;
1556         }
1557         break;
1558         default: break;
1559     }
1560
1561     return bHandled;
1562 }
1563
1564 bool FmFilterNavigator::getNextEntry(weld::TreeIter& rEntry)
1565 {
1566     bool bEntry = m_xTreeView->iter_next(rEntry);
1567     // we need the next filter entry
1568     if (bEntry)
1569     {
1570         while (!m_xTreeView->iter_has_child(rEntry))
1571         {
1572             std::unique_ptr<weld::TreeIter> xNext = m_xTreeView->make_iterator(&rEntry);
1573             if (!m_xTreeView->iter_next(*xNext))
1574                 break;
1575             m_xTreeView->copy_iterator(*xNext, rEntry);
1576         }
1577     }
1578     return bEntry;
1579 }
1580
1581 bool FmFilterNavigator::getPrevEntry(weld::TreeIter& rEntry)
1582 {
1583     bool bEntry = m_xTreeView->iter_previous(rEntry);
1584     // check if the previous entry is a filter, if so get the next prev
1585     if (bEntry && m_xTreeView->iter_has_child(rEntry))
1586     {
1587         bEntry = m_xTreeView->iter_previous(rEntry);
1588         // if the entry is still no leaf return
1589         if (bEntry && m_xTreeView->iter_has_child(rEntry))
1590             bEntry = false;
1591     }
1592     return bEntry;
1593 }
1594 IMPL_LINK(FmFilterNavigator, KeyInputHdl, const ::KeyEvent&, rKEvt, bool)
1595 {
1596     const vcl::KeyCode& rKeyCode = rKEvt.GetKeyCode();
1597
1598     switch ( rKeyCode.GetCode() )
1599     {
1600         case KEY_UP:
1601         case KEY_DOWN:
1602         {
1603             if ( !rKeyCode.IsMod1() || !rKeyCode.IsMod2() || rKeyCode.IsShift() )
1604                 break;
1605
1606             ::std::vector<FmFilterItem*> aItemList;
1607             if ( !getSelectedFilterItems( aItemList ) )
1608                 break;
1609
1610
1611             std::vector<std::unique_ptr<weld::TreeIter>> aSelected;
1612             m_xTreeView->selected_foreach([this, &aSelected](weld::TreeIter& rEntry){
1613                 aSelected.emplace_back(m_xTreeView->make_iterator(&rEntry));
1614                 return false;
1615             });
1616
1617             std::unique_ptr<weld::TreeIter> xTarget;
1618             ::std::function<bool(FmFilterNavigator*, weld::TreeIter&)> getter;
1619
1620             if (rKeyCode.GetCode() == KEY_UP)
1621             {
1622                 xTarget = m_xTreeView->make_iterator(aSelected.front().get());
1623                 getter = ::std::mem_fn(&FmFilterNavigator::getPrevEntry);
1624             }
1625             else
1626             {
1627                 xTarget = m_xTreeView->make_iterator(aSelected.back().get());
1628                 getter = ::std::mem_fn(&FmFilterNavigator::getNextEntry);
1629             }
1630
1631             bool bTarget = getter(this, *xTarget);
1632             if (!bTarget)
1633                 break;
1634
1635             FmFilterItems* pTargetItems = getTargetItems(*m_xTreeView, *xTarget);
1636             if (!pTargetItems)
1637                 break;
1638
1639             ::std::vector<FmFilterItem*>::const_iterator aEnd = aItemList.end();
1640             bool bNextTargetItem = true;
1641             while ( bNextTargetItem )
1642             {
1643                 ::std::vector<FmFilterItem*>::const_iterator i = aItemList.begin();
1644                 for (; i != aEnd; ++i)
1645                 {
1646                     if ( (*i)->GetParent() == pTargetItems )
1647                     {
1648                         bTarget = getter(this, *xTarget);
1649                         if (!bTarget)
1650                             return true;
1651                         pTargetItems = getTargetItems(*m_xTreeView, *xTarget);
1652                         break;
1653                     }
1654                     else
1655                     {
1656                         FmFilterItem* pFilterItem = pTargetItems->Find( (*i)->GetComponentIndex() );
1657                         // we found the text component so jump above
1658                         if ( pFilterItem )
1659                         {
1660                             bTarget = getter(this, *xTarget);
1661                             if (!bTarget)
1662                                 return true;
1663
1664                             pTargetItems = getTargetItems(*m_xTreeView, *xTarget);
1665                             break;
1666                         }
1667                     }
1668                 }
1669                 bNextTargetItem = i != aEnd && pTargetItems;
1670             }
1671
1672             if ( pTargetItems )
1673             {
1674                 insertFilterItem( aItemList, pTargetItems, false );
1675                 return true;
1676             }
1677         }
1678         break;
1679
1680         case KEY_DELETE:
1681         {
1682             if ( rKeyCode.GetModifier() )
1683                 break;
1684
1685             std::unique_ptr<weld::TreeIter> xEntry = m_xTreeView->make_iterator();
1686             if (m_xTreeView->get_iter_first(*xEntry) && !m_xTreeView->is_selected(*xEntry))
1687                 DeleteSelection();
1688
1689             return true;
1690         }
1691     }
1692
1693     return false;
1694 }
1695
1696 void FmFilterNavigator::DeleteSelection()
1697 {
1698     // to avoid the deletion of an entry twice (e.g. deletion of a parent and afterward
1699     // the deletion of its child, I have to shrink the selection list
1700     std::vector<FmFilterData*> aEntryList;
1701
1702     m_xTreeView->selected_foreach([this, &aEntryList](weld::TreeIter& rEntry) {
1703         FmFilterData* pFilterEntry = weld::fromId<FmFilterData*>(m_xTreeView->get_id(rEntry));
1704
1705         if (dynamic_cast<FmFilterItem*>(pFilterEntry))
1706         {
1707             std::unique_ptr<weld::TreeIter> xParent(m_xTreeView->make_iterator(&rEntry));
1708             if (m_xTreeView->iter_parent(*xParent) && m_xTreeView->is_selected(*xParent))
1709                 return false;
1710         }
1711
1712         FmFormItem* pForm = dynamic_cast<FmFormItem*>(pFilterEntry);
1713         if (!pForm)
1714             aEntryList.emplace_back(pFilterEntry);
1715
1716         return false;
1717     });
1718
1719     // Remove the selection
1720     m_xTreeView->unselect_all();
1721
1722     for (auto i = aEntryList.rbegin(); i != aEntryList.rend(); ++i)
1723         m_pModel->Remove(*i);
1724 }
1725
1726 FmFilterNavigatorWin::FmFilterNavigatorWin(SfxBindings* _pBindings, SfxChildWindow* _pMgr,
1727                                            vcl::Window* _pParent)
1728     : SfxDockingWindow(_pBindings, _pMgr, _pParent, "FilterNavigator", "svx/ui/filternavigator.ui")
1729     , SfxControllerItem( SID_FM_FILTER_NAVIGATOR_CONTROL, *_pBindings )
1730     , m_xNavigatorTree(new FmFilterNavigator(this, m_xBuilder->weld_tree_view("treeview")))
1731 {
1732     SetHelpId( HID_FILTER_NAVIGATOR_WIN );
1733
1734     SetText( SvxResId(RID_STR_FILTER_NAVIGATOR) );
1735     SfxDockingWindow::SetFloatingSize( Size(200,200) );
1736 }
1737
1738 FmFilterNavigatorWin::~FmFilterNavigatorWin()
1739 {
1740     disposeOnce();
1741 }
1742
1743 void FmFilterNavigatorWin::dispose()
1744 {
1745     m_xNavigatorTree.reset();
1746     ::SfxControllerItem::dispose();
1747     SfxDockingWindow::dispose();
1748 }
1749
1750 void FmFilterNavigatorWin::UpdateContent(FmFormShell const * pFormShell)
1751 {
1752     if (!m_xNavigatorTree)
1753         return;
1754
1755     if (!pFormShell)
1756         m_xNavigatorTree->UpdateContent( nullptr, nullptr );
1757     else
1758     {
1759         Reference<XFormController> const xController(pFormShell->GetImpl()->getActiveInternalController_Lock());
1760         Reference< XIndexAccess >   xContainer;
1761         if (xController.is())
1762         {
1763             Reference< XChild >  xChild = xController;
1764             for (Reference< XInterface >  xParent(xChild->getParent());
1765                  xParent.is();
1766                  xParent = xChild.is() ? xChild->getParent() : Reference< XInterface > ())
1767             {
1768                 xContainer.set(xParent, UNO_QUERY);
1769                 xChild.set(xParent, UNO_QUERY);
1770             }
1771         }
1772         m_xNavigatorTree->UpdateContent(xContainer, xController);
1773     }
1774 }
1775
1776 void FmFilterNavigatorWin::StateChangedAtToolBoxControl( sal_uInt16 nSID, SfxItemState eState, const SfxPoolItem* pState )
1777 {
1778     if( !pState  || SID_FM_FILTER_NAVIGATOR_CONTROL != nSID )
1779         return;
1780
1781     if( eState >= SfxItemState::DEFAULT )
1782     {
1783         FmFormShell* pShell = dynamic_cast<FmFormShell*>( static_cast<const SfxObjectItem*>(pState)->GetShell()  );
1784         UpdateContent( pShell );
1785     }
1786     else
1787         UpdateContent( nullptr );
1788 }
1789
1790 bool FmFilterNavigatorWin::Close()
1791 {
1792     if (m_xNavigatorTree)
1793         m_xNavigatorTree->EndEditing();
1794
1795     UpdateContent( nullptr );
1796     return SfxDockingWindow::Close();
1797 }
1798
1799 void FmFilterNavigatorWin::FillInfo( SfxChildWinInfo& rInfo ) const
1800 {
1801     SfxDockingWindow::FillInfo( rInfo );
1802     rInfo.bVisible = false;
1803 }
1804
1805 Size FmFilterNavigatorWin::CalcDockingSize( SfxChildAlignment eAlign )
1806 {
1807     if ( ( eAlign == SfxChildAlignment::TOP ) || ( eAlign == SfxChildAlignment::BOTTOM ) )
1808         return Size();
1809
1810     return SfxDockingWindow::CalcDockingSize( eAlign );
1811 }
1812
1813 SfxChildAlignment FmFilterNavigatorWin::CheckAlignment( SfxChildAlignment eActAlign, SfxChildAlignment eAlign )
1814 {
1815     switch (eAlign)
1816     {
1817         case SfxChildAlignment::LEFT:
1818         case SfxChildAlignment::RIGHT:
1819         case SfxChildAlignment::NOALIGNMENT:
1820             return eAlign;
1821         default:
1822             break;
1823     }
1824
1825     return eActAlign;
1826 }
1827
1828 void FmFilterNavigatorWin::GetFocus()
1829 {
1830     // oj #97405#
1831     if (m_xNavigatorTree)
1832         m_xNavigatorTree->GrabFocus();
1833     else
1834         SfxDockingWindow::GetFocus();
1835 }
1836
1837 SFX_IMPL_DOCKINGWINDOW( FmFilterNavigatorWinMgr, SID_FM_FILTER_NAVIGATOR )
1838
1839
1840 FmFilterNavigatorWinMgr::FmFilterNavigatorWinMgr( vcl::Window *_pParent, sal_uInt16 _nId,
1841                                     SfxBindings *_pBindings, SfxChildWinInfo* _pInfo )
1842                  :SfxChildWindow( _pParent, _nId )
1843 {
1844     SetWindow( VclPtr<FmFilterNavigatorWin>::Create( _pBindings, this, _pParent ) );
1845     static_cast<SfxDockingWindow*>(GetWindow())->Initialize( _pInfo );
1846 }
1847
1848
1849 }
1850
1851 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */