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 <svx/dialmgr.hxx>
42 #include <svx/fmshell.hxx>
43 #include <svx/fmtools.hxx>
44 #include <svx/svxids.hrc>
46 #include <tools/diagnose_ex.h>
47 #include <vcl/commandevent.hxx>
48 #include <vcl/event.hxx>
49 #include <vcl/settings.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  {
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 (auto pFilterItems = dynamic_cast<FmFilterItems*>( pData))
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 = pFilterItems->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 = weld::fromId<FmFilterData*>(rId);
928  OUString sText = pData->GetText();
929 
930  if (FmFilterItem* pItem = dynamic_cast<FmFilterItem*>(pData))
931  {
932  rRenderContext.Push(vcl::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(vcl::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 = weld::fromId<FmFilterData*>(rId);
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(vcl::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(vcl::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_nAsyncRemoveEvent(nullptr)
1053 {
1054  m_xTreeView->set_help_id(HID_FILTER_NAVIGATOR);
1055 
1056  m_xTreeView->set_selection_mode(SelectionMode::Multiple);
1057 
1058  m_pModel.reset( new FmFilterModel() );
1060 
1061  m_xTreeView->connect_custom_get_size(LINK(this, FmFilterNavigator, CustomGetSizeHdl));
1062  m_xTreeView->connect_custom_render(LINK(this, FmFilterNavigator, CustomRenderHdl));
1063  m_xTreeView->set_column_custom_renderer(0, true);
1064 
1065  m_xTreeView->connect_changed(LINK(this, FmFilterNavigator, SelectHdl));
1066  m_xTreeView->connect_key_press(LINK(this, FmFilterNavigator, KeyInputHdl));
1067  m_xTreeView->connect_popup_menu(LINK(this, FmFilterNavigator, PopupMenuHdl));
1068  m_xTreeView->connect_editing(LINK(this, FmFilterNavigator, EditingEntryHdl),
1069  LINK(this, FmFilterNavigator, EditedEntryHdl));
1070  m_xTreeView->connect_drag_begin(LINK(this, FmFilterNavigator, DragBeginHdl));
1071 }
1072 
1074 {
1075  if (m_nAsyncRemoveEvent)
1078  m_pModel.reset();
1079 }
1080 
1081 void FmFilterNavigator::UpdateContent(const Reference< XIndexAccess > & xControllers, const Reference< XFormController > & xCurrent)
1082 {
1083  if (xCurrent == m_pModel->GetCurrentController())
1084  return;
1085 
1086  m_pModel->Update(xControllers, xCurrent);
1087 
1088  // expand the filters for the current controller
1089  std::unique_ptr<weld::TreeIter> xEntry = FindEntry(m_pModel->GetCurrentForm());
1090  if (!xEntry || m_xTreeView->get_row_expanded(*xEntry))
1091  return;
1092 
1093  m_xTreeView->unselect_all();
1094 
1095  m_xTreeView->expand_row(*xEntry);
1096 
1097  xEntry = FindEntry(m_pModel->GetCurrentItems());
1098  if (xEntry)
1099  {
1100  if (!m_xTreeView->get_row_expanded(*xEntry))
1101  m_xTreeView->expand_row(*xEntry);
1102  m_xTreeView->select(*xEntry);
1103  SelectHdl(*m_xTreeView);
1104  }
1105 }
1106 
1107 IMPL_LINK(FmFilterNavigator, EditingEntryHdl, const weld::TreeIter&, rIter, bool)
1108 {
1109  // returns true to allow editing
1110  if (dynamic_cast<const FmFilterItem*>(weld::fromId<FmFilterData*>(m_xTreeView->get_id(rIter))))
1111  {
1112  m_xEditingCurrently = m_xTreeView->make_iterator(&rIter);
1113  return true;
1114  }
1115  m_xEditingCurrently.reset();
1116  return false;
1117 }
1118 
1119 IMPL_LINK(FmFilterNavigator, EditedEntryHdl, const IterString&, rIterString, bool)
1120 {
1121  const weld::TreeIter& rIter = rIterString.first;
1122  const OUString& rNewText = rIterString.second;
1123 
1124  assert(m_xEditingCurrently && m_xTreeView->iter_compare(rIter, *m_xEditingCurrently) == 0 &&
1125  "FmFilterNavigator::EditedEntry: suspicious entry!");
1126  m_xEditingCurrently.reset();
1127 
1128  FmFilterData* pData = weld::fromId<FmFilterData*>(m_xTreeView->get_id(rIter));
1129 
1130  DBG_ASSERT(dynamic_cast<const FmFilterItem*>(pData) != nullptr,
1131  "FmFilterNavigator::EditedEntry() wrong entry");
1132 
1133  OUString aText(comphelper::string::strip(rNewText, ' '));
1134  if (aText.isEmpty())
1135  {
1136  // deleting the entry asynchron
1137  m_nAsyncRemoveEvent = Application::PostUserEvent(LINK(this, FmFilterNavigator, OnRemove), pData);
1138  }
1139  else
1140  {
1141  OUString aErrorMsg;
1142 
1143  if (m_pModel->ValidateText(static_cast<FmFilterItem*>(pData), aText, aErrorMsg))
1144  {
1145  // this will set the text at the FmFilterItem, as well as update any filter controls
1146  // which are connected to this particular entry
1147  m_pModel->SetTextForItem(static_cast<FmFilterItem*>(pData), aText);
1148  m_xTreeView->set_text(rIter, aText);
1149  }
1150  else
1151  {
1152  // display the error and return sal_False
1153  SQLContext aError;
1154  aError.Message = SvxResId(RID_STR_SYNTAXERROR);
1155  aError.Details = aErrorMsg;
1156  displayException(aError, VCLUnoHelper::GetInterface(m_xTopLevel));
1157 
1158  return false;
1159  }
1160  }
1161  return true;
1162 }
1163 
1164 IMPL_LINK( FmFilterNavigator, OnRemove, void*, p, void )
1165 {
1166  m_nAsyncRemoveEvent = nullptr;
1167  // now remove the entry
1168  m_pModel->Remove(static_cast<FmFilterData*>(p));
1169 }
1170 
1172 {
1173  if (!m_aControlExchange.isDragSource())
1174  return DND_ACTION_NONE;
1175 
1177  return DND_ACTION_NONE;
1178 
1179  // do we contain the formitem?
1181  return DND_ACTION_NONE;
1182 
1183  Point aDropPos = rEvt.maPosPixel;
1184  std::unique_ptr<weld::TreeIter> xDropTarget(m_xTreeView->make_iterator());
1185  // get_dest_row_at_pos with false cause we must drop exactly "on" a node to paste a condition into it
1186  if (!m_xTreeView->get_dest_row_at_pos(aDropPos, xDropTarget.get(), false))
1187  xDropTarget.reset();
1188 
1189  if (!xDropTarget)
1190  return DND_ACTION_NONE;
1191 
1192  FmFilterData* pData = weld::fromId<FmFilterData*>(m_xTreeView->get_id(*xDropTarget));
1193  FmFormItem* pForm = nullptr;
1194  if (dynamic_cast<const FmFilterItem*>(pData) != nullptr)
1195  {
1196  pForm = dynamic_cast<FmFormItem*>( pData->GetParent()->GetParent() );
1197  if (pForm != m_aControlExchange->getFormItem())
1198  return DND_ACTION_NONE;
1199  }
1200  else if (dynamic_cast<const FmFilterItems*>( pData) != nullptr)
1201  {
1202  pForm = dynamic_cast<FmFormItem*>( pData->GetParent() );
1203  if (pForm != m_aControlExchange->getFormItem())
1204  return DND_ACTION_NONE;
1205  }
1206  else
1207  return DND_ACTION_NONE;
1208 
1209  return rEvt.mnAction;
1210 }
1211 
1212 namespace
1213 {
1214  FmFilterItems* getTargetItems(const weld::TreeView& rTreeView, const weld::TreeIter& rTarget)
1215  {
1216  FmFilterData* pData = weld::fromId<FmFilterData*>(rTreeView.get_id(rTarget));
1217  FmFilterItems* pTargetItems = dynamic_cast<FmFilterItems*>(pData);
1218  if (!pTargetItems)
1219  pTargetItems = dynamic_cast<FmFilterItems*>(pData->GetParent());
1220  return pTargetItems;
1221  }
1222 }
1223 
1225 {
1226  if (!m_aControlExchange.isDragSource())
1227  return DND_ACTION_NONE;
1228 
1229  Point aDropPos = rEvt.maPosPixel;
1230  std::unique_ptr<weld::TreeIter> xDropTarget(m_xTreeView->make_iterator());
1231  // get_dest_row_at_pos with false cause we must drop exactly "on" a node to paste a condition into it
1232  if (!m_xTreeView->get_dest_row_at_pos(aDropPos, xDropTarget.get(), false))
1233  xDropTarget.reset();
1234  if (!xDropTarget)
1235  return DND_ACTION_NONE;
1236 
1237  // search the container where to add the items
1238  FmFilterItems* pTargetItems = getTargetItems(*m_xTreeView, *xDropTarget);
1239  m_xTreeView->unselect_all();
1240  std::unique_ptr<weld::TreeIter> xEntry = FindEntry(pTargetItems);
1241  if (xEntry)
1242  {
1243  m_xTreeView->select(*xEntry);
1244  m_xTreeView->set_cursor(*xEntry);
1245  }
1246 
1248 
1249  return DND_ACTION_COPY;
1250 }
1251 
1253 {
1254  std::unique_ptr<weld::TreeIter> xIter(m_xTreeView->make_iterator());
1255  if (!m_xTreeView->get_selected(xIter.get()))
1256  return;
1257 
1258  FmFilterData* pData = weld::fromId<FmFilterData*>(m_xTreeView->get_id(*xIter));
1259 
1260  FmFormItem* pFormItem = nullptr;
1261  if (FmFilterItem* pItem = dynamic_cast<FmFilterItem*>(pData))
1262  pFormItem = static_cast<FmFormItem*>(pItem->GetParent()->GetParent());
1263  else if (FmFilterItems* pItems = dynamic_cast<FmFilterItems*>(pData))
1264  pFormItem = static_cast<FmFormItem*>(pItems->GetParent()->GetParent());
1265  else
1266  pFormItem = dynamic_cast<FmFormItem*>(pData);
1267 
1268  if (pFormItem)
1269  {
1270  // will the controller be exchanged?
1271  if (FmFilterItem* pItem = dynamic_cast<FmFilterItem*>(pData))
1272  m_pModel->SetCurrentItems(static_cast<FmFilterItems*>(pItem->GetParent()));
1273  else if (FmFilterItems* pItems = dynamic_cast<FmFilterItems*>(pData))
1274  m_pModel->SetCurrentItems(pItems);
1275  else
1276  m_pModel->SetCurrentController(pFormItem->GetController());
1277  }
1278 }
1279 
1280 void FmFilterNavigator::Notify( SfxBroadcaster& /*rBC*/, const SfxHint& rHint )
1281 {
1282  if (const FmFilterInsertedHint* pInsertHint = dynamic_cast<const FmFilterInsertedHint*>(&rHint))
1283  {
1284  Insert(pInsertHint->GetData(), pInsertHint->GetPos());
1285  }
1286  else if( dynamic_cast<const FilterClearingHint*>(&rHint) )
1287  {
1288  m_xTreeView->clear();
1289  }
1290  else if (const FmFilterRemovedHint* pRemoveHint = dynamic_cast<const FmFilterRemovedHint*>(&rHint))
1291  {
1292  Remove(pRemoveHint->GetData());
1293  }
1294  else if (const FmFilterTextChangedHint *pChangeHint = dynamic_cast<const FmFilterTextChangedHint*>(&rHint))
1295  {
1296  std::unique_ptr<weld::TreeIter> xEntry = FindEntry(pChangeHint->GetData());
1297  if (xEntry)
1298  m_xTreeView->set_text(*xEntry, pChangeHint->GetData()->GetText());
1299  }
1300  else if( dynamic_cast<const FmFilterCurrentChangedHint*>(&rHint) )
1301  {
1302  m_xTreeView->queue_draw();
1303  }
1304 }
1305 
1306 std::unique_ptr<weld::TreeIter> FmFilterNavigator::FindEntry(const FmFilterData* pItem) const
1307 {
1308  if (!pItem)
1309  return nullptr;
1310  std::unique_ptr<weld::TreeIter> xEntry = m_xTreeView->make_iterator();
1311  if (!m_xTreeView->get_iter_first(*xEntry))
1312  return nullptr;
1313  do
1314  {
1315  FmFilterData* pEntryItem = weld::fromId<FmFilterData*>(m_xTreeView->get_id(*xEntry));
1316  if (pEntryItem == pItem)
1317  return xEntry;
1318  }
1319  while (m_xTreeView->iter_next(*xEntry));
1320 
1321  return nullptr;
1322 }
1323 
1324 void FmFilterNavigator::Insert(const FmFilterData* pItem, int nPos)
1325 {
1326  const FmParentData* pParent = pItem->GetParent() ? pItem->GetParent() : m_pModel.get();
1327 
1328  // insert the item
1329  std::unique_ptr<weld::TreeIter> xParentEntry = FindEntry(pParent);
1330 
1331  OUString sId(weld::toId(pItem));
1332  std::unique_ptr<weld::TreeIter> xRet(m_xTreeView->make_iterator());
1333  m_xTreeView->insert(xParentEntry.get(), nPos, &pItem->GetText(), &sId,
1334  nullptr, nullptr, false, xRet.get());
1335  m_xTreeView->set_image(*xRet, pItem->GetImage());
1336 
1337  if (!xParentEntry)
1338  return;
1339  m_xTreeView->expand_row(*xParentEntry);
1340 }
1341 
1343 {
1344  if (m_xEditingCurrently)
1345  {
1346  // end editing
1347  m_xTreeView->end_editing();
1348  m_xEditingCurrently.reset();
1349  }
1350 }
1351 
1353 {
1354  // the entry for the data
1355  std::unique_ptr<weld::TreeIter> xEntry = FindEntry(pItem);
1356  if (!xEntry)
1357  return;
1358 
1359  if (m_xEditingCurrently && m_xTreeView->iter_compare(*xEntry, *m_xEditingCurrently) == 0)
1360  EndEditing();
1361 
1362  m_xTreeView->remove(*xEntry);
1363 }
1364 
1365 FmFormItem* FmFilterNavigator::getSelectedFilterItems(::std::vector<FmFilterItem*>& _rItemList)
1366 {
1367  // be sure that the data is only used within only one form!
1368  FmFormItem* pFirstItem = nullptr;
1369 
1370  bool bHandled = true;
1371  bool bFoundSomething = false;
1372 
1373  m_xTreeView->selected_foreach([this, &bHandled, &bFoundSomething, &pFirstItem, &_rItemList](weld::TreeIter& rEntry) {
1374  FmFilterData* pFilterEntry = weld::fromId<FmFilterData*>(m_xTreeView->get_id(rEntry));
1375  FmFilterItem* pFilter = dynamic_cast<FmFilterItem*>(pFilterEntry);
1376  if (pFilter)
1377  {
1378  FmFormItem* pForm = dynamic_cast<FmFormItem*>( pFilter->GetParent()->GetParent() );
1379  if (!pForm)
1380  bHandled = false;
1381  else if (!pFirstItem)
1382  pFirstItem = pForm;
1383  else if (pFirstItem != pForm)
1384  bHandled = false;
1385 
1386  if (bHandled)
1387  {
1388  _rItemList.push_back(pFilter);
1389  bFoundSomething = true;
1390  }
1391  }
1392  return !bHandled;
1393  });
1394 
1395  if ( !bHandled || !bFoundSomething )
1396  pFirstItem = nullptr;
1397  return pFirstItem;
1398 }
1399 
1400 void FmFilterNavigator::insertFilterItem(const ::std::vector<FmFilterItem*>& _rFilterList,FmFilterItems* _pTargetItems,bool _bCopy)
1401 {
1402  for (FmFilterItem* pLookupItem : _rFilterList)
1403  {
1404  if ( pLookupItem->GetParent() == _pTargetItems )
1405  continue;
1406 
1407  FmFilterItem* pFilterItem = _pTargetItems->Find( pLookupItem->GetComponentIndex() );
1408  OUString aText = pLookupItem->GetText();
1409  if ( !pFilterItem )
1410  {
1411  pFilterItem = new FmFilterItem( _pTargetItems, pLookupItem->GetFieldName(), aText, pLookupItem->GetComponentIndex() );
1412  m_pModel->Append( _pTargetItems, std::unique_ptr<FmFilterItem>(pFilterItem) );
1413  }
1414 
1415  if ( !_bCopy )
1416  m_pModel->Remove( pLookupItem );
1417 
1418  // now set the text for the new dragged item
1419  m_pModel->SetTextForItem( pFilterItem, aText );
1420  }
1421 
1422  m_pModel->EnsureEmptyFilterRows( *_pTargetItems->GetParent() );
1423 }
1424 
1425 IMPL_LINK(FmFilterNavigator, DragBeginHdl, bool&, rUnsetDragIcon, bool)
1426 {
1427  rUnsetDragIcon = false;
1428 
1429  // be sure that the data is only used within an only one form!
1430  m_aControlExchange.prepareDrag();
1431 
1432  ::std::vector<FmFilterItem*> aItemList;
1433  if (FmFormItem* pFirstItem = getSelectedFilterItems(aItemList))
1434  {
1435  m_aControlExchange->setDraggedEntries(std::move(aItemList));
1436  m_aControlExchange->setFormItem(pFirstItem);
1437 
1438  OFilterItemExchange& rExchange = *m_aControlExchange;
1439  rtl::Reference<TransferDataContainer> xHelper(&rExchange);
1440  m_xTreeView->enable_drag_source(xHelper, DND_ACTION_COPYMOVE);
1441  rExchange.setDragging(true);
1442 
1443  return false;
1444  }
1445  return true;
1446 }
1447 
1448 IMPL_LINK(FmFilterNavigator, PopupMenuHdl, const CommandEvent&, rEvt, bool)
1449 {
1450  bool bHandled = false;
1451  switch (rEvt.GetCommand())
1452  {
1453  case CommandEventId::ContextMenu:
1454  {
1455  // the place where it was clicked
1456  Point aWhere;
1457  std::unique_ptr<weld::TreeIter> xClicked(m_xTreeView->make_iterator());
1458  if (rEvt.IsMouseEvent())
1459  {
1460  aWhere = rEvt.GetMousePosPixel();
1461  if (!m_xTreeView->get_dest_row_at_pos(aWhere, xClicked.get(), false))
1462  break;
1463 
1464  if (!m_xTreeView->is_selected(*xClicked))
1465  {
1466  m_xTreeView->unselect_all();
1467  m_xTreeView->select(*xClicked);
1468  m_xTreeView->set_cursor(*xClicked);
1469  }
1470  }
1471  else
1472  {
1473  if (!m_xTreeView->get_cursor(xClicked.get()))
1474  break;
1475  aWhere = m_xTreeView->get_row_area(*xClicked).Center();
1476  }
1477 
1478  ::std::vector<FmFilterData*> aSelectList;
1479  m_xTreeView->selected_foreach([this, &aSelectList](weld::TreeIter& rEntry) {
1480  FmFilterData* pFilterEntry = weld::fromId<FmFilterData*>(m_xTreeView->get_id(rEntry));
1481 
1482  // don't delete forms
1483  FmFormItem* pForm = dynamic_cast<FmFormItem*>(pFilterEntry);
1484  if (!pForm)
1485  aSelectList.push_back(pFilterEntry);
1486 
1487  return false;
1488  });
1489 
1490  if (aSelectList.size() == 1)
1491  {
1492  // don't delete the only empty row of a form
1493  FmFilterItems* pFilterItems = dynamic_cast<FmFilterItems*>( aSelectList[0] );
1494  if (pFilterItems && pFilterItems->GetChildren().empty()
1495  && pFilterItems->GetParent()->GetChildren().size() == 1)
1496  aSelectList.clear();
1497  }
1498 
1499  std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(m_xTreeView.get(), "svx/ui/filtermenu.ui"));
1500  std::unique_ptr<weld::Menu> xContextMenu(xBuilder->weld_menu("menu"));
1501 
1502  // every condition could be deleted except the first one if it's the only one
1503  bool bNoDelete = false;
1504  if (aSelectList.empty())
1505  {
1506  bNoDelete = true;
1507  xContextMenu->remove("delete");
1508  }
1509 
1510  FmFilterData* pFilterEntry = weld::fromId<FmFilterData*>(m_xTreeView->get_id(*xClicked));
1511  auto pFilterItem = dynamic_cast<FmFilterItem*>(pFilterEntry);
1512  bool bEdit = pFilterItem &&
1513  m_xTreeView->is_selected(*xClicked) && m_xTreeView->count_selected_rows() == 1;
1514 
1515  if (bNoDelete && !bEdit)
1516  {
1517  // nothing is in the menu, don't bother
1518  return true;
1519  }
1520 
1521  if (!bEdit)
1522  {
1523  xContextMenu->remove("edit");
1524  xContextMenu->remove("isnull");
1525  xContextMenu->remove("isnotnull");
1526  }
1527 
1528  OString sIdent = xContextMenu->popup_at_rect(m_xTreeView.get(), tools::Rectangle(aWhere, ::Size(1, 1)));
1529  if (sIdent == "edit")
1530  {
1531  m_xTreeView->start_editing(*xClicked);
1532  }
1533  else if (sIdent == "isnull")
1534  {
1535  OUString aErrorMsg;
1536  OUString aText = "IS NULL";
1537  assert(pFilterItem && "if item is null this menu entry was removed and unavailable");
1538  m_pModel->ValidateText(pFilterItem, aText, aErrorMsg);
1539  m_pModel->SetTextForItem(pFilterItem, aText);
1540  }
1541  else if (sIdent == "isnotnull")
1542  {
1543  OUString aErrorMsg;
1544  OUString aText = "IS NOT NULL";
1545 
1546  assert(pFilterItem && "if item is null this menu entry was removed and unavailable");
1547  m_pModel->ValidateText(pFilterItem, aText, aErrorMsg);
1548  m_pModel->SetTextForItem(pFilterItem, aText);
1549  }
1550  else if (sIdent == "delete")
1551  {
1552  DeleteSelection();
1553  }
1554  bHandled = true;
1555  }
1556  break;
1557  default: break;
1558  }
1559 
1560  return bHandled;
1561 }
1562 
1564 {
1565  bool bEntry = m_xTreeView->iter_next(rEntry);
1566  // we need the next filter entry
1567  if (bEntry)
1568  {
1569  while (!m_xTreeView->iter_has_child(rEntry))
1570  {
1571  std::unique_ptr<weld::TreeIter> xNext = m_xTreeView->make_iterator(&rEntry);
1572  if (!m_xTreeView->iter_next(*xNext))
1573  break;
1574  m_xTreeView->copy_iterator(*xNext, rEntry);
1575  }
1576  }
1577  return bEntry;
1578 }
1579 
1581 {
1582  bool bEntry = m_xTreeView->iter_previous(rEntry);
1583  // check if the previous entry is a filter, if so get the next prev
1584  if (bEntry && m_xTreeView->iter_has_child(rEntry))
1585  {
1586  bEntry = m_xTreeView->iter_previous(rEntry);
1587  // if the entry is still no leaf return
1588  if (bEntry && m_xTreeView->iter_has_child(rEntry))
1589  bEntry = false;
1590  }
1591  return bEntry;
1592 }
1593 IMPL_LINK(FmFilterNavigator, KeyInputHdl, const ::KeyEvent&, rKEvt, bool)
1594 {
1595  const vcl::KeyCode& rKeyCode = rKEvt.GetKeyCode();
1596 
1597  switch ( rKeyCode.GetCode() )
1598  {
1599  case KEY_UP:
1600  case KEY_DOWN:
1601  {
1602  if ( !rKeyCode.IsMod1() || !rKeyCode.IsMod2() || rKeyCode.IsShift() )
1603  break;
1604 
1605  ::std::vector<FmFilterItem*> aItemList;
1606  if ( !getSelectedFilterItems( aItemList ) )
1607  break;
1608 
1609 
1610  std::vector<std::unique_ptr<weld::TreeIter>> aSelected;
1611  m_xTreeView->selected_foreach([this, &aSelected](weld::TreeIter& rEntry){
1612  aSelected.emplace_back(m_xTreeView->make_iterator(&rEntry));
1613  return false;
1614  });
1615 
1616  std::unique_ptr<weld::TreeIter> xTarget;
1617  ::std::function<bool(FmFilterNavigator*, weld::TreeIter&)> getter;
1618 
1619  if (rKeyCode.GetCode() == KEY_UP)
1620  {
1621  xTarget = m_xTreeView->make_iterator(aSelected.front().get());
1622  getter = ::std::mem_fn(&FmFilterNavigator::getPrevEntry);
1623  }
1624  else
1625  {
1626  xTarget = m_xTreeView->make_iterator(aSelected.back().get());
1627  getter = ::std::mem_fn(&FmFilterNavigator::getNextEntry);
1628  }
1629 
1630  bool bTarget = getter(this, *xTarget);
1631  if (!bTarget)
1632  break;
1633 
1634  FmFilterItems* pTargetItems = getTargetItems(*m_xTreeView, *xTarget);
1635  if (!pTargetItems)
1636  break;
1637 
1638  ::std::vector<FmFilterItem*>::const_iterator aEnd = aItemList.end();
1639  bool bNextTargetItem = true;
1640  while ( bNextTargetItem )
1641  {
1642  ::std::vector<FmFilterItem*>::const_iterator i = aItemList.begin();
1643  for (; i != aEnd; ++i)
1644  {
1645  if ( (*i)->GetParent() == pTargetItems )
1646  {
1647  bTarget = getter(this, *xTarget);
1648  if (!bTarget)
1649  return true;
1650  pTargetItems = getTargetItems(*m_xTreeView, *xTarget);
1651  break;
1652  }
1653  else
1654  {
1655  FmFilterItem* pFilterItem = pTargetItems->Find( (*i)->GetComponentIndex() );
1656  // we found the text component so jump above
1657  if ( pFilterItem )
1658  {
1659  bTarget = getter(this, *xTarget);
1660  if (!bTarget)
1661  return true;
1662 
1663  pTargetItems = getTargetItems(*m_xTreeView, *xTarget);
1664  break;
1665  }
1666  }
1667  }
1668  bNextTargetItem = i != aEnd && pTargetItems;
1669  }
1670 
1671  if ( pTargetItems )
1672  {
1673  insertFilterItem( aItemList, pTargetItems, false );
1674  return true;
1675  }
1676  }
1677  break;
1678 
1679  case KEY_DELETE:
1680  {
1681  if ( rKeyCode.GetModifier() )
1682  break;
1683 
1684  std::unique_ptr<weld::TreeIter> xEntry = m_xTreeView->make_iterator();
1685  if (m_xTreeView->get_iter_first(*xEntry) && !m_xTreeView->is_selected(*xEntry))
1686  DeleteSelection();
1687 
1688  return true;
1689  }
1690  }
1691 
1692  return false;
1693 }
1694 
1696 {
1697  // to avoid the deletion of an entry twice (e.g. deletion of a parent and afterward
1698  // the deletion of its child, I have to shrink the selection list
1699  std::vector<FmFilterData*> aEntryList;
1700 
1701  m_xTreeView->selected_foreach([this, &aEntryList](weld::TreeIter& rEntry) {
1702  FmFilterData* pFilterEntry = weld::fromId<FmFilterData*>(m_xTreeView->get_id(rEntry));
1703 
1704  if (dynamic_cast<FmFilterItem*>(pFilterEntry))
1705  {
1706  std::unique_ptr<weld::TreeIter> xParent(m_xTreeView->make_iterator(&rEntry));
1707  if (m_xTreeView->iter_parent(*xParent) && m_xTreeView->is_selected(*xParent))
1708  return false;
1709  }
1710 
1711  FmFormItem* pForm = dynamic_cast<FmFormItem*>(pFilterEntry);
1712  if (!pForm)
1713  aEntryList.emplace_back(pFilterEntry);
1714 
1715  return false;
1716  });
1717 
1718  // Remove the selection
1719  m_xTreeView->unselect_all();
1720 
1721  for (auto i = aEntryList.rbegin(); i != aEntryList.rend(); ++i)
1722  m_pModel->Remove(*i);
1723 }
1724 
1726  vcl::Window* _pParent)
1727  : SfxDockingWindow(_pBindings, _pMgr, _pParent, "FilterNavigator", "svx/ui/filternavigator.ui")
1728  , SfxControllerItem( SID_FM_FILTER_NAVIGATOR_CONTROL, *_pBindings )
1729  , m_xNavigatorTree(new FmFilterNavigator(this, m_xBuilder->weld_tree_view("treeview")))
1730 {
1732 
1733  SetText( SvxResId(RID_STR_FILTER_NAVIGATOR) );
1735 }
1736 
1738 {
1739  disposeOnce();
1740 }
1741 
1743 {
1744  m_xNavigatorTree.reset();
1747 }
1748 
1750 {
1751  if (!m_xNavigatorTree)
1752  return;
1753 
1754  if (!pFormShell)
1755  m_xNavigatorTree->UpdateContent( nullptr, nullptr );
1756  else
1757  {
1758  Reference<XFormController> const xController(pFormShell->GetImpl()->getActiveInternalController_Lock());
1759  Reference< XIndexAccess > xContainer;
1760  if (xController.is())
1761  {
1762  Reference< XChild > xChild = xController;
1763  for (Reference< XInterface > xParent(xChild->getParent());
1764  xParent.is();
1765  xParent = xChild.is() ? xChild->getParent() : Reference< XInterface > ())
1766  {
1767  xContainer.set(xParent, UNO_QUERY);
1768  xChild.set(xParent, UNO_QUERY);
1769  }
1770  }
1771  m_xNavigatorTree->UpdateContent(xContainer, xController);
1772  }
1773 }
1774 
1776 {
1777  if( !pState || SID_FM_FILTER_NAVIGATOR_CONTROL != nSID )
1778  return;
1779 
1780  if( eState >= SfxItemState::DEFAULT )
1781  {
1782  FmFormShell* pShell = dynamic_cast<FmFormShell*>( static_cast<const SfxObjectItem*>(pState)->GetShell() );
1783  UpdateContent( pShell );
1784  }
1785  else
1786  UpdateContent( nullptr );
1787 }
1788 
1790 {
1791  if (m_xNavigatorTree)
1792  m_xNavigatorTree->EndEditing();
1793 
1794  UpdateContent( nullptr );
1795  return SfxDockingWindow::Close();
1796 }
1797 
1799 {
1800  SfxDockingWindow::FillInfo( rInfo );
1801  rInfo.bVisible = false;
1802 }
1803 
1805 {
1806  if ( ( eAlign == SfxChildAlignment::TOP ) || ( eAlign == SfxChildAlignment::BOTTOM ) )
1807  return Size();
1808 
1809  return SfxDockingWindow::CalcDockingSize( eAlign );
1810 }
1811 
1813 {
1814  switch (eAlign)
1815  {
1816  case SfxChildAlignment::LEFT:
1817  case SfxChildAlignment::RIGHT:
1818  case SfxChildAlignment::NOALIGNMENT:
1819  return eAlign;
1820  default:
1821  break;
1822  }
1823 
1824  return eActAlign;
1825 }
1826 
1828 {
1829  // oj #97405#
1830  if (m_xNavigatorTree)
1831  m_xNavigatorTree->GrabFocus();
1832  else
1833  SfxDockingWindow::GetFocus();
1834 }
1835 
1836 SFX_IMPL_DOCKINGWINDOW( FmFilterNavigatorWinMgr, SID_FM_FILTER_NAVIGATOR )
1837 
1838 
1839 FmFilterNavigatorWinMgr::FmFilterNavigatorWinMgr( vcl::Window *_pParent, sal_uInt16 _nId,
1840  SfxBindings *_pBindings, SfxChildWinInfo* _pInfo )
1841  :SfxChildWindow( _pParent, _nId )
1842 {
1843  SetWindow( VclPtr<FmFilterNavigatorWin>::Create( _pBindings, this, _pParent ) );
1844  static_cast<SfxDockingWindow*>(GetWindow())->Initialize( _pInfo );
1845 }
1846 
1847 
1848 }
1849 
1850 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
virtual ~FmFilterModel() override
Definition: filtnav.cxx:458
friend class FmFilterAdapter
Definition: filtnav.hxx:140
const Color & GetTextColor() const
FmFilterNavigator & m_rTreeView
Definition: filtnav.hxx:220
void UpdateContent(const css::uno::Reference< css::container::XIndexAccess > &xControllers, const css::uno::Reference< css::form::runtime::XFormController > &xCurrent)
Definition: filtnav.cxx:1081
virtual SfxChildAlignment CheckAlignment(SfxChildAlignment, SfxChildAlignment) override
Definition: filtnav.cxx:1812
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:1400
size_t m_nPos
Definition: filtnav.cxx:171
virtual void SAL_CALL disjunctiveTermRemoved(const FilterEvent &Event) override
Definition: filtnav.cxx:386
virtual sal_Int8 AcceptDrop(const AcceptDropEvent &rEvt) override
Definition: filtnav.cxx:1029
void StateChangedAtToolBoxControl(sal_uInt16 nSID, SfxItemState eState, const SfxPoolItem *pState) override
Definition: filtnav.cxx:1775
virtual void SetHelpId(const OString &) override
#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:1580
virtual ~FmFilterNavigatorWin() override
Definition: filtnav.cxx:1737
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
std::unique_ptr< sal_Int32[]> pData
FmFilterNavigatorDropTarget(FmFilterNavigator &rTreeView)
Definition: filtnav.cxx:1023
virtual void SetText(const OUString &rStr) override
void Remove(FmFilterData *pFilterItem)
Definition: filtnav.cxx:688
const StyleSettings & GetStyleSettings() const
static const AllSettings & GetSettings()
void Push(vcl::PushFlags nFlags=vcl::PushFlags::ALL)
Reference< XInterface > xTarget
void SetWeight(FontWeight)
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
constexpr OUStringLiteral FM_PROP_BOUNDFIELD
Definition: fmprop.hxx:103
virtual void Notify(SfxBroadcaster &rBC, const SfxHint &rHint) override
Definition: filtnav.cxx:1280
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:1171
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:61
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
constexpr tools::Long Width() const
Reference< XIndexAccess > m_xControllers
Definition: filtnav.cxx:214
void UpdateContent(FmFormShell const *pFormShell)
Definition: filtnav.cxx:1749
constexpr OStringLiteral HID_FILTER_NAVIGATOR_WIN
Definition: helpids.h:51
void Insert(const FmFilterData *pItem, int nPos)
Definition: filtnav.cxx:1324
css::uno::Reference< css::container::XIndexAccess > m_xControllers
Definition: filtnav.hxx:142
Reference< XController > xController
FmFilterData * m_pData
Definition: filtnav.cxx:162
virtual OUString GetImage() const override
Definition: filtnav.cxx:136
const vcl::Font & GetFont() const
const DataFlavorExVector & GetDataFlavorExVector() const
int nCount
OUString SvxResId(TranslateId aId)
Definition: dialmgr.cxx:24
ImplSVEvent * m_nAsyncRemoveEvent
Definition: filtnav.hxx:239
#define DND_ACTION_NONE
void SetFloatingSize(const Size &rSize)
bool getNextEntry(weld::TreeIter &rEntry)
Definition: filtnav.cxx:1563
const int nxDBmp
Definition: filtnav.cxx:918
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:232
virtual bool Close() override
FmParentData * GetParent() const
Definition: filtnav.hxx:63
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:1306
void FillInfo(SfxChildWinInfo &rInfo) const override
Definition: filtnav.cxx:1798
rtl::Reference< FmFilterAdapter > m_pAdapter
Definition: filtnav.hxx:144
constexpr sal_uInt16 KEY_DOWN
static void RemoveUserEvent(ImplSVEvent *nUserEvent)
void Remove(FmFilterData const *pItem)
Definition: filtnav.cxx:1352
FmFormItem * getFormItem() const
Definition: filtnav.hxx:190
virtual void GetFocus() override
Definition: filtnav.cxx:1827
#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
tools::Long GetTextWidth(const OUString &rStr, sal_Int32 nIndex=0, sal_Int32 nLen=-1, vcl::text::TextLayoutCache const *=nullptr, SalLayoutGlyphs const *const pLayoutCache=nullptr) const
virtual void dispose()
class SAL_NO_VTABLE XPropertySet
Definition: xmlexchg.hxx:28
virtual Size CalcDockingSize(SfxChildAlignment)
OUString sName
constexpr OStringLiteral HID_FILTER_NAVIGATOR
Definition: helpids.h:50
const ::std::vector< FmFilterItem * > & getDraggedEntries() const
Definition: filtnav.hxx:188
const css::uno::Reference< css::form::runtime::XFormController > & GetController() const
Definition: filtnav.hxx:100
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)
weld::TreeView & get_widget()
Definition: filtnav.hxx:254
std::unique_ptr< FmFilterNavigator > m_xNavigatorTree
Definition: filtnav.hxx:307
sal_Int8 ExecuteDrop(const ExecuteDropEvent &rEvt)
Definition: filtnav.cxx:1224
FmFilterItems * m_pCurrentItems
Definition: filtnav.hxx:145
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:233
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:237
static void setText(sal_Int32 nPos, const FmFilterItem *pFilterItem, const OUString &rText)
Definition: filtnav.cxx:276
OUString toId(const void *pValue)
FmFormItem * getSelectedFilterItems(::std::vector< FmFilterItem * > &_rItemList)
returns the first form item and the selected FilterItems in the vector
Definition: filtnav.cxx:1365
const OUString & GetText() const
Definition: filtnav.hxx:62
void Broadcast(const SfxHint &rHint)
bool IsShift() const
css::uno::Reference< css::form::runtime::XFormController > m_xController
Definition: filtnav.hxx:143
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
virtual rtl::Reference< OLocalExchange > createExchange() const override
Definition: filtnav.cxx:106
void SetFont(const vcl::Font &rNewFont)
FmFilterItem(FmFilterItems *pParent, const OUString &aFieldName, const OUString &aCondition, const sal_Int32 _nComponentIndex)
Definition: filtnav.cxx:141
tools::Long GetTextHeight() const
OUString aName
FmFilterNavigatorWin(SfxBindings *pBindings, SfxChildWindow *pMgr, vcl::Window *pParent)
Definition: filtnav.cxx:1725
::std::vector< std::unique_ptr< FmFilterData > > m_aChildren
Definition: filtnav.hxx:71
OString strip(const OString &rIn, char c)
virtual bool Close() override
Definition: filtnav.cxx:1789
tools::Long AdjustWidth(tools::Long n)
bool IsMod1() const
void EndListening(SfxBroadcaster &rBroadcaster, bool bRemoveAllDuplicates=false)
constexpr OUStringLiteral FM_PROP_NAME
Definition: fmprop.hxx:31
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:1804
std::unique_ptr< FmFilterModel > m_pModel
Definition: filtnav.hxx:235
const css::uno::Reference< css::form::runtime::XFilterController > & GetFilterController() const
Definition: filtnav.hxx:103
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:79
std::unique_ptr< weld::TreeIter > m_xEditingCurrently
Definition: filtnav.hxx:236
OUString getLabelName(const Reference< css::beans::XPropertySet > &xControlModel)
Definition: fmtools.cxx:149
Reference< XModel > xModel
class FmSearchEngine - Impl class for FmSearchDialog
sal_Int32 GetComponentIndex() const
Definition: filtnav.hxx:131
constexpr sal_uInt16 KEY_DELETE
static bool hasFormat(const DataFlavorExVector &_rFormats)
Definition: filtnav.hxx:198
std::pair< vcl::RenderContext &, const OUString & > get_size_args
virtual OUString GetImage() const
Definition: filtnav.cxx:111
static css::uno::Reference< css::awt::XWindow > GetInterface(vcl::Window *pWindow)
sal_Int8 mnAction
const Color & GetDialogTextColor() const
virtual void dispose() override
void DrawText(const Point &rStartPt, const OUString &rStr, sal_Int32 nIndex=0, sal_Int32 nLen=-1, std::vector< tools::Rectangle > *pVector=nullptr, OUString *pDisplayText=nullptr, const SalLayoutGlyphs *pLayoutCache=nullptr)
void AddOrRemoveListener(const Reference< XIndexAccess > &_rxControllers, const bool _bAdd)
Definition: filtnav.cxx:253
virtual ~FmFilterNavigator() override
Definition: filtnav.cxx:1073
sal_uInt16 nPos
virtual void dispose() override
Definition: filtnav.cxx:1742
static std::unique_ptr< weld::Builder > CreateBuilder(weld::Widget *pParent, const OUString &rUIFile, bool bMobile=false, sal_uInt64 nLOKWindowId=0)
void displayException(const Any &_rExcept, const css::uno::Reference< css::awt::XWindow > &rParent)
Definition: fmtools.cxx:83
OUString sDisplayName
bool IsMod2() const
OUString sId