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