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 <sfx2/request.hxx>
  42 #include <svx/dialmgr.hxx>
  43 #include <svx/fmshell.hxx>
  44 #include <svx/fmtools.hxx>
  45 #include <svx/svxids.hrc>
  46 #include <toolkit/helper/vclunohelper.hxx>
  47 #include <tools/diagnose_ex.h>
  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                             const OUString& aFieldName,
 144                             const OUString& aText,
 145                             const sal_Int32 _nComponentIndex )
 146           :FmFilterData(pParent, aText)
 147           ,m_aFieldName(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 = reinterpret_cast<FmFilterData*>(rId.toUInt64());
 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 = reinterpret_cast<FmFilterData*>(rId.toUInt64());
 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*>(reinterpret_cast<FmFilterData*>(m_xTreeView->get_id(rIter).toUInt64())))
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 = reinterpret_cast<FmFilterData*>(m_xTreeView->get_id(rIter).toUInt64());
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 = reinterpret_cast<FmFilterData*>(m_xTreeView->get_id(*xDropTarget).toUInt64());
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 = reinterpret_cast<FmFilterData*>(rTreeView.get_id(rTarget).toUInt64());
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     m_xTreeView->select(*xEntry);
1243     m_xTreeView->set_cursor(*xEntry);
1244
1245     insertFilterItem(m_aControlExchange->getDraggedEntries(),pTargetItems,DND_ACTION_COPY == rEvt.mnAction);
1246
1247     return DND_ACTION_COPY;
1248 }
1249
1250 IMPL_LINK_NOARG(FmFilterNavigator, SelectHdl, weld::TreeView&, void)
1251 {
1252     std::unique_ptr<weld::TreeIter> xIter(m_xTreeView->make_iterator());
1253     if (!m_xTreeView->get_selected(xIter.get()))
1254         return;
1255
1256     FmFilterData* pData = reinterpret_cast<FmFilterData*>(m_xTreeView->get_id(*xIter).toUInt64());
1257
1258     FmFormItem* pFormItem = nullptr;
1259     if (FmFilterItem* pItem = dynamic_cast<FmFilterItem*>(pData))
1260         pFormItem = static_cast<FmFormItem*>(pItem->GetParent()->GetParent());
1261     else if (FmFilterItems* pItems = dynamic_cast<FmFilterItems*>(pData))
1262         pFormItem = static_cast<FmFormItem*>(pItems->GetParent()->GetParent());
1263     else
1264         pFormItem = dynamic_cast<FmFormItem*>(pData);
1265
1266     if (pFormItem)
1267     {
1268         // will the controller be exchanged?
1269         if (FmFilterItem* pItem = dynamic_cast<FmFilterItem*>(pData))
1270             m_pModel->SetCurrentItems(static_cast<FmFilterItems*>(pItem->GetParent()));
1271         else if (FmFilterItems* pItems = dynamic_cast<FmFilterItems*>(pData))
1272             m_pModel->SetCurrentItems(pItems);
1273         else
1274             m_pModel->SetCurrentController(pFormItem->GetController());
1275     }
1276 }
1277
1278 void FmFilterNavigator::Notify( SfxBroadcaster& /*rBC*/, const SfxHint& rHint )
1279 {
1280     if (const FmFilterInsertedHint* pInsertHint = dynamic_cast<const FmFilterInsertedHint*>(&rHint))
1281     {
1282         Insert(pInsertHint->GetData(), pInsertHint->GetPos());
1283     }
1284     else if( dynamic_cast<const FilterClearingHint*>(&rHint) )
1285     {
1286         m_xTreeView->clear();
1287     }
1288     else if (const FmFilterRemovedHint* pRemoveHint = dynamic_cast<const FmFilterRemovedHint*>(&rHint))
1289     {
1290         Remove(pRemoveHint->GetData());
1291     }
1292     else if (const FmFilterTextChangedHint *pChangeHint = dynamic_cast<const FmFilterTextChangedHint*>(&rHint))
1293     {
1294         std::unique_ptr<weld::TreeIter> xEntry = FindEntry(pChangeHint->GetData());
1295         if (xEntry)
1296             m_xTreeView->set_text(*xEntry, pChangeHint->GetData()->GetText());
1297     }
1298     else if( dynamic_cast<const FmFilterCurrentChangedHint*>(&rHint) )
1299     {
1300         m_xTreeView->queue_draw();
1301     }
1302 }
1303
1304 std::unique_ptr<weld::TreeIter> FmFilterNavigator::FindEntry(const FmFilterData* pItem) const
1305 {
1306     if (!pItem)
1307         return nullptr;
1308     std::unique_ptr<weld::TreeIter> xEntry = m_xTreeView->make_iterator();
1309     if (!m_xTreeView->get_iter_first(*xEntry))
1310         return nullptr;
1311     do
1312     {
1313         FmFilterData* pEntryItem = reinterpret_cast<FmFilterData*>(m_xTreeView->get_id(*xEntry).toUInt64());
1314         if (pEntryItem == pItem)
1315             return xEntry;
1316     }
1317     while (m_xTreeView->iter_next(*xEntry));
1318
1319     return nullptr;
1320 }
1321
1322 void FmFilterNavigator::Insert(FmFilterData* pItem, int nPos)
1323 {
1324     const FmParentData* pParent = pItem->GetParent() ? pItem->GetParent() : m_pModel.get();
1325
1326     // insert the item
1327     std::unique_ptr<weld::TreeIter> xParentEntry = FindEntry(pParent);
1328
1329     OUString sId(OUString::number(reinterpret_cast<sal_uIntPtr>(pItem)));
1330     std::unique_ptr<weld::TreeIter> xRet(m_xTreeView->make_iterator());
1331     m_xTreeView->insert(xParentEntry.get(), nPos, &pItem->GetText(), &sId,
1332                         nullptr, nullptr, false, xRet.get());
1333     m_xTreeView->set_image(*xRet, pItem->GetImage());
1334
1335     if (!xParentEntry)
1336         return;
1337     m_xTreeView->expand_row(*xParentEntry);
1338 }
1339
1340 void FmFilterNavigator::EndEditing()
1341 {
1342     if (m_xEditingCurrently)
1343     {
1344         // end editing
1345         m_xTreeView->end_editing();
1346         m_xEditingCurrently.reset();
1347     }
1348 }
1349
1350 void FmFilterNavigator::Remove(FmFilterData const * pItem)
1351 {
1352     // the entry for the data
1353     std::unique_ptr<weld::TreeIter> xEntry = FindEntry(pItem);
1354     if (!xEntry)
1355         return;
1356
1357     if (m_xEditingCurrently && m_xTreeView->iter_compare(*xEntry, *m_xEditingCurrently) == 0)
1358         EndEditing();
1359
1360     m_xTreeView->remove(*xEntry);
1361 }
1362
1363 FmFormItem* FmFilterNavigator::getSelectedFilterItems(::std::vector<FmFilterItem*>& _rItemList)
1364 {
1365     // be sure that the data is only used within only one form!
1366     FmFormItem* pFirstItem = nullptr;
1367
1368     bool bHandled = true;
1369     bool bFoundSomething = false;
1370
1371     m_xTreeView->selected_foreach([this, &bHandled, &bFoundSomething, &pFirstItem, &_rItemList](weld::TreeIter& rEntry) {
1372         FmFilterData* pFilterEntry = reinterpret_cast<FmFilterData*>(m_xTreeView->get_id(rEntry).toInt64());
1373         FmFilterItem* pFilter = dynamic_cast<FmFilterItem*>(pFilterEntry);
1374         if (pFilter)
1375         {
1376             FmFormItem* pForm = dynamic_cast<FmFormItem*>( pFilter->GetParent()->GetParent() );
1377             if (!pForm)
1378                 bHandled = false;
1379             else if (!pFirstItem)
1380                 pFirstItem = pForm;
1381             else if (pFirstItem != pForm)
1382                 bHandled = false;
1383
1384             if (bHandled)
1385             {
1386                 _rItemList.push_back(pFilter);
1387                 bFoundSomething = true;
1388             }
1389         }
1390         return !bHandled;
1391     });
1392
1393     if ( !bHandled || !bFoundSomething )
1394         pFirstItem = nullptr;
1395     return pFirstItem;
1396 }
1397
1398 void FmFilterNavigator::insertFilterItem(const ::std::vector<FmFilterItem*>& _rFilterList,FmFilterItems* _pTargetItems,bool _bCopy)
1399 {
1400     for (FmFilterItem* pLookupItem : _rFilterList)
1401     {
1402         if ( pLookupItem->GetParent() == _pTargetItems )
1403             continue;
1404
1405         FmFilterItem* pFilterItem = _pTargetItems->Find( pLookupItem->GetComponentIndex() );
1406         OUString aText = pLookupItem->GetText();
1407         if ( !pFilterItem )
1408         {
1409             pFilterItem = new FmFilterItem( _pTargetItems, pLookupItem->GetFieldName(), aText, pLookupItem->GetComponentIndex() );
1410             m_pModel->Append( _pTargetItems, std::unique_ptr<FmFilterItem>(pFilterItem) );
1411         }
1412
1413         if ( !_bCopy )
1414             m_pModel->Remove( pLookupItem );
1415
1416         // now set the text for the new dragged item
1417         m_pModel->SetTextForItem( pFilterItem, aText );
1418     }
1419
1420     m_pModel->EnsureEmptyFilterRows( *_pTargetItems->GetParent() );
1421 }
1422
1423 IMPL_LINK(FmFilterNavigator, DragBeginHdl, bool&, rUnsetDragIcon, bool)
1424 {
1425     rUnsetDragIcon = false;
1426
1427     // be sure that the data is only used within an only one form!
1428     m_aControlExchange.prepareDrag();
1429
1430     ::std::vector<FmFilterItem*> aItemList;
1431     if (FmFormItem* pFirstItem = getSelectedFilterItems(aItemList))
1432     {
1433         m_aControlExchange->setDraggedEntries(std::move(aItemList));
1434         m_aControlExchange->setFormItem(pFirstItem);
1435
1436         OFilterItemExchange& rExchange = *m_aControlExchange;
1437         rtl::Reference<TransferDataContainer> xHelper(&rExchange);
1438         m_xTreeView->enable_drag_source(xHelper, DND_ACTION_COPYMOVE);
1439         rExchange.setDragging(true);
1440
1441         return false;
1442     }
1443     return true;
1444 }
1445
1446 IMPL_LINK(FmFilterNavigator, PopupMenuHdl, const CommandEvent&, rEvt, bool)
1447 {
1448     bool bHandled = false;
1449     switch (rEvt.GetCommand())
1450     {
1451         case CommandEventId::ContextMenu:
1452         {
1453             // the place where it was clicked
1454             Point aWhere;
1455             std::unique_ptr<weld::TreeIter> xClicked(m_xTreeView->make_iterator());
1456             if (rEvt.IsMouseEvent())
1457             {
1458                 aWhere = rEvt.GetMousePosPixel();
1459                 if (!m_xTreeView->get_dest_row_at_pos(aWhere, xClicked.get(), false))
1460                     break;
1461
1462                 if (!m_xTreeView->is_selected(*xClicked))
1463                 {
1464                     m_xTreeView->unselect_all();
1465                     m_xTreeView->select(*xClicked);
1466                     m_xTreeView->set_cursor(*xClicked);
1467                 }
1468             }
1469             else
1470             {
1471                 if (!m_xTreeView->get_cursor(xClicked.get()))
1472                     break;
1473                 aWhere = m_xTreeView->get_row_area(*xClicked).Center();
1474             }
1475
1476             ::std::vector<FmFilterData*> aSelectList;
1477             m_xTreeView->selected_foreach([this, &aSelectList](weld::TreeIter& rEntry) {
1478                 FmFilterData* pFilterEntry = reinterpret_cast<FmFilterData*>(m_xTreeView->get_id(rEntry).toInt64());
1479
1480                 // don't delete forms
1481                 FmFormItem* pForm = dynamic_cast<FmFormItem*>(pFilterEntry);
1482                 if (!pForm)
1483                     aSelectList.push_back(pFilterEntry);
1484
1485                 return false;
1486             });
1487
1488             if (aSelectList.size() == 1)
1489             {
1490                 // don't delete the only empty row of a form
1491                 FmFilterItems* pFilterItems = dynamic_cast<FmFilterItems*>( aSelectList[0] );
1492                 if (pFilterItems && pFilterItems->GetChildren().empty()
1493                     && pFilterItems->GetParent()->GetChildren().size() == 1)
1494                     aSelectList.clear();
1495             }
1496
1497             std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(m_xTreeView.get(), "svx/ui/filtermenu.ui"));
1498             std::unique_ptr<weld::Menu> xContextMenu(xBuilder->weld_menu("menu"));
1499
1500             // every condition could be deleted except the first one if it's the only one
1501             bool bNoDelete = false;
1502             if (aSelectList.empty())
1503             {
1504                 bNoDelete = true;
1505                 xContextMenu->remove("delete");
1506             }
1507
1508             FmFilterData* pFilterEntry = reinterpret_cast<FmFilterData*>(m_xTreeView->get_id(*xClicked).toInt64());
1509             auto pFilterItem = dynamic_cast<FmFilterItem*>(pFilterEntry);
1510             bool bEdit = pFilterItem &&
1511                 m_xTreeView->is_selected(*xClicked) && m_xTreeView->count_selected_rows() == 1;
1512
1513             if (bNoDelete && !bEdit)
1514             {
1515                 // nothing is in the menu, don't bother
1516                 return true;
1517             }
1518
1519             if (!bEdit)
1520             {
1521                 xContextMenu->remove("edit");
1522                 xContextMenu->remove("isnull");
1523                 xContextMenu->remove("isnotnull");
1524             }
1525
1526             OString sIdent = xContextMenu->popup_at_rect(m_xTreeView.get(), tools::Rectangle(aWhere, ::Size(1, 1)));
1527             if (sIdent == "edit")
1528             {
1529                 m_xTreeView->start_editing(*xClicked);
1530             }
1531             else if (sIdent == "isnull")
1532             {
1533                 OUString aErrorMsg;
1534                 OUString aText = "IS NULL";
1535                 assert(pFilterItem && "if item is null this menu entry was removed and unavailable");
1536                 m_pModel->ValidateText(pFilterItem, aText, aErrorMsg);
1537                 m_pModel->SetTextForItem(pFilterItem, aText);
1538             }
1539             else if (sIdent == "isnotnull")
1540             {
1541                 OUString aErrorMsg;
1542                 OUString aText = "IS NOT NULL";
1543
1544                 assert(pFilterItem && "if item is null this menu entry was removed and unavailable");
1545                 m_pModel->ValidateText(pFilterItem, aText, aErrorMsg);
1546                 m_pModel->SetTextForItem(pFilterItem, aText);
1547             }
1548             else if (sIdent == "delete")
1549             {
1550                 DeleteSelection();
1551             }
1552             bHandled = true;
1553         }
1554         break;
1555         default: break;
1556     }
1557
1558     return bHandled;
1559 }
1560
1561 bool FmFilterNavigator::getNextEntry(weld::TreeIter& rEntry)
1562 {
1563     bool bEntry = m_xTreeView->iter_next(rEntry);
1564     // we need the next filter entry
1565     if (bEntry)
1566     {
1567         while (!m_xTreeView->iter_has_child(rEntry))
1568         {
1569             std::unique_ptr<weld::TreeIter> xNext = m_xTreeView->make_iterator(&rEntry);
1570             if (!m_xTreeView->iter_next(*xNext))
1571                 break;
1572             m_xTreeView->copy_iterator(*xNext, rEntry);
1573         }
1574     }
1575     return bEntry;
1576 }
1577
1578 bool FmFilterNavigator::getPrevEntry(weld::TreeIter& rEntry)
1579 {
1580     bool bEntry = m_xTreeView->iter_previous(rEntry);
1581     // check if the previous entry is a filter, if so get the next prev
1582     if (bEntry && m_xTreeView->iter_has_child(rEntry))
1583     {
1584         bEntry = m_xTreeView->iter_previous(rEntry);
1585         // if the entry is still no leaf return
1586         if (bEntry && m_xTreeView->iter_has_child(rEntry))
1587             bEntry = false;
1588     }
1589     return bEntry;
1590 }
1591 IMPL_LINK(FmFilterNavigator, KeyInputHdl, const ::KeyEvent&, rKEvt, bool)
1592 {
1593     const vcl::KeyCode& rKeyCode = rKEvt.GetKeyCode();
1594
1595     switch ( rKeyCode.GetCode() )
1596     {
1597         case KEY_UP:
1598         case KEY_DOWN:
1599         {
1600             if ( !rKeyCode.IsMod1() || !rKeyCode.IsMod2() || rKeyCode.IsShift() )
1601                 break;
1602
1603             ::std::vector<FmFilterItem*> aItemList;
1604             if ( !getSelectedFilterItems( aItemList ) )
1605                 break;
1606
1607
1608             std::vector<std::unique_ptr<weld::TreeIter>> aSelected;
1609             m_xTreeView->selected_foreach([this, &aSelected](weld::TreeIter& rEntry){
1610                 aSelected.emplace_back(m_xTreeView->make_iterator(&rEntry));
1611                 return false;
1612             });
1613
1614             std::unique_ptr<weld::TreeIter> xTarget;
1615             ::std::function<bool(FmFilterNavigator*, weld::TreeIter&)> getter;
1616
1617             if (rKeyCode.GetCode() == KEY_UP)
1618             {
1619                 xTarget = m_xTreeView->make_iterator(aSelected.front().get());
1620                 getter = ::std::mem_fn(&FmFilterNavigator::getPrevEntry);
1621             }
1622             else
1623             {
1624                 xTarget = m_xTreeView->make_iterator(aSelected.back().get());
1625                 getter = ::std::mem_fn(&FmFilterNavigator::getNextEntry);
1626             }
1627
1628             bool bTarget = getter(this, *xTarget);
1629             if (!bTarget)
1630                 break;
1631
1632             FmFilterItems* pTargetItems = getTargetItems(*m_xTreeView, *xTarget);
1633             if (!pTargetItems)
1634                 break;
1635
1636             ::std::vector<FmFilterItem*>::const_iterator aEnd = aItemList.end();
1637             bool bNextTargetItem = true;
1638             while ( bNextTargetItem )
1639             {
1640                 ::std::vector<FmFilterItem*>::const_iterator i = aItemList.begin();
1641                 for (; i != aEnd; ++i)
1642                 {
1643                     if ( (*i)->GetParent() == pTargetItems )
1644                     {
1645                         bTarget = getter(this, *xTarget);
1646                         if (!bTarget)
1647                             return true;
1648                         pTargetItems = getTargetItems(*m_xTreeView, *xTarget);
1649                         break;
1650                     }
1651                     else
1652                     {
1653                         FmFilterItem* pFilterItem = pTargetItems->Find( (*i)->GetComponentIndex() );
1654                         // we found the text component so jump above
1655                         if ( pFilterItem )
1656                         {
1657                             bTarget = getter(this, *xTarget);
1658                             if (!bTarget)
1659                                 return true;
1660
1661                             pTargetItems = getTargetItems(*m_xTreeView, *xTarget);
1662                             break;
1663                         }
1664                     }
1665                 }
1666                 bNextTargetItem = i != aEnd && pTargetItems;
1667             }
1668
1669             if ( pTargetItems )
1670             {
1671                 insertFilterItem( aItemList, pTargetItems, false );
1672                 return true;
1673             }
1674         }
1675         break;
1676
1677         case KEY_DELETE:
1678         {
1679             if ( rKeyCode.GetModifier() )
1680                 break;
1681
1682             std::unique_ptr<weld::TreeIter> xEntry = m_xTreeView->make_iterator();
1683             if (m_xTreeView->get_iter_first(*xEntry) && !m_xTreeView->is_selected(*xEntry))
1684                 DeleteSelection();
1685
1686             return true;
1687         }
1688     }
1689
1690     return false;
1691 }
1692
1693 void FmFilterNavigator::DeleteSelection()
1694 {
1695     // to avoid the deletion of an entry twice (e.g. deletion of a parent and afterward
1696     // the deletion of its child, I have to shrink the selection list
1697     std::vector<FmFilterData*> aEntryList;
1698
1699     m_xTreeView->selected_foreach([this, &aEntryList](weld::TreeIter& rEntry) {
1700         FmFilterData* pFilterEntry = reinterpret_cast<FmFilterData*>(m_xTreeView->get_id(rEntry).toInt64());
1701
1702         if (dynamic_cast<FmFilterItem*>(pFilterEntry))
1703         {
1704             std::unique_ptr<weld::TreeIter> xParent(m_xTreeView->make_iterator(&rEntry));
1705             if (m_xTreeView->iter_parent(*xParent) && m_xTreeView->is_selected(*xParent))
1706                 return false;
1707         }
1708
1709         FmFormItem* pForm = dynamic_cast<FmFormItem*>(pFilterEntry);
1710         if (!pForm)
1711             aEntryList.emplace_back(pFilterEntry);
1712
1713         return false;
1714     });
1715
1716     // Remove the selection
1717     m_xTreeView->unselect_all();
1718
1719     for (auto i = aEntryList.rbegin(); i != aEntryList.rend(); ++i)
1720         m_pModel->Remove(*i);
1721 }
1722
1723 FmFilterNavigatorWin::FmFilterNavigatorWin(SfxBindings* _pBindings, SfxChildWindow* _pMgr,
1724                                            vcl::Window* _pParent)
1725     : SfxDockingWindow(_pBindings, _pMgr, _pParent, "FilterNavigator", "svx/ui/filternavigator.ui")
1726     , SfxControllerItem( SID_FM_FILTER_NAVIGATOR_CONTROL, *_pBindings )
1727     , m_xNavigatorTree(new FmFilterNavigator(this, m_xBuilder->weld_tree_view("treeview")))
1728 {
1729     SetHelpId( HID_FILTER_NAVIGATOR_WIN );
1730
1731     SetText( SvxResId(RID_STR_FILTER_NAVIGATOR) );
1732     SfxDockingWindow::SetFloatingSize( Size(200,200) );
1733 }
1734
1735 FmFilterNavigatorWin::~FmFilterNavigatorWin()
1736 {
1737     disposeOnce();
1738 }
1739
1740 void FmFilterNavigatorWin::dispose()
1741 {
1742     m_xNavigatorTree.reset();
1743     ::SfxControllerItem::dispose();
1744     SfxDockingWindow::dispose();
1745 }
1746
1747 void FmFilterNavigatorWin::UpdateContent(FmFormShell const * pFormShell)
1748 {
1749     if (!m_xNavigatorTree)
1750         return;
1751
1752     if (!pFormShell)
1753         m_xNavigatorTree->UpdateContent( nullptr, nullptr );
1754     else
1755     {
1756         Reference<XFormController> const xController(pFormShell->GetImpl()->getActiveInternalController_Lock());
1757         Reference< XIndexAccess >   xContainer;
1758         if (xController.is())
1759         {
1760             Reference< XChild >  xChild = xController;
1761             for (Reference< XInterface >  xParent(xChild->getParent());
1762                  xParent.is();
1763                  xParent = xChild.is() ? xChild->getParent() : Reference< XInterface > ())
1764             {
1765                 xContainer.set(xParent, UNO_QUERY);
1766                 xChild.set(xParent, UNO_QUERY);
1767             }
1768         }
1769         m_xNavigatorTree->UpdateContent(xContainer, xController);
1770     }
1771 }
1772
1773 void FmFilterNavigatorWin::StateChangedAtToolBoxControl( sal_uInt16 nSID, SfxItemState eState, const SfxPoolItem* pState )
1774 {
1775     if( !pState  || SID_FM_FILTER_NAVIGATOR_CONTROL != nSID )
1776         return;
1777
1778     if( eState >= SfxItemState::DEFAULT )
1779     {
1780         FmFormShell* pShell = dynamic_cast<FmFormShell*>( static_cast<const SfxObjectItem*>(pState)->GetShell()  );
1781         UpdateContent( pShell );
1782     }
1783     else
1784         UpdateContent( nullptr );
1785 }
1786
1787 bool FmFilterNavigatorWin::Close()
1788 {
1789     if (m_xNavigatorTree)
1790         m_xNavigatorTree->EndEditing();
1791
1792     UpdateContent( nullptr );
1793     return SfxDockingWindow::Close();
1794 }
1795
1796 void FmFilterNavigatorWin::FillInfo( SfxChildWinInfo& rInfo ) const
1797 {
1798     SfxDockingWindow::FillInfo( rInfo );
1799     rInfo.bVisible = false;
1800 }
1801
1802 Size FmFilterNavigatorWin::CalcDockingSize( SfxChildAlignment eAlign )
1803 {
1804     if ( ( eAlign == SfxChildAlignment::TOP ) || ( eAlign == SfxChildAlignment::BOTTOM ) )
1805         return Size();
1806
1807     return SfxDockingWindow::CalcDockingSize( eAlign );
1808 }
1809
1810 SfxChildAlignment FmFilterNavigatorWin::CheckAlignment( SfxChildAlignment eActAlign, SfxChildAlignment eAlign )
1811 {
1812     switch (eAlign)
1813     {
1814         case SfxChildAlignment::LEFT:
1815         case SfxChildAlignment::RIGHT:
1816         case SfxChildAlignment::NOALIGNMENT:
1817             return eAlign;
1818         default:
1819             break;
1820     }
1821
1822     return eActAlign;
1823 }
1824
1825 void FmFilterNavigatorWin::GetFocus()
1826 {
1827     // oj #97405#
1828     if (m_xNavigatorTree)
1829         m_xNavigatorTree->GrabFocus();
1830     else
1831         SfxDockingWindow::GetFocus();
1832 }
1833
1834 SFX_IMPL_DOCKINGWINDOW( FmFilterNavigatorWinMgr, SID_FM_FILTER_NAVIGATOR )
1835
1836
1837 FmFilterNavigatorWinMgr::FmFilterNavigatorWinMgr( vcl::Window *_pParent, sal_uInt16 _nId,
1838                                     SfxBindings *_pBindings, SfxChildWinInfo* _pInfo )
1839                  :SfxChildWindow( _pParent, _nId )
1840 {
1841     SetWindow( VclPtr<FmFilterNavigatorWin>::Create( _pBindings, this, _pParent ) );
1842     static_cast<SfxDockingWindow*>(GetWindow())->Initialize( _pInfo );
1843 }
1844
1845
1846 }
1847
1848 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */