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>
38#include <fmshimp.hxx>
39#include <o3tl/safeint.hxx>
40#include <sfx2/objitem.hxx>
41#include <svx/dialmgr.hxx>
42#include <svx/fmshell.hxx>
43#include <svx/fmtools.hxx>
44#include <svx/svxids.hrc>
47#include <utility>
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
57using namespace ::svxform;
58using namespace ::connectivity;
59using namespace ::dbtools;
60
61namespace 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
113{
114 return OUString();
115}
116
118{
119}
120
121OUString FmFormItem::GetImage() const
122{
123 return RID_SVXBMP_FORM;
124}
125
126FmFilterItem* 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
138{
139 return RID_SVXBMP_FILTER;
140}
141
143 OUString aFieldName,
144 const OUString& aText,
145 const sal_Int32 _nComponentIndex )
146 :FmFilterData(pParent, aText)
147 ,m_aFieldName(std::move(aFieldName))
148 ,m_nComponentIndex( _nComponentIndex )
149{
150}
151
153{
154 return RID_SVXBMP_FIELD;
155}
156
157// Hints for communication between model and view
158
159namespace {
160
161class FmFilterHint : public SfxHint
162{
163 FmFilterData* m_pData;
164
165public:
166 explicit FmFilterHint(FmFilterData* pData):m_pData(pData){}
167 FmFilterData* GetData() const { return m_pData; }
168};
169
170class FmFilterInsertedHint : public FmFilterHint
171{
172 size_t m_nPos; // Position relative to the parent of the data
173
174public:
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
182class FmFilterRemovedHint : public FmFilterHint
183{
184public:
185 explicit FmFilterRemovedHint(FmFilterData* pData)
186 :FmFilterHint(pData){}
187};
188
189
190class FmFilterTextChangedHint : public FmFilterHint
191{
192public:
193 explicit FmFilterTextChangedHint(FmFilterData* pData)
194 :FmFilterHint(pData){}
195};
196
197class FilterClearingHint : public SfxHint
198{
199public:
200 FilterClearingHint(){}
201};
202
203class FmFilterCurrentChangedHint : public SfxHint
204{
205public:
206 FmFilterCurrentChangedHint(){}
207};
208
209}
210
211// class FmFilterAdapter, listener at the FilterControls
212class FmFilterAdapter : public ::cppu::WeakImplHelper< XFilterControllerListener >
213{
215 Reference< XIndexAccess > m_xControllers;
216
217public:
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
240FmFilterAdapter::FmFilterAdapter(FmFilterModel* pModel, const Reference< XIndexAccess >& xControllers)
241 :m_pModel( pModel )
242 ,m_xControllers( xControllers )
243{
245}
246
247
249{
251}
252
253
254void 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
277void 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
297void SAL_CALL FmFilterAdapter::disposing(const EventObject& /*e*/)
298{
299}
300
301
302namespace
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 {
321 Reference< XPropertySet > xField;
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
336void 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
387void 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
422void 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
486void 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
518void 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
581FmFormItem* 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
602FmFormItem* 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
622void 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
668void 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
756void 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
768bool 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
813void FmFilterModel::Append(FmFilterItems* pItems, std::unique_ptr<FmFilterItem> pFilterItem)
814{
815 Insert(pItems->GetChildren().end(), std::move(pFilterItem));
816}
817
818
819void 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
918const int nxD = 4;
919const 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 = weld::fromId<FmFilterData*>(rId);
929 OUString sText = pData->GetText();
930
931 if (FmFilterItem* pItem = dynamic_cast<FmFilterItem*>(pData))
932 {
933 rRenderContext.Push(vcl::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(vcl::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 = weld::fromId<FmFilterData*>(rId);
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(vcl::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(vcl::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
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
1049FmFilterNavigator::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{
1079 m_pModel.reset();
1080}
1081
1082void 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
1108IMPL_LINK(FmFilterNavigator, EditingEntryHdl, const weld::TreeIter&, rIter, bool)
1109{
1110 // returns true to allow editing
1111 if (dynamic_cast<const FmFilterItem*>(weld::fromId<FmFilterData*>(m_xTreeView->get_id(rIter))))
1112 {
1113 m_xEditingCurrently = m_xTreeView->make_iterator(&rIter);
1114 return true;
1115 }
1116 m_xEditingCurrently.reset();
1117 return false;
1118}
1119
1120IMPL_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 = weld::fromId<FmFilterData*>(m_xTreeView->get_id(rIter));
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
1165IMPL_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
1177 if (!OFilterItemExchange::hasFormat(m_aDropTargetHelper.GetDataFlavorExVector()))
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 = weld::fromId<FmFilterData*>(m_xTreeView->get_id(*xDropTarget));
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
1213namespace
1214{
1215 FmFilterItems* getTargetItems(const weld::TreeView& rTreeView, const weld::TreeIter& rTarget)
1216 {
1217 FmFilterData* pData = weld::fromId<FmFilterData*>(rTreeView.get_id(rTarget));
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 if (xEntry)
1243 {
1244 m_xTreeView->select(*xEntry);
1245 m_xTreeView->set_cursor(*xEntry);
1246 }
1247
1249
1250 return DND_ACTION_COPY;
1251}
1252
1254{
1255 std::unique_ptr<weld::TreeIter> xIter(m_xTreeView->make_iterator());
1256 if (!m_xTreeView->get_selected(xIter.get()))
1257 return;
1258
1259 FmFilterData* pData = weld::fromId<FmFilterData*>(m_xTreeView->get_id(*xIter));
1260
1261 FmFormItem* pFormItem = nullptr;
1262 if (FmFilterItem* pItem = dynamic_cast<FmFilterItem*>(pData))
1263 pFormItem = static_cast<FmFormItem*>(pItem->GetParent()->GetParent());
1264 else if (FmFilterItems* pItems = dynamic_cast<FmFilterItems*>(pData))
1265 pFormItem = static_cast<FmFormItem*>(pItems->GetParent()->GetParent());
1266 else
1267 pFormItem = dynamic_cast<FmFormItem*>(pData);
1268
1269 if (pFormItem)
1270 {
1271 // will the controller be exchanged?
1272 if (FmFilterItem* pItem = dynamic_cast<FmFilterItem*>(pData))
1273 m_pModel->SetCurrentItems(static_cast<FmFilterItems*>(pItem->GetParent()));
1274 else if (FmFilterItems* pItems = dynamic_cast<FmFilterItems*>(pData))
1275 m_pModel->SetCurrentItems(pItems);
1276 else
1277 m_pModel->SetCurrentController(pFormItem->GetController());
1278 }
1279}
1280
1282{
1283 if (const FmFilterInsertedHint* pInsertHint = dynamic_cast<const FmFilterInsertedHint*>(&rHint))
1284 {
1285 Insert(pInsertHint->GetData(), pInsertHint->GetPos());
1286 }
1287 else if( dynamic_cast<const FilterClearingHint*>(&rHint) )
1288 {
1289 m_xTreeView->clear();
1290 }
1291 else if (const FmFilterRemovedHint* pRemoveHint = dynamic_cast<const FmFilterRemovedHint*>(&rHint))
1292 {
1293 Remove(pRemoveHint->GetData());
1294 }
1295 else if (const FmFilterTextChangedHint *pChangeHint = dynamic_cast<const FmFilterTextChangedHint*>(&rHint))
1296 {
1297 std::unique_ptr<weld::TreeIter> xEntry = FindEntry(pChangeHint->GetData());
1298 if (xEntry)
1299 m_xTreeView->set_text(*xEntry, pChangeHint->GetData()->GetText());
1300 }
1301 else if( dynamic_cast<const FmFilterCurrentChangedHint*>(&rHint) )
1302 {
1303 m_xTreeView->queue_draw();
1304 }
1305}
1306
1307std::unique_ptr<weld::TreeIter> FmFilterNavigator::FindEntry(const FmFilterData* pItem) const
1308{
1309 if (!pItem)
1310 return nullptr;
1311 std::unique_ptr<weld::TreeIter> xEntry = m_xTreeView->make_iterator();
1312 if (!m_xTreeView->get_iter_first(*xEntry))
1313 return nullptr;
1314 do
1315 {
1316 FmFilterData* pEntryItem = weld::fromId<FmFilterData*>(m_xTreeView->get_id(*xEntry));
1317 if (pEntryItem == pItem)
1318 return xEntry;
1319 }
1320 while (m_xTreeView->iter_next(*xEntry));
1321
1322 return nullptr;
1323}
1324
1325void FmFilterNavigator::Insert(const FmFilterData* pItem, int nPos)
1326{
1327 const FmParentData* pParent = pItem->GetParent() ? pItem->GetParent() : m_pModel.get();
1328
1329 // insert the item
1330 std::unique_ptr<weld::TreeIter> xParentEntry = FindEntry(pParent);
1331
1332 OUString sId(weld::toId(pItem));
1333 std::unique_ptr<weld::TreeIter> xRet(m_xTreeView->make_iterator());
1334 m_xTreeView->insert(xParentEntry.get(), nPos, &pItem->GetText(), &sId,
1335 nullptr, nullptr, false, xRet.get());
1336 m_xTreeView->set_image(*xRet, pItem->GetImage());
1337
1338 if (!xParentEntry)
1339 return;
1340 m_xTreeView->expand_row(*xParentEntry);
1341}
1342
1344{
1346 {
1347 // end editing
1348 m_xTreeView->end_editing();
1349 m_xEditingCurrently.reset();
1350 }
1351}
1352
1354{
1355 // the entry for the data
1356 std::unique_ptr<weld::TreeIter> xEntry = FindEntry(pItem);
1357 if (!xEntry)
1358 return;
1359
1360 if (m_xEditingCurrently && m_xTreeView->iter_compare(*xEntry, *m_xEditingCurrently) == 0)
1361 EndEditing();
1362
1363 m_xTreeView->remove(*xEntry);
1364}
1365
1366FmFormItem* FmFilterNavigator::getSelectedFilterItems(::std::vector<FmFilterItem*>& _rItemList)
1367{
1368 // be sure that the data is only used within only one form!
1369 FmFormItem* pFirstItem = nullptr;
1370
1371 bool bHandled = true;
1372 bool bFoundSomething = false;
1373
1374 m_xTreeView->selected_foreach([this, &bHandled, &bFoundSomething, &pFirstItem, &_rItemList](weld::TreeIter& rEntry) {
1375 FmFilterData* pFilterEntry = weld::fromId<FmFilterData*>(m_xTreeView->get_id(rEntry));
1376 FmFilterItem* pFilter = dynamic_cast<FmFilterItem*>(pFilterEntry);
1377 if (pFilter)
1378 {
1379 FmFormItem* pForm = dynamic_cast<FmFormItem*>( pFilter->GetParent()->GetParent() );
1380 if (!pForm)
1381 bHandled = false;
1382 else if (!pFirstItem)
1383 pFirstItem = pForm;
1384 else if (pFirstItem != pForm)
1385 bHandled = false;
1386
1387 if (bHandled)
1388 {
1389 _rItemList.push_back(pFilter);
1390 bFoundSomething = true;
1391 }
1392 }
1393 return !bHandled;
1394 });
1395
1396 if ( !bHandled || !bFoundSomething )
1397 pFirstItem = nullptr;
1398 return pFirstItem;
1399}
1400
1401void FmFilterNavigator::insertFilterItem(const ::std::vector<FmFilterItem*>& _rFilterList,FmFilterItems* _pTargetItems,bool _bCopy)
1402{
1403 for (FmFilterItem* pLookupItem : _rFilterList)
1404 {
1405 if ( pLookupItem->GetParent() == _pTargetItems )
1406 continue;
1407
1408 FmFilterItem* pFilterItem = _pTargetItems->Find( pLookupItem->GetComponentIndex() );
1409 OUString aText = pLookupItem->GetText();
1410 if ( !pFilterItem )
1411 {
1412 pFilterItem = new FmFilterItem( _pTargetItems, pLookupItem->GetFieldName(), aText, pLookupItem->GetComponentIndex() );
1413 m_pModel->Append( _pTargetItems, std::unique_ptr<FmFilterItem>(pFilterItem) );
1414 }
1415
1416 if ( !_bCopy )
1417 m_pModel->Remove( pLookupItem );
1418
1419 // now set the text for the new dragged item
1420 m_pModel->SetTextForItem( pFilterItem, aText );
1421 }
1422
1423 m_pModel->EnsureEmptyFilterRows( *_pTargetItems->GetParent() );
1424}
1425
1426IMPL_LINK(FmFilterNavigator, DragBeginHdl, bool&, rUnsetDragIcon, bool)
1427{
1428 rUnsetDragIcon = false;
1429
1430 // be sure that the data is only used within an only one form!
1431 m_aControlExchange.prepareDrag();
1432
1433 ::std::vector<FmFilterItem*> aItemList;
1434 if (FmFormItem* pFirstItem = getSelectedFilterItems(aItemList))
1435 {
1436 m_aControlExchange->setDraggedEntries(std::move(aItemList));
1437 m_aControlExchange->setFormItem(pFirstItem);
1438
1439 OFilterItemExchange& rExchange = *m_aControlExchange;
1440 rtl::Reference<TransferDataContainer> xHelper(&rExchange);
1441 m_xTreeView->enable_drag_source(xHelper, DND_ACTION_COPYMOVE);
1442 rExchange.setDragging(true);
1443
1444 return false;
1445 }
1446 return true;
1447}
1448
1449IMPL_LINK(FmFilterNavigator, PopupMenuHdl, const CommandEvent&, rEvt, bool)
1450{
1451 bool bHandled = false;
1452 switch (rEvt.GetCommand())
1453 {
1454 case CommandEventId::ContextMenu:
1455 {
1456 // the place where it was clicked
1457 Point aWhere;
1458 std::unique_ptr<weld::TreeIter> xClicked(m_xTreeView->make_iterator());
1459 if (rEvt.IsMouseEvent())
1460 {
1461 aWhere = rEvt.GetMousePosPixel();
1462 if (!m_xTreeView->get_dest_row_at_pos(aWhere, xClicked.get(), false))
1463 break;
1464
1465 if (!m_xTreeView->is_selected(*xClicked))
1466 {
1467 m_xTreeView->unselect_all();
1468 m_xTreeView->select(*xClicked);
1469 m_xTreeView->set_cursor(*xClicked);
1470 }
1471 }
1472 else
1473 {
1474 if (!m_xTreeView->get_cursor(xClicked.get()))
1475 break;
1476 aWhere = m_xTreeView->get_row_area(*xClicked).Center();
1477 }
1478
1479 ::std::vector<FmFilterData*> aSelectList;
1480 m_xTreeView->selected_foreach([this, &aSelectList](weld::TreeIter& rEntry) {
1481 FmFilterData* pFilterEntry = weld::fromId<FmFilterData*>(m_xTreeView->get_id(rEntry));
1482
1483 // don't delete forms
1484 FmFormItem* pForm = dynamic_cast<FmFormItem*>(pFilterEntry);
1485 if (!pForm)
1486 aSelectList.push_back(pFilterEntry);
1487
1488 return false;
1489 });
1490
1491 if (aSelectList.size() == 1)
1492 {
1493 // don't delete the only empty row of a form
1494 FmFilterItems* pFilterItems = dynamic_cast<FmFilterItems*>( aSelectList[0] );
1495 if (pFilterItems && pFilterItems->GetChildren().empty()
1496 && pFilterItems->GetParent()->GetChildren().size() == 1)
1497 aSelectList.clear();
1498 }
1499
1500 std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(m_xTreeView.get(), "svx/ui/filtermenu.ui"));
1501 std::unique_ptr<weld::Menu> xContextMenu(xBuilder->weld_menu("menu"));
1502
1503 // every condition could be deleted except the first one if it's the only one
1504 bool bNoDelete = false;
1505 if (aSelectList.empty())
1506 {
1507 bNoDelete = true;
1508 xContextMenu->remove("delete");
1509 }
1510
1511 FmFilterData* pFilterEntry = weld::fromId<FmFilterData*>(m_xTreeView->get_id(*xClicked));
1512 auto pFilterItem = dynamic_cast<FmFilterItem*>(pFilterEntry);
1513 bool bEdit = pFilterItem &&
1514 m_xTreeView->is_selected(*xClicked) && m_xTreeView->count_selected_rows() == 1;
1515
1516 if (bNoDelete && !bEdit)
1517 {
1518 // nothing is in the menu, don't bother
1519 return true;
1520 }
1521
1522 if (!bEdit)
1523 {
1524 xContextMenu->remove("edit");
1525 xContextMenu->remove("isnull");
1526 xContextMenu->remove("isnotnull");
1527 }
1528
1529 OString sIdent = xContextMenu->popup_at_rect(m_xTreeView.get(), tools::Rectangle(aWhere, ::Size(1, 1)));
1530 if (sIdent == "edit")
1531 {
1532 m_xTreeView->start_editing(*xClicked);
1533 }
1534 else if (sIdent == "isnull")
1535 {
1536 OUString aErrorMsg;
1537 OUString aText = "IS NULL";
1538 assert(pFilterItem && "if item is null this menu entry was removed and unavailable");
1539 m_pModel->ValidateText(pFilterItem, aText, aErrorMsg);
1540 m_pModel->SetTextForItem(pFilterItem, aText);
1541 }
1542 else if (sIdent == "isnotnull")
1543 {
1544 OUString aErrorMsg;
1545 OUString aText = "IS NOT NULL";
1546
1547 assert(pFilterItem && "if item is null this menu entry was removed and unavailable");
1548 m_pModel->ValidateText(pFilterItem, aText, aErrorMsg);
1549 m_pModel->SetTextForItem(pFilterItem, aText);
1550 }
1551 else if (sIdent == "delete")
1552 {
1553 DeleteSelection();
1554 }
1555 bHandled = true;
1556 }
1557 break;
1558 default: break;
1559 }
1560
1561 return bHandled;
1562}
1563
1565{
1566 bool bEntry = m_xTreeView->iter_next(rEntry);
1567 // we need the next filter entry
1568 if (bEntry)
1569 {
1570 while (!m_xTreeView->iter_has_child(rEntry))
1571 {
1572 std::unique_ptr<weld::TreeIter> xNext = m_xTreeView->make_iterator(&rEntry);
1573 if (!m_xTreeView->iter_next(*xNext))
1574 break;
1575 m_xTreeView->copy_iterator(*xNext, rEntry);
1576 }
1577 }
1578 return bEntry;
1579}
1580
1582{
1583 bool bEntry = m_xTreeView->iter_previous(rEntry);
1584 // check if the previous entry is a filter, if so get the next prev
1585 if (bEntry && m_xTreeView->iter_has_child(rEntry))
1586 {
1587 bEntry = m_xTreeView->iter_previous(rEntry);
1588 // if the entry is still no leaf return
1589 if (bEntry && m_xTreeView->iter_has_child(rEntry))
1590 bEntry = false;
1591 }
1592 return bEntry;
1593}
1594IMPL_LINK(FmFilterNavigator, KeyInputHdl, const ::KeyEvent&, rKEvt, bool)
1595{
1596 const vcl::KeyCode& rKeyCode = rKEvt.GetKeyCode();
1597
1598 switch ( rKeyCode.GetCode() )
1599 {
1600 case KEY_UP:
1601 case KEY_DOWN:
1602 {
1603 if ( !rKeyCode.IsMod1() || !rKeyCode.IsMod2() || rKeyCode.IsShift() )
1604 break;
1605
1606 ::std::vector<FmFilterItem*> aItemList;
1607 if ( !getSelectedFilterItems( aItemList ) )
1608 break;
1609
1610
1611 std::vector<std::unique_ptr<weld::TreeIter>> aSelected;
1612 m_xTreeView->selected_foreach([this, &aSelected](weld::TreeIter& rEntry){
1613 aSelected.emplace_back(m_xTreeView->make_iterator(&rEntry));
1614 return false;
1615 });
1616
1617 std::unique_ptr<weld::TreeIter> xTarget;
1618 ::std::function<bool(FmFilterNavigator*, weld::TreeIter&)> getter;
1619
1620 if (rKeyCode.GetCode() == KEY_UP)
1621 {
1622 xTarget = m_xTreeView->make_iterator(aSelected.front().get());
1623 getter = ::std::mem_fn(&FmFilterNavigator::getPrevEntry);
1624 }
1625 else
1626 {
1627 xTarget = m_xTreeView->make_iterator(aSelected.back().get());
1628 getter = ::std::mem_fn(&FmFilterNavigator::getNextEntry);
1629 }
1630
1631 bool bTarget = getter(this, *xTarget);
1632 if (!bTarget)
1633 break;
1634
1635 FmFilterItems* pTargetItems = getTargetItems(*m_xTreeView, *xTarget);
1636 if (!pTargetItems)
1637 break;
1638
1639 ::std::vector<FmFilterItem*>::const_iterator aEnd = aItemList.end();
1640 bool bNextTargetItem = true;
1641 while ( bNextTargetItem )
1642 {
1643 ::std::vector<FmFilterItem*>::const_iterator i = aItemList.begin();
1644 for (; i != aEnd; ++i)
1645 {
1646 if ( (*i)->GetParent() == pTargetItems )
1647 {
1648 bTarget = getter(this, *xTarget);
1649 if (!bTarget)
1650 return true;
1651 pTargetItems = getTargetItems(*m_xTreeView, *xTarget);
1652 break;
1653 }
1654 else
1655 {
1656 FmFilterItem* pFilterItem = pTargetItems->Find( (*i)->GetComponentIndex() );
1657 // we found the text component so jump above
1658 if ( pFilterItem )
1659 {
1660 bTarget = getter(this, *xTarget);
1661 if (!bTarget)
1662 return true;
1663
1664 pTargetItems = getTargetItems(*m_xTreeView, *xTarget);
1665 break;
1666 }
1667 }
1668 }
1669 bNextTargetItem = i != aEnd && pTargetItems;
1670 }
1671
1672 if ( pTargetItems )
1673 {
1674 insertFilterItem( aItemList, pTargetItems, false );
1675 return true;
1676 }
1677 }
1678 break;
1679
1680 case KEY_DELETE:
1681 {
1682 if ( rKeyCode.GetModifier() )
1683 break;
1684
1685 std::unique_ptr<weld::TreeIter> xEntry = m_xTreeView->make_iterator();
1686 if (m_xTreeView->get_iter_first(*xEntry) && !m_xTreeView->is_selected(*xEntry))
1687 DeleteSelection();
1688
1689 return true;
1690 }
1691 }
1692
1693 return false;
1694}
1695
1697{
1698 // to avoid the deletion of an entry twice (e.g. deletion of a parent and afterward
1699 // the deletion of its child, I have to shrink the selection list
1700 std::vector<FmFilterData*> aEntryList;
1701
1702 m_xTreeView->selected_foreach([this, &aEntryList](weld::TreeIter& rEntry) {
1703 FmFilterData* pFilterEntry = weld::fromId<FmFilterData*>(m_xTreeView->get_id(rEntry));
1704
1705 if (dynamic_cast<FmFilterItem*>(pFilterEntry))
1706 {
1707 std::unique_ptr<weld::TreeIter> xParent(m_xTreeView->make_iterator(&rEntry));
1708 if (m_xTreeView->iter_parent(*xParent) && m_xTreeView->is_selected(*xParent))
1709 return false;
1710 }
1711
1712 FmFormItem* pForm = dynamic_cast<FmFormItem*>(pFilterEntry);
1713 if (!pForm)
1714 aEntryList.emplace_back(pFilterEntry);
1715
1716 return false;
1717 });
1718
1719 // Remove the selection
1720 m_xTreeView->unselect_all();
1721
1722 for (auto i = aEntryList.rbegin(); i != aEntryList.rend(); ++i)
1723 m_pModel->Remove(*i);
1724}
1725
1727 vcl::Window* _pParent)
1728 : SfxDockingWindow(_pBindings, _pMgr, _pParent, "FilterNavigator", "svx/ui/filternavigator.ui")
1729 , SfxControllerItem( SID_FM_FILTER_NAVIGATOR_CONTROL, *_pBindings )
1730 , m_xNavigatorTree(new FmFilterNavigator(this, m_xBuilder->weld_tree_view("treeview")))
1731{
1733
1734 SetText( SvxResId(RID_STR_FILTER_NAVIGATOR) );
1736}
1737
1739{
1740 disposeOnce();
1741}
1742
1744{
1745 m_xNavigatorTree.reset();
1748}
1749
1751{
1752 if (!m_xNavigatorTree)
1753 return;
1754
1755 if (!pFormShell)
1756 m_xNavigatorTree->UpdateContent( nullptr, nullptr );
1757 else
1758 {
1759 Reference<XFormController> const xController(pFormShell->GetImpl()->getActiveInternalController_Lock());
1760 Reference< XIndexAccess > xContainer;
1761 if (xController.is())
1762 {
1763 Reference< XChild > xChild = xController;
1764 for (Reference< XInterface > xParent(xChild->getParent());
1765 xParent.is();
1766 xParent = xChild.is() ? xChild->getParent() : Reference< XInterface > ())
1767 {
1768 xContainer.set(xParent, UNO_QUERY);
1769 xChild.set(xParent, UNO_QUERY);
1770 }
1771 }
1772 m_xNavigatorTree->UpdateContent(xContainer, xController);
1773 }
1774}
1775
1777{
1778 if( !pState || SID_FM_FILTER_NAVIGATOR_CONTROL != nSID )
1779 return;
1780
1781 if( eState >= SfxItemState::DEFAULT )
1782 {
1783 FmFormShell* pShell = dynamic_cast<FmFormShell*>( static_cast<const SfxObjectItem*>(pState)->GetShell() );
1784 UpdateContent( pShell );
1785 }
1786 else
1787 UpdateContent( nullptr );
1788}
1789
1791{
1792 if (m_xNavigatorTree)
1793 m_xNavigatorTree->EndEditing();
1794
1795 UpdateContent( nullptr );
1796 return SfxDockingWindow::Close();
1797}
1798
1800{
1802 rInfo.bVisible = false;
1803}
1804
1806{
1807 if ( ( eAlign == SfxChildAlignment::TOP ) || ( eAlign == SfxChildAlignment::BOTTOM ) )
1808 return Size();
1809
1810 return SfxDockingWindow::CalcDockingSize( eAlign );
1811}
1812
1814{
1815 switch (eAlign)
1816 {
1817 case SfxChildAlignment::LEFT:
1818 case SfxChildAlignment::RIGHT:
1819 case SfxChildAlignment::NOALIGNMENT:
1820 return eAlign;
1821 default:
1822 break;
1823 }
1824
1825 return eActAlign;
1826}
1827
1829{
1830 // oj #97405#
1831 if (m_xNavigatorTree)
1832 m_xNavigatorTree->GrabFocus();
1833 else
1834 SfxDockingWindow::GetFocus();
1835}
1836
1837SFX_IMPL_DOCKINGWINDOW( FmFilterNavigatorWinMgr, SID_FM_FILTER_NAVIGATOR )
1838
1839
1840FmFilterNavigatorWinMgr::FmFilterNavigatorWinMgr( vcl::Window *_pParent, sal_uInt16 _nId,
1841 SfxBindings *_pBindings, SfxChildWinInfo* _pInfo )
1842 :SfxChildWindow( _pParent, _nId )
1843{
1844 SetWindow( VclPtr<FmFilterNavigatorWin>::Create( _pBindings, this, _pParent ) );
1845 static_cast<SfxDockingWindow*>(GetWindow())->Initialize( _pInfo );
1846}
1847
1848
1849}
1850
1851/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
SfxChildAlignment
const LanguageTag & GetUILanguageTag() const
const StyleSettings & GetStyleSettings() const
static const AllSettings & GetSettings()
static ImplSVEvent * PostUserEvent(const Link< void *, void > &rLink, void *pCaller=nullptr, bool bReferenceLink=false)
static std::unique_ptr< weld::Builder > CreateBuilder(weld::Widget *pParent, const OUString &rUIFile, bool bMobile=false, sal_uInt64 nLOKWindowId=0)
static void RemoveUserEvent(ImplSVEvent *nUserEvent)
FmXFormShell * GetImpl() const
Definition: fmshell.hxx:118
const css::lang::Locale & getLocale(bool bResolveSystem=true) const
Size GetOutputSize() const
const vcl::Font & GetFont() const
void SetFont(const vcl::Font &rNewFont)
void DrawLine(const Point &rStartPt, const Point &rEndPt)
void SetLineColor()
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
void SetTextColor(const Color &rColor)
const Color & GetTextColor() const
void Push(vcl::PushFlags nFlags=vcl::PushFlags::ALL)
tools::Long GetTextHeight() const
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 Broadcast(const SfxHint &rHint)
virtual void dispose()
virtual void FillInfo(SfxChildWinInfo &) const
virtual bool Close() override
void SetFloatingSize(const Size &rSize)
virtual Size CalcDockingSize(SfxChildAlignment)
virtual void dispose() override
void StartListening(SfxBroadcaster &rBroadcaster, DuplicateHandling eDuplicateHanding=DuplicateHandling::Unexpected)
void EndListening(SfxBroadcaster &rBroadcaster, bool bRemoveAllDuplicates=false)
tools::Long AdjustWidth(tools::Long n)
constexpr tools::Long Width() const
static SotClipboardFormatId RegisterFormatName(const OUString &rName)
const Color & GetDialogTextColor() const
const Color & GetHighlightTextColor() const
static css::uno::Reference< css::awt::XWindow > GetInterface(vcl::Window *pWindow)
virtual void SAL_CALL disjunctiveTermAdded(const FilterEvent &Event) override
Definition: filtnav.cxx:422
FmFilterModel * m_pModel
Definition: filtnav.cxx:214
FmFilterAdapter(FmFilterModel *pModel, const Reference< XIndexAccess > &xControllers)
Definition: filtnav.cxx:240
void AddOrRemoveListener(const Reference< XIndexAccess > &_rxControllers, const bool _bAdd)
Definition: filtnav.cxx:254
virtual void SAL_CALL disposing(const EventObject &Source) override
Definition: filtnav.cxx:297
virtual void SAL_CALL predicateExpressionChanged(const FilterEvent &Event) override
Definition: filtnav.cxx:336
virtual void SAL_CALL disjunctiveTermRemoved(const FilterEvent &Event) override
Definition: filtnav.cxx:387
Reference< XIndexAccess > m_xControllers
Definition: filtnav.cxx:215
static void setText(sal_Int32 nPos, const FmFilterItem *pFilterItem, const OUString &rText)
Definition: filtnav.cxx:277
const OUString & GetText() const
Definition: filtnav.hxx:63
void SetText(const OUString &rText)
Definition: filtnav.hxx:62
virtual OUString GetImage() const
Definition: filtnav.cxx:112
FmParentData * GetParent() const
Definition: filtnav.hxx:64
sal_Int32 GetComponentIndex() const
Definition: filtnav.hxx:132
FmFilterItem(FmFilterItems *pParent, OUString aFieldName, const OUString &aCondition, const sal_Int32 _nComponentIndex)
Definition: filtnav.cxx:142
virtual OUString GetImage() const override
Definition: filtnav.cxx:152
virtual OUString GetImage() const override
Definition: filtnav.cxx:137
FmFilterItem * Find(const ::sal_Int32 _nFilterComponentIndex) const
Definition: filtnav.cxx:126
virtual ~FmFilterModel() override
Definition: filtnav.cxx:459
FmFormItem * Find(const ::std::vector< std::unique_ptr< FmFilterData > > &rItems, const css::uno::Reference< css::form::runtime::XFormController > &xController) const
bool ValidateText(FmFilterItem const *pItem, OUString &rText, OUString &rErrorMsg) const
Definition: filtnav.cxx:768
static void AppendFilterItems(FmFormItem &_rItem)
Definition: filtnav.cxx:648
void Update(const css::uno::Reference< css::container::XIndexAccess > &xControllers, const css::uno::Reference< css::form::runtime::XFormController > &xCurrent)
rtl::Reference< FmFilterAdapter > m_pAdapter
Definition: filtnav.hxx:145
void Remove(FmFilterData *pFilterItem)
Definition: filtnav.cxx:689
friend class FmFilterAdapter
Definition: filtnav.hxx:141
void SetCurrentController(const css::uno::Reference< css::form::runtime::XFormController > &xController)
Definition: filtnav.cxx:622
void SetTextForItem(FmFilterItem *pItem, const OUString &rText)
Definition: filtnav.cxx:819
void Insert(const ::std::vector< std::unique_ptr< FmFilterData > >::iterator &rPos, std::unique_ptr< FmFilterData > pFilterItem)
Definition: filtnav.cxx:668
FmFilterItems * m_pCurrentItems
Definition: filtnav.hxx:146
css::uno::Reference< css::form::runtime::XFormController > m_xController
Definition: filtnav.hxx:144
css::uno::Reference< css::container::XIndexAccess > m_xControllers
Definition: filtnav.hxx:143
void SetCurrentItems(FmFilterItems *pCurrent)
Definition: filtnav.cxx:840
void EnsureEmptyFilterRows(FmParentData &_rItem)
Definition: filtnav.cxx:886
void Append(FmFilterItems *pItems, std::unique_ptr< FmFilterItem > pFilterItem)
Definition: filtnav.cxx:813
virtual sal_Int8 ExecuteDrop(const ExecuteDropEvent &rEvt) override
Definition: filtnav.cxx:1044
FmFilterNavigatorDropTarget(FmFilterNavigator &rTreeView)
Definition: filtnav.cxx:1024
FmFilterNavigator & m_rTreeView
Definition: filtnav.hxx:221
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:1776
virtual ~FmFilterNavigatorWin() override
Definition: filtnav.cxx:1738
void FillInfo(SfxChildWinInfo &rInfo) const override
Definition: filtnav.cxx:1799
virtual Size CalcDockingSize(SfxChildAlignment) override
Definition: filtnav.cxx:1805
virtual SfxChildAlignment CheckAlignment(SfxChildAlignment, SfxChildAlignment) override
Definition: filtnav.cxx:1813
virtual bool Close() override
Definition: filtnav.cxx:1790
std::unique_ptr< FmFilterNavigator > m_xNavigatorTree
Definition: filtnav.hxx:308
virtual void GetFocus() override
Definition: filtnav.cxx:1828
virtual void dispose() override
Definition: filtnav.cxx:1743
void UpdateContent(FmFormShell const *pFormShell)
Definition: filtnav.cxx:1750
FmFilterNavigatorWin(SfxBindings *pBindings, SfxChildWindow *pMgr, vcl::Window *pParent)
Definition: filtnav.cxx:1726
bool getPrevEntry(weld::TreeIter &rEntry)
Definition: filtnav.cxx:1581
virtual void Notify(SfxBroadcaster &rBC, const SfxHint &rHint) override
Definition: filtnav.cxx:1281
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:1401
std::unique_ptr< weld::TreeIter > FindEntry(const FmFilterData *pItem) const
Definition: filtnav.cxx:1307
FmFilterNavigator(vcl::Window *pTopLevel, std::unique_ptr< weld::TreeView > xTreeView)
Definition: filtnav.cxx:1049
sal_Int8 ExecuteDrop(const ExecuteDropEvent &rEvt)
Definition: filtnav.cxx:1225
std::unique_ptr< weld::TreeIter > m_xEditingCurrently
Definition: filtnav.hxx:237
weld::TreeView & get_widget()
Definition: filtnav.hxx:255
void Remove(FmFilterData const *pItem)
Definition: filtnav.cxx:1353
ImplSVEvent * m_nAsyncRemoveEvent
Definition: filtnav.hxx:240
void Insert(const FmFilterData *pItem, int nPos)
Definition: filtnav.cxx:1325
FmFilterNavigatorDropTarget m_aDropTargetHelper
Definition: filtnav.hxx:234
FmFormItem * getSelectedFilterItems(::std::vector< FmFilterItem * > &_rItemList)
returns the first form item and the selected FilterItems in the vector
Definition: filtnav.cxx:1366
sal_Int8 AcceptDrop(const AcceptDropEvent &rEvt)
Definition: filtnav.cxx:1172
std::unique_ptr< FmFilterModel > m_pModel
Definition: filtnav.hxx:236
OFilterExchangeHelper m_aControlExchange
Definition: filtnav.hxx:238
void UpdateContent(const css::uno::Reference< css::container::XIndexAccess > &xControllers, const css::uno::Reference< css::form::runtime::XFormController > &xCurrent)
Definition: filtnav.cxx:1082
std::unique_ptr< weld::TreeView > m_xTreeView
Definition: filtnav.hxx:233
virtual ~FmFilterNavigator() override
Definition: filtnav.cxx:1074
bool getNextEntry(weld::TreeIter &rEntry)
Definition: filtnav.cxx:1564
const css::uno::Reference< css::form::runtime::XFormController > & GetController() const
Definition: filtnav.hxx:101
const css::uno::Reference< css::form::runtime::XFilterController > & GetFilterController() const
Definition: filtnav.hxx:104
virtual OUString GetImage() const override
Definition: filtnav.cxx:121
::std::vector< std::unique_ptr< FmFilterData > > m_aChildren
Definition: filtnav.hxx:72
::std::vector< std::unique_ptr< FmFilterData > > & GetChildren()
Definition: filtnav.hxx:80
virtual ~FmParentData() override
Definition: filtnav.cxx:117
virtual rtl::Reference< OLocalExchange > createExchange() const override
Definition: filtnav.cxx:107
FmFormItem * getFormItem() const
Definition: filtnav.hxx:191
const ::std::vector< FmFilterItem * > & getDraggedEntries() const
Definition: filtnav.hxx:189
static SotClipboardFormatId getFormatId()
Definition: filtnav.cxx:99
virtual void AddSupportedFormats() override
Definition: filtnav.cxx:94
static bool hasFormat(const DataFlavorExVector &_rFormats)
Definition: filtnav.hxx:199
constexpr Point TopLeft() const
constexpr tools::Long Bottom() const
void SetWeight(FontWeight)
bool IsMod1() const
sal_uInt16 GetCode() const
sal_uInt16 GetModifier() const
bool IsShift() const
bool IsMod2() const
std::tuple< vcl::RenderContext &, const tools::Rectangle &, bool, const OUString & > render_args
virtual bool get_dest_row_at_pos(const Point &rPos, weld::TreeIter *pResult, bool bDnDMode, bool bAutoScroll=true)=0
std::pair< vcl::RenderContext &, const OUString & > get_size_args
virtual OUString get_id(int pos) const=0
int nCount
#define DBG_ASSERT(sCon, aError)
#define DBG_UNHANDLED_EXCEPTION(...)
OUString SvxResId(TranslateId aId)
Definition: dialmgr.cxx:24
virtual void SetHelpId(const OString &) override
virtual void SetText(const OUString &rStr) override
Reference< XInterface > xTarget
FmFilterData * m_pData
Definition: filtnav.cxx:163
size_t m_nPos
Definition: filtnav.cxx:172
constexpr OUStringLiteral FM_PROP_BOUNDFIELD
Definition: fmprop.hxx:103
constexpr OUStringLiteral FM_PROP_NAME
Definition: fmprop.hxx:31
void displayException(const Any &_rExcept, const css::uno::Reference< css::awt::XWindow > &rParent)
Definition: fmtools.cxx:83
OUString getLabelName(const Reference< css::beans::XPropertySet > &xControlModel)
Definition: fmtools.cxx:149
WEIGHT_BOLD
SotClipboardFormatId
OUString sName
OUString sDisplayName
constexpr OStringLiteral HID_FILTER_NAVIGATOR_WIN
Definition: helpids.h:51
constexpr OStringLiteral HID_FILTER_NAVIGATOR
Definition: helpids.h:50
OUString aName
void * p
constexpr sal_uInt16 KEY_UP
constexpr sal_uInt16 KEY_DELETE
constexpr sal_uInt16 KEY_DOWN
sal_uInt16 nPos
std::unique_ptr< sal_Int32[]> pData
Shell * GetShell()
@ Exception
class SAL_NO_VTABLE XPropertySet
Definition: xmlexchg.hxx:28
OString strip(const OString &rIn, char c)
Reference< XComponentContext > getProcessComponentContext()
Reference< XConnection > getConnection(const Reference< XRowSet > &_rxRowSet)
Reference< XNumberFormatsSupplier > getNumberFormats(const Reference< XConnection > &_rxConn, bool _bAlloweDefault, const Reference< XComponentContext > &_rxContext)
int i
constexpr std::enable_if_t< std::is_signed_v< T >, std::make_unsigned_t< T > > make_unsigned(T value)
class FmSearchEngine - Impl class for FmSearchDialog
IMPL_LINK_NOARG(XFormsPage, ItemSelectHdl, weld::TreeView &, void)
Definition: datanavi.cxx:243
IMPL_STATIC_LINK(FmFilterNavigator, CustomGetSizeHdl, weld::TreeView::get_size_args, aPayload, Size)
Definition: filtnav.cxx:921
const int nxD
Definition: filtnav.cxx:918
IMPL_LINK(XFormsPage, PopupMenuHdl, const CommandEvent &, rCEvt, bool)
Definition: datanavi.cxx:136
const int nxDBmp
Definition: filtnav.cxx:919
css::uno::Reference< css::linguistic2::XProofreadingIterator > get(css::uno::Reference< css::uno::XComponentContext > const &context)
OUString toId(const void *pValue)
SFX_IMPL_DOCKINGWINDOW(SwNavigatorWrapper, SID_NAVIGATOR)
SfxItemState
sal_Int8 mnAction
Reference< XController > xController
Reference< XModel > xModel
#define DND_ACTION_COPYMOVE
#define DND_ACTION_COPY
#define DND_ACTION_NONE
signed char sal_Int8
OUString sId