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