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