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>
47 #include <tools/diagnose_ex.h>
48 #include <vcl/commandevent.hxx>
49 #include <vcl/event.hxx>
50 #include <vcl/settings.hxx>
51 #include <vcl/svapp.hxx>
52 
53 #include <bitmaps.hlst>
54 
55 #include <functional>
56 
57 using namespace ::svxform;
58 using namespace ::connectivity;
59 using namespace ::dbtools;
60 
61 namespace svxform
62 {
63  using ::com::sun::star::uno::Reference;
64  using ::com::sun::star::container::XIndexAccess;
65  using ::com::sun::star::uno::UNO_QUERY;
67  using ::com::sun::star::form::runtime::XFormController;
68  using ::com::sun::star::form::runtime::XFilterController;
69  using ::com::sun::star::form::runtime::XFilterControllerListener;
70  using ::com::sun::star::form::runtime::FilterEvent;
71  using ::com::sun::star::lang::EventObject;
72  using ::com::sun::star::form::XForm;
73  using ::com::sun::star::container::XChild;
74  using ::com::sun::star::awt::XControl;
75  using ::com::sun::star::sdbc::XConnection;
76  using ::com::sun::star::util::XNumberFormatsSupplier;
77  using ::com::sun::star::util::XNumberFormatter;
78  using ::com::sun::star::util::NumberFormatter;
79  using ::com::sun::star::sdbc::XRowSet;
80  using ::com::sun::star::lang::Locale;
81  using ::com::sun::star::sdb::SQLContext;
82  using ::com::sun::star::uno::XInterface;
83  using ::com::sun::star::uno::UNO_QUERY_THROW;
84  using ::com::sun::star::uno::UNO_SET_THROW;
85  using ::com::sun::star::uno::Exception;
86  using ::com::sun::star::uno::Sequence;
87 
88 
90  : m_pFormItem(nullptr)
91 {
92 }
93 
95 {
96  AddFormat(getFormatId());
97 }
98 
100 {
101  static SotClipboardFormatId s_nFormat =
102  SotExchange::RegisterFormatName("application/x-openoffice;windows_formatname=\"form.FilterControlExchange\"");
103  DBG_ASSERT(static_cast<SotClipboardFormatId>(-1) != s_nFormat, "OFilterExchangeHelper::getFormatId: bad exchange id!");
104  return s_nFormat;
105 }
106 
108 {
109  return new OFilterItemExchange;
110 }
111 
112 OUString FmFilterData::GetImage() const
113 {
114  return OUString();
115 }
116 
118 {
119 }
120 
121 OUString FmFormItem::GetImage() const
122 {
123  return RID_SVXBMP_FORM;
124 }
125 
126 FmFilterItem* FmFilterItems::Find( const ::sal_Int32 _nFilterComponentIndex ) const
127 {
128  for ( auto & pData : m_aChildren )
129  {
130  FmFilterItem& rCondition = dynamic_cast<FmFilterItem&>(*pData);
131  if ( _nFilterComponentIndex == rCondition.GetComponentIndex() )
132  return &rCondition;
133  }
134  return nullptr;
135 }
136 
137 OUString FmFilterItems::GetImage() const
138 {
139  return RID_SVXBMP_FILTER;
140 }
141 
143  const OUString& aFieldName,
144  const OUString& aText,
145  const sal_Int32 _nComponentIndex )
146  :FmFilterData(pParent, aText)
147  ,m_aFieldName(aFieldName)
148  ,m_nComponentIndex( _nComponentIndex )
149 {
150 }
151 
152 OUString FmFilterItem::GetImage() const
153 {
154  return RID_SVXBMP_FIELD;
155 }
156 
157 // Hints for communication between model and view
158 
159 namespace {
160 
161 class FmFilterHint : public SfxHint
162 {
163  FmFilterData* m_pData;
164 
165 public:
166  explicit FmFilterHint(FmFilterData* pData):m_pData(pData){}
167  FmFilterData* GetData() const { return m_pData; }
168 };
169 
170 class FmFilterInsertedHint : public FmFilterHint
171 {
172  size_t m_nPos; // Position relative to the parent of the data
173 
174 public:
175  FmFilterInsertedHint(FmFilterData* pData, size_t nRelPos)
176  :FmFilterHint(pData)
177  ,m_nPos(nRelPos){}
178 
179  size_t GetPos() const { return m_nPos; }
180 };
181 
182 class FmFilterRemovedHint : public FmFilterHint
183 {
184 public:
185  explicit FmFilterRemovedHint(FmFilterData* pData)
186  :FmFilterHint(pData){}
187 };
188 
189 
190 class FmFilterTextChangedHint : public FmFilterHint
191 {
192 public:
193  explicit FmFilterTextChangedHint(FmFilterData* pData)
194  :FmFilterHint(pData){}
195 };
196 
197 class FilterClearingHint : public SfxHint
198 {
199 public:
200  FilterClearingHint(){}
201 };
202 
203 class FmFilterCurrentChangedHint : public SfxHint
204 {
205 public:
206  FmFilterCurrentChangedHint(){}
207 };
208 
209 }
210 
211 // class FmFilterAdapter, listener at the FilterControls
212 class FmFilterAdapter : public ::cppu::WeakImplHelper< XFilterControllerListener >
213 {
215  Reference< XIndexAccess > m_xControllers;
216 
217 public:
218  FmFilterAdapter(FmFilterModel* pModel, const Reference< XIndexAccess >& xControllers);
219 
220 // XEventListener
221  virtual void SAL_CALL disposing(const EventObject& Source) override;
222 
223 // XFilterControllerListener
224  virtual void SAL_CALL predicateExpressionChanged( const FilterEvent& Event ) override;
225  virtual void SAL_CALL disjunctiveTermRemoved( const FilterEvent& Event ) override;
226  virtual void SAL_CALL disjunctiveTermAdded( const FilterEvent& Event ) override;
227 
228 // helpers
230  void dispose();
231 
232  void AddOrRemoveListener( const Reference< XIndexAccess >& _rxControllers, const bool _bAdd );
233 
234  static void setText(sal_Int32 nPos,
235  const FmFilterItem* pFilterItem,
236  const OUString& rText);
237 };
238 
239 
240 FmFilterAdapter::FmFilterAdapter(FmFilterModel* pModel, const Reference< XIndexAccess >& xControllers)
241  :m_pModel( pModel )
242  ,m_xControllers( xControllers )
243 {
245 }
246 
247 
249 {
251 }
252 
253 
254 void FmFilterAdapter::AddOrRemoveListener( const Reference< XIndexAccess >& _rxControllers, const bool _bAdd )
255 {
256  for (sal_Int32 i = 0, nLen = _rxControllers->getCount(); i < nLen; ++i)
257  {
258  Reference< XIndexAccess > xElement( _rxControllers->getByIndex(i), UNO_QUERY );
259 
260  // step down
261  AddOrRemoveListener( xElement, _bAdd );
262 
263  // handle this particular controller
264  Reference< XFilterController > xController( xElement, UNO_QUERY );
265  OSL_ENSURE( xController.is(), "FmFilterAdapter::InsertElements: no XFilterController, cannot sync data!" );
266  if ( xController.is() )
267  {
268  if ( _bAdd )
269  xController->addFilterControllerListener( this );
270  else
271  xController->removeFilterControllerListener( this );
272  }
273  }
274 }
275 
276 
277 void FmFilterAdapter::setText(sal_Int32 nRowPos,
278  const FmFilterItem* pFilterItem,
279  const OUString& rText)
280 {
281  FmFormItem* pFormItem = dynamic_cast<FmFormItem*>( pFilterItem->GetParent()->GetParent() );
282  assert(pFormItem);
283  try
284  {
285  Reference< XFilterController > xController( pFormItem->GetController(), UNO_QUERY_THROW );
286  xController->setPredicateExpression( pFilterItem->GetComponentIndex(), nRowPos, rText );
287  }
288  catch( const Exception& )
289  {
291  }
292 }
293 
294 
295 // XEventListener
296 
297 void SAL_CALL FmFilterAdapter::disposing(const EventObject& /*e*/)
298 {
299 }
300 
301 
302 namespace
303 {
304  OUString lcl_getLabelName_nothrow( const Reference< XControl >& _rxControl )
305  {
306  OUString sLabelName;
307  try
308  {
309  Reference< XPropertySet > xModel( _rxControl->getModel(), UNO_QUERY_THROW );
310  sLabelName = getLabelName( xModel );
311  }
312  catch( const Exception& )
313  {
315  }
316  return sLabelName;
317  }
318 
319  Reference< XPropertySet > lcl_getBoundField_nothrow( const Reference< XControl >& _rxControl )
320  {
322  try
323  {
324  Reference< XPropertySet > xModelProps( _rxControl->getModel(), UNO_QUERY_THROW );
325  xField.set( xModelProps->getPropertyValue( FM_PROP_BOUNDFIELD ), UNO_QUERY_THROW );
326  }
327  catch( const Exception& )
328  {
330  }
331  return xField;
332  }
333 }
334 
335 // XFilterControllerListener
336 void FmFilterAdapter::predicateExpressionChanged( const FilterEvent& Event )
337 {
338  SolarMutexGuard aGuard;
339 
340  if ( !m_pModel )
341  return;
342 
343  // the controller which sent the event
344  Reference< XFormController > xController( Event.Source, UNO_QUERY_THROW );
345  Reference< XFilterController > xFilterController( Event.Source, UNO_QUERY_THROW );
346  Reference< XForm > xForm( xController->getModel(), UNO_QUERY_THROW );
347 
348  FmFormItem* pFormItem = m_pModel->Find( m_pModel->m_aChildren, xForm );
349  OSL_ENSURE( pFormItem, "FmFilterAdapter::predicateExpressionChanged: don't know this form!" );
350  if ( !pFormItem )
351  return;
352 
353  const sal_Int32 nActiveTerm( xFilterController->getActiveTerm() );
354 
355  FmFilterData* pData = pFormItem->GetChildren()[nActiveTerm].get();
356  FmFilterItems& rFilter = dynamic_cast<FmFilterItems&>(*pData);
357  FmFilterItem* pFilterItem = rFilter.Find( Event.FilterComponent );
358  if ( pFilterItem )
359  {
360  if ( !Event.PredicateExpression.isEmpty())
361  {
362  pFilterItem->SetText( Event.PredicateExpression );
363  // notify the UI
364  FmFilterTextChangedHint aChangeHint(pFilterItem);
365  m_pModel->Broadcast( aChangeHint );
366  }
367  else
368  {
369  // no text anymore so remove the condition
370  m_pModel->Remove(pFilterItem);
371  }
372  }
373  else
374  {
375  // searching the component by field name
376  OUString aFieldName( lcl_getLabelName_nothrow( xFilterController->getFilterComponent( Event.FilterComponent ) ) );
377 
378  std::unique_ptr<FmFilterItem> pNewFilterItem(new FmFilterItem(&rFilter, aFieldName, Event.PredicateExpression, Event.FilterComponent));
379  m_pModel->Insert(rFilter.GetChildren().end(), std::move(pNewFilterItem));
380  }
381 
382  // ensure there's one empty term in the filter, just in case the active term was previously empty
383  m_pModel->EnsureEmptyFilterRows( *pFormItem );
384 }
385 
386 
387 void SAL_CALL FmFilterAdapter::disjunctiveTermRemoved( const FilterEvent& Event )
388 {
389  SolarMutexGuard aGuard;
390 
391  Reference< XFormController > xController( Event.Source, UNO_QUERY_THROW );
392  Reference< XFilterController > xFilterController( Event.Source, UNO_QUERY_THROW );
393  Reference< XForm > xForm( xController->getModel(), UNO_QUERY_THROW );
394 
395  FmFormItem* pFormItem = m_pModel->Find( m_pModel->m_aChildren, xForm );
396  OSL_ENSURE( pFormItem, "FmFilterAdapter::disjunctiveTermRemoved: don't know this form!" );
397  if ( !pFormItem )
398  return;
399 
400  auto& rTermItems = pFormItem->GetChildren();
401  const bool bValidIndex = ( Event.DisjunctiveTerm >= 0 ) && ( o3tl::make_unsigned(Event.DisjunctiveTerm) < rTermItems.size() );
402  OSL_ENSURE( bValidIndex, "FmFilterAdapter::disjunctiveTermRemoved: invalid term index!" );
403  if ( !bValidIndex )
404  return;
405 
406  // if the first term was removed, then the to-be first term needs its text updated
407  if ( Event.DisjunctiveTerm == 0 )
408  {
409  rTermItems[1]->SetText( SvxResId(RID_STR_FILTER_FILTER_FOR));
410  FmFilterTextChangedHint aChangeHint( rTermItems[1].get() );
411  m_pModel->Broadcast( aChangeHint );
412  }
413 
414  // finally remove the entry from the model
415  m_pModel->Remove( rTermItems.begin() + Event.DisjunctiveTerm );
416 
417  // ensure there's one empty term in the filter, just in case the currently removed one was the last empty one
418  m_pModel->EnsureEmptyFilterRows( *pFormItem );
419 }
420 
421 
422 void SAL_CALL FmFilterAdapter::disjunctiveTermAdded( const FilterEvent& Event )
423 {
424  SolarMutexGuard aGuard;
425 
426  Reference< XFormController > xController( Event.Source, UNO_QUERY_THROW );
427  Reference< XFilterController > xFilterController( Event.Source, UNO_QUERY_THROW );
428  Reference< XForm > xForm( xController->getModel(), UNO_QUERY_THROW );
429 
430  FmFormItem* pFormItem = m_pModel->Find( m_pModel->m_aChildren, xForm );
431  OSL_ENSURE( pFormItem, "FmFilterAdapter::disjunctiveTermAdded: don't know this form!" );
432  if ( !pFormItem )
433  return;
434 
435  const sal_Int32 nInsertPos = Event.DisjunctiveTerm;
436  bool bValidIndex = ( nInsertPos >= 0 ) && ( o3tl::make_unsigned(nInsertPos) <= pFormItem->GetChildren().size() );
437  if ( !bValidIndex )
438  {
439  OSL_FAIL( "FmFilterAdapter::disjunctiveTermAdded: invalid index!" );
440  return;
441  }
442 
443  auto insertPos = pFormItem->GetChildren().begin() + nInsertPos;
444 
445  // "Filter for" for first position, "Or" for the other positions
446  std::unique_ptr<FmFilterItems> pFilterItems(new FmFilterItems(pFormItem, (nInsertPos?SvxResId(RID_STR_FILTER_FILTER_OR):SvxResId(RID_STR_FILTER_FILTER_FOR))));
447  m_pModel->Insert( insertPos, std::move(pFilterItems) );
448 }
449 
450 
452  :FmParentData(nullptr, OUString())
453  ,OSQLParserClient(comphelper::getProcessComponentContext())
454  ,m_pCurrentItems(nullptr)
455 {
456 }
457 
458 
460 {
461  Clear();
462 }
463 
464 
466 {
467  // notify
468  FilterClearingHint aClearedHint;
469  Broadcast( aClearedHint );
470 
471  // lose endings
472  if (m_pAdapter.is())
473  {
474  m_pAdapter->dispose();
475  m_pAdapter.clear();
476  }
477 
478  m_pCurrentItems = nullptr;
479  m_xController = nullptr;
480  m_xControllers = nullptr;
481 
482  m_aChildren.clear();
483 }
484 
485 
486 void FmFilterModel::Update(const Reference< XIndexAccess > & xControllers, const Reference< XFormController > & xCurrent)
487 {
488  if ( xCurrent == m_xController )
489  return;
490 
491  if (!xControllers.is())
492  {
493  Clear();
494  return;
495  }
496 
497  // there is only a new current controller
498  if ( m_xControllers != xControllers )
499  {
500  Clear();
501 
502  m_xControllers = xControllers;
503  Update(m_xControllers, this);
504 
505  DBG_ASSERT(xCurrent.is(), "FmFilterModel::Update(...) no current controller");
506 
507  // Listening for TextChanges
508  m_pAdapter = new FmFilterAdapter(this, xControllers);
509 
510  SetCurrentController(xCurrent);
511  EnsureEmptyFilterRows( *this );
512  }
513  else
514  SetCurrentController(xCurrent);
515 }
516 
517 
518 void FmFilterModel::Update(const Reference< XIndexAccess > & xControllers, FmParentData* pParent)
519 {
520  try
521  {
522  sal_Int32 nCount = xControllers->getCount();
523  for ( sal_Int32 i = 0; i < nCount; ++i )
524  {
525  Reference< XFormController > xController( xControllers->getByIndex(i), UNO_QUERY_THROW );
526 
527  Reference< XPropertySet > xFormProperties( xController->getModel(), UNO_QUERY_THROW );
528  OUString aName;
529  OSL_VERIFY( xFormProperties->getPropertyValue( FM_PROP_NAME ) >>= aName );
530 
531  // Insert a new item for the form
532  FmFormItem* pFormItem = new FmFormItem( pParent, xController, aName );
533  Insert( pParent->GetChildren().end(), std::unique_ptr<FmFilterData>(pFormItem) );
534 
535  Reference< XFilterController > xFilterController( pFormItem->GetFilterController(), UNO_SET_THROW );
536 
537  // insert the existing filters for the form
538  OUString aTitle(SvxResId(RID_STR_FILTER_FILTER_FOR));
539 
540  const Sequence< Sequence< OUString > > aExpressions = xFilterController->getPredicateExpressions();
541  for ( auto const & conjunctionTerm : aExpressions )
542  {
543  // we always display one row, even if there's no term to be displayed
544  FmFilterItems* pFilterItems = new FmFilterItems( pFormItem, aTitle );
545  Insert( pFormItem->GetChildren().end(), std::unique_ptr<FmFilterData>(pFilterItems) );
546 
547  const Sequence< OUString >& rDisjunction( conjunctionTerm );
548  sal_Int32 nComponentIndex = -1;
549  for ( const OUString& rDisjunctiveTerm : rDisjunction )
550  {
551  ++nComponentIndex;
552 
553  if ( rDisjunctiveTerm.isEmpty() )
554  // no condition for this particular component in this particular conjunction term
555  continue;
556 
557  // determine the display name of the control
558  const Reference< XControl > xFilterControl( xFilterController->getFilterComponent( nComponentIndex ) );
559  const OUString sDisplayName( lcl_getLabelName_nothrow( xFilterControl ) );
560 
561  // insert a new entry
562  std::unique_ptr<FmFilterItem> pANDCondition(new FmFilterItem( pFilterItems, sDisplayName, rDisjunctiveTerm, nComponentIndex ));
563  Insert( pFilterItems->GetChildren().end(), std::move(pANDCondition) );
564  }
565 
566  // title for the next conditions
567  aTitle = SvxResId( RID_STR_FILTER_FILTER_OR );
568  }
569 
570  // now add dependent controllers
571  Update( xController, pFormItem );
572  }
573  }
574  catch( const Exception& )
575  {
577  }
578 }
579 
580 
581 FmFormItem* FmFilterModel::Find(const ::std::vector<std::unique_ptr<FmFilterData>>& rItems, const Reference< XFormController > & xController) const
582 {
583  for (const auto& rItem : rItems)
584  {
585  FmFormItem* pForm = dynamic_cast<FmFormItem*>( rItem.get() );
586  if (pForm)
587  {
588  if ( xController == pForm->GetController() )
589  return pForm;
590  else
591  {
592  pForm = Find(pForm->GetChildren(), xController);
593  if (pForm)
594  return pForm;
595  }
596  }
597  }
598  return nullptr;
599 }
600 
601 
602 FmFormItem* FmFilterModel::Find(const ::std::vector<std::unique_ptr<FmFilterData>>& rItems, const Reference< XForm >& xForm) const
603 {
604  for (const auto& rItem : rItems)
605  {
606  FmFormItem* pForm = dynamic_cast<FmFormItem*>( rItem.get() );
607  if (pForm)
608  {
609  if (xForm == pForm->GetController()->getModel())
610  return pForm;
611  else
612  {
613  pForm = Find(pForm->GetChildren(), xForm);
614  if (pForm)
615  return pForm;
616  }
617  }
618  }
619  return nullptr;
620 }
621 
622 void FmFilterModel::SetCurrentController(const Reference< XFormController > & xCurrent)
623 {
624  if ( xCurrent == m_xController )
625  return;
626 
627  m_xController = xCurrent;
628 
629  FmFormItem* pItem = Find( m_aChildren, xCurrent );
630  if ( !pItem )
631  return;
632 
633  try
634  {
635  Reference< XFilterController > xFilterController( m_xController, UNO_QUERY_THROW );
636  const sal_Int32 nActiveTerm( xFilterController->getActiveTerm() );
637  if (nActiveTerm != -1 && pItem->GetChildren().size() > o3tl::make_unsigned(nActiveTerm))
638  {
639  SetCurrentItems( static_cast< FmFilterItems* >( pItem->GetChildren()[ nActiveTerm ].get() ) );
640  }
641  }
642  catch( const Exception& )
643  {
645  }
646 }
647 
649 {
650  // insert the condition behind the last filter items
651  auto iter = std::find_if(_rFormItem.GetChildren().rbegin(), _rFormItem.GetChildren().rend(),
652  [](const std::unique_ptr<FmFilterData>& rChild) { return dynamic_cast<const FmFilterItems*>(rChild.get()) != nullptr; });
653 
654  sal_Int32 nInsertPos = iter.base() - _rFormItem.GetChildren().begin();
655  // delegate this to the FilterController, it will notify us, which will let us update our model
656  try
657  {
658  Reference< XFilterController > xFilterController( _rFormItem.GetFilterController(), UNO_SET_THROW );
659  if ( nInsertPos >= xFilterController->getDisjunctiveTerms() )
660  xFilterController->appendEmptyDisjunctiveTerm();
661  }
662  catch( const Exception& )
663  {
665  }
666 }
667 
668 void FmFilterModel::Insert(const ::std::vector<std::unique_ptr<FmFilterData>>::iterator& rPos, std::unique_ptr<FmFilterData> pData)
669 {
670  auto pTemp = pData.get();
671  size_t nPos;
672  ::std::vector<std::unique_ptr<FmFilterData>>& rItems = pData->GetParent()->GetChildren();
673  if (rPos == rItems.end())
674  {
675  nPos = rItems.size();
676  rItems.push_back(std::move(pData));
677  }
678  else
679  {
680  nPos = rPos - rItems.begin();
681  rItems.insert(rPos, std::move(pData));
682  }
683 
684  // notify the UI
685  FmFilterInsertedHint aInsertedHint(pTemp, nPos);
686  Broadcast( aInsertedHint );
687 }
688 
690 {
691  FmParentData* pParent = pData->GetParent();
692  ::std::vector<std::unique_ptr<FmFilterData>>& rItems = pParent->GetChildren();
693 
694  // erase the item from the model
695  auto i = ::std::find_if(rItems.begin(), rItems.end(),
696  [&](const std::unique_ptr<FmFilterData>& p) { return p.get() == pData; } );
697  DBG_ASSERT(i != rItems.end(), "FmFilterModel::Remove(): unknown Item");
698  // position within the parent
699  sal_Int32 nPos = i - rItems.begin();
700  if (auto pFilterItems = dynamic_cast<FmFilterItems*>( pData))
701  {
702  FmFormItem* pFormItem = static_cast<FmFormItem*>(pParent);
703 
704  try
705  {
706  Reference< XFilterController > xFilterController( pFormItem->GetFilterController(), UNO_SET_THROW );
707 
708  bool bEmptyLastTerm = ( ( nPos == 0 ) && xFilterController->getDisjunctiveTerms() == 1 );
709  if ( bEmptyLastTerm )
710  {
711  // remove all children (by setting an empty predicate expression)
712  ::std::vector< std::unique_ptr<FmFilterData> >& rChildren = pFilterItems->GetChildren();
713  while ( !rChildren.empty() )
714  {
715  auto removePos = rChildren.end() - 1;
716  if (FmFilterItem* pFilterItem = dynamic_cast<FmFilterItem*>( removePos->get() ))
717  {
718  FmFilterAdapter::setText( nPos, pFilterItem, OUString() );
719  }
720  Remove( removePos );
721  }
722  }
723  else
724  {
725  xFilterController->removeDisjunctiveTerm( nPos );
726  }
727  }
728  catch( const Exception& )
729  {
731  }
732  }
733  else // FormItems can not be deleted
734  {
735  FmFilterItem& rFilterItem = dynamic_cast<FmFilterItem&>(*pData);
736 
737  // if it's the last condition remove the parent
738  if (rItems.size() == 1)
739  Remove(rFilterItem.GetParent());
740  else
741  {
742  // find the position of the father within his father
743  ::std::vector<std::unique_ptr<FmFilterData>>& rParentParentItems = pData->GetParent()->GetParent()->GetChildren();
744  auto j = ::std::find_if(rParentParentItems.begin(), rParentParentItems.end(),
745  [&](const std::unique_ptr<FmFilterData>& p) { return p.get() == rFilterItem.GetParent(); });
746  DBG_ASSERT(j != rParentParentItems.end(), "FmFilterModel::Remove(): unknown Item");
747  sal_Int32 nParentPos = j - rParentParentItems.begin();
748 
749  // EmptyText removes the filter
750  FmFilterAdapter::setText(nParentPos, &rFilterItem, OUString());
751  Remove( i );
752  }
753  }
754 }
755 
756 void FmFilterModel::Remove( const ::std::vector<std::unique_ptr<FmFilterData>>::iterator& rPos )
757 {
758  // remove from parent's child list
759  std::unique_ptr<FmFilterData> pData = std::move(*rPos);
760  pData->GetParent()->GetChildren().erase( rPos );
761 
762  // notify the view, this will remove the actual SvTreeListEntry
763  FmFilterRemovedHint aRemoveHint( pData.get() );
764  Broadcast( aRemoveHint );
765 }
766 
767 
768 bool FmFilterModel::ValidateText(FmFilterItem const * pItem, OUString& rText, OUString& rErrorMsg) const
769 {
770  FmFormItem* pFormItem = dynamic_cast<FmFormItem*>( pItem->GetParent()->GetParent() );
771  assert(pFormItem);
772  try
773  {
774  Reference< XFormController > xFormController( pFormItem->GetController() );
775  // obtain the connection of the form belonging to the controller
776  Reference< XRowSet > xRowSet( xFormController->getModel(), UNO_QUERY_THROW );
777  Reference< XConnection > xConnection( getConnection( xRowSet ) );
778 
779  // obtain a number formatter for this connection
780  // TODO: shouldn't this be cached?
781  Reference< XNumberFormatsSupplier > xFormatSupplier = getNumberFormats( xConnection, true );
782  Reference< XNumberFormatter > xFormatter( NumberFormatter::create( comphelper::getProcessComponentContext() ), UNO_QUERY_THROW );
783  xFormatter->attachNumberFormatsSupplier( xFormatSupplier );
784 
785  // get the field (database column) which the item is responsible for
786  Reference< XFilterController > xFilterController( xFormController, UNO_QUERY_THROW );
787  Reference< XPropertySet > xField( lcl_getBoundField_nothrow( xFilterController->getFilterComponent( pItem->GetComponentIndex() ) ), UNO_SET_THROW );
788 
789  // parse the given text as filter predicate
790  OUString aErr, aTxt( rText );
791  std::unique_ptr< OSQLParseNode > pParseNode = predicateTree( aErr, aTxt, xFormatter, xField );
792  rErrorMsg = aErr;
793  rText = aTxt;
794  if ( pParseNode != nullptr )
795  {
796  OUString aPreparedText;
798  pParseNode->parseNodeToPredicateStr(
799  aPreparedText, xConnection, xFormatter, xField, OUString(), aAppLocale, OUString("."), getParseContext() );
800  rText = aPreparedText;
801  return true;
802  }
803  }
804  catch( const Exception& )
805  {
807  }
808 
809  return false;
810 }
811 
812 
813 void FmFilterModel::Append(FmFilterItems* pItems, std::unique_ptr<FmFilterItem> pFilterItem)
814 {
815  Insert(pItems->GetChildren().end(), std::move(pFilterItem));
816 }
817 
818 
819 void FmFilterModel::SetTextForItem(FmFilterItem* pItem, const OUString& rText)
820 {
821  ::std::vector<std::unique_ptr<FmFilterData>>& rItems = pItem->GetParent()->GetParent()->GetChildren();
822  auto i = ::std::find_if(rItems.begin(), rItems.end(),
823  [&](const std::unique_ptr<FmFilterData>& p) { return p.get() == pItem->GetParent(); });
824  sal_Int32 nParentPos = i - rItems.begin();
825 
826  FmFilterAdapter::setText(nParentPos, pItem, rText);
827 
828  if (rText.isEmpty())
829  Remove(pItem);
830  else
831  {
832  // Change the text
833  pItem->SetText(rText);
834  FmFilterTextChangedHint aChangeHint(pItem);
835  Broadcast( aChangeHint );
836  }
837 }
838 
839 
841 {
842  if (m_pCurrentItems == pCurrent)
843  return;
844 
845  // search for the condition
846  if (pCurrent)
847  {
848  FmFormItem* pFormItem = static_cast<FmFormItem*>(pCurrent->GetParent());
849  ::std::vector<std::unique_ptr<FmFilterData>>& rItems = pFormItem->GetChildren();
850  auto i = ::std::find_if(rItems.begin(), rItems.end(),
851  [&](const std::unique_ptr<FmFilterData>& p) { return p.get() == pCurrent; });
852 
853  if (i != rItems.end())
854  {
855  // determine the filter position
856  sal_Int32 nPos = i - rItems.begin();
857  try
858  {
859  Reference< XFilterController > xFilterController( pFormItem->GetFilterController(), UNO_SET_THROW );
860  xFilterController->setActiveTerm( nPos );
861  }
862  catch( const Exception& )
863  {
865  }
866 
867  if ( m_xController != pFormItem->GetController() )
868  // calls SetCurrentItems again
869  SetCurrentController( pFormItem->GetController() );
870  else
871  m_pCurrentItems = pCurrent;
872  }
873  else
874  m_pCurrentItems = nullptr;
875  }
876  else
877  m_pCurrentItems = nullptr;
878 
879 
880  // notify the UI
881  FmFilterCurrentChangedHint aHint;
882  Broadcast( aHint );
883 }
884 
885 
887 {
888  // checks whether for each form there's one free level for input
889  ::std::vector< std::unique_ptr<FmFilterData> >& rChildren = _rItem.GetChildren();
890  bool bAppendLevel = dynamic_cast<const FmFormItem*>(&_rItem) != nullptr;
891 
892  for ( const auto& rpChild : rChildren )
893  {
894  FmFilterItems* pItems = dynamic_cast<FmFilterItems*>( rpChild.get() );
895  if ( pItems && pItems->GetChildren().empty() )
896  {
897  bAppendLevel = false;
898  break;
899  }
900 
901  FmFormItem* pFormItem = dynamic_cast<FmFormItem*>( rpChild.get() );
902  if (pFormItem)
903  {
904  EnsureEmptyFilterRows( *pFormItem );
905  continue;
906  }
907  }
908 
909  if ( bAppendLevel )
910  {
911  FmFormItem* pFormItem = dynamic_cast<FmFormItem*>( &_rItem );
912  OSL_ENSURE( pFormItem, "FmFilterModel::EnsureEmptyFilterRows: no FmFormItem, but a FmFilterItems child?" );
913  if ( pFormItem )
914  AppendFilterItems( *pFormItem );
915  }
916 }
917 
918 const int nxD = 4;
919 const int nxDBmp = 12;
920 
922 {
923  vcl::RenderContext& rRenderContext = aPayload.first;
924  const OUString& rId = aPayload.second;
925 
926  Size aSize;
927 
928  FmFilterData* pData = reinterpret_cast<FmFilterData*>(rId.toUInt64());
929  OUString sText = pData->GetText();
930 
931  if (FmFilterItem* pItem = dynamic_cast<FmFilterItem*>(pData))
932  {
933  rRenderContext.Push(PushFlags::FONT);
934  vcl::Font aFont(rRenderContext.GetFont());
935  aFont.SetWeight(WEIGHT_BOLD);
936  rRenderContext.SetFont(aFont);
937 
938  OUString sName = pItem->GetFieldName() + ": ";
939  aSize = Size(rRenderContext.GetTextWidth(sName), rRenderContext.GetTextHeight());
940 
941  rRenderContext.Pop();
942 
943  aSize.AdjustWidth(rRenderContext.GetTextWidth(sText) + nxD);
944  }
945  else
946  {
947  aSize = Size(rRenderContext.GetTextWidth(sText), rRenderContext.GetTextHeight());
948  if (dynamic_cast<FmFilterItems*>(pData))
949  aSize.AdjustWidth(nxDBmp);
950  }
951 
952  return aSize;
953 }
954 
956 {
957  vcl::RenderContext& rRenderContext = std::get<0>(aPayload);
958  const ::tools::Rectangle& rRect = std::get<1>(aPayload);
959  ::tools::Rectangle aRect(rRect.TopLeft(), Size(rRenderContext.GetOutputSize().Width() - rRect.Left(), rRect.GetHeight()));
960  bool bSelected = std::get<2>(aPayload);
961  const OUString& rId = std::get<3>(aPayload);
962 
963  rRenderContext.Push(PushFlags::TEXTCOLOR);
964  const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();
965  if (bSelected)
966  rRenderContext.SetTextColor(rStyleSettings.GetHighlightTextColor());
967  else
968  rRenderContext.SetTextColor(rStyleSettings.GetDialogTextColor());
969 
970  FmFilterData* pData = reinterpret_cast<FmFilterData*>(rId.toUInt64());
971  OUString sText = pData->GetText();
972  Point aPos(aRect.TopLeft());
973 
974  if (FmFilterItem* pFilter = dynamic_cast<FmFilterItem*>(pData))
975  {
976  vcl::Font aFont(rRenderContext.GetFont());
977  aFont.SetWeight(WEIGHT_BOLD);
978 
979  rRenderContext.Push(PushFlags::FONT);
980  rRenderContext.SetFont(aFont);
981 
982  OUString sName = pFilter->GetFieldName() + ": ";
983  rRenderContext.DrawText(aPos, sName);
984 
985  // position for the second text
986  aPos.AdjustX(rRenderContext.GetTextWidth(sName) + nxD);
987  rRenderContext.Pop();
988 
989  rRenderContext.DrawText(aPos, sText);
990  }
991  else if (FmFilterItems* pRow = dynamic_cast<FmFilterItems*>(pData))
992  {
993  FmFormItem* pForm = static_cast<FmFormItem*>(pRow->GetParent());
994 
995  // current filter is significant painted
996  const bool bIsCurrentFilter = pForm->GetChildren()[ pForm->GetFilterController()->getActiveTerm() ].get() == pRow;
997  if (bIsCurrentFilter)
998  {
999  rRenderContext.Push(PushFlags::LINECOLOR);
1000  rRenderContext.SetLineColor(rRenderContext.GetTextColor());
1001 
1002  Point aFirst(aPos.X(), aRect.Bottom() - 6);
1003  Point aSecond(aFirst .X() + 2, aFirst.Y() + 3);
1004 
1005  rRenderContext.DrawLine(aFirst, aSecond);
1006 
1007  aFirst = aSecond;
1008  aFirst.AdjustX(1);
1009  aSecond.AdjustX(6);
1010  aSecond.AdjustY(-5);
1011 
1012  rRenderContext.DrawLine(aFirst, aSecond);
1013  rRenderContext.Pop();
1014  }
1015 
1016  rRenderContext.DrawText(Point(aPos.X() + nxDBmp, aPos.Y()), sText);
1017  }
1018  else
1019  rRenderContext.DrawText(aPos, sText);
1020 
1021  rRenderContext.Pop();
1022 }
1023 
1025  : DropTargetHelper(rTreeView.get_widget().get_drop_target())
1026  , m_rTreeView(rTreeView)
1027 {
1028 }
1029 
1031 {
1032  sal_Int8 nAccept = m_rTreeView.AcceptDrop(rEvt);
1033 
1034  if (nAccept != DND_ACTION_NONE)
1035  {
1036  // to enable the autoscroll when we're close to the edges
1037  weld::TreeView& rWidget = m_rTreeView.get_widget();
1038  rWidget.get_dest_row_at_pos(rEvt.maPosPixel, nullptr, true);
1039  }
1040 
1041  return nAccept;
1042 }
1043 
1045 {
1046  return m_rTreeView.ExecuteDrop(rEvt);
1047 }
1048 
1049 FmFilterNavigator::FmFilterNavigator(vcl::Window* pTopLevel, std::unique_ptr<weld::TreeView> xTreeView)
1050  : m_xTopLevel(pTopLevel)
1051  , m_xTreeView(std::move(xTreeView))
1052  , m_aDropTargetHelper(*this)
1053  , m_nAsyncRemoveEvent(nullptr)
1054 {
1055  m_xTreeView->set_help_id(HID_FILTER_NAVIGATOR);
1056 
1057  m_xTreeView->set_selection_mode(SelectionMode::Multiple);
1058 
1059  m_pModel.reset( new FmFilterModel() );
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, VCLUnoHelper::GetInterface(m_xTopLevel));
1158 
1159  return false;
1160  }
1161  }
1162  return true;
1163 }
1164 
1165 IMPL_LINK( FmFilterNavigator, OnRemove, void*, p, void )
1166 {
1167  m_nAsyncRemoveEvent = nullptr;
1168  // now remove the entry
1169  m_pModel->Remove(static_cast<FmFilterData*>(p));
1170 }
1171 
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(const weld::TreeView& rTreeView, const weld::TreeIter& rTarget)
1216  {
1217  FmFilterData* pData = reinterpret_cast<FmFilterData*>(rTreeView.get_id(rTarget).toUInt64());
1218  FmFilterItems* pTargetItems = dynamic_cast<FmFilterItems*>(pData);
1219  if (!pTargetItems)
1220  pTargetItems = dynamic_cast<FmFilterItems*>(pData->GetParent());
1221  return pTargetItems;
1222  }
1223 }
1224 
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  auto pFilterItem = dynamic_cast<FmFilterItem*>(pFilterEntry);
1510  bool bEdit = pFilterItem &&
1511  m_xTreeView->is_selected(*xClicked) && m_xTreeView->count_selected_rows() == 1;
1512 
1513  if (bNoDelete && !bEdit)
1514  {
1515  // nothing is in the menu, don't bother
1516  return true;
1517  }
1518 
1519  if (!bEdit)
1520  {
1521  xContextMenu->remove("edit");
1522  xContextMenu->remove("isnull");
1523  xContextMenu->remove("isnotnull");
1524  }
1525 
1526  OString sIdent = xContextMenu->popup_at_rect(m_xTreeView.get(), tools::Rectangle(aWhere, ::Size(1, 1)));
1527  if (sIdent == "edit")
1528  {
1529  m_xTreeView->start_editing(*xClicked);
1530  }
1531  else if (sIdent == "isnull")
1532  {
1533  OUString aErrorMsg;
1534  OUString aText = "IS NULL";
1535  assert(pFilterItem && "if item is null this menu entry was removed and unavailable");
1536  m_pModel->ValidateText(pFilterItem, aText, aErrorMsg);
1537  m_pModel->SetTextForItem(pFilterItem, aText);
1538  }
1539  else if (sIdent == "isnotnull")
1540  {
1541  OUString aErrorMsg;
1542  OUString aText = "IS NOT NULL";
1543 
1544  assert(pFilterItem && "if item is null this menu entry was removed and unavailable");
1545  m_pModel->ValidateText(pFilterItem, aText, aErrorMsg);
1546  m_pModel->SetTextForItem(pFilterItem, aText);
1547  }
1548  else if (sIdent == "delete")
1549  {
1550  DeleteSelection();
1551  }
1552  bHandled = true;
1553  }
1554  break;
1555  default: break;
1556  }
1557 
1558  return bHandled;
1559 }
1560 
1562 {
1563  bool bEntry = m_xTreeView->iter_next(rEntry);
1564  // we need the next filter entry
1565  if (bEntry)
1566  {
1567  while (!m_xTreeView->iter_has_child(rEntry))
1568  {
1569  std::unique_ptr<weld::TreeIter> xNext = m_xTreeView->make_iterator(&rEntry);
1570  if (!m_xTreeView->iter_next(*xNext))
1571  break;
1572  m_xTreeView->copy_iterator(*xNext, rEntry);
1573  }
1574  }
1575  return bEntry;
1576 }
1577 
1579 {
1580  bool bEntry = m_xTreeView->iter_previous(rEntry);
1581  // check if the previous entry is a filter, if so get the next prev
1582  if (bEntry && m_xTreeView->iter_has_child(rEntry))
1583  {
1584  bEntry = m_xTreeView->iter_previous(rEntry);
1585  // if the entry is still no leaf return
1586  if (bEntry && m_xTreeView->iter_has_child(rEntry))
1587  bEntry = false;
1588  }
1589  return bEntry;
1590 }
1591 IMPL_LINK(FmFilterNavigator, KeyInputHdl, const ::KeyEvent&, rKEvt, bool)
1592 {
1593  const vcl::KeyCode& rKeyCode = rKEvt.GetKeyCode();
1594 
1595  switch ( rKeyCode.GetCode() )
1596  {
1597  case KEY_UP:
1598  case KEY_DOWN:
1599  {
1600  if ( !rKeyCode.IsMod1() || !rKeyCode.IsMod2() || rKeyCode.IsShift() )
1601  break;
1602 
1603  ::std::vector<FmFilterItem*> aItemList;
1604  if ( !getSelectedFilterItems( aItemList ) )
1605  break;
1606 
1607 
1608  std::vector<std::unique_ptr<weld::TreeIter>> aSelected;
1609  m_xTreeView->selected_foreach([this, &aSelected](weld::TreeIter& rEntry){
1610  aSelected.emplace_back(m_xTreeView->make_iterator(&rEntry));
1611  return false;
1612  });
1613 
1614  std::unique_ptr<weld::TreeIter> xTarget;
1615  ::std::function<bool(FmFilterNavigator*, weld::TreeIter&)> getter;
1616 
1617  if (rKeyCode.GetCode() == KEY_UP)
1618  {
1619  xTarget = m_xTreeView->make_iterator(aSelected.front().get());
1620  getter = ::std::mem_fn(&FmFilterNavigator::getPrevEntry);
1621  }
1622  else
1623  {
1624  xTarget = m_xTreeView->make_iterator(aSelected.back().get());
1625  getter = ::std::mem_fn(&FmFilterNavigator::getNextEntry);
1626  }
1627 
1628  bool bTarget = getter(this, *xTarget);
1629  if (!bTarget)
1630  break;
1631 
1632  FmFilterItems* pTargetItems = getTargetItems(*m_xTreeView, *xTarget);
1633  if (!pTargetItems)
1634  break;
1635 
1636  ::std::vector<FmFilterItem*>::const_iterator aEnd = aItemList.end();
1637  bool bNextTargetItem = true;
1638  while ( bNextTargetItem )
1639  {
1640  ::std::vector<FmFilterItem*>::const_iterator i = aItemList.begin();
1641  for (; i != aEnd; ++i)
1642  {
1643  if ( (*i)->GetParent() == pTargetItems )
1644  {
1645  bTarget = getter(this, *xTarget);
1646  if (!bTarget)
1647  return true;
1648  pTargetItems = getTargetItems(*m_xTreeView, *xTarget);
1649  break;
1650  }
1651  else
1652  {
1653  FmFilterItem* pFilterItem = pTargetItems->Find( (*i)->GetComponentIndex() );
1654  // we found the text component so jump above
1655  if ( pFilterItem )
1656  {
1657  bTarget = getter(this, *xTarget);
1658  if (!bTarget)
1659  return true;
1660 
1661  pTargetItems = getTargetItems(*m_xTreeView, *xTarget);
1662  break;
1663  }
1664  }
1665  }
1666  bNextTargetItem = i != aEnd && pTargetItems;
1667  }
1668 
1669  if ( pTargetItems )
1670  {
1671  insertFilterItem( aItemList, pTargetItems, false );
1672  return true;
1673  }
1674  }
1675  break;
1676 
1677  case KEY_DELETE:
1678  {
1679  if ( rKeyCode.GetModifier() )
1680  break;
1681 
1682  std::unique_ptr<weld::TreeIter> xEntry = m_xTreeView->make_iterator();
1683  if (m_xTreeView->get_iter_first(*xEntry) && !m_xTreeView->is_selected(*xEntry))
1684  DeleteSelection();
1685 
1686  return true;
1687  }
1688  }
1689 
1690  return false;
1691 }
1692 
1694 {
1695  // to avoid the deletion of an entry twice (e.g. deletion of a parent and afterward
1696  // the deletion of its child, I have to shrink the selection list
1697  std::vector<FmFilterData*> aEntryList;
1698 
1699  m_xTreeView->selected_foreach([this, &aEntryList](weld::TreeIter& rEntry) {
1700  FmFilterData* pFilterEntry = reinterpret_cast<FmFilterData*>(m_xTreeView->get_id(rEntry).toInt64());
1701 
1702  if (dynamic_cast<FmFilterItem*>(pFilterEntry))
1703  {
1704  std::unique_ptr<weld::TreeIter> xParent(m_xTreeView->make_iterator(&rEntry));
1705  if (m_xTreeView->iter_parent(*xParent) && m_xTreeView->is_selected(*xParent))
1706  return false;
1707  }
1708 
1709  FmFormItem* pForm = dynamic_cast<FmFormItem*>(pFilterEntry);
1710  if (!pForm)
1711  aEntryList.emplace_back(pFilterEntry);
1712 
1713  return false;
1714  });
1715 
1716  // Remove the selection
1717  m_xTreeView->unselect_all();
1718 
1719  for (auto i = aEntryList.rbegin(); i != aEntryList.rend(); ++i)
1720  m_pModel->Remove(*i);
1721 }
1722 
1724  vcl::Window* _pParent)
1725  : SfxDockingWindow(_pBindings, _pMgr, _pParent, "FilterNavigator", "svx/ui/filternavigator.ui")
1726  , SfxControllerItem( SID_FM_FILTER_NAVIGATOR_CONTROL, *_pBindings )
1727  , m_xNavigatorTree(new FmFilterNavigator(this, m_xBuilder->weld_tree_view("treeview")))
1728 {
1729  SetHelpId( HID_FILTER_NAVIGATOR_WIN );
1730 
1731  SetText( SvxResId(RID_STR_FILTER_NAVIGATOR) );
1733 }
1734 
1736 {
1737  disposeOnce();
1738 }
1739 
1741 {
1742  m_xNavigatorTree.reset();
1745 }
1746 
1748 {
1749  if (!m_xNavigatorTree)
1750  return;
1751 
1752  if (!pFormShell)
1753  m_xNavigatorTree->UpdateContent( nullptr, nullptr );
1754  else
1755  {
1756  Reference<XFormController> const xController(pFormShell->GetImpl()->getActiveInternalController_Lock());
1757  Reference< XIndexAccess > xContainer;
1758  if (xController.is())
1759  {
1760  Reference< XChild > xChild = xController;
1761  for (Reference< XInterface > xParent(xChild->getParent());
1762  xParent.is();
1763  xParent = xChild.is() ? xChild->getParent() : Reference< XInterface > ())
1764  {
1765  xContainer.set(xParent, UNO_QUERY);
1766  xChild.set(xParent, UNO_QUERY);
1767  }
1768  }
1769  m_xNavigatorTree->UpdateContent(xContainer, xController);
1770  }
1771 }
1772 
1774 {
1775  if( !pState || SID_FM_FILTER_NAVIGATOR_CONTROL != nSID )
1776  return;
1777 
1778  if( eState >= SfxItemState::DEFAULT )
1779  {
1780  FmFormShell* pShell = dynamic_cast<FmFormShell*>( static_cast<const SfxObjectItem*>(pState)->GetShell() );
1781  UpdateContent( pShell );
1782  }
1783  else
1784  UpdateContent( nullptr );
1785 }
1786 
1788 {
1789  if (m_xNavigatorTree)
1790  m_xNavigatorTree->EndEditing();
1791 
1792  UpdateContent( nullptr );
1793  return SfxDockingWindow::Close();
1794 }
1795 
1797 {
1798  SfxDockingWindow::FillInfo( rInfo );
1799  rInfo.bVisible = false;
1800 }
1801 
1803 {
1804  if ( ( eAlign == SfxChildAlignment::TOP ) || ( eAlign == SfxChildAlignment::BOTTOM ) )
1805  return Size();
1806 
1807  return SfxDockingWindow::CalcDockingSize( eAlign );
1808 }
1809 
1811 {
1812  switch (eAlign)
1813  {
1814  case SfxChildAlignment::LEFT:
1815  case SfxChildAlignment::RIGHT:
1816  case SfxChildAlignment::NOALIGNMENT:
1817  return eAlign;
1818  default:
1819  break;
1820  }
1821 
1822  return eActAlign;
1823 }
1824 
1826 {
1827  // oj #97405#
1828  if (m_xNavigatorTree)
1829  m_xNavigatorTree->GrabFocus();
1830  else
1831  SfxDockingWindow::GetFocus();
1832 }
1833 
1834 SFX_IMPL_DOCKINGWINDOW( FmFilterNavigatorWinMgr, SID_FM_FILTER_NAVIGATOR )
1835 
1836 
1837 FmFilterNavigatorWinMgr::FmFilterNavigatorWinMgr( vcl::Window *_pParent, sal_uInt16 _nId,
1838  SfxBindings *_pBindings, SfxChildWinInfo* _pInfo )
1839  :SfxChildWindow( _pParent, _nId )
1840 {
1841  SetWindow( VclPtr<FmFilterNavigatorWin>::Create( _pBindings, this, _pParent ) );
1842  static_cast<SfxDockingWindow*>(GetWindow())->Initialize( _pInfo );
1843 }
1844 
1845 
1846 }
1847 
1848 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
virtual ~FmFilterModel() override
Definition: filtnav.cxx:459
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:1082
virtual SfxChildAlignment CheckAlignment(SfxChildAlignment, SfxChildAlignment) override
Definition: filtnav.cxx:1810
void EnsureEmptyFilterRows(FmParentData &_rItem)
Definition: filtnav.cxx:886
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
static weld::Builder * CreateBuilder(weld::Widget *pParent, const OUString &rUIFile, bool bMobile=false, sal_uInt64 nLOKWindowId=0)
size_t m_nPos
Definition: filtnav.cxx:172
virtual void SAL_CALL disjunctiveTermRemoved(const FilterEvent &Event) override
Definition: filtnav.cxx:387
virtual sal_Int8 AcceptDrop(const AcceptDropEvent &rEvt) override
Definition: filtnav.cxx:1030
void StateChangedAtToolBoxControl(sal_uInt16 nSID, SfxItemState eState, const SfxPoolItem *pState) override
Definition: filtnav.cxx:1773
#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:1578
std::unique_ptr< ContentProperties > pData
virtual ~FmFilterNavigatorWin() override
Definition: filtnav.cxx:1735
signed char sal_Int8
static SotClipboardFormatId getFormatId()
Definition: filtnav.cxx:99
IMPL_STATIC_LINK(FmFilterNavigator, CustomGetSizeHdl, weld::TreeView::get_size_args, aPayload, Size)
Definition: filtnav.cxx:921
OString strip(std::string_view rIn, char c)
FmFilterNavigatorDropTarget(FmFilterNavigator &rTreeView)
Definition: filtnav.cxx:1024
void Remove(FmFilterData *pFilterItem)
Definition: filtnav.cxx:689
const StyleSettings & GetStyleSettings() const
static const AllSettings & GetSettings()
Reference< XInterface > xTarget
void SetWeight(FontWeight)
IMPL_LINK_NOARG(XFormsPage, ItemSelectHdl, weld::TreeView &, void)
Definition: datanavi.cxx:241
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:297
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:117
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:336
void SetText(const OUString &rText)
Definition: filtnav.hxx:61
virtual sal_Int8 ExecuteDrop(const ExecuteDropEvent &rEvt) override
Definition: filtnav.cxx:1044
IMPL_LINK(XFormsPage, PopupMenuHdl, const CommandEvent &, rCEvt, bool)
Definition: datanavi.cxx:134
FmFilterItem * Find(const ::sal_Int32 _nFilterComponentIndex) const
Definition: filtnav.cxx:126
WEIGHT_BOLD
#define FM_PROP_NAME
Definition: fmprop.hxx:29
constexpr tools::Long Width() const
Reference< XIndexAccess > m_xControllers
Definition: filtnav.cxx:215
void UpdateContent(FmFormShell const *pFormShell)
Definition: filtnav.cxx:1747
css::uno::Reference< css::container::XIndexAccess > m_xControllers
Definition: filtnav.hxx:142
Reference< XController > xController
FmFilterData * m_pData
Definition: filtnav.cxx:163
virtual OUString GetImage() const override
Definition: filtnav.cxx:137
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:1561
const int nxDBmp
Definition: filtnav.cxx:919
#define FM_PROP_BOUNDFIELD
Definition: fmprop.hxx:101
void Append(FmFilterItems *pItems, std::unique_ptr< FmFilterItem > pFilterItem)
Definition: filtnav.cxx:813
virtual OUString get_id(int pos) const =0
virtual OUString GetImage() const override
Definition: filtnav.cxx:121
FmFilterAdapter(FmFilterModel *pModel, const Reference< XIndexAccess > &xControllers)
Definition: filtnav.cxx:240
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:648
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:1796
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:1350
FmFormItem * getFormItem() const
Definition: filtnav.hxx:190
virtual void GetFocus() override
Definition: filtnav.cxx:1825
#define DBG_UNHANDLED_EXCEPTION(...)
void SetLineColor()
virtual void AddSupportedFormats() override
Definition: filtnav.cxx:94
bool ValidateText(FmFilterItem const *pItem, OUString &rText, OUString &rErrorMsg) const
Definition: filtnav.cxx:768
FmFilterNavigator(vcl::Window *pTopLevel, std::unique_ptr< weld::TreeView > xTreeView)
Definition: filtnav.cxx:1049
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
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)
void Insert(FmFilterData *pItem, int nPos)
Definition: filtnav.cxx:1322
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:1225
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:668
void StartListening(SfxBroadcaster &rBroadcaster, DuplicateHandling eDuplicateHanding=DuplicateHandling::Unexpected)
FmFilterNavigatorDropTarget m_aDropTargetHelper
Definition: filtnav.hxx:233
#define HID_FILTER_NAVIGATOR_WIN
Definition: helpids.h:49
FmFilterModel * m_pModel
Definition: filtnav.cxx:214
virtual void SAL_CALL disjunctiveTermAdded(const FilterEvent &Event) override
Definition: filtnav.cxx:422
OFilterExchangeHelper m_aControlExchange
Definition: filtnav.hxx:237
static void setText(sal_Int32 nPos, const FmFilterItem *pFilterItem, const OUString &rText)
Definition: filtnav.cxx:277
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: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:918
SfxItemState
SfxChildAlignment
virtual OUString GetImage() const override
Definition: filtnav.cxx:152
void SetCurrentItems(FmFilterItems *pCurrent)
Definition: filtnav.cxx:840
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
virtual rtl::Reference< OLocalExchange > createExchange() const override
Definition: filtnav.cxx:107
void SetFont(const vcl::Font &rNewFont)
FmFilterItem(FmFilterItems *pParent, const OUString &aFieldName, const OUString &aCondition, const sal_Int32 _nComponentIndex)
Definition: filtnav.cxx:142
tools::Long GetTextHeight() const
OUString aName
FmFilterNavigatorWin(SfxBindings *pBindings, SfxChildWindow *pMgr, vcl::Window *pParent)
Definition: filtnav.cxx:1723
::std::vector< std::unique_ptr< FmFilterData > > m_aChildren
Definition: filtnav.hxx:71
virtual bool Close() override
Definition: filtnav.cxx:1787
tools::Long AdjustWidth(tools::Long n)
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:622
virtual Size CalcDockingSize(SfxChildAlignment) override
Definition: filtnav.cxx:1802
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:819
::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:152
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:112
static css::uno::Reference< css::awt::XWindow > GetInterface(vcl::Window *pWindow)
sal_Int8 mnAction
const Color & GetDialogTextColor() const
virtual void dispose() override
void Push(PushFlags nFlags=PushFlags::ALL)
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:254
virtual ~FmFilterNavigator() override
Definition: filtnav.cxx:1074
sal_uInt16 nPos
virtual void dispose() override
Definition: filtnav.cxx:1740
void displayException(const Any &_rExcept, const css::uno::Reference< css::awt::XWindow > &rParent)
Definition: fmtools.cxx:86
OUString sDisplayName
bool IsMod2() const
OUString sId