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 "filtnav.hxx"
  21 #include "fmexch.hxx"
  22 #include "fmhelp.hrc"
  23 #include "fmitems.hxx"
  24 #include "fmprop.hrc"
  25 #include "svx/fmresids.hrc"
  26
  27 #include <com/sun/star/awt/XControlModel.hpp>
  28 #include <com/sun/star/awt/XControl.hpp>
  29 #include <com/sun/star/awt/XTextComponent.hpp>
  30 #include <com/sun/star/form/runtime/XFormController.hpp>
  31 #include <com/sun/star/lang/XUnoTunnel.hpp>
  32 #include <com/sun/star/util/NumberFormatter.hpp>
  33 #include <com/sun/star/beans/XFastPropertySet.hpp>
  34
  35 #include <comphelper/processfactory.hxx>
  36 #include <comphelper/property.hxx>
  37 #include <comphelper/sequence.hxx>
  38 #include <comphelper/string.hxx>
  39 #include <comphelper/uno3.hxx>
  40 #include <connectivity/dbtools.hxx>
  41 #include <connectivity/sqlnode.hxx>
  42 #include <cppuhelper/implbase1.hxx>
  43 #include <fmservs.hxx>
  44 #include <fmshimp.hxx>
  45 #include <sfx2/dispatch.hxx>
  46 #include <sfx2/objitem.hxx>
  47 #include <sfx2/objsh.hxx>
  48 #include <sfx2/request.hxx>
  49 #include <svx/dialmgr.hxx>
  50 #include <svx/fmshell.hxx>
  51 #include <svx/fmtools.hxx>
  52 #include <svx/svxids.hrc>
  53 #include <vcl/wrkwin.hxx>
  54 #include <vcl/settings.hxx>
  55 #include <tools/diagnose_ex.h>
  56 #include <svtools/svlbitm.hxx>
  57 #include "svtools/treelistentry.hxx"
  58 #include "svtools/viewdataentry.hxx"
  59
  60 #include <functional>
  61
  62 #define DROP_ACTION_TIMER_INITIAL_TICKS     10
  63     // solange dauert es, bis das Scrollen anspringt
  64 #define DROP_ACTION_TIMER_SCROLL_TICKS      3
  65     // in diesen Intervallen wird jeweils eine Zeile gescrollt
  66 #define DROP_ACTION_TIMER_TICK_BASE         10
  67     // das ist die Basis, mit der beide Angaben multipliziert werden (in ms)
  68
  69 using namespace ::svxform;
  70 using namespace ::connectivity;
  71 using namespace ::dbtools;
  72
  73
  74 namespace svxform
  75 {
  76
  77
  78     using ::com::sun::star::uno::Reference;
  79     using ::com::sun::star::lang::XMultiServiceFactory;
  80     using ::com::sun::star::awt::TextEvent;
  81     using ::com::sun::star::container::XIndexAccess;
  82     using ::com::sun::star::uno::UNO_QUERY;
  83     using ::com::sun::star::beans::XPropertySet;
  84     using ::com::sun::star::form::runtime::XFormController;
  85     using ::com::sun::star::form::runtime::XFilterController;
  86     using ::com::sun::star::form::runtime::XFilterControllerListener;
  87     using ::com::sun::star::form::runtime::FilterEvent;
  88     using ::com::sun::star::lang::EventObject;
  89     using ::com::sun::star::uno::RuntimeException;
  90     using ::com::sun::star::form::XForm;
  91     using ::com::sun::star::container::XChild;
  92     using ::com::sun::star::awt::XControl;
  93     using ::com::sun::star::sdbc::XConnection;
  94     using ::com::sun::star::util::XNumberFormatsSupplier;
  95     using ::com::sun::star::util::XNumberFormatter;
  96     using ::com::sun::star::util::XNumberFormatter2;
  97     using ::com::sun::star::util::NumberFormatter;
  98     using ::com::sun::star::sdbc::XRowSet;
  99     using ::com::sun::star::lang::Locale;
 100     using ::com::sun::star::sdb::SQLContext;
 101     using ::com::sun::star::uno::XInterface;
 102     using ::com::sun::star::uno::UNO_QUERY_THROW;
 103     using ::com::sun::star::uno::UNO_SET_THROW;
 104     using ::com::sun::star::uno::Exception;
 105     using ::com::sun::star::awt::XTextComponent;
 106     using ::com::sun::star::uno::Sequence;
 107
 108
 109 OFilterItemExchange::OFilterItemExchange()
 110     : m_pFormItem(NULL)
 111 {
 112 }
 113
 114 void OFilterItemExchange::AddSupportedFormats()
 115 {
 116     AddFormat(getFormatId());
 117 }
 118
 119
 120 SotClipboardFormatId OFilterItemExchange::getFormatId()
 121 {
 122     static SotClipboardFormatId s_nFormat = static_cast<SotClipboardFormatId>(-1);
 123     if (static_cast<SotClipboardFormatId>(-1) == s_nFormat)
 124     {
 125         s_nFormat = SotExchange::RegisterFormatName(OUString("application/x-openoffice;windows_formatname=\"form.FilterControlExchange\""));
 126         DBG_ASSERT(static_cast<SotClipboardFormatId>(-1) != s_nFormat, "OFilterExchangeHelper::getFormatId: bad exchange id!");
 127     }
 128     return s_nFormat;
 129 }
 130
 131
 132 OLocalExchange* OFilterExchangeHelper::createExchange() const
 133 {
 134     return new OFilterItemExchange;
 135 }
 136
 137
 138 TYPEINIT0(FmFilterData);
 139 Image FmFilterData::GetImage() const
 140 {
 141     return Image();
 142 }
 143
 144
 145 TYPEINIT1(FmParentData, FmFilterData);
 146
 147 FmParentData::~FmParentData()
 148 {
 149     for (::std::vector<FmFilterData*>::const_iterator i = m_aChildren.begin();
 150          i != m_aChildren.end(); ++i)
 151         delete (*i);
 152 }
 153
 154
 155 TYPEINIT1(FmFormItem, FmParentData);
 156
 157 Image FmFormItem::GetImage() const
 158 {
 159     static Image aImage;
 160
 161     if (!aImage)
 162     {
 163         ImageList aNavigatorImages( SVX_RES( RID_SVXIMGLIST_FMEXPL ) );
 164         aImage = aNavigatorImages.GetImage( RID_SVXIMG_FORM );
 165     }
 166     return aImage;
 167 }
 168
 169
 170 TYPEINIT1(FmFilterItems, FmParentData);
 171
 172 FmFilterItem* FmFilterItems::Find( const ::sal_Int32 _nFilterComponentIndex ) const
 173 {
 174     for (   ::std::vector< FmFilterData* >::const_iterator i = m_aChildren.begin();
 175             i != m_aChildren.end();
 176             ++i
 177         )
 178     {
 179         FmFilterItem* pCondition = PTR_CAST( FmFilterItem, *i );
 180         DBG_ASSERT( pCondition, "FmFilterItems::Find: Wrong element in container!" );
 181         if ( _nFilterComponentIndex == pCondition->GetComponentIndex() )
 182             return pCondition;
 183     }
 184     return NULL;
 185 }
 186
 187
 188 Image FmFilterItems::GetImage() const
 189 {
 190     static Image aImage;
 191
 192     if (!aImage)
 193     {
 194         ImageList aNavigatorImages( SVX_RES( RID_SVXIMGLIST_FMEXPL ) );
 195         aImage = aNavigatorImages.GetImage( RID_SVXIMG_FILTER );
 196     }
 197     return aImage;
 198 }
 199
 200
 201 TYPEINIT1(FmFilterItem, FmFilterData);
 202
 203 FmFilterItem::FmFilterItem( FmFilterItems* pParent,
 204                             const OUString& aFieldName,
 205                             const OUString& aText,
 206                             const sal_Int32 _nComponentIndex )
 207           :FmFilterData(pParent, aText)
 208           ,m_aFieldName(aFieldName)
 209           ,m_nComponentIndex( _nComponentIndex )
 210 {
 211 }
 212
 213
 214 Image FmFilterItem::GetImage() const
 215 {
 216     static Image aImage;
 217
 218     if (!aImage)
 219     {
 220         ImageList aNavigatorImages( SVX_RES( RID_SVXIMGLIST_FMEXPL ) );
 221         aImage = aNavigatorImages.GetImage( RID_SVXIMG_FIELD );
 222     }
 223     return aImage;
 224 }
 225
 226
 227 // Hints for communicatition between model and view
 228
 229 class FmFilterHint : public SfxHint
 230 {
 231     FmFilterData*   m_pData;
 232
 233 public:
 234     FmFilterHint(FmFilterData* pData):m_pData(pData){}
 235     FmFilterData* GetData() const { return m_pData; }
 236 };
 237
 238
 239 class FmFilterInsertedHint : public FmFilterHint
 240 {
 241     sal_uLong m_nPos;   // Position relative to the parent of the data
 242
 243 public:
 244     FmFilterInsertedHint(FmFilterData* pData, sal_uLong nRelPos)
 245         :FmFilterHint(pData)
 246         ,m_nPos(nRelPos){}
 247
 248     sal_uLong GetPos() const { return m_nPos; }
 249 };
 250
 251
 252 class FmFilterRemovedHint : public FmFilterHint
 253 {
 254 public:
 255     FmFilterRemovedHint(FmFilterData* pData)
 256         :FmFilterHint(pData){}
 257 };
 258
 259
 260 class FmFilterTextChangedHint : public FmFilterHint
 261 {
 262 public:
 263     FmFilterTextChangedHint(FmFilterData* pData)
 264         :FmFilterHint(pData){}
 265 };
 266
 267
 268 class FilterClearingHint : public SfxHint
 269 {
 270 public:
 271     FilterClearingHint(){}
 272 };
 273
 274
 275 class FmFilterCurrentChangedHint : public SfxHint
 276 {
 277 public:
 278     FmFilterCurrentChangedHint(){}
 279 };
 280
 281
 282 // class FmFilterAdapter, Listener an den FilterControls
 283
 284 class FmFilterAdapter : public ::cppu::WeakImplHelper1< XFilterControllerListener >
 285 {
 286     FmFilterModel*              m_pModel;
 287     Reference< XIndexAccess >   m_xControllers;
 288
 289 public:
 290     FmFilterAdapter(FmFilterModel* pModel, const Reference< XIndexAccess >& xControllers);
 291
 292 // XEventListener
 293     virtual void SAL_CALL disposing(const EventObject& Source) throw( RuntimeException, std::exception ) SAL_OVERRIDE;
 294
 295 // XFilterControllerListener
 296     virtual void SAL_CALL predicateExpressionChanged( const FilterEvent& _Event ) throw (RuntimeException, std::exception) SAL_OVERRIDE;
 297     virtual void SAL_CALL disjunctiveTermRemoved( const FilterEvent& _Event ) throw (RuntimeException, std::exception) SAL_OVERRIDE;
 298     virtual void SAL_CALL disjunctiveTermAdded( const FilterEvent& _Event ) throw (RuntimeException, std::exception) SAL_OVERRIDE;
 299
 300 // helpers
 301     void dispose() throw( RuntimeException );
 302
 303     void AddOrRemoveListener( const Reference< XIndexAccess >& _rxControllers, const bool _bAdd );
 304
 305     static void setText(sal_Int32 nPos,
 306         const FmFilterItem* pFilterItem,
 307         const OUString& rText);
 308 };
 309
 310
 311 FmFilterAdapter::FmFilterAdapter(FmFilterModel* pModel, const Reference< XIndexAccess >& xControllers)
 312     :m_pModel( pModel )
 313     ,m_xControllers( xControllers )
 314 {
 315     AddOrRemoveListener( m_xControllers, true );
 316 }
 317
 318
 319 void FmFilterAdapter::dispose() throw( RuntimeException )
 320 {
 321     AddOrRemoveListener( m_xControllers, false );
 322 }
 323
 324
 325 void FmFilterAdapter::AddOrRemoveListener( const Reference< XIndexAccess >& _rxControllers, const bool _bAdd )
 326 {
 327     for (sal_Int32 i = 0, nLen = _rxControllers->getCount(); i < nLen; ++i)
 328     {
 329         Reference< XIndexAccess > xElement( _rxControllers->getByIndex(i), UNO_QUERY );
 330
 331         // step down
 332         AddOrRemoveListener( xElement, _bAdd );
 333
 334         // handle this particular controller
 335         Reference< XFilterController > xController( xElement, UNO_QUERY );
 336         OSL_ENSURE( xController.is(), "FmFilterAdapter::InsertElements: no XFilterController, cannot sync data!" );
 337         if ( xController.is() )
 338         {
 339             if ( _bAdd )
 340                 xController->addFilterControllerListener( this );
 341             else
 342                 xController->removeFilterControllerListener( this );
 343         }
 344     }
 345 }
 346
 347
 348 void FmFilterAdapter::setText(sal_Int32 nRowPos,
 349                               const FmFilterItem* pFilterItem,
 350                               const OUString& rText)
 351 {
 352     FmFormItem* pFormItem = PTR_CAST( FmFormItem, pFilterItem->GetParent()->GetParent() );
 353
 354     try
 355     {
 356         Reference< XFilterController > xController( pFormItem->GetController(), UNO_QUERY_THROW );
 357         xController->setPredicateExpression( pFilterItem->GetComponentIndex(), nRowPos, rText );
 358     }
 359     catch( const Exception& )
 360     {
 361         DBG_UNHANDLED_EXCEPTION();
 362     }
 363 }
 364
 365
 366 // XEventListener
 367
 368 void SAL_CALL FmFilterAdapter::disposing(const EventObject& /*e*/) throw( RuntimeException, std::exception )
 369 {
 370 }
 371
 372
 373 namespace
 374 {
 375     OUString lcl_getLabelName_nothrow( const Reference< XControl >& _rxControl )
 376     {
 377         OUString sLabelName;
 378         try
 379         {
 380             Reference< XPropertySet > xModel( _rxControl->getModel(), UNO_QUERY_THROW );
 381             sLabelName = getLabelName( xModel );
 382         }
 383         catch( const Exception& )
 384         {
 385             DBG_UNHANDLED_EXCEPTION();
 386         }
 387         return sLabelName;
 388     }
 389
 390     Reference< XPropertySet > lcl_getBoundField_nothrow( const Reference< XControl >& _rxControl )
 391     {
 392         Reference< XPropertySet > xField;
 393         try
 394         {
 395             Reference< XPropertySet > xModelProps( _rxControl->getModel(), UNO_QUERY_THROW );
 396             xField.set( xModelProps->getPropertyValue( FM_PROP_BOUNDFIELD ), UNO_QUERY_THROW );
 397         }
 398         catch( const Exception& )
 399         {
 400             DBG_UNHANDLED_EXCEPTION();
 401         }
 402         return xField;
 403     }
 404 }
 405
 406 // XFilterControllerListener
 407
 408 void FmFilterAdapter::predicateExpressionChanged( const FilterEvent& _Event ) throw( RuntimeException, std::exception )
 409 {
 410     SolarMutexGuard aGuard;
 411
 412     if ( !m_pModel )
 413         return;
 414
 415     // the controller which sent the event
 416     Reference< XFormController > xController( _Event.Source, UNO_QUERY_THROW );
 417     Reference< XFilterController > xFilterController( _Event.Source, UNO_QUERY_THROW );
 418     Reference< XForm > xForm( xController->getModel(), UNO_QUERY_THROW );
 419
 420     FmFormItem* pFormItem = m_pModel->Find( m_pModel->m_aChildren, xForm );
 421     OSL_ENSURE( pFormItem, "FmFilterAdapter::predicateExpressionChanged: don't know this form!" );
 422     if ( !pFormItem )
 423         return;
 424
 425     const sal_Int32 nActiveTerm( xFilterController->getActiveTerm() );
 426
 427     FmFilterItems* pFilter = PTR_CAST( FmFilterItems, pFormItem->GetChildren()[ nActiveTerm ] );
 428     FmFilterItem* pFilterItem = pFilter->Find( _Event.FilterComponent );
 429     if ( pFilterItem )
 430     {
 431         if ( !_Event.PredicateExpression.isEmpty())
 432         {
 433             pFilterItem->SetText( _Event.PredicateExpression );
 434             // UI benachrichtigen
 435             FmFilterTextChangedHint aChangeHint(pFilterItem);
 436             m_pModel->Broadcast( aChangeHint );
 437         }
 438         else
 439         {
 440             // no text anymore so remove the condition
 441             m_pModel->Remove(pFilterItem);
 442         }
 443     }
 444     else
 445     {
 446         // searching the component by field name
 447         OUString aFieldName( lcl_getLabelName_nothrow( xFilterController->getFilterComponent( _Event.FilterComponent ) ) );
 448
 449         pFilterItem = new FmFilterItem( pFilter, aFieldName, _Event.PredicateExpression, _Event.FilterComponent );
 450         m_pModel->Insert(pFilter->GetChildren().end(), pFilterItem);
 451     }
 452
 453     // ensure there's one empty term in the filter, just in case the active term was previously empty
 454     m_pModel->EnsureEmptyFilterRows( *pFormItem );
 455 }
 456
 457
 458 void SAL_CALL FmFilterAdapter::disjunctiveTermRemoved( const FilterEvent& _Event ) throw (RuntimeException, std::exception)
 459 {
 460     SolarMutexGuard aGuard;
 461
 462     Reference< XFormController > xController( _Event.Source, UNO_QUERY_THROW );
 463     Reference< XFilterController > xFilterController( _Event.Source, UNO_QUERY_THROW );
 464     Reference< XForm > xForm( xController->getModel(), UNO_QUERY_THROW );
 465
 466     FmFormItem* pFormItem = m_pModel->Find( m_pModel->m_aChildren, xForm );
 467     OSL_ENSURE( pFormItem, "FmFilterAdapter::disjunctiveTermRemoved: don't know this form!" );
 468     if ( !pFormItem )
 469         return;
 470
 471     ::std::vector< FmFilterData* >& rTermItems = pFormItem->GetChildren();
 472     const bool bValidIndex = ( _Event.DisjunctiveTerm >= 0 ) && ( (size_t)_Event.DisjunctiveTerm < rTermItems.size() );
 473     OSL_ENSURE( bValidIndex, "FmFilterAdapter::disjunctiveTermRemoved: invalid term index!" );
 474     if ( !bValidIndex )
 475         return;
 476
 477     // if the first term was removed, then the to-be first term needs its text updated
 478     if ( _Event.DisjunctiveTerm == 0 )
 479     {
 480         rTermItems[1]->SetText( SVX_RESSTR(RID_STR_FILTER_FILTER_FOR));
 481         FmFilterTextChangedHint aChangeHint( rTermItems[1] );
 482         m_pModel->Broadcast( aChangeHint );
 483     }
 484
 485     // finally remove the entry from the model
 486     m_pModel->Remove( rTermItems.begin() + _Event.DisjunctiveTerm );
 487
 488     // ensure there's one empty term in the filter, just in case the currently removed one was the last empty one
 489     m_pModel->EnsureEmptyFilterRows( *pFormItem );
 490 }
 491
 492
 493 void SAL_CALL FmFilterAdapter::disjunctiveTermAdded( const FilterEvent& _Event ) throw (RuntimeException, std::exception)
 494 {
 495     SolarMutexGuard aGuard;
 496
 497     Reference< XFormController > xController( _Event.Source, UNO_QUERY_THROW );
 498     Reference< XFilterController > xFilterController( _Event.Source, UNO_QUERY_THROW );
 499     Reference< XForm > xForm( xController->getModel(), UNO_QUERY_THROW );
 500
 501     FmFormItem* pFormItem = m_pModel->Find( m_pModel->m_aChildren, xForm );
 502     OSL_ENSURE( pFormItem, "FmFilterAdapter::disjunctiveTermAdded: don't know this form!" );
 503     if ( !pFormItem )
 504         return;
 505
 506     const sal_Int32 nInsertPos = _Event.DisjunctiveTerm;
 507     bool bValidIndex = ( nInsertPos >= 0 ) && ( (size_t)nInsertPos <= pFormItem->GetChildren().size() );
 508     if ( !bValidIndex )
 509     {
 510         OSL_FAIL( "FmFilterAdapter::disjunctiveTermAdded: invalid index!" );
 511         return;
 512     }
 513
 514     const ::std::vector< FmFilterData* >::iterator insertPos = pFormItem->GetChildren().begin() + nInsertPos;
 515
 516     FmFilterItems* pFilterItems = new FmFilterItems(pFormItem, SVX_RESSTR(RID_STR_FILTER_FILTER_OR));
 517     m_pModel->Insert( insertPos, pFilterItems );
 518 }
 519
 520 TYPEINIT1(FmFilterModel, FmParentData);
 521
 522 FmFilterModel::FmFilterModel()
 523               :FmParentData(NULL, OUString())
 524               ,OSQLParserClient(comphelper::getProcessComponentContext())
 525               ,m_pAdapter(NULL)
 526               ,m_pCurrentItems(NULL)
 527 {
 528 }
 529
 530
 531 FmFilterModel::~FmFilterModel()
 532 {
 533     Clear();
 534 }
 535
 536
 537 void FmFilterModel::Clear()
 538 {
 539     // notify
 540     FilterClearingHint aClearedHint;
 541     Broadcast( aClearedHint );
 542
 543     // lose endings
 544     if (m_pAdapter)
 545     {
 546         m_pAdapter->dispose();
 547         m_pAdapter->release();
 548         m_pAdapter= NULL;
 549     }
 550
 551     m_pCurrentItems  = NULL;
 552     m_xController    = NULL;
 553     m_xControllers   = NULL;
 554
 555     for (::std::vector<FmFilterData*>::const_iterator i = m_aChildren.begin();
 556          i != m_aChildren.end(); ++i)
 557         delete (*i);
 558
 559     m_aChildren.clear();
 560 }
 561
 562
 563 void FmFilterModel::Update(const Reference< XIndexAccess > & xControllers, const Reference< XFormController > & xCurrent)
 564 {
 565     if ( xCurrent == m_xController )
 566         return;
 567
 568     if (!xControllers.is())
 569     {
 570         Clear();
 571         return;
 572     }
 573
 574     // there is only a new current controller
 575     if ( m_xControllers != xControllers )
 576     {
 577         Clear();
 578
 579         m_xControllers = xControllers;
 580         Update(m_xControllers, this);
 581
 582         DBG_ASSERT(xCurrent.is(), "FmFilterModel::Update(...) no current controller");
 583
 584         // Listening for TextChanges
 585         m_pAdapter = new FmFilterAdapter(this, xControllers);
 586         m_pAdapter->acquire();
 587
 588         SetCurrentController(xCurrent);
 589         EnsureEmptyFilterRows( *this );
 590     }
 591     else
 592         SetCurrentController(xCurrent);
 593 }
 594
 595
 596 void FmFilterModel::Update(const Reference< XIndexAccess > & xControllers, FmParentData* pParent)
 597 {
 598     try
 599     {
 600         sal_Int32 nCount = xControllers->getCount();
 601         for ( sal_Int32 i = 0; i < nCount; ++i )
 602         {
 603             Reference< XFormController > xController( xControllers->getByIndex(i), UNO_QUERY_THROW );
 604
 605             Reference< XPropertySet > xFormProperties( xController->getModel(), UNO_QUERY_THROW );
 606             OUString aName;
 607             OSL_VERIFY( xFormProperties->getPropertyValue( FM_PROP_NAME ) >>= aName );
 608
 609             // Insert a new item for the form
 610             FmFormItem* pFormItem = new FmFormItem( pParent, xController, aName );
 611             Insert( pParent->GetChildren().end(), pFormItem );
 612
 613             Reference< XFilterController > xFilterController( pFormItem->GetFilterController(), UNO_SET_THROW );
 614
 615             // insert the existing filters for the form
 616             OUString aTitle(SVX_RESSTR(RID_STR_FILTER_FILTER_FOR));
 617
 618             Sequence< Sequence< OUString > > aExpressions = xFilterController->getPredicateExpressions();
 619             for (   const Sequence< OUString >* pConjunctionTerm = aExpressions.getConstArray();
 620                     pConjunctionTerm != aExpressions.getConstArray() + aExpressions.getLength();
 621                     ++pConjunctionTerm
 622                 )
 623             {
 624                 // we always display one row, even if there's no term to be displayed
 625                 FmFilterItems* pFilterItems = new FmFilterItems( pFormItem, aTitle );
 626                 Insert( pFormItem->GetChildren().end(), pFilterItems );
 627
 628                 const Sequence< OUString >& rDisjunction( *pConjunctionTerm );
 629                 for (   const OUString* pDisjunctiveTerm = rDisjunction.getConstArray();
 630                         pDisjunctiveTerm != rDisjunction.getConstArray() + rDisjunction.getLength();
 631                         ++pDisjunctiveTerm
 632                     )
 633                 {
 634                     if ( pDisjunctiveTerm->isEmpty() )
 635                         // no condition for this particular component in this particular conjunction term
 636                         continue;
 637
 638                     const sal_Int32 nComponentIndex = pDisjunctiveTerm - rDisjunction.getConstArray();
 639
 640                     // determine the display name of the control
 641                     const Reference< XControl > xFilterControl( xFilterController->getFilterComponent( nComponentIndex ) );
 642                     const OUString sDisplayName( lcl_getLabelName_nothrow( xFilterControl ) );
 643
 644                     // insert a new entry
 645                     FmFilterItem* pANDCondition = new FmFilterItem( pFilterItems, sDisplayName, *pDisjunctiveTerm, nComponentIndex );
 646                     Insert( pFilterItems->GetChildren().end(), pANDCondition );
 647                 }
 648
 649                 // title for the next conditions
 650                 aTitle = SVX_RESSTR( RID_STR_FILTER_FILTER_OR );
 651             }
 652
 653             // now add dependent controllers
 654             Update( xController, pFormItem );
 655         }
 656     }
 657     catch( const Exception& )
 658     {
 659         DBG_UNHANDLED_EXCEPTION();
 660     }
 661 }
 662
 663
 664 FmFormItem* FmFilterModel::Find(const ::std::vector<FmFilterData*>& rItems, const Reference< XFormController > & xController) const
 665 {
 666     for (::std::vector<FmFilterData*>::const_iterator i = rItems.begin();
 667          i != rItems.end(); ++i)
 668     {
 669         FmFormItem* pForm = PTR_CAST(FmFormItem,*i);
 670         if (pForm)
 671         {
 672             if ( xController == pForm->GetController() )
 673                 return pForm;
 674             else
 675             {
 676                 pForm = Find(pForm->GetChildren(), xController);
 677                 if (pForm)
 678                     return pForm;
 679             }
 680         }
 681     }
 682     return NULL;
 683 }
 684
 685
 686 FmFormItem* FmFilterModel::Find(const ::std::vector<FmFilterData*>& rItems, const Reference< XForm >& xForm) const
 687 {
 688     for (::std::vector<FmFilterData*>::const_iterator i = rItems.begin();
 689          i != rItems.end(); ++i)
 690     {
 691         FmFormItem* pForm = PTR_CAST(FmFormItem,*i);
 692         if (pForm)
 693         {
 694             if (xForm == pForm->GetController()->getModel())
 695                 return pForm;
 696             else
 697             {
 698                 pForm = Find(pForm->GetChildren(), xForm);
 699                 if (pForm)
 700                     return pForm;
 701             }
 702         }
 703     }
 704     return NULL;
 705 }
 706
 707
 708 void FmFilterModel::SetCurrentController(const Reference< XFormController > & xCurrent)
 709 {
 710     if ( xCurrent == m_xController )
 711         return;
 712
 713     m_xController = xCurrent;
 714
 715     FmFormItem* pItem = Find( m_aChildren, xCurrent );
 716     if ( !pItem )
 717         return;
 718
 719     try
 720     {
 721         Reference< XFilterController > xFilterController( m_xController, UNO_QUERY_THROW );
 722         const sal_Int32 nActiveTerm( xFilterController->getActiveTerm() );
 723         if ( pItem->GetChildren().size() > (size_t)nActiveTerm )
 724         {
 725             SetCurrentItems( static_cast< FmFilterItems* >( pItem->GetChildren()[ nActiveTerm ] ) );
 726         }
 727     }
 728     catch( const Exception& )
 729     {
 730         DBG_UNHANDLED_EXCEPTION();
 731     }
 732 }
 733
 734
 735 void FmFilterModel::AppendFilterItems( FmFormItem& _rFormItem )
 736 {
 737     // insert the condition behind the last filter items
 738     ::std::vector<FmFilterData*>::reverse_iterator iter;
 739     for (   iter = _rFormItem.GetChildren().rbegin();
 740             iter != _rFormItem.GetChildren().rend();
 741             ++iter
 742         )
 743     {
 744         if ((*iter)->ISA(FmFilterItems))
 745             break;
 746     }
 747
 748     sal_Int32 nInsertPos = iter.base() - _rFormItem.GetChildren().begin();
 749     // delegate this to the FilterController, it will notify us, which will let us update our model
 750     try
 751     {
 752         Reference< XFilterController > xFilterController( _rFormItem.GetFilterController(), UNO_SET_THROW );
 753         if ( nInsertPos >= xFilterController->getDisjunctiveTerms() )
 754             xFilterController->appendEmptyDisjunctiveTerm();
 755     }
 756     catch( const Exception& )
 757     {
 758         DBG_UNHANDLED_EXCEPTION();
 759     }
 760 }
 761
 762
 763 void FmFilterModel::Insert(const ::std::vector<FmFilterData*>::iterator& rPos, FmFilterData* pData)
 764 {
 765     ::std::vector<FmFilterData*>& rItems = pData->GetParent()->GetChildren();
 766     sal_uLong nPos = rPos == rItems.end() ? CONTAINER_APPEND : rPos - rItems.begin();
 767     if (nPos == CONTAINER_APPEND)
 768     {
 769         rItems.push_back(pData);
 770         nPos = rItems.size() - 1;
 771     }
 772     else
 773     {
 774         rItems.insert(rPos, pData);
 775     }
 776
 777     // UI benachrichtigen
 778     FmFilterInsertedHint aInsertedHint(pData, nPos);
 779     Broadcast( aInsertedHint );
 780 }
 781
 782
 783 void FmFilterModel::Remove(FmFilterData* pData)
 784 {
 785     FmParentData* pParent = pData->GetParent();
 786     ::std::vector<FmFilterData*>& rItems = pParent->GetChildren();
 787
 788     // erase the item from the model
 789     ::std::vector<FmFilterData*>::iterator i = ::std::find(rItems.begin(), rItems.end(), pData);
 790     DBG_ASSERT(i != rItems.end(), "FmFilterModel::Remove(): unknown Item");
 791     // position within the parent
 792     sal_Int32 nPos = i - rItems.begin();
 793     if (pData->ISA(FmFilterItems))
 794     {
 795         FmFormItem* pFormItem = static_cast<FmFormItem*>(pParent);
 796
 797         try
 798         {
 799             Reference< XFilterController > xFilterController( pFormItem->GetFilterController(), UNO_SET_THROW );
 800
 801             bool bEmptyLastTerm = ( ( nPos == 0 ) && xFilterController->getDisjunctiveTerms() == 1 );
 802             if ( bEmptyLastTerm )
 803             {
 804                 // remove all children (by setting an empty predicate expression)
 805                 ::std::vector< FmFilterData* >& rChildren = static_cast<FmFilterItems*>(pData)->GetChildren();
 806                 while ( !rChildren.empty() )
 807                 {
 808                     ::std::vector< FmFilterData* >::iterator removePos = rChildren.end() - 1;
 809                     FmFilterItem* pFilterItem = PTR_CAST( FmFilterItem, *removePos );
 810                     FmFilterAdapter::setText( nPos, pFilterItem, OUString() );
 811                     Remove( removePos );
 812                 }
 813             }
 814             else
 815             {
 816                 xFilterController->removeDisjunctiveTerm( nPos );
 817             }
 818         }
 819         catch( const Exception& )
 820         {
 821             DBG_UNHANDLED_EXCEPTION();
 822         }
 823     }
 824     else // FormItems can not be deleted
 825     {
 826         FmFilterItem* pFilterItem = PTR_CAST(FmFilterItem, pData);
 827
 828         // if its the last condition remove the parent
 829         if (rItems.size() == 1)
 830             Remove(pFilterItem->GetParent());
 831         else
 832         {
 833             // find the position of the father within his father
 834             ::std::vector<FmFilterData*>& rParentParentItems = pData->GetParent()->GetParent()->GetChildren();
 835             ::std::vector<FmFilterData*>::iterator j = ::std::find(rParentParentItems.begin(), rParentParentItems.end(), pFilterItem->GetParent());
 836             DBG_ASSERT(j != rParentParentItems.end(), "FmFilterModel::Remove(): unknown Item");
 837             sal_Int32 nParentPos = j - rParentParentItems.begin();
 838
 839             // EmptyText removes the filter
 840             FmFilterAdapter::setText(nParentPos, pFilterItem, OUString());
 841             Remove( i );
 842         }
 843     }
 844 }
 845
 846
 847 void FmFilterModel::Remove( const ::std::vector<FmFilterData*>::iterator& rPos )
 848 {
 849     // remove from parent's child list
 850     FmFilterData* pData = *rPos;
 851     pData->GetParent()->GetChildren().erase( rPos );
 852
 853     // notify the view, this will remove the actual SvTreeListEntry
 854     FmFilterRemovedHint aRemoveHint( pData );
 855     Broadcast( aRemoveHint );
 856
 857     delete pData;
 858 }
 859
 860
 861 bool FmFilterModel::ValidateText(FmFilterItem* pItem, OUString& rText, OUString& rErrorMsg) const
 862 {
 863     FmFormItem* pFormItem = PTR_CAST( FmFormItem, pItem->GetParent()->GetParent() );
 864     try
 865     {
 866         Reference< XFormController > xFormController( pFormItem->GetController() );
 867         // obtain the connection of the form belonging to the controller
 868         Reference< XRowSet > xRowSet( xFormController->getModel(), UNO_QUERY_THROW );
 869         Reference< XConnection > xConnection( getConnection( xRowSet ) );
 870
 871         // obtain a number formatter for this connection
 872         // TODO: shouldn't this be cached?
 873         Reference< XNumberFormatsSupplier > xFormatSupplier = getNumberFormats( xConnection, true );
 874         Reference< XNumberFormatter > xFormatter( NumberFormatter::create( comphelper::getProcessComponentContext() ), UNO_QUERY_THROW );
 875         xFormatter->attachNumberFormatsSupplier( xFormatSupplier );
 876
 877         // get the field (database column) which the item is responsible for
 878         Reference< XFilterController > xFilterController( xFormController, UNO_QUERY_THROW );
 879         Reference< XPropertySet > xField( lcl_getBoundField_nothrow( xFilterController->getFilterComponent( pItem->GetComponentIndex() ) ), UNO_SET_THROW );
 880
 881         // parse the given text as filter predicate
 882         OUString aErr, aTxt( rText );
 883         std::shared_ptr< OSQLParseNode > pParseNode = predicateTree( aErr, aTxt, xFormatter, xField );
 884         rErrorMsg = aErr;
 885         rText = aTxt;
 886         if ( pParseNode != nullptr )
 887         {
 888             OUString aPreparedText;
 889             Locale aAppLocale = Application::GetSettings().GetUILanguageTag().getLocale();
 890             pParseNode->parseNodeToPredicateStr(
 891                 aPreparedText, xConnection, xFormatter, xField, OUString(), aAppLocale, '.', getParseContext() );
 892             rText = aPreparedText;
 893             return true;
 894         }
 895     }
 896     catch( const Exception& )
 897     {
 898         DBG_UNHANDLED_EXCEPTION();
 899     }
 900
 901     return false;
 902 }
 903
 904
 905 void FmFilterModel::Append(FmFilterItems* pItems, FmFilterItem* pFilterItem)
 906 {
 907     Insert(pItems->GetChildren().end(), pFilterItem);
 908 }
 909
 910
 911 void FmFilterModel::SetTextForItem(FmFilterItem* pItem, const OUString& rText)
 912 {
 913     ::std::vector<FmFilterData*>& rItems = pItem->GetParent()->GetParent()->GetChildren();
 914     ::std::vector<FmFilterData*>::iterator i = ::std::find(rItems.begin(), rItems.end(), pItem->GetParent());
 915     sal_Int32 nParentPos = i - rItems.begin();
 916
 917     FmFilterAdapter::setText(nParentPos, pItem, rText);
 918
 919     if (rText.isEmpty())
 920         Remove(pItem);
 921     else
 922     {
 923         // Change the text
 924         pItem->SetText(rText);
 925         FmFilterTextChangedHint aChangeHint(pItem);
 926         Broadcast( aChangeHint );
 927     }
 928 }
 929
 930
 931 void FmFilterModel::SetCurrentItems(FmFilterItems* pCurrent)
 932 {
 933     if (m_pCurrentItems == pCurrent)
 934         return;
 935
 936     // search for the condition
 937     if (pCurrent)
 938     {
 939         FmFormItem* pFormItem = static_cast<FmFormItem*>(pCurrent->GetParent());
 940         ::std::vector<FmFilterData*>& rItems = pFormItem->GetChildren();
 941         ::std::vector<FmFilterData*>::const_iterator i = ::std::find(rItems.begin(), rItems.end(), pCurrent);
 942
 943         if (i != rItems.end())
 944         {
 945             // determine the filter position
 946             sal_Int32 nPos = i - rItems.begin();
 947             try
 948             {
 949                 Reference< XFilterController > xFilterController( pFormItem->GetFilterController(), UNO_SET_THROW );
 950                 xFilterController->setActiveTerm( nPos );
 951             }
 952             catch( const Exception& )
 953             {
 954                 DBG_UNHANDLED_EXCEPTION();
 955             }
 956
 957             if ( m_xController != pFormItem->GetController() )
 958                 // calls SetCurrentItems again
 959                 SetCurrentController( pFormItem->GetController() );
 960             else
 961                 m_pCurrentItems = pCurrent;
 962         }
 963         else
 964             m_pCurrentItems = NULL;
 965     }
 966     else
 967         m_pCurrentItems = NULL;
 968
 969
 970     // UI benachrichtigen
 971     FmFilterCurrentChangedHint aHint;
 972     Broadcast( aHint );
 973 }
 974
 975
 976 void FmFilterModel::EnsureEmptyFilterRows( FmParentData& _rItem )
 977 {
 978     // checks whether for each form there's one free level for input
 979     ::std::vector< FmFilterData* >& rChildren = _rItem.GetChildren();
 980     bool bAppendLevel = _rItem.ISA( FmFormItem );
 981
 982     for (   ::std::vector<FmFilterData*>::iterator i = rChildren.begin();
 983             i != rChildren.end();
 984             ++i
 985         )
 986     {
 987         FmFilterItems* pItems = PTR_CAST(FmFilterItems, *i);
 988         if ( pItems && pItems->GetChildren().empty() )
 989         {
 990             bAppendLevel = false;
 991             break;
 992         }
 993
 994         FmFormItem* pFormItem = PTR_CAST(FmFormItem, *i);
 995         if (pFormItem)
 996         {
 997             EnsureEmptyFilterRows( *pFormItem );
 998             continue;
 999         }
1000     }
1001
1002     if ( bAppendLevel )
1003     {
1004         FmFormItem* pFormItem = PTR_CAST( FmFormItem, &_rItem );
1005         OSL_ENSURE( pFormItem, "FmFilterModel::EnsureEmptyFilterRows: no FmFormItem, but a FmFilterItems child?" );
1006         if ( pFormItem )
1007             AppendFilterItems( *pFormItem );
1008     }
1009 }
1010
1011 class FmFilterItemsString : public SvLBoxString
1012 {
1013 public:
1014     FmFilterItemsString( SvTreeListEntry* pEntry, sal_uInt16 nFlags, const OUString& rStr )
1015         :SvLBoxString(pEntry,nFlags,rStr){}
1016
1017     virtual void Paint(const Point& rPos, SvTreeListBox& rDev, vcl::RenderContext& rRenderContext,
1018                        const SvViewDataEntry* pView, const SvTreeListEntry* pEntry) SAL_OVERRIDE;
1019     virtual void InitViewData( SvTreeListBox* pView,SvTreeListEntry* pEntry, SvViewDataItem* pViewData) SAL_OVERRIDE;
1020 };
1021
1022 const int nxDBmp = 12;
1023
1024 void FmFilterItemsString::Paint(const Point& rPos, SvTreeListBox& rDev, vcl::RenderContext& rRenderContext,
1025                                 const SvViewDataEntry* /*pView*/, const SvTreeListEntry* pEntry)
1026 {
1027     FmFilterItems* pRow = static_cast<FmFilterItems*>(pEntry->GetUserData());
1028     FmFormItem* pForm = static_cast<FmFormItem*>(pRow->GetParent());
1029
1030     // current filter is significant painted
1031     const bool bIsCurrentFilter = pForm->GetChildren()[ pForm->GetFilterController()->getActiveTerm() ] == pRow;
1032     if (bIsCurrentFilter)
1033     {
1034         rRenderContext.Push(PushFlags::LINECOLOR);
1035         rRenderContext.SetLineColor(rRenderContext.GetTextColor());
1036
1037         Rectangle aRect(rPos, GetSize(&rDev, pEntry));
1038         Point aFirst(rPos.X(), aRect.Bottom() - 6);
1039         Point aSecond(aFirst .X() + 2, aFirst.Y() + 3);
1040
1041         rRenderContext.DrawLine(aFirst, aSecond);
1042
1043         aFirst = aSecond;
1044         aFirst.X() += 1;
1045         aSecond.X() += 6;
1046         aSecond.Y() -= 5;
1047
1048         rRenderContext.DrawLine(aFirst, aSecond);
1049         rRenderContext.Pop();
1050     }
1051
1052     rRenderContext.DrawText(Point(rPos.X() + nxDBmp, rPos.Y()), GetText());
1053 }
1054
1055
1056 void FmFilterItemsString::InitViewData( SvTreeListBox* pView,SvTreeListEntry* pEntry, SvViewDataItem* pViewData)
1057 {
1058     if( !pViewData )
1059         pViewData = pView->GetViewDataItem( pEntry, this );
1060
1061     Size aSize(pView->GetTextWidth(GetText()), pView->GetTextHeight());
1062     aSize.Width() += nxDBmp;
1063     pViewData->maSize = aSize;
1064 }
1065
1066 class FmFilterString : public SvLBoxString
1067 {
1068     OUString m_aName;
1069
1070 public:
1071     FmFilterString( SvTreeListEntry* pEntry, sal_uInt16 nFlags, const OUString& rStr, const OUString& aName)
1072         : SvLBoxString(pEntry,nFlags,rStr)
1073         , m_aName(aName)
1074     {
1075         m_aName += ": ";
1076     }
1077
1078     virtual void Paint(const Point& rPos, SvTreeListBox& rDev, vcl::RenderContext& rRenderContext,
1079                        const SvViewDataEntry* pView, const SvTreeListEntry* pEntry) SAL_OVERRIDE;
1080     virtual void InitViewData( SvTreeListBox* pView,SvTreeListEntry* pEntry, SvViewDataItem* pViewData) SAL_OVERRIDE;
1081 };
1082
1083 const int nxD = 4;
1084
1085
1086 void FmFilterString::InitViewData( SvTreeListBox* pView,SvTreeListEntry* pEntry, SvViewDataItem* pViewData)
1087 {
1088     if( !pViewData )
1089         pViewData = pView->GetViewDataItem( pEntry, this );
1090
1091     vcl::Font aOldFont( pView->GetFont());
1092     vcl::Font aFont( aOldFont );
1093     aFont.SetWeight(WEIGHT_BOLD);
1094     pView->Control::SetFont( aFont );
1095
1096     Size aSize(pView->GetTextWidth(m_aName), pView->GetTextHeight());
1097     pView->Control::SetFont( aOldFont );
1098     aSize.Width() += pView->GetTextWidth(GetText()) + nxD;
1099     pViewData->maSize = aSize;
1100 }
1101
1102
1103 void FmFilterString::Paint(const Point& rPos, SvTreeListBox& rDev, vcl::RenderContext& rRenderContext,
1104                            const SvViewDataEntry* /*pView*/, const SvTreeListEntry* /*pEntry*/)
1105 {
1106     rRenderContext.Push(PushFlags::FONT);
1107     vcl::Font aFont(rRenderContext.GetFont());
1108     aFont.SetWeight(WEIGHT_BOLD);
1109     rRenderContext.SetFont(aFont);
1110
1111     Point aPos(rPos);
1112     rRenderContext.DrawText(aPos, m_aName);
1113
1114     // position for the second text
1115     aPos.X() += rDev.GetTextWidth(m_aName) + nxD;
1116     rRenderContext.Pop();
1117     rDev.DrawText(aPos, GetText());
1118 }
1119
1120 FmFilterNavigator::FmFilterNavigator( vcl::Window* pParent )
1121                   :SvTreeListBox( pParent, WB_HASBUTTONS|WB_HASLINES|WB_BORDER|WB_HASBUTTONSATROOT )
1122                   ,m_pModel( NULL )
1123                   ,m_pEditingCurrently( NULL )
1124                   ,m_aControlExchange( this )
1125                   ,m_aTimerCounter( 0 )
1126                   ,m_aDropActionType( DA_SCROLLUP )
1127 {
1128     SetHelpId( HID_FILTER_NAVIGATOR );
1129
1130     {
1131         ImageList aNavigatorImages( SVX_RES( RID_SVXIMGLIST_FMEXPL ) );
1132         SetNodeBitmaps(
1133             aNavigatorImages.GetImage( RID_SVXIMG_COLLAPSEDNODE ),
1134             aNavigatorImages.GetImage( RID_SVXIMG_EXPANDEDNODE )
1135         );
1136     }
1137
1138     m_pModel = new FmFilterModel();
1139     StartListening( *m_pModel );
1140
1141     EnableInplaceEditing( true );
1142     SetSelectionMode(MULTIPLE_SELECTION);
1143
1144     SetDragDropMode(DragDropMode::ALL);
1145
1146     m_aDropActionTimer.SetTimeoutHdl(LINK(this, FmFilterNavigator, OnDropActionTimer));
1147 }
1148
1149
1150 FmFilterNavigator::~FmFilterNavigator()
1151 {
1152     disposeOnce();
1153 }
1154
1155 void FmFilterNavigator::dispose()
1156 {
1157     EndListening( *m_pModel );
1158     delete m_pModel;
1159     SvTreeListBox::dispose();
1160 }
1161
1162
1163 void FmFilterNavigator::UpdateContent(const Reference< XIndexAccess > & xControllers, const Reference< XFormController > & xCurrent)
1164 {
1165     if (xCurrent == m_pModel->GetCurrentController())
1166         return;
1167
1168     m_pModel->Update(xControllers, xCurrent);
1169
1170     // expand the filters for the current controller
1171     SvTreeListEntry* pEntry = FindEntry(m_pModel->GetCurrentForm());
1172     if (pEntry && !IsExpanded(pEntry))
1173     {
1174         SelectAll(false);
1175
1176         if (!IsExpanded(pEntry))
1177             Expand(pEntry);
1178
1179         pEntry = FindEntry(m_pModel->GetCurrentItems());
1180         if (pEntry)
1181         {
1182             if (!IsExpanded(pEntry))
1183                 Expand(pEntry);
1184             Select(pEntry, true);
1185         }
1186     }
1187 }
1188
1189
1190 bool FmFilterNavigator::EditingEntry( SvTreeListEntry* pEntry, Selection& rSelection )
1191 {
1192     m_pEditingCurrently = pEntry;
1193     if (!SvTreeListBox::EditingEntry( pEntry, rSelection ))
1194         return false;
1195
1196     return pEntry && static_cast<FmFilterData*>(pEntry->GetUserData())->ISA(FmFilterItem);
1197 }
1198
1199
1200 bool FmFilterNavigator::EditedEntry( SvTreeListEntry* pEntry, const OUString& rNewText )
1201 {
1202     DBG_ASSERT(pEntry == m_pEditingCurrently, "FmFilterNavigator::EditedEntry: suspicious entry!");
1203     m_pEditingCurrently = NULL;
1204
1205     if (EditingCanceled())
1206         return true;
1207
1208     DBG_ASSERT(static_cast<FmFilterData*>(pEntry->GetUserData())->ISA(FmFilterItem),
1209                     "FmFilterNavigator::EditedEntry() wrong entry");
1210
1211     OUString aText(comphelper::string::strip(rNewText, ' '));
1212     if (aText.isEmpty())
1213     {
1214         // deleting the entry asynchron
1215         PostUserEvent(LINK(this, FmFilterNavigator, OnRemove), pEntry, true);
1216     }
1217     else
1218     {
1219         OUString aErrorMsg;
1220
1221         if (m_pModel->ValidateText(static_cast<FmFilterItem*>(pEntry->GetUserData()), aText, aErrorMsg))
1222         {
1223             GrabFocus();
1224             // this will set the text at the FmFilterItem, as well as update any filter controls
1225             // which are connected to this particular entry
1226             m_pModel->SetTextForItem( static_cast< FmFilterItem* >( pEntry->GetUserData() ), aText );
1227
1228             SetCursor( pEntry, true );
1229             SetEntryText( pEntry, aText );
1230         }
1231         else
1232         {
1233             // display the error and return sal_False
1234             SQLContext aError;
1235             aError.Message = SVX_RESSTR(RID_STR_SYNTAXERROR);
1236             aError.Details = aErrorMsg;
1237             displayException(aError, this);
1238
1239             return false;
1240         }
1241     }
1242     return true;
1243 }
1244
1245
1246 IMPL_LINK( FmFilterNavigator, OnRemove, SvTreeListEntry*, pEntry )
1247 {
1248     // now remove the entry
1249     m_pModel->Remove(static_cast<FmFilterData*>(pEntry->GetUserData()));
1250     return 0L;
1251 }
1252
1253
1254 IMPL_LINK_NOARG_TYPED(FmFilterNavigator, OnDropActionTimer, Timer *, void)
1255 {
1256     if (--m_aTimerCounter > 0)
1257         return;
1258
1259     switch (m_aDropActionType)
1260     {
1261         case DA_SCROLLUP :
1262             ScrollOutputArea(1);
1263             m_aTimerCounter = DROP_ACTION_TIMER_SCROLL_TICKS;
1264             break;
1265         case DA_SCROLLDOWN :
1266             ScrollOutputArea(-1);
1267             m_aTimerCounter = DROP_ACTION_TIMER_SCROLL_TICKS;
1268             break;
1269         case DA_EXPANDNODE:
1270         {
1271             SvTreeListEntry* pToExpand = GetEntry(m_aTimerTriggered);
1272             if (pToExpand && (GetChildCount(pToExpand) > 0) &&  !IsExpanded(pToExpand))
1273                 Expand(pToExpand);
1274             m_aDropActionTimer.Stop();
1275         }
1276         break;
1277     }
1278 }
1279
1280
1281
1282 sal_Int8 FmFilterNavigator::AcceptDrop( const AcceptDropEvent& rEvt )
1283 {
1284     Point aDropPos = rEvt.maPosPixel;
1285
1286     // possible DropActions scroll and expand
1287     if (rEvt.mbLeaving)
1288     {
1289         if (m_aDropActionTimer.IsActive())
1290             m_aDropActionTimer.Stop();
1291     }
1292     else
1293     {
1294         bool bNeedTrigger = false;
1295         // first entry ?
1296         if ((aDropPos.Y() >= 0) && (aDropPos.Y() < GetEntryHeight()))
1297         {
1298             m_aDropActionType = DA_SCROLLUP;
1299             bNeedTrigger = true;
1300         }
1301         else
1302         {
1303             if ((aDropPos.Y() < GetSizePixel().Height()) && (aDropPos.Y() >= GetSizePixel().Height() - GetEntryHeight()))
1304             {
1305                 m_aDropActionType = DA_SCROLLDOWN;
1306                 bNeedTrigger = true;
1307             }
1308             else
1309             {   // is it an entry with children, and not yet expanded?
1310                 SvTreeListEntry* pDropppedOn = GetEntry(aDropPos);
1311                 if (pDropppedOn && (GetChildCount(pDropppedOn) > 0) && !IsExpanded(pDropppedOn))
1312                 {
1313                     // -> expand
1314                     m_aDropActionType = DA_EXPANDNODE;
1315                     bNeedTrigger = true;
1316                 }
1317             }
1318         }
1319         if (bNeedTrigger && (m_aTimerTriggered != aDropPos))
1320         {
1321             m_aTimerCounter = DROP_ACTION_TIMER_INITIAL_TICKS;
1322             // remember DropPos because there are QueryDrops even though the mouse was not moved
1323             m_aTimerTriggered = aDropPos;
1324             if (!m_aDropActionTimer.IsActive())
1325             {
1326                 m_aDropActionTimer.SetTimeout(DROP_ACTION_TIMER_TICK_BASE);
1327                 m_aDropActionTimer.Start();
1328             }
1329         }
1330         else if (!bNeedTrigger)
1331             m_aDropActionTimer.Stop();
1332     }
1333
1334     if (!m_aControlExchange.isDragSource())
1335         return DND_ACTION_NONE;
1336
1337     if (!OFilterItemExchange::hasFormat(GetDataFlavorExVector()))
1338         return DND_ACTION_NONE;
1339
1340     // do we conain the formitem?
1341     if (!FindEntry(m_aControlExchange->getFormItem()))
1342         return DND_ACTION_NONE;
1343
1344     SvTreeListEntry* pDropTarget = GetEntry(aDropPos);
1345     if (!pDropTarget)
1346         return DND_ACTION_NONE;
1347
1348     FmFilterData* pData = static_cast<FmFilterData*>(pDropTarget->GetUserData());
1349     FmFormItem* pForm = NULL;
1350     if (pData->ISA(FmFilterItem))
1351     {
1352         pForm = PTR_CAST(FmFormItem,pData->GetParent()->GetParent());
1353         if (pForm != m_aControlExchange->getFormItem())
1354             return DND_ACTION_NONE;
1355     }
1356     else if (pData->ISA(FmFilterItems))
1357     {
1358         pForm = PTR_CAST(FmFormItem,pData->GetParent());
1359         if (pForm != m_aControlExchange->getFormItem())
1360             return DND_ACTION_NONE;
1361     }
1362     else
1363         return DND_ACTION_NONE;
1364
1365     return rEvt.mnAction;
1366 }
1367
1368 namespace
1369 {
1370     FmFilterItems* getTargetItems(SvTreeListEntry* _pTarget)
1371     {
1372         FmFilterData*   pData = static_cast<FmFilterData*>(_pTarget->GetUserData());
1373         FmFilterItems*  pTargetItems = dynamic_cast<FmFilterItems*>(pData);
1374         if (!pTargetItems)
1375             pTargetItems = dynamic_cast<FmFilterItems*>(pData->GetParent());
1376         return pTargetItems;
1377     }
1378 }
1379
1380 sal_Int8 FmFilterNavigator::ExecuteDrop( const ExecuteDropEvent& rEvt )
1381 {
1382     // you can't scroll after dropping...
1383     if (m_aDropActionTimer.IsActive())
1384         m_aDropActionTimer.Stop();
1385
1386     if (!m_aControlExchange.isDragSource())
1387         return DND_ACTION_NONE;
1388
1389     Point aDropPos = rEvt.maPosPixel;
1390     SvTreeListEntry* pDropTarget = GetEntry( aDropPos );
1391     if (!pDropTarget)
1392         return DND_ACTION_NONE;
1393
1394     // search the container where to add the items
1395     FmFilterItems*  pTargetItems = getTargetItems(pDropTarget);
1396     SelectAll(false);
1397     SvTreeListEntry* pEntry = FindEntry(pTargetItems);
1398     Select(pEntry, true);
1399     SetCurEntry(pEntry);
1400
1401     insertFilterItem(m_aControlExchange->getDraggedEntries(),pTargetItems,DND_ACTION_COPY == rEvt.mnAction);
1402
1403     return DND_ACTION_COPY;
1404 }
1405
1406
1407 void FmFilterNavigator::InitEntry(SvTreeListEntry* pEntry,
1408                                   const OUString& rStr,
1409                                   const Image& rImg1,
1410                                   const Image& rImg2,
1411                                   SvLBoxButtonKind eButtonKind)
1412 {
1413     SvTreeListBox::InitEntry( pEntry, rStr, rImg1, rImg2, eButtonKind );
1414     SvLBoxString* pString = NULL;
1415
1416     if (static_cast<FmFilterData*>(pEntry->GetUserData())->ISA(FmFilterItem))
1417         pString = new FmFilterString(pEntry, 0, rStr, static_cast<FmFilterItem*>(pEntry->GetUserData())->GetFieldName());
1418     else if (static_cast<FmFilterData*>(pEntry->GetUserData())->ISA(FmFilterItems))
1419         pString = new FmFilterItemsString(pEntry, 0, rStr );
1420
1421     if (pString)
1422         pEntry->ReplaceItem( pString, 1 );
1423 }
1424
1425
1426 bool FmFilterNavigator::Select( SvTreeListEntry* pEntry, bool bSelect )
1427 {
1428     if (bSelect == IsSelected(pEntry))  // das passiert manchmal, ich glaube, die Basisklasse geht zu sehr auf Nummer sicher ;)
1429         return true;
1430
1431     if (SvTreeListBox::Select(pEntry, bSelect))
1432     {
1433         if (bSelect)
1434         {
1435             FmFormItem* pFormItem = NULL;
1436             if (static_cast<FmFilterData*>(pEntry->GetUserData())->ISA(FmFilterItem))
1437                 pFormItem = static_cast<FmFormItem*>(static_cast<FmFilterItem*>(pEntry->GetUserData())->GetParent()->GetParent());
1438             else if (static_cast<FmFilterData*>(pEntry->GetUserData())->ISA(FmFilterItems))
1439                 pFormItem = static_cast<FmFormItem*>(static_cast<FmFilterItem*>(pEntry->GetUserData())->GetParent()->GetParent());
1440             else if (static_cast<FmFilterData*>(pEntry->GetUserData())->ISA(FmFormItem))
1441                 pFormItem = static_cast<FmFormItem*>(pEntry->GetUserData());
1442
1443             if (pFormItem)
1444             {
1445                 // will the controller be exchanged?
1446                 if (static_cast<FmFilterData*>(pEntry->GetUserData())->ISA(FmFilterItem))
1447                     m_pModel->SetCurrentItems(static_cast<FmFilterItems*>(static_cast<FmFilterItem*>(pEntry->GetUserData())->GetParent()));
1448                 else if (static_cast<FmFilterData*>(pEntry->GetUserData())->ISA(FmFilterItems))
1449                     m_pModel->SetCurrentItems(static_cast<FmFilterItems*>(pEntry->GetUserData()));
1450                 else if (static_cast<FmFilterData*>(pEntry->GetUserData())->ISA(FmFormItem))
1451                     m_pModel->SetCurrentController(static_cast<FmFormItem*>(pEntry->GetUserData())->GetController());
1452             }
1453         }
1454         return true;
1455     }
1456     else
1457         return false;
1458 }
1459
1460 void FmFilterNavigator::Notify( SfxBroadcaster& /*rBC*/, const SfxHint& rHint )
1461 {
1462     if (const FmFilterInsertedHint* pInsertHint = dynamic_cast<const FmFilterInsertedHint*>(&rHint))
1463     {
1464         Insert(pInsertHint->GetData(), pInsertHint->GetPos());
1465     }
1466     else if( dynamic_cast<const FilterClearingHint*>(&rHint) )
1467     {
1468         SvTreeListBox::Clear();
1469     }
1470     else if (const FmFilterRemovedHint* pRemoveHint = dynamic_cast<const FmFilterRemovedHint*>(&rHint))
1471     {
1472         Remove(pRemoveHint->GetData());
1473     }
1474     else if (const FmFilterTextChangedHint *pChangeHint = dynamic_cast<const FmFilterTextChangedHint*>(&rHint))
1475     {
1476         SvTreeListEntry* pEntry = FindEntry(pChangeHint->GetData());
1477         if (pEntry)
1478             SetEntryText( pEntry, pChangeHint->GetData()->GetText());
1479     }
1480     else if( dynamic_cast<const FmFilterCurrentChangedHint*>(&rHint) )
1481     {
1482         // invalidate the entries
1483         for (SvTreeListEntry* pEntry = First(); pEntry != NULL;
1484              pEntry = Next(pEntry))
1485             GetModel()->InvalidateEntry( pEntry );
1486     }
1487 }
1488
1489 SvTreeListEntry* FmFilterNavigator::FindEntry(const FmFilterData* pItem) const
1490 {
1491     SvTreeListEntry* pEntry = NULL;
1492     if (pItem)
1493     {
1494         for (pEntry = First(); pEntry != NULL; pEntry = Next( pEntry ))
1495         {
1496             FmFilterData* pEntryItem = static_cast<FmFilterData*>(pEntry->GetUserData());
1497             if (pEntryItem == pItem)
1498                 break;
1499         }
1500     }
1501     return pEntry;
1502 }
1503
1504
1505 void FmFilterNavigator::Insert(FmFilterData* pItem, sal_uLong nPos)
1506 {
1507     const FmParentData* pParent = pItem->GetParent() ? pItem->GetParent() : GetFilterModel();
1508
1509     // insert the item
1510     SvTreeListEntry* pParentEntry = FindEntry( pParent );
1511     InsertEntry( pItem->GetText(), pItem->GetImage(), pItem->GetImage(), pParentEntry, false, nPos, pItem );
1512     if ( pParentEntry )
1513         Expand( pParentEntry );
1514 }
1515
1516
1517 void FmFilterNavigator::Remove(FmFilterData* pItem)
1518 {
1519     // der Entry zu den Daten
1520     SvTreeListEntry* pEntry = FindEntry(pItem);
1521
1522     if (pEntry == m_pEditingCurrently)
1523         // cancel editing
1524         EndEditing(true);
1525
1526     if (pEntry)
1527         GetModel()->Remove( pEntry );
1528 }
1529
1530 FmFormItem* FmFilterNavigator::getSelectedFilterItems(::std::vector<FmFilterItem*>& _rItemList)
1531 {
1532     // be sure that the data is only used within only one form!
1533     FmFormItem* pFirstItem = NULL;
1534
1535     bool bHandled = true;
1536     bool bFoundSomething = false;
1537     for (SvTreeListEntry* pEntry = FirstSelected();
1538          bHandled && pEntry != NULL;
1539          pEntry = NextSelected(pEntry))
1540     {
1541         FmFilterItem* pFilter = PTR_CAST(FmFilterItem, static_cast<FmFilterData*>(pEntry->GetUserData()));
1542         if (pFilter)
1543         {
1544             FmFormItem* pForm = PTR_CAST(FmFormItem,pFilter->GetParent()->GetParent());
1545             if (!pForm)
1546                 bHandled = false;
1547             else if (!pFirstItem)
1548                 pFirstItem = pForm;
1549             else if (pFirstItem != pForm)
1550                 bHandled = false;
1551
1552             if (bHandled)
1553             {
1554                 _rItemList.push_back(pFilter);
1555                 bFoundSomething = true;
1556             }
1557         }
1558     }
1559     if ( !bHandled || !bFoundSomething )
1560         pFirstItem = NULL;
1561     return pFirstItem;
1562 }
1563
1564 void FmFilterNavigator::insertFilterItem(const ::std::vector<FmFilterItem*>& _rFilterList,FmFilterItems* _pTargetItems,bool _bCopy)
1565 {
1566     ::std::vector<FmFilterItem*>::const_iterator aEnd = _rFilterList.end();
1567     for (   ::std::vector< FmFilterItem* >::const_iterator i = _rFilterList.begin();
1568             i != aEnd;
1569             ++i
1570         )
1571     {
1572         FmFilterItem* pLookupItem( *i );
1573         if ( pLookupItem->GetParent() == _pTargetItems )
1574             continue;
1575
1576         FmFilterItem* pFilterItem = _pTargetItems->Find( pLookupItem->GetComponentIndex() );
1577         OUString aText = pLookupItem->GetText();
1578         if ( !pFilterItem )
1579         {
1580             pFilterItem = new FmFilterItem( _pTargetItems, pLookupItem->GetFieldName(), aText, pLookupItem->GetComponentIndex() );
1581             m_pModel->Append( _pTargetItems, pFilterItem );
1582         }
1583
1584         if ( !_bCopy )
1585             m_pModel->Remove( pLookupItem );
1586
1587         // now set the text for the new dragged item
1588         m_pModel->SetTextForItem( pFilterItem, aText );
1589     }
1590
1591     m_pModel->EnsureEmptyFilterRows( *_pTargetItems->GetParent() );
1592 }
1593
1594
1595 void FmFilterNavigator::StartDrag( sal_Int8 /*_nAction*/, const Point& /*_rPosPixel*/ )
1596 {
1597     EndSelection();
1598
1599     // be sure that the data is only used within a only one form!
1600     m_aControlExchange.prepareDrag();
1601
1602     ::std::vector<FmFilterItem*> aItemList;
1603     if ( FmFormItem* pFirstItem = getSelectedFilterItems(aItemList) )
1604     {
1605         m_aControlExchange->setDraggedEntries(aItemList);
1606         m_aControlExchange->setFormItem(pFirstItem);
1607         m_aControlExchange.startDrag( DND_ACTION_COPYMOVE );
1608     }
1609 }
1610
1611
1612 void FmFilterNavigator::Command( const CommandEvent& rEvt )
1613 {
1614     bool bHandled = false;
1615     switch (rEvt.GetCommand())
1616     {
1617         case CommandEventId::ContextMenu:
1618         {
1619             // die Stelle, an der geklickt wurde
1620             Point aWhere;
1621             SvTreeListEntry* pClicked = NULL;
1622             if (rEvt.IsMouseEvent())
1623             {
1624                 aWhere = rEvt.GetMousePosPixel();
1625                 pClicked = GetEntry(aWhere);
1626                 if (pClicked == NULL)
1627                     break;
1628
1629                 if (!IsSelected(pClicked))
1630                 {
1631                     SelectAll(false);
1632                     Select(pClicked, true);
1633                     SetCurEntry(pClicked);
1634                 }
1635             }
1636             else
1637             {
1638                 pClicked = GetCurEntry();
1639                 if (!pClicked)
1640                     break;
1641                 aWhere = GetEntryPosition( pClicked );
1642             }
1643
1644             ::std::vector<FmFilterData*> aSelectList;
1645             for (SvTreeListEntry* pEntry = FirstSelected();
1646                  pEntry != NULL;
1647                  pEntry = NextSelected(pEntry))
1648             {
1649                 // don't delete forms
1650                 FmFormItem* pForm = PTR_CAST(FmFormItem, static_cast<FmFilterData*>(pEntry->GetUserData()));
1651                 if (!pForm)
1652                     aSelectList.push_back(static_cast<FmFilterData*>(pEntry->GetUserData()));
1653             }
1654             if (aSelectList.size() == 1)
1655             {
1656                 // don't delete the only empty row of a form
1657                 FmFilterItems* pFilterItems = PTR_CAST(FmFilterItems, aSelectList[0]);
1658                 if (pFilterItems && pFilterItems->GetChildren().empty()
1659                     && pFilterItems->GetParent()->GetChildren().size() == 1)
1660                     aSelectList.clear();
1661             }
1662
1663             PopupMenu aContextMenu(SVX_RES(RID_FM_FILTER_MENU));
1664
1665             // every condition could be deleted except the first one if its the only one
1666             aContextMenu.EnableItem( SID_FM_DELETE, !aSelectList.empty() );
1667
1668
1669             bool bEdit = PTR_CAST(FmFilterItem, static_cast<FmFilterData*>(pClicked->GetUserData())) != NULL &&
1670                 IsSelected(pClicked) && GetSelectionCount() == 1;
1671
1672             aContextMenu.EnableItem( SID_FM_FILTER_EDIT,
1673                 bEdit );
1674             aContextMenu.EnableItem( SID_FM_FILTER_IS_NULL,
1675                 bEdit );
1676             aContextMenu.EnableItem( SID_FM_FILTER_IS_NOT_NULL,
1677                 bEdit );
1678
1679             aContextMenu.RemoveDisabledEntries(true, true);
1680             sal_uInt16 nSlotId = aContextMenu.Execute( this, aWhere );
1681             switch( nSlotId )
1682             {
1683                 case SID_FM_FILTER_EDIT:
1684                 {
1685                     EditEntry( pClicked );
1686                 }   break;
1687                 case SID_FM_FILTER_IS_NULL:
1688                 case SID_FM_FILTER_IS_NOT_NULL:
1689                 {
1690                     OUString aErrorMsg;
1691                     OUString aText;
1692                     if (nSlotId == SID_FM_FILTER_IS_NULL)
1693                         aText = "IS NULL";
1694                     else
1695                         aText = "IS NOT NULL";
1696
1697                     m_pModel->ValidateText(static_cast<FmFilterItem*>(pClicked->GetUserData()),
1698                                             aText, aErrorMsg);
1699                     m_pModel->SetTextForItem(static_cast<FmFilterItem*>(pClicked->GetUserData()), aText);
1700                 }   break;
1701                 case SID_FM_DELETE:
1702                 {
1703                     DeleteSelection();
1704                 }   break;
1705             }
1706             bHandled = true;
1707         }
1708         break;
1709         default: break;
1710     }
1711
1712     if (!bHandled)
1713         SvTreeListBox::Command( rEvt );
1714 }
1715
1716 SvTreeListEntry* FmFilterNavigator::getNextEntry(SvTreeListEntry* _pStartWith)
1717 {
1718     SvTreeListEntry* pEntry = _pStartWith ? _pStartWith : LastSelected();
1719     pEntry = Next(pEntry);
1720     // we need the next filter entry
1721     while( pEntry && GetChildCount( pEntry ) == 0 && pEntry != Last() )
1722         pEntry = Next(pEntry);
1723     return pEntry;
1724 }
1725
1726 SvTreeListEntry* FmFilterNavigator::getPrevEntry(SvTreeListEntry* _pStartWith)
1727 {
1728     SvTreeListEntry* pEntry = _pStartWith ? _pStartWith : FirstSelected();
1729     pEntry = Prev(pEntry);
1730     // check if the previous entry is a filter, if so get the next prev
1731     if ( pEntry && GetChildCount( pEntry ) != 0 )
1732     {
1733         pEntry = Prev(pEntry);
1734         // if the entry is still no leaf return
1735         if ( pEntry && GetChildCount( pEntry ) != 0 )
1736             pEntry = NULL;
1737     }
1738     return pEntry;
1739 }
1740
1741 void FmFilterNavigator::KeyInput(const KeyEvent& rKEvt)
1742 {
1743     const vcl::KeyCode& rKeyCode = rKEvt.GetKeyCode();
1744
1745     switch ( rKeyCode.GetCode() )
1746     {
1747     case KEY_UP:
1748     case KEY_DOWN:
1749     {
1750         if ( !rKeyCode.IsMod1() || !rKeyCode.IsMod2() || rKeyCode.IsShift() )
1751             break;
1752
1753         ::std::vector<FmFilterItem*> aItemList;
1754         if ( !getSelectedFilterItems( aItemList ) )
1755             break;
1756
1757         ::std::mem_fun1_t<SvTreeListEntry*,FmFilterNavigator,SvTreeListEntry*> getter = ::std::mem_fun(&FmFilterNavigator::getNextEntry);
1758         if ( rKeyCode.GetCode() == KEY_UP )
1759             getter = ::std::mem_fun(&FmFilterNavigator::getPrevEntry);
1760
1761         SvTreeListEntry* pTarget = getter( this, NULL );
1762         if ( !pTarget )
1763             break;
1764
1765         FmFilterItems* pTargetItems = getTargetItems( pTarget );
1766         if ( !pTargetItems )
1767             break;
1768
1769         ::std::vector<FmFilterItem*>::const_iterator aEnd = aItemList.end();
1770         bool bNextTargetItem = true;
1771         while ( bNextTargetItem )
1772         {
1773             ::std::vector<FmFilterItem*>::const_iterator i = aItemList.begin();
1774             for (; i != aEnd; ++i)
1775             {
1776                 if ( (*i)->GetParent() == pTargetItems )
1777                 {
1778                     pTarget = getter(this,pTarget);
1779                     if ( !pTarget )
1780                         return;
1781                     pTargetItems = getTargetItems( pTarget );
1782                     break;
1783                 }
1784                 else
1785                 {
1786                     FmFilterItem* pFilterItem = pTargetItems->Find( (*i)->GetComponentIndex() );
1787                     // we found the text component so jump above
1788                     if ( pFilterItem )
1789                     {
1790                         pTarget = getter( this, pTarget );
1791                         if ( !pTarget )
1792                             return;
1793
1794                         pTargetItems = getTargetItems( pTarget );
1795                         break;
1796                     }
1797                 }
1798             }
1799             bNextTargetItem = i != aEnd && pTargetItems;
1800         }
1801
1802         if ( pTargetItems )
1803         {
1804             insertFilterItem( aItemList, pTargetItems );
1805             return;
1806         }
1807     }
1808     break;
1809
1810     case KEY_DELETE:
1811     {
1812         if ( rKeyCode.GetModifier() )
1813             break;
1814
1815         if ( !IsSelected( First() ) || GetEntryCount() > 1 )
1816             DeleteSelection();
1817         return;
1818     }
1819     }
1820
1821     SvTreeListBox::KeyInput(rKEvt);
1822 }
1823
1824
1825 void FmFilterNavigator::DeleteSelection()
1826 {
1827     // to avoid the deletion of an entry twice (e.g. deletion of a parent and afterward
1828     // the deletion of its child, i have to shrink the selecton list
1829     ::std::vector<SvTreeListEntry*> aEntryList;
1830     for (SvTreeListEntry* pEntry = FirstSelected();
1831          pEntry != NULL;
1832          pEntry = NextSelected(pEntry))
1833     {
1834         FmFilterItem* pFilterItem = PTR_CAST(FmFilterItem, static_cast<FmFilterData*>(pEntry->GetUserData()));
1835         if (pFilterItem && IsSelected(GetParent(pEntry)))
1836             continue;
1837
1838         FmFormItem* pForm = PTR_CAST(FmFormItem, static_cast<FmFilterData*>(pEntry->GetUserData()));
1839         if (!pForm)
1840             aEntryList.push_back(pEntry);
1841     }
1842
1843     // Remove the selection
1844     SelectAll(false);
1845
1846     for (::std::vector<SvTreeListEntry*>::reverse_iterator i = aEntryList.rbegin();
1847         // link problems with operator ==
1848         i.base() != aEntryList.rend().base(); ++i)
1849     {
1850         m_pModel->Remove(static_cast<FmFilterData*>((*i)->GetUserData()));
1851     }
1852 }
1853
1854 FmFilterNavigatorWin::FmFilterNavigatorWin( SfxBindings* _pBindings, SfxChildWindow* _pMgr,
1855                               vcl::Window* _pParent )
1856                      :SfxDockingWindow( _pBindings, _pMgr, _pParent, WinBits(WB_STDMODELESS|WB_SIZEABLE|WB_ROLLABLE|WB_3DLOOK|WB_DOCKABLE) )
1857                      ,SfxControllerItem( SID_FM_FILTER_NAVIGATOR_CONTROL, *_pBindings )
1858 {
1859     SetHelpId( HID_FILTER_NAVIGATOR_WIN );
1860
1861     m_pNavigator = VclPtr<FmFilterNavigator>::Create( this );
1862     m_pNavigator->Show();
1863     SetText( SVX_RES(RID_STR_FILTER_NAVIGATOR) );
1864     SfxDockingWindow::SetFloatingSize( Size(200,200) );
1865 }
1866
1867
1868 FmFilterNavigatorWin::~FmFilterNavigatorWin()
1869 {
1870     disposeOnce();
1871 }
1872
1873 void FmFilterNavigatorWin::dispose()
1874 {
1875     m_pNavigator.disposeAndClear();
1876     SfxDockingWindow::dispose();
1877 }
1878
1879
1880 void FmFilterNavigatorWin::UpdateContent(FmFormShell* pFormShell)
1881 {
1882     if (!m_pNavigator)
1883         return;
1884
1885     if (!pFormShell)
1886         m_pNavigator->UpdateContent( NULL, NULL );
1887     else
1888     {
1889         Reference< XFormController >  xController(pFormShell->GetImpl()->getActiveInternalController());
1890         Reference< XIndexAccess >   xContainer;
1891         if (xController.is())
1892         {
1893             Reference< XChild >  xChild(xController, UNO_QUERY);
1894             for (Reference< XInterface >  xParent(xChild->getParent());
1895                  xParent.is();
1896                  xParent = xChild.is() ? xChild->getParent() : Reference< XInterface > ())
1897             {
1898                 xContainer = Reference< XIndexAccess > (xParent, UNO_QUERY);
1899                 xChild = Reference< XChild > (xParent, UNO_QUERY);
1900             }
1901         }
1902         m_pNavigator->UpdateContent(xContainer, xController);
1903     }
1904 }
1905
1906
1907 void FmFilterNavigatorWin::StateChanged( sal_uInt16 nSID, SfxItemState eState, const SfxPoolItem* pState )
1908 {
1909     if( !pState  || SID_FM_FILTER_NAVIGATOR_CONTROL != nSID )
1910         return;
1911
1912     if( eState >= SfxItemState::DEFAULT )
1913     {
1914         FmFormShell* pShell = PTR_CAST( FmFormShell, static_cast<const SfxObjectItem*>(pState)->GetShell() );
1915         UpdateContent( pShell );
1916     }
1917     else
1918         UpdateContent( NULL );
1919 }
1920
1921
1922 bool FmFilterNavigatorWin::Close()
1923 {
1924     if ( m_pNavigator && m_pNavigator->IsEditingActive() )
1925         m_pNavigator->EndEditing();
1926
1927     if ( m_pNavigator && m_pNavigator->IsEditingActive() )
1928         // the EndEditing was vetoed (perhaps of an syntax error or such)
1929         return false;
1930
1931     UpdateContent( NULL );
1932     return SfxDockingWindow::Close();
1933 }
1934
1935
1936 void FmFilterNavigatorWin::FillInfo( SfxChildWinInfo& rInfo ) const
1937 {
1938     SfxDockingWindow::FillInfo( rInfo );
1939     rInfo.bVisible = false;
1940 }
1941
1942
1943 Size FmFilterNavigatorWin::CalcDockingSize( SfxChildAlignment eAlign )
1944 {
1945     if ( ( eAlign == SfxChildAlignment::TOP ) || ( eAlign == SfxChildAlignment::BOTTOM ) )
1946         return Size();
1947
1948     return SfxDockingWindow::CalcDockingSize( eAlign );
1949 }
1950
1951
1952 SfxChildAlignment FmFilterNavigatorWin::CheckAlignment( SfxChildAlignment eActAlign, SfxChildAlignment eAlign )
1953 {
1954     switch (eAlign)
1955     {
1956         case SfxChildAlignment::LEFT:
1957         case SfxChildAlignment::RIGHT:
1958         case SfxChildAlignment::NOALIGNMENT:
1959             return eAlign;
1960         default:
1961             break;
1962     }
1963
1964     return eActAlign;
1965 }
1966
1967
1968 void FmFilterNavigatorWin::Resize()
1969 {
1970     SfxDockingWindow::Resize();
1971
1972     Size aLogOutputSize = PixelToLogic( GetOutputSizePixel(), MAP_APPFONT );
1973     Size aLogExplSize = aLogOutputSize;
1974     aLogExplSize.Width() -= 6;
1975     aLogExplSize.Height() -= 6;
1976
1977     Point aExplPos = LogicToPixel( Point(3,3), MAP_APPFONT );
1978     Size aExplSize = LogicToPixel( aLogExplSize, MAP_APPFONT );
1979
1980     m_pNavigator->SetPosSizePixel( aExplPos, aExplSize );
1981 }
1982
1983 void FmFilterNavigatorWin::GetFocus()
1984 {
1985     // oj #97405#
1986     if ( m_pNavigator )
1987         m_pNavigator->GrabFocus();
1988 }
1989
1990 SFX_IMPL_DOCKINGWINDOW( FmFilterNavigatorWinMgr, SID_FM_FILTER_NAVIGATOR )
1991
1992
1993 FmFilterNavigatorWinMgr::FmFilterNavigatorWinMgr( vcl::Window *_pParent, sal_uInt16 _nId,
1994                                     SfxBindings *_pBindings, SfxChildWinInfo* _pInfo )
1995                  :SfxChildWindow( _pParent, _nId )
1996 {
1997     pWindow = VclPtr<FmFilterNavigatorWin>::Create( _pBindings, this, _pParent );
1998     eChildAlignment = SfxChildAlignment::NOALIGNMENT;
1999     static_cast<SfxDockingWindow*>(pWindow.get())->Initialize( _pInfo );
2000 }
2001
2002
2003 }
2004
2005
2006 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */