Line data Source code
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 "filtnav.hxx"
21 : #include "fmexch.hxx"
22 : #include "fmhelp.hrc"
23 : #include "fmitems.hxx"
24 : #include "fmprop.hrc"
25 : #include "svx/fmresids.hrc"
26 :
27 : #include <com/sun/star/awt/XControlModel.hpp>
28 : #include <com/sun/star/awt/XControl.hpp>
29 : #include <com/sun/star/awt/XTextComponent.hpp>
30 : #include <com/sun/star/form/runtime/XFormController.hpp>
31 : #include <com/sun/star/lang/XUnoTunnel.hpp>
32 : #include <com/sun/star/util/NumberFormatter.hpp>
33 : #include <com/sun/star/beans/XFastPropertySet.hpp>
34 :
35 : #include <comphelper/processfactory.hxx>
36 : #include <comphelper/property.hxx>
37 : #include <comphelper/sequence.hxx>
38 : #include <comphelper/string.hxx>
39 : #include <comphelper/uno3.hxx>
40 : #include <connectivity/dbtools.hxx>
41 : #include <cppuhelper/implbase1.hxx>
42 : #include <fmservs.hxx>
43 : #include <fmshimp.hxx>
44 : #include <sfx2/dispatch.hxx>
45 : #include <sfx2/objitem.hxx>
46 : #include <sfx2/objsh.hxx>
47 : #include <sfx2/request.hxx>
48 : #include <svx/dialmgr.hxx>
49 : #include <svx/fmshell.hxx>
50 : #include <svx/fmtools.hxx>
51 : #include <svx/svxids.hrc>
52 : #include <vcl/wrkwin.hxx>
53 : #include <vcl/settings.hxx>
54 : #include <tools/diagnose_ex.h>
55 : #include <svtools/svlbitm.hxx>
56 : #include "svtools/treelistentry.hxx"
57 : #include "svtools/viewdataentry.hxx"
58 :
59 : #include <functional>
60 :
61 : #define DROP_ACTION_TIMER_INITIAL_TICKS 10
62 : // solange dauert es, bis das Scrollen anspringt
63 : #define DROP_ACTION_TIMER_SCROLL_TICKS 3
64 : // in diesen Intervallen wird jeweils eine Zeile gescrollt
65 : #define DROP_ACTION_TIMER_TICK_BASE 10
66 : // das ist die Basis, mit der beide Angaben multipliziert werden (in ms)
67 :
68 : using namespace ::svxform;
69 : using namespace ::connectivity::simple;
70 : using namespace ::connectivity;
71 :
72 :
73 :
74 : namespace svxform
75 : {
76 :
77 :
78 : using ::com::sun::star::uno::Reference;
79 : using ::com::sun::star::lang::XMultiServiceFactory;
80 : using ::com::sun::star::awt::TextEvent;
81 : using ::com::sun::star::container::XIndexAccess;
82 : using ::com::sun::star::uno::UNO_QUERY;
83 : using ::com::sun::star::beans::XPropertySet;
84 : using ::com::sun::star::form::runtime::XFormController;
85 : using ::com::sun::star::form::runtime::XFilterController;
86 : using ::com::sun::star::form::runtime::XFilterControllerListener;
87 : using ::com::sun::star::form::runtime::FilterEvent;
88 : using ::com::sun::star::lang::EventObject;
89 : using ::com::sun::star::uno::RuntimeException;
90 : using ::com::sun::star::form::XForm;
91 : using ::com::sun::star::container::XChild;
92 : using ::com::sun::star::awt::XControl;
93 : using ::com::sun::star::sdbc::XConnection;
94 : using ::com::sun::star::util::XNumberFormatsSupplier;
95 : using ::com::sun::star::util::XNumberFormatter;
96 : using ::com::sun::star::util::XNumberFormatter2;
97 : using ::com::sun::star::util::NumberFormatter;
98 : using ::com::sun::star::sdbc::XRowSet;
99 : using ::com::sun::star::lang::Locale;
100 : using ::com::sun::star::sdb::SQLContext;
101 : using ::com::sun::star::uno::XInterface;
102 : using ::com::sun::star::uno::UNO_QUERY_THROW;
103 : using ::com::sun::star::uno::UNO_SET_THROW;
104 : using ::com::sun::star::uno::Exception;
105 : using ::com::sun::star::awt::XTextComponent;
106 : using ::com::sun::star::uno::Sequence;
107 :
108 :
109 0 : OFilterItemExchange::OFilterItemExchange()
110 0 : : m_pFormItem(NULL)
111 : {
112 0 : }
113 :
114 0 : void OFilterItemExchange::AddSupportedFormats()
115 : {
116 0 : AddFormat(getFormatId());
117 0 : }
118 :
119 :
120 0 : sal_uInt32 OFilterItemExchange::getFormatId()
121 : {
122 : static sal_uInt32 s_nFormat = (sal_uInt32)-1;
123 0 : if ((sal_uInt32)-1 == s_nFormat)
124 : {
125 0 : s_nFormat = SotExchange::RegisterFormatName(OUString("application/x-openoffice;windows_formatname=\"form.FilterControlExchange\""));
126 : DBG_ASSERT((sal_uInt32)-1 != s_nFormat, "OFilterExchangeHelper::getFormatId: bad exchange id!");
127 : }
128 0 : return s_nFormat;
129 : }
130 :
131 :
132 0 : OLocalExchange* OFilterExchangeHelper::createExchange() const
133 : {
134 0 : return new OFilterItemExchange;
135 : }
136 :
137 :
138 0 : TYPEINIT0(FmFilterData);
139 0 : Image FmFilterData::GetImage() const
140 : {
141 0 : return Image();
142 : }
143 :
144 :
145 0 : TYPEINIT1(FmParentData, FmFilterData);
146 :
147 0 : FmParentData::~FmParentData()
148 : {
149 0 : for (::std::vector<FmFilterData*>::const_iterator i = m_aChildren.begin();
150 0 : i != m_aChildren.end(); ++i)
151 0 : delete (*i);
152 0 : }
153 :
154 :
155 0 : TYPEINIT1(FmFormItem, FmParentData);
156 :
157 0 : Image FmFormItem::GetImage() const
158 : {
159 0 : static Image aImage;
160 :
161 0 : if (!aImage)
162 : {
163 0 : ImageList aNavigatorImages( SVX_RES( RID_SVXIMGLIST_FMEXPL ) );
164 0 : aImage = aNavigatorImages.GetImage( RID_SVXIMG_FORM );
165 : }
166 0 : return aImage;
167 : }
168 :
169 :
170 0 : TYPEINIT1(FmFilterItems, FmParentData);
171 :
172 0 : FmFilterItem* FmFilterItems::Find( const ::sal_Int32 _nFilterComponentIndex ) const
173 : {
174 0 : for ( ::std::vector< FmFilterData* >::const_iterator i = m_aChildren.begin();
175 0 : i != m_aChildren.end();
176 : ++i
177 : )
178 : {
179 0 : FmFilterItem* pCondition = PTR_CAST( FmFilterItem, *i );
180 : DBG_ASSERT( pCondition, "FmFilterItems::Find: Wrong element in container!" );
181 0 : if ( _nFilterComponentIndex == pCondition->GetComponentIndex() )
182 0 : return pCondition;
183 : }
184 0 : return NULL;
185 : }
186 :
187 :
188 0 : Image FmFilterItems::GetImage() const
189 : {
190 0 : static Image aImage;
191 :
192 0 : if (!aImage)
193 : {
194 0 : ImageList aNavigatorImages( SVX_RES( RID_SVXIMGLIST_FMEXPL ) );
195 0 : aImage = aNavigatorImages.GetImage( RID_SVXIMG_FILTER );
196 : }
197 0 : return aImage;
198 : }
199 :
200 :
201 0 : TYPEINIT1(FmFilterItem, FmFilterData);
202 :
203 0 : FmFilterItem::FmFilterItem( FmFilterItems* pParent,
204 : const OUString& aFieldName,
205 : const OUString& aText,
206 : const sal_Int32 _nComponentIndex )
207 : :FmFilterData(pParent, aText)
208 : ,m_aFieldName(aFieldName)
209 0 : ,m_nComponentIndex( _nComponentIndex )
210 : {
211 0 : }
212 :
213 :
214 0 : Image FmFilterItem::GetImage() const
215 : {
216 0 : static Image aImage;
217 :
218 0 : if (!aImage)
219 : {
220 0 : ImageList aNavigatorImages( SVX_RES( RID_SVXIMGLIST_FMEXPL ) );
221 0 : aImage = aNavigatorImages.GetImage( RID_SVXIMG_FIELD );
222 : }
223 0 : return aImage;
224 : }
225 :
226 :
227 : // Hints for communicatition between model and view
228 :
229 0 : class FmFilterHint : public SfxHint
230 : {
231 : FmFilterData* m_pData;
232 :
233 : public:
234 0 : FmFilterHint(FmFilterData* pData):m_pData(pData){}
235 0 : FmFilterData* GetData() const { return m_pData; }
236 : };
237 :
238 :
239 0 : class FmFilterInsertedHint : public FmFilterHint
240 : {
241 : sal_uLong m_nPos; // Position relative to the parent of the data
242 :
243 : public:
244 0 : FmFilterInsertedHint(FmFilterData* pData, sal_uLong nRelPos)
245 : :FmFilterHint(pData)
246 0 : ,m_nPos(nRelPos){}
247 :
248 0 : sal_uLong GetPos() const { return m_nPos; }
249 : };
250 :
251 :
252 0 : class FmFilterRemovedHint : public FmFilterHint
253 : {
254 : public:
255 0 : FmFilterRemovedHint(FmFilterData* pData)
256 0 : :FmFilterHint(pData){}
257 : };
258 :
259 :
260 0 : class FmFilterTextChangedHint : public FmFilterHint
261 : {
262 : public:
263 0 : FmFilterTextChangedHint(FmFilterData* pData)
264 0 : :FmFilterHint(pData){}
265 : };
266 :
267 :
268 0 : class FilterClearingHint : public SfxHint
269 : {
270 : public:
271 0 : FilterClearingHint(){}
272 : };
273 :
274 :
275 0 : class FmFilterCurrentChangedHint : public SfxHint
276 : {
277 : public:
278 0 : FmFilterCurrentChangedHint(){}
279 : };
280 :
281 :
282 : // class FmFilterAdapter, Listener an den FilterControls
283 :
284 0 : class FmFilterAdapter : public ::cppu::WeakImplHelper1< XFilterControllerListener >
285 : {
286 : FmFilterModel* m_pModel;
287 : Reference< XIndexAccess > m_xControllers;
288 :
289 : public:
290 : FmFilterAdapter(FmFilterModel* pModel, const Reference< XIndexAccess >& xControllers);
291 :
292 : // XEventListener
293 : virtual void SAL_CALL disposing(const EventObject& Source) throw( RuntimeException, std::exception ) SAL_OVERRIDE;
294 :
295 : // XFilterControllerListener
296 : virtual void SAL_CALL predicateExpressionChanged( const FilterEvent& _Event ) throw (RuntimeException, std::exception) SAL_OVERRIDE;
297 : virtual void SAL_CALL disjunctiveTermRemoved( const FilterEvent& _Event ) throw (RuntimeException, std::exception) SAL_OVERRIDE;
298 : virtual void SAL_CALL disjunctiveTermAdded( const FilterEvent& _Event ) throw (RuntimeException, std::exception) SAL_OVERRIDE;
299 :
300 : // helpers
301 : void dispose() throw( RuntimeException );
302 :
303 : void AddOrRemoveListener( const Reference< XIndexAccess >& _rxControllers, const bool _bAdd );
304 :
305 : void setText(sal_Int32 nPos,
306 : const FmFilterItem* pFilterItem,
307 : const OUString& rText);
308 : };
309 :
310 :
311 0 : FmFilterAdapter::FmFilterAdapter(FmFilterModel* pModel, const Reference< XIndexAccess >& xControllers)
312 : :m_pModel( pModel )
313 0 : ,m_xControllers( xControllers )
314 : {
315 0 : AddOrRemoveListener( m_xControllers, true );
316 0 : }
317 :
318 :
319 0 : void FmFilterAdapter::dispose() throw( RuntimeException )
320 : {
321 0 : AddOrRemoveListener( m_xControllers, false );
322 0 : }
323 :
324 :
325 0 : void FmFilterAdapter::AddOrRemoveListener( const Reference< XIndexAccess >& _rxControllers, const bool _bAdd )
326 : {
327 0 : for (sal_Int32 i = 0, nLen = _rxControllers->getCount(); i < nLen; ++i)
328 : {
329 0 : Reference< XIndexAccess > xElement( _rxControllers->getByIndex(i), UNO_QUERY );
330 :
331 : // step down
332 0 : AddOrRemoveListener( xElement, _bAdd );
333 :
334 : // handle this particular controller
335 0 : Reference< XFilterController > xController( xElement, UNO_QUERY );
336 : OSL_ENSURE( xController.is(), "FmFilterAdapter::InsertElements: no XFilterController, cannot sync data!" );
337 0 : if ( xController.is() )
338 : {
339 0 : if ( _bAdd )
340 0 : xController->addFilterControllerListener( this );
341 : else
342 0 : xController->removeFilterControllerListener( this );
343 : }
344 0 : }
345 0 : }
346 :
347 :
348 0 : void FmFilterAdapter::setText(sal_Int32 nRowPos,
349 : const FmFilterItem* pFilterItem,
350 : const OUString& rText)
351 : {
352 0 : FmFormItem* pFormItem = PTR_CAST( FmFormItem, pFilterItem->GetParent()->GetParent() );
353 :
354 : try
355 : {
356 0 : Reference< XFilterController > xController( pFormItem->GetController(), UNO_QUERY_THROW );
357 0 : xController->setPredicateExpression( pFilterItem->GetComponentIndex(), nRowPos, rText );
358 : }
359 0 : catch( const Exception& )
360 : {
361 : DBG_UNHANDLED_EXCEPTION();
362 : }
363 0 : }
364 :
365 :
366 : // XEventListener
367 :
368 0 : void SAL_CALL FmFilterAdapter::disposing(const EventObject& /*e*/) throw( RuntimeException, std::exception )
369 : {
370 0 : }
371 :
372 :
373 : namespace
374 : {
375 0 : OUString lcl_getLabelName_nothrow( const Reference< XControl >& _rxControl )
376 : {
377 0 : OUString sLabelName;
378 : try
379 : {
380 0 : Reference< XPropertySet > xModel( _rxControl->getModel(), UNO_QUERY_THROW );
381 0 : sLabelName = getLabelName( xModel );
382 : }
383 0 : catch( const Exception& )
384 : {
385 : DBG_UNHANDLED_EXCEPTION();
386 : }
387 0 : return sLabelName;
388 : }
389 :
390 0 : Reference< XPropertySet > lcl_getBoundField_nothrow( const Reference< XControl >& _rxControl )
391 : {
392 0 : Reference< XPropertySet > xField;
393 : try
394 : {
395 0 : Reference< XPropertySet > xModelProps( _rxControl->getModel(), UNO_QUERY_THROW );
396 0 : xField.set( xModelProps->getPropertyValue( FM_PROP_BOUNDFIELD ), UNO_QUERY_THROW );
397 : }
398 0 : catch( const Exception& )
399 : {
400 : DBG_UNHANDLED_EXCEPTION();
401 : }
402 0 : return xField;
403 : }
404 : }
405 :
406 : // XFilterControllerListener
407 :
408 0 : void FmFilterAdapter::predicateExpressionChanged( const FilterEvent& _Event ) throw( RuntimeException, std::exception )
409 : {
410 0 : SolarMutexGuard aGuard;
411 :
412 0 : if ( !m_pModel )
413 0 : return;
414 :
415 : // the controller which sent the event
416 0 : Reference< XFormController > xController( _Event.Source, UNO_QUERY_THROW );
417 0 : Reference< XFilterController > xFilterController( _Event.Source, UNO_QUERY_THROW );
418 0 : Reference< XForm > xForm( xController->getModel(), UNO_QUERY_THROW );
419 :
420 0 : FmFormItem* pFormItem = m_pModel->Find( m_pModel->m_aChildren, xForm );
421 : OSL_ENSURE( pFormItem, "FmFilterAdapter::predicateExpressionChanged: don't know this form!" );
422 0 : if ( !pFormItem )
423 0 : return;
424 :
425 0 : const sal_Int32 nActiveTerm( xFilterController->getActiveTerm() );
426 :
427 0 : FmFilterItems* pFilter = PTR_CAST( FmFilterItems, pFormItem->GetChildren()[ nActiveTerm ] );
428 0 : FmFilterItem* pFilterItem = pFilter->Find( _Event.FilterComponent );
429 0 : if ( pFilterItem )
430 : {
431 0 : if ( !_Event.PredicateExpression.isEmpty())
432 : {
433 0 : pFilterItem->SetText( _Event.PredicateExpression );
434 : // UI benachrichtigen
435 0 : FmFilterTextChangedHint aChangeHint(pFilterItem);
436 0 : m_pModel->Broadcast( aChangeHint );
437 : }
438 : else
439 : {
440 : // no text anymore so remove the condition
441 0 : m_pModel->Remove(pFilterItem);
442 : }
443 : }
444 : else
445 : {
446 : // searching the component by field name
447 0 : OUString aFieldName( lcl_getLabelName_nothrow( xFilterController->getFilterComponent( _Event.FilterComponent ) ) );
448 :
449 0 : pFilterItem = new FmFilterItem( pFilter, aFieldName, _Event.PredicateExpression, _Event.FilterComponent );
450 0 : m_pModel->Insert(pFilter->GetChildren().end(), pFilterItem);
451 : }
452 :
453 : // ensure there's one empty term in the filter, just in case the active term was previously empty
454 0 : m_pModel->EnsureEmptyFilterRows( *pFormItem );
455 : }
456 :
457 :
458 0 : void SAL_CALL FmFilterAdapter::disjunctiveTermRemoved( const FilterEvent& _Event ) throw (RuntimeException, std::exception)
459 : {
460 0 : SolarMutexGuard aGuard;
461 :
462 0 : Reference< XFormController > xController( _Event.Source, UNO_QUERY_THROW );
463 0 : Reference< XFilterController > xFilterController( _Event.Source, UNO_QUERY_THROW );
464 0 : Reference< XForm > xForm( xController->getModel(), UNO_QUERY_THROW );
465 :
466 0 : FmFormItem* pFormItem = m_pModel->Find( m_pModel->m_aChildren, xForm );
467 : OSL_ENSURE( pFormItem, "FmFilterAdapter::disjunctiveTermRemoved: don't know this form!" );
468 0 : if ( !pFormItem )
469 0 : return;
470 :
471 0 : ::std::vector< FmFilterData* >& rTermItems = pFormItem->GetChildren();
472 0 : const bool bValidIndex = ( _Event.DisjunctiveTerm >= 0 ) && ( (size_t)_Event.DisjunctiveTerm < rTermItems.size() );
473 : OSL_ENSURE( bValidIndex, "FmFilterAdapter::disjunctiveTermRemoved: invalid term index!" );
474 0 : if ( !bValidIndex )
475 0 : return;
476 :
477 : // if the first term was removed, then the to-be first term needs its text updated
478 0 : if ( _Event.DisjunctiveTerm == 0 )
479 : {
480 0 : rTermItems[1]->SetText( SVX_RESSTR(RID_STR_FILTER_FILTER_FOR));
481 0 : FmFilterTextChangedHint aChangeHint( rTermItems[1] );
482 0 : m_pModel->Broadcast( aChangeHint );
483 : }
484 :
485 : // finally remove the entry from the model
486 0 : m_pModel->Remove( rTermItems.begin() + _Event.DisjunctiveTerm );
487 :
488 : // ensure there's one empty term in the filter, just in case the currently removed one was the last empty one
489 0 : m_pModel->EnsureEmptyFilterRows( *pFormItem );
490 : }
491 :
492 :
493 0 : void SAL_CALL FmFilterAdapter::disjunctiveTermAdded( const FilterEvent& _Event ) throw (RuntimeException, std::exception)
494 : {
495 0 : SolarMutexGuard aGuard;
496 :
497 0 : Reference< XFormController > xController( _Event.Source, UNO_QUERY_THROW );
498 0 : Reference< XFilterController > xFilterController( _Event.Source, UNO_QUERY_THROW );
499 0 : Reference< XForm > xForm( xController->getModel(), UNO_QUERY_THROW );
500 :
501 0 : FmFormItem* pFormItem = m_pModel->Find( m_pModel->m_aChildren, xForm );
502 : OSL_ENSURE( pFormItem, "FmFilterAdapter::disjunctiveTermAdded: don't know this form!" );
503 0 : if ( !pFormItem )
504 0 : return;
505 :
506 0 : const sal_Int32 nInsertPos = _Event.DisjunctiveTerm;
507 0 : bool bValidIndex = ( nInsertPos >= 0 ) && ( (size_t)nInsertPos <= pFormItem->GetChildren().size() );
508 0 : if ( !bValidIndex )
509 : {
510 : OSL_FAIL( "FmFilterAdapter::disjunctiveTermAdded: invalid index!" );
511 0 : return;
512 : }
513 :
514 0 : const ::std::vector< FmFilterData* >::iterator insertPos = pFormItem->GetChildren().begin() + nInsertPos;
515 :
516 0 : FmFilterItems* pFilterItems = new FmFilterItems(pFormItem, SVX_RESSTR(RID_STR_FILTER_FILTER_OR));
517 0 : m_pModel->Insert( insertPos, pFilterItems );
518 : }
519 :
520 0 : TYPEINIT1(FmFilterModel, FmParentData);
521 :
522 0 : FmFilterModel::FmFilterModel()
523 : :FmParentData(NULL, OUString())
524 : ,OSQLParserClient(comphelper::getProcessComponentContext())
525 : ,m_pAdapter(NULL)
526 0 : ,m_pCurrentItems(NULL)
527 : {
528 0 : }
529 :
530 :
531 0 : FmFilterModel::~FmFilterModel()
532 : {
533 0 : Clear();
534 0 : }
535 :
536 :
537 0 : void FmFilterModel::Clear()
538 : {
539 : // notify
540 0 : FilterClearingHint aClearedHint;
541 0 : Broadcast( aClearedHint );
542 :
543 : // lose endings
544 0 : if (m_pAdapter)
545 : {
546 0 : m_pAdapter->dispose();
547 0 : m_pAdapter->release();
548 0 : m_pAdapter= NULL;
549 : }
550 :
551 0 : m_pCurrentItems = NULL;
552 0 : m_xController = NULL;
553 0 : m_xControllers = NULL;
554 :
555 0 : for (::std::vector<FmFilterData*>::const_iterator i = m_aChildren.begin();
556 0 : i != m_aChildren.end(); ++i)
557 0 : delete (*i);
558 :
559 0 : m_aChildren.clear();
560 0 : }
561 :
562 :
563 0 : void FmFilterModel::Update(const Reference< XIndexAccess > & xControllers, const Reference< XFormController > & xCurrent)
564 : {
565 0 : if ( xCurrent == m_xController )
566 0 : return;
567 :
568 0 : if (!xControllers.is())
569 : {
570 0 : Clear();
571 0 : return;
572 : }
573 :
574 : // there is only a new current controller
575 0 : if ( m_xControllers != xControllers )
576 : {
577 0 : Clear();
578 :
579 0 : m_xControllers = xControllers;
580 0 : Update(m_xControllers, this);
581 :
582 : DBG_ASSERT(xCurrent.is(), "FmFilterModel::Update(...) no current controller");
583 :
584 : // Listening for TextChanges
585 0 : m_pAdapter = new FmFilterAdapter(this, xControllers);
586 0 : m_pAdapter->acquire();
587 :
588 0 : SetCurrentController(xCurrent);
589 0 : EnsureEmptyFilterRows( *this );
590 : }
591 : else
592 0 : SetCurrentController(xCurrent);
593 : }
594 :
595 :
596 0 : void FmFilterModel::Update(const Reference< XIndexAccess > & xControllers, FmParentData* pParent)
597 : {
598 : try
599 : {
600 0 : sal_Int32 nCount = xControllers->getCount();
601 0 : for ( sal_Int32 i = 0; i < nCount; ++i )
602 : {
603 0 : Reference< XFormController > xController( xControllers->getByIndex(i), UNO_QUERY_THROW );
604 :
605 0 : Reference< XPropertySet > xFormProperties( xController->getModel(), UNO_QUERY_THROW );
606 0 : OUString aName;
607 0 : OSL_VERIFY( xFormProperties->getPropertyValue( FM_PROP_NAME ) >>= aName );
608 :
609 : // Insert a new item for the form
610 0 : FmFormItem* pFormItem = new FmFormItem( pParent, xController, aName );
611 0 : Insert( pParent->GetChildren().end(), pFormItem );
612 :
613 0 : Reference< XFilterController > xFilterController( pFormItem->GetFilterController(), UNO_SET_THROW );
614 :
615 : // insert the existing filters for the form
616 0 : OUString aTitle(SVX_RESSTR(RID_STR_FILTER_FILTER_FOR));
617 :
618 0 : Sequence< Sequence< OUString > > aExpressions = xFilterController->getPredicateExpressions();
619 0 : for ( const Sequence< OUString >* pConjunctionTerm = aExpressions.getConstArray();
620 0 : pConjunctionTerm != aExpressions.getConstArray() + aExpressions.getLength();
621 : ++pConjunctionTerm
622 : )
623 : {
624 : // we always display one row, even if there's no term to be displayed
625 0 : FmFilterItems* pFilterItems = new FmFilterItems( pFormItem, aTitle );
626 0 : Insert( pFormItem->GetChildren().end(), pFilterItems );
627 :
628 0 : const Sequence< OUString >& rDisjunction( *pConjunctionTerm );
629 0 : for ( const OUString* pDisjunctiveTerm = rDisjunction.getConstArray();
630 0 : pDisjunctiveTerm != rDisjunction.getConstArray() + rDisjunction.getLength();
631 : ++pDisjunctiveTerm
632 : )
633 : {
634 0 : if ( pDisjunctiveTerm->isEmpty() )
635 : // no condition for this particular component in this particular conjunction term
636 0 : continue;
637 :
638 0 : const sal_Int32 nComponentIndex = pDisjunctiveTerm - rDisjunction.getConstArray();
639 :
640 : // determine the display name of the control
641 0 : const Reference< XControl > xFilterControl( xFilterController->getFilterComponent( nComponentIndex ) );
642 0 : const OUString sDisplayName( lcl_getLabelName_nothrow( xFilterControl ) );
643 :
644 : // insert a new entry
645 0 : FmFilterItem* pANDCondition = new FmFilterItem( pFilterItems, sDisplayName, *pDisjunctiveTerm, nComponentIndex );
646 0 : Insert( pFilterItems->GetChildren().end(), pANDCondition );
647 0 : }
648 :
649 : // title for the next conditions
650 0 : aTitle = SVX_RESSTR( RID_STR_FILTER_FILTER_OR );
651 : }
652 :
653 : // now add dependent controllers
654 0 : Update( xController, pFormItem );
655 0 : }
656 : }
657 0 : catch( const Exception& )
658 : {
659 : DBG_UNHANDLED_EXCEPTION();
660 : }
661 0 : }
662 :
663 :
664 0 : FmFormItem* FmFilterModel::Find(const ::std::vector<FmFilterData*>& rItems, const Reference< XFormController > & xController) const
665 : {
666 0 : for (::std::vector<FmFilterData*>::const_iterator i = rItems.begin();
667 0 : i != rItems.end(); ++i)
668 : {
669 0 : FmFormItem* pForm = PTR_CAST(FmFormItem,*i);
670 0 : if (pForm)
671 : {
672 0 : if ( xController == pForm->GetController() )
673 0 : return pForm;
674 : else
675 : {
676 0 : pForm = Find(pForm->GetChildren(), xController);
677 0 : if (pForm)
678 0 : return pForm;
679 : }
680 : }
681 : }
682 0 : return NULL;
683 : }
684 :
685 :
686 0 : FmFormItem* FmFilterModel::Find(const ::std::vector<FmFilterData*>& rItems, const Reference< XForm >& xForm) const
687 : {
688 0 : for (::std::vector<FmFilterData*>::const_iterator i = rItems.begin();
689 0 : i != rItems.end(); ++i)
690 : {
691 0 : FmFormItem* pForm = PTR_CAST(FmFormItem,*i);
692 0 : if (pForm)
693 : {
694 0 : if (xForm == pForm->GetController()->getModel())
695 0 : return pForm;
696 : else
697 : {
698 0 : pForm = Find(pForm->GetChildren(), xForm);
699 0 : if (pForm)
700 0 : return pForm;
701 : }
702 : }
703 : }
704 0 : return NULL;
705 : }
706 :
707 :
708 0 : void FmFilterModel::SetCurrentController(const Reference< XFormController > & xCurrent)
709 : {
710 0 : if ( xCurrent == m_xController )
711 0 : return;
712 :
713 0 : m_xController = xCurrent;
714 :
715 0 : FmFormItem* pItem = Find( m_aChildren, xCurrent );
716 0 : if ( !pItem )
717 0 : return;
718 :
719 : try
720 : {
721 0 : Reference< XFilterController > xFilterController( m_xController, UNO_QUERY_THROW );
722 0 : const sal_Int32 nActiveTerm( xFilterController->getActiveTerm() );
723 0 : if ( pItem->GetChildren().size() > (size_t)nActiveTerm )
724 : {
725 0 : SetCurrentItems( static_cast< FmFilterItems* >( pItem->GetChildren()[ nActiveTerm ] ) );
726 0 : }
727 : }
728 0 : catch( const Exception& )
729 : {
730 : DBG_UNHANDLED_EXCEPTION();
731 : }
732 : }
733 :
734 :
735 0 : void FmFilterModel::AppendFilterItems( FmFormItem& _rFormItem )
736 : {
737 : // insert the condition behind the last filter items
738 0 : ::std::vector<FmFilterData*>::reverse_iterator iter;
739 0 : for ( iter = _rFormItem.GetChildren().rbegin();
740 0 : iter != _rFormItem.GetChildren().rend();
741 : ++iter
742 : )
743 : {
744 0 : if ((*iter)->ISA(FmFilterItems))
745 0 : break;
746 : }
747 :
748 0 : sal_Int32 nInsertPos = iter.base() - _rFormItem.GetChildren().begin();
749 : // delegate this to the FilterController, it will notify us, which will let us update our model
750 : try
751 : {
752 0 : Reference< XFilterController > xFilterController( _rFormItem.GetFilterController(), UNO_SET_THROW );
753 0 : if ( nInsertPos >= xFilterController->getDisjunctiveTerms() )
754 0 : xFilterController->appendEmptyDisjunctiveTerm();
755 : }
756 0 : catch( const Exception& )
757 : {
758 : DBG_UNHANDLED_EXCEPTION();
759 : }
760 0 : }
761 :
762 :
763 0 : void FmFilterModel::Insert(const ::std::vector<FmFilterData*>::iterator& rPos, FmFilterData* pData)
764 : {
765 0 : ::std::vector<FmFilterData*>& rItems = pData->GetParent()->GetChildren();
766 0 : sal_uLong nPos = rPos == rItems.end() ? CONTAINER_APPEND : rPos - rItems.begin();
767 0 : if (nPos == CONTAINER_APPEND)
768 : {
769 0 : rItems.push_back(pData);
770 0 : nPos = rItems.size() - 1;
771 : }
772 : else
773 : {
774 0 : rItems.insert(rPos, pData);
775 : }
776 :
777 : // UI benachrichtigen
778 0 : FmFilterInsertedHint aInsertedHint(pData, nPos);
779 0 : Broadcast( aInsertedHint );
780 0 : }
781 :
782 :
783 0 : void FmFilterModel::Remove(FmFilterData* pData)
784 : {
785 0 : FmParentData* pParent = pData->GetParent();
786 0 : ::std::vector<FmFilterData*>& rItems = pParent->GetChildren();
787 :
788 : // erase the item from the model
789 0 : ::std::vector<FmFilterData*>::iterator i = ::std::find(rItems.begin(), rItems.end(), pData);
790 : DBG_ASSERT(i != rItems.end(), "FmFilterModel::Remove(): unknown Item");
791 : // position within the parent
792 0 : sal_Int32 nPos = i - rItems.begin();
793 0 : if (pData->ISA(FmFilterItems))
794 : {
795 0 : FmFormItem* pFormItem = static_cast<FmFormItem*>(pParent);
796 :
797 : try
798 : {
799 0 : Reference< XFilterController > xFilterController( pFormItem->GetFilterController(), UNO_SET_THROW );
800 :
801 0 : bool bEmptyLastTerm = ( ( nPos == 0 ) && xFilterController->getDisjunctiveTerms() == 1 );
802 0 : if ( bEmptyLastTerm )
803 : {
804 : // remove all children (by setting an empty predicate expression)
805 0 : ::std::vector< FmFilterData* >& rChildren = static_cast<FmFilterItems*>(pData)->GetChildren();
806 0 : while ( !rChildren.empty() )
807 : {
808 0 : ::std::vector< FmFilterData* >::iterator removePos = rChildren.end() - 1;
809 0 : FmFilterItem* pFilterItem = PTR_CAST( FmFilterItem, *removePos );
810 0 : m_pAdapter->setText( nPos, pFilterItem, OUString() );
811 0 : Remove( removePos );
812 : }
813 : }
814 : else
815 : {
816 0 : xFilterController->removeDisjunctiveTerm( nPos );
817 0 : }
818 : }
819 0 : catch( const Exception& )
820 : {
821 : DBG_UNHANDLED_EXCEPTION();
822 : }
823 : }
824 : else // FormItems can not be deleted
825 : {
826 0 : FmFilterItem* pFilterItem = PTR_CAST(FmFilterItem, pData);
827 :
828 : // if its the last condition remove the parent
829 0 : if (rItems.size() == 1)
830 0 : Remove(pFilterItem->GetParent());
831 : else
832 : {
833 : // find the position of the father within his father
834 0 : ::std::vector<FmFilterData*>& rParentParentItems = pData->GetParent()->GetParent()->GetChildren();
835 0 : ::std::vector<FmFilterData*>::iterator j = ::std::find(rParentParentItems.begin(), rParentParentItems.end(), pFilterItem->GetParent());
836 : DBG_ASSERT(j != rParentParentItems.end(), "FmFilterModel::Remove(): unknown Item");
837 0 : sal_Int32 nParentPos = j - rParentParentItems.begin();
838 :
839 : // EmptyText removes the filter
840 0 : m_pAdapter->setText(nParentPos, pFilterItem, OUString());
841 0 : Remove( i );
842 : }
843 : }
844 0 : }
845 :
846 :
847 0 : void FmFilterModel::Remove( const ::std::vector<FmFilterData*>::iterator& rPos )
848 : {
849 : // remove from parent's child list
850 0 : FmFilterData* pData = *rPos;
851 0 : pData->GetParent()->GetChildren().erase( rPos );
852 :
853 : // notify the view, this will remove the actual SvTreeListEntry
854 0 : FmFilterRemovedHint aRemoveHint( pData );
855 0 : Broadcast( aRemoveHint );
856 :
857 0 : delete pData;
858 0 : }
859 :
860 :
861 0 : bool FmFilterModel::ValidateText(FmFilterItem* pItem, OUString& rText, OUString& rErrorMsg) const
862 : {
863 0 : FmFormItem* pFormItem = PTR_CAST( FmFormItem, pItem->GetParent()->GetParent() );
864 : try
865 : {
866 0 : Reference< XFormController > xFormController( pFormItem->GetController() );
867 : // obtain the connection of the form belonging to the controller
868 0 : OStaticDataAccessTools aStaticTools;
869 0 : Reference< XRowSet > xRowSet( xFormController->getModel(), UNO_QUERY_THROW );
870 0 : Reference< XConnection > xConnection( aStaticTools.getRowSetConnection( xRowSet ) );
871 :
872 : // obtain a number formatter for this connection
873 : // TODO: shouldn't this be cached?
874 0 : Reference< XNumberFormatsSupplier > xFormatSupplier = aStaticTools.getNumberFormats( xConnection, true );
875 0 : Reference< XNumberFormatter > xFormatter( NumberFormatter::create( comphelper::getProcessComponentContext() ), UNO_QUERY_THROW );
876 0 : xFormatter->attachNumberFormatsSupplier( xFormatSupplier );
877 :
878 : // get the field (database column) which the item is responsible for
879 0 : Reference< XFilterController > xFilterController( xFormController, UNO_QUERY_THROW );
880 0 : Reference< XPropertySet > xField( lcl_getBoundField_nothrow( xFilterController->getFilterComponent( pItem->GetComponentIndex() ) ), UNO_SET_THROW );
881 :
882 : // parse the given text as filter predicate
883 0 : OUString aErr, aTxt( rText );
884 0 : ::rtl::Reference< ISQLParseNode > xParseNode = predicateTree( aErr, aTxt, xFormatter, xField );
885 0 : rErrorMsg = aErr;
886 0 : rText = aTxt;
887 0 : if ( xParseNode.is() )
888 : {
889 0 : OUString aPreparedText;
890 0 : Locale aAppLocale = Application::GetSettings().GetUILanguageTag().getLocale();
891 0 : xParseNode->parseNodeToPredicateStr(
892 0 : aPreparedText, xConnection, xFormatter, xField, OUString(), aAppLocale, '.', getParseContext() );
893 0 : rText = aPreparedText;
894 0 : return true;
895 0 : }
896 : }
897 0 : catch( const Exception& )
898 : {
899 : DBG_UNHANDLED_EXCEPTION();
900 : }
901 :
902 0 : return false;
903 : }
904 :
905 :
906 0 : void FmFilterModel::Append(FmFilterItems* pItems, FmFilterItem* pFilterItem)
907 : {
908 0 : Insert(pItems->GetChildren().end(), pFilterItem);
909 0 : }
910 :
911 :
912 0 : void FmFilterModel::SetTextForItem(FmFilterItem* pItem, const OUString& rText)
913 : {
914 0 : ::std::vector<FmFilterData*>& rItems = pItem->GetParent()->GetParent()->GetChildren();
915 0 : ::std::vector<FmFilterData*>::iterator i = ::std::find(rItems.begin(), rItems.end(), pItem->GetParent());
916 0 : sal_Int32 nParentPos = i - rItems.begin();
917 :
918 0 : m_pAdapter->setText(nParentPos, pItem, rText);
919 :
920 0 : if (rText.isEmpty())
921 0 : Remove(pItem);
922 : else
923 : {
924 : // Change the text
925 0 : pItem->SetText(rText);
926 0 : FmFilterTextChangedHint aChangeHint(pItem);
927 0 : Broadcast( aChangeHint );
928 : }
929 0 : }
930 :
931 :
932 0 : void FmFilterModel::SetCurrentItems(FmFilterItems* pCurrent)
933 : {
934 0 : if (m_pCurrentItems == pCurrent)
935 0 : return;
936 :
937 : // search for the condition
938 0 : if (pCurrent)
939 : {
940 0 : FmFormItem* pFormItem = static_cast<FmFormItem*>(pCurrent->GetParent());
941 0 : ::std::vector<FmFilterData*>& rItems = pFormItem->GetChildren();
942 0 : ::std::vector<FmFilterData*>::const_iterator i = ::std::find(rItems.begin(), rItems.end(), pCurrent);
943 :
944 0 : if (i != rItems.end())
945 : {
946 : // determine the filter position
947 0 : sal_Int32 nPos = i - rItems.begin();
948 : try
949 : {
950 0 : Reference< XFilterController > xFilterController( pFormItem->GetFilterController(), UNO_SET_THROW );
951 0 : xFilterController->setActiveTerm( nPos );
952 : }
953 0 : catch( const Exception& )
954 : {
955 : DBG_UNHANDLED_EXCEPTION();
956 : }
957 :
958 0 : if ( m_xController != pFormItem->GetController() )
959 : // calls SetCurrentItems again
960 0 : SetCurrentController( pFormItem->GetController() );
961 : else
962 0 : m_pCurrentItems = pCurrent;
963 : }
964 : else
965 0 : m_pCurrentItems = NULL;
966 : }
967 : else
968 0 : m_pCurrentItems = NULL;
969 :
970 :
971 : // UI benachrichtigen
972 0 : FmFilterCurrentChangedHint aHint;
973 0 : Broadcast( aHint );
974 : }
975 :
976 :
977 0 : void FmFilterModel::EnsureEmptyFilterRows( FmParentData& _rItem )
978 : {
979 : // checks whether for each form there's one free level for input
980 0 : ::std::vector< FmFilterData* >& rChildren = _rItem.GetChildren();
981 0 : bool bAppendLevel = _rItem.ISA( FmFormItem );
982 :
983 0 : for ( ::std::vector<FmFilterData*>::iterator i = rChildren.begin();
984 0 : i != rChildren.end();
985 : ++i
986 : )
987 : {
988 0 : FmFilterItems* pItems = PTR_CAST(FmFilterItems, *i);
989 0 : if ( pItems && pItems->GetChildren().empty() )
990 : {
991 0 : bAppendLevel = false;
992 0 : break;
993 : }
994 :
995 0 : FmFormItem* pFormItem = PTR_CAST(FmFormItem, *i);
996 0 : if (pFormItem)
997 : {
998 0 : EnsureEmptyFilterRows( *pFormItem );
999 0 : continue;
1000 : }
1001 : }
1002 :
1003 0 : if ( bAppendLevel )
1004 : {
1005 0 : FmFormItem* pFormItem = PTR_CAST( FmFormItem, &_rItem );
1006 : OSL_ENSURE( pFormItem, "FmFilterModel::EnsureEmptyFilterRows: no FmFormItem, but a FmFilterItems child?" );
1007 0 : if ( pFormItem )
1008 0 : AppendFilterItems( *pFormItem );
1009 : }
1010 0 : }
1011 :
1012 0 : class FmFilterItemsString : public SvLBoxString
1013 : {
1014 : public:
1015 0 : FmFilterItemsString( SvTreeListEntry* pEntry, sal_uInt16 nFlags, const OUString& rStr )
1016 0 : :SvLBoxString(pEntry,nFlags,rStr){}
1017 :
1018 : virtual void Paint(const Point& rPos, SvTreeListBox& rDev, const SvViewDataEntry* pView, const SvTreeListEntry* pEntry) SAL_OVERRIDE;
1019 : virtual void InitViewData( SvTreeListBox* pView,SvTreeListEntry* pEntry, SvViewDataItem* pViewData) SAL_OVERRIDE;
1020 : };
1021 :
1022 : const int nxDBmp = 12;
1023 :
1024 0 : void FmFilterItemsString::Paint(
1025 : const Point& rPos, SvTreeListBox& rDev, const SvViewDataEntry* /*pView*/, const SvTreeListEntry* pEntry)
1026 : {
1027 0 : FmFilterItems* pRow = (FmFilterItems*)pEntry->GetUserData();
1028 0 : FmFormItem* pForm = static_cast<FmFormItem*>(pRow->GetParent());
1029 :
1030 : // current filter is significant painted
1031 0 : const bool bIsCurrentFilter = pForm->GetChildren()[ pForm->GetFilterController()->getActiveTerm() ] == pRow;
1032 0 : if ( bIsCurrentFilter )
1033 : {
1034 0 : rDev.Push( PushFlags::LINECOLOR );
1035 :
1036 0 : rDev.SetLineColor( rDev.GetTextColor() );
1037 :
1038 0 : Rectangle aRect( rPos, GetSize( &rDev, pEntry ) );
1039 0 : Point aFirst( rPos.X(), aRect.Bottom() - 6 );
1040 0 : Point aSecond(aFirst .X() + 2, aFirst.Y() + 3 );
1041 :
1042 0 : rDev.DrawLine( aFirst, aSecond );
1043 :
1044 0 : aFirst = aSecond;
1045 0 : aFirst.X() += 1;
1046 0 : aSecond.X() += 6;
1047 0 : aSecond.Y() -= 5;
1048 :
1049 0 : rDev.DrawLine( aFirst, aSecond );
1050 :
1051 0 : rDev.Pop();
1052 : }
1053 :
1054 0 : rDev.DrawText( Point(rPos.X() + nxDBmp, rPos.Y()), GetText() );
1055 0 : }
1056 :
1057 :
1058 0 : void FmFilterItemsString::InitViewData( SvTreeListBox* pView,SvTreeListEntry* pEntry, SvViewDataItem* pViewData)
1059 : {
1060 0 : if( !pViewData )
1061 0 : pViewData = pView->GetViewDataItem( pEntry, this );
1062 :
1063 0 : Size aSize(pView->GetTextWidth(GetText()), pView->GetTextHeight());
1064 0 : aSize.Width() += nxDBmp;
1065 0 : pViewData->maSize = aSize;
1066 0 : }
1067 :
1068 0 : class FmFilterString : public SvLBoxString
1069 : {
1070 : OUString m_aName;
1071 :
1072 : public:
1073 0 : FmFilterString( SvTreeListEntry* pEntry, sal_uInt16 nFlags, const OUString& rStr, const OUString& aName)
1074 : :SvLBoxString(pEntry,nFlags,rStr)
1075 0 : ,m_aName(aName)
1076 : {
1077 0 : m_aName += ": ";
1078 0 : }
1079 :
1080 : virtual void Paint(const Point& rPos, SvTreeListBox& rDev, const SvViewDataEntry* pView, const SvTreeListEntry* pEntry) SAL_OVERRIDE;
1081 : virtual void InitViewData( SvTreeListBox* pView,SvTreeListEntry* pEntry, SvViewDataItem* pViewData) SAL_OVERRIDE;
1082 : };
1083 :
1084 : const int nxD = 4;
1085 :
1086 :
1087 0 : void FmFilterString::InitViewData( SvTreeListBox* pView,SvTreeListEntry* pEntry, SvViewDataItem* pViewData)
1088 : {
1089 0 : if( !pViewData )
1090 0 : pViewData = pView->GetViewDataItem( pEntry, this );
1091 :
1092 0 : vcl::Font aOldFont( pView->GetFont());
1093 0 : vcl::Font aFont( aOldFont );
1094 0 : aFont.SetWeight(WEIGHT_BOLD);
1095 0 : pView->Control::SetFont( aFont );
1096 :
1097 0 : Size aSize(pView->GetTextWidth(m_aName), pView->GetTextHeight());
1098 0 : pView->Control::SetFont( aOldFont );
1099 0 : aSize.Width() += pView->GetTextWidth(GetText()) + nxD;
1100 0 : pViewData->maSize = aSize;
1101 0 : }
1102 :
1103 :
1104 0 : void FmFilterString::Paint(
1105 : const Point& rPos, SvTreeListBox& rDev, const SvViewDataEntry* /*pView*/, const SvTreeListEntry* /*pEntry*/)
1106 : {
1107 0 : vcl::Font aOldFont( rDev.GetFont());
1108 0 : vcl::Font aFont( aOldFont );
1109 0 : aFont.SetWeight(WEIGHT_BOLD);
1110 0 : rDev.SetFont( aFont );
1111 :
1112 0 : Point aPos(rPos);
1113 0 : rDev.DrawText( aPos, m_aName );
1114 :
1115 : // position for the second text
1116 0 : aPos.X() += rDev.GetTextWidth(m_aName) + nxD;
1117 0 : rDev.SetFont( aOldFont );
1118 0 : rDev.DrawText( aPos, GetText() );
1119 0 : }
1120 :
1121 0 : FmFilterNavigator::FmFilterNavigator( vcl::Window* pParent )
1122 : :SvTreeListBox( pParent, WB_HASBUTTONS|WB_HASLINES|WB_BORDER|WB_HASBUTTONSATROOT )
1123 : ,m_pModel( NULL )
1124 : ,m_pEditingCurrently( NULL )
1125 : ,m_aControlExchange( this )
1126 : ,m_aTimerCounter( 0 )
1127 0 : ,m_aDropActionType( DA_SCROLLUP )
1128 : {
1129 0 : SetHelpId( HID_FILTER_NAVIGATOR );
1130 :
1131 : {
1132 0 : ImageList aNavigatorImages( SVX_RES( RID_SVXIMGLIST_FMEXPL ) );
1133 : SetNodeBitmaps(
1134 : aNavigatorImages.GetImage( RID_SVXIMG_COLLAPSEDNODE ),
1135 : aNavigatorImages.GetImage( RID_SVXIMG_EXPANDEDNODE )
1136 0 : );
1137 : }
1138 :
1139 0 : m_pModel = new FmFilterModel();
1140 0 : StartListening( *m_pModel );
1141 :
1142 0 : EnableInplaceEditing( true );
1143 0 : SetSelectionMode(MULTIPLE_SELECTION);
1144 :
1145 0 : SetDragDropMode(0xFFFF);
1146 :
1147 0 : m_aDropActionTimer.SetTimeoutHdl(LINK(this, FmFilterNavigator, OnDropActionTimer));
1148 0 : }
1149 :
1150 :
1151 0 : FmFilterNavigator::~FmFilterNavigator()
1152 : {
1153 0 : EndListening( *m_pModel );
1154 0 : delete m_pModel;
1155 0 : }
1156 :
1157 :
1158 0 : void FmFilterNavigator::UpdateContent(const Reference< XIndexAccess > & xControllers, const Reference< XFormController > & xCurrent)
1159 : {
1160 0 : if (xCurrent == m_pModel->GetCurrentController())
1161 0 : return;
1162 :
1163 0 : m_pModel->Update(xControllers, xCurrent);
1164 :
1165 : // expand the filters for the current controller
1166 0 : SvTreeListEntry* pEntry = FindEntry(m_pModel->GetCurrentForm());
1167 0 : if (pEntry && !IsExpanded(pEntry))
1168 : {
1169 0 : SelectAll(false);
1170 :
1171 0 : if (!IsExpanded(pEntry))
1172 0 : Expand(pEntry);
1173 :
1174 0 : pEntry = FindEntry(m_pModel->GetCurrentItems());
1175 0 : if (pEntry)
1176 : {
1177 0 : if (!IsExpanded(pEntry))
1178 0 : Expand(pEntry);
1179 0 : Select(pEntry, true);
1180 : }
1181 : }
1182 : }
1183 :
1184 :
1185 0 : bool FmFilterNavigator::EditingEntry( SvTreeListEntry* pEntry, Selection& rSelection )
1186 : {
1187 0 : m_pEditingCurrently = pEntry;
1188 0 : if (!SvTreeListBox::EditingEntry( pEntry, rSelection ))
1189 0 : return false;
1190 :
1191 0 : return pEntry && ((FmFilterData*)pEntry->GetUserData())->ISA(FmFilterItem);
1192 : }
1193 :
1194 :
1195 0 : bool FmFilterNavigator::EditedEntry( SvTreeListEntry* pEntry, const OUString& rNewText )
1196 : {
1197 : DBG_ASSERT(pEntry == m_pEditingCurrently, "FmFilterNavigator::EditedEntry: suspicious entry!");
1198 0 : m_pEditingCurrently = NULL;
1199 :
1200 0 : if (EditingCanceled())
1201 0 : return true;
1202 :
1203 : DBG_ASSERT(((FmFilterData*)pEntry->GetUserData())->ISA(FmFilterItem),
1204 : "FmFilterNavigator::EditedEntry() wrong entry");
1205 :
1206 0 : OUString aText(comphelper::string::strip(rNewText, ' '));
1207 0 : if (aText.isEmpty())
1208 : {
1209 : // deleting the entry asynchron
1210 0 : PostUserEvent(LINK(this, FmFilterNavigator, OnRemove), pEntry);
1211 : }
1212 : else
1213 : {
1214 0 : OUString aErrorMsg;
1215 :
1216 0 : if (m_pModel->ValidateText((FmFilterItem*)pEntry->GetUserData(), aText, aErrorMsg))
1217 : {
1218 0 : GrabFocus();
1219 : // this will set the text at the FmFilterItem, as well as update any filter controls
1220 : // which are connected to this particular entry
1221 0 : m_pModel->SetTextForItem( static_cast< FmFilterItem* >( pEntry->GetUserData() ), aText );
1222 :
1223 0 : SetCursor( pEntry, true );
1224 0 : SetEntryText( pEntry, aText );
1225 : }
1226 : else
1227 : {
1228 : // display the error and return sal_False
1229 0 : SQLContext aError;
1230 0 : aError.Message = SVX_RESSTR(RID_STR_SYNTAXERROR);
1231 0 : aError.Details = aErrorMsg;
1232 0 : displayException(aError, this);
1233 :
1234 0 : return false;
1235 0 : }
1236 : }
1237 0 : return true;
1238 : }
1239 :
1240 :
1241 0 : IMPL_LINK( FmFilterNavigator, OnRemove, SvTreeListEntry*, pEntry )
1242 : {
1243 : // now remove the entry
1244 0 : m_pModel->Remove((FmFilterData*) pEntry->GetUserData());
1245 0 : return 0L;
1246 : }
1247 :
1248 :
1249 0 : IMPL_LINK_NOARG(FmFilterNavigator, OnDropActionTimer)
1250 : {
1251 0 : if (--m_aTimerCounter > 0)
1252 0 : return 0L;
1253 :
1254 0 : switch (m_aDropActionType)
1255 : {
1256 : case DA_SCROLLUP :
1257 0 : ScrollOutputArea(1);
1258 0 : m_aTimerCounter = DROP_ACTION_TIMER_SCROLL_TICKS;
1259 0 : break;
1260 : case DA_SCROLLDOWN :
1261 0 : ScrollOutputArea(-1);
1262 0 : m_aTimerCounter = DROP_ACTION_TIMER_SCROLL_TICKS;
1263 0 : break;
1264 : case DA_EXPANDNODE:
1265 : {
1266 0 : SvTreeListEntry* pToExpand = GetEntry(m_aTimerTriggered);
1267 0 : if (pToExpand && (GetChildCount(pToExpand) > 0) && !IsExpanded(pToExpand))
1268 : // tja, eigentlich muesste ich noch testen, ob die Node nicht schon expandiert ist, aber ich
1269 : // habe dazu weder in den Basisklassen noch im Model eine Methode gefunden ...
1270 : // aber ich denke, die BK sollte es auch so vertragen
1271 0 : Expand(pToExpand);
1272 :
1273 : // nach dem Expand habe ich im Gegensatz zum Scrollen natuerlich nix mehr zu tun
1274 0 : m_aDropActionTimer.Stop();
1275 : }
1276 0 : break;
1277 : }
1278 0 : return 0L;
1279 : }
1280 :
1281 :
1282 :
1283 0 : sal_Int8 FmFilterNavigator::AcceptDrop( const AcceptDropEvent& rEvt )
1284 : {
1285 0 : Point aDropPos = rEvt.maPosPixel;
1286 :
1287 : // kuemmern wir uns erst mal um moeglich DropActions (Scrollen und Aufklappen)
1288 0 : if (rEvt.mbLeaving)
1289 : {
1290 0 : if (m_aDropActionTimer.IsActive())
1291 0 : m_aDropActionTimer.Stop();
1292 : }
1293 : else
1294 : {
1295 0 : bool bNeedTrigger = false;
1296 : // auf dem ersten Eintrag ?
1297 0 : if ((aDropPos.Y() >= 0) && (aDropPos.Y() < GetEntryHeight()))
1298 : {
1299 0 : m_aDropActionType = DA_SCROLLUP;
1300 0 : bNeedTrigger = true;
1301 : }
1302 : else
1303 : {
1304 : // auf dem letzten (bzw. in dem Bereich, den ein Eintrag einnehmen wuerde, wenn er unten genau buendig
1305 : // abschliessen wuerde) ?
1306 0 : if ((aDropPos.Y() < GetSizePixel().Height()) && (aDropPos.Y() >= GetSizePixel().Height() - GetEntryHeight()))
1307 : {
1308 0 : m_aDropActionType = DA_SCROLLDOWN;
1309 0 : bNeedTrigger = true;
1310 : }
1311 : else
1312 : { // is it an entry with children, and not yet expanded?
1313 0 : SvTreeListEntry* pDropppedOn = GetEntry(aDropPos);
1314 0 : if (pDropppedOn && (GetChildCount(pDropppedOn) > 0) && !IsExpanded(pDropppedOn))
1315 : {
1316 : // -> aufklappen
1317 0 : m_aDropActionType = DA_EXPANDNODE;
1318 0 : bNeedTrigger = true;
1319 : }
1320 : }
1321 : }
1322 0 : if (bNeedTrigger && (m_aTimerTriggered != aDropPos))
1323 : {
1324 : // neu anfangen zu zaehlen
1325 0 : m_aTimerCounter = DROP_ACTION_TIMER_INITIAL_TICKS;
1326 : // die Pos merken, da ich auch QueryDrops bekomme, wenn sich die Maus gar nicht bewegt hat
1327 0 : m_aTimerTriggered = aDropPos;
1328 : // und den Timer los
1329 0 : if (!m_aDropActionTimer.IsActive()) // gibt es den Timer schon ?
1330 : {
1331 0 : m_aDropActionTimer.SetTimeout(DROP_ACTION_TIMER_TICK_BASE);
1332 0 : m_aDropActionTimer.Start();
1333 : }
1334 : }
1335 0 : else if (!bNeedTrigger)
1336 0 : m_aDropActionTimer.Stop();
1337 : }
1338 :
1339 :
1340 : // Hat das Object das richtige Format?
1341 0 : if (!m_aControlExchange.isDragSource())
1342 0 : return DND_ACTION_NONE;
1343 :
1344 0 : if (!OFilterItemExchange::hasFormat(GetDataFlavorExVector()))
1345 0 : return DND_ACTION_NONE;
1346 :
1347 : // do we conain the formitem?
1348 0 : if (!FindEntry(m_aControlExchange->getFormItem()))
1349 0 : return DND_ACTION_NONE;
1350 :
1351 0 : SvTreeListEntry* pDropTarget = GetEntry(aDropPos);
1352 0 : if (!pDropTarget)
1353 0 : return DND_ACTION_NONE;
1354 :
1355 0 : FmFilterData* pData = (FmFilterData*)pDropTarget->GetUserData();
1356 0 : FmFormItem* pForm = NULL;
1357 0 : if (pData->ISA(FmFilterItem))
1358 : {
1359 0 : pForm = PTR_CAST(FmFormItem,pData->GetParent()->GetParent());
1360 0 : if (pForm != m_aControlExchange->getFormItem())
1361 0 : return DND_ACTION_NONE;
1362 : }
1363 0 : else if (pData->ISA(FmFilterItems))
1364 : {
1365 0 : pForm = PTR_CAST(FmFormItem,pData->GetParent());
1366 0 : if (pForm != m_aControlExchange->getFormItem())
1367 0 : return DND_ACTION_NONE;
1368 : }
1369 : else
1370 0 : return DND_ACTION_NONE;
1371 :
1372 0 : return rEvt.mnAction;
1373 : }
1374 :
1375 : namespace
1376 : {
1377 0 : FmFilterItems* getTargetItems(SvTreeListEntry* _pTarget)
1378 : {
1379 0 : FmFilterData* pData = static_cast<FmFilterData*>(_pTarget->GetUserData());
1380 0 : FmFilterItems* pTargetItems = dynamic_cast<FmFilterItems*>(pData);
1381 0 : if (!pTargetItems)
1382 0 : pTargetItems = dynamic_cast<FmFilterItems*>(pData->GetParent());
1383 0 : return pTargetItems;
1384 : }
1385 : }
1386 :
1387 0 : sal_Int8 FmFilterNavigator::ExecuteDrop( const ExecuteDropEvent& rEvt )
1388 : {
1389 : // ware schlecht, wenn nach dem Droppen noch gescrollt wird ...
1390 0 : if (m_aDropActionTimer.IsActive())
1391 0 : m_aDropActionTimer.Stop();
1392 :
1393 : // Format-Ueberpruefung
1394 0 : if (!m_aControlExchange.isDragSource())
1395 0 : return DND_ACTION_NONE;
1396 :
1397 : // das Ziel des Drop sowie einige Daten darueber
1398 0 : Point aDropPos = rEvt.maPosPixel;
1399 0 : SvTreeListEntry* pDropTarget = GetEntry( aDropPos );
1400 0 : if (!pDropTarget)
1401 0 : return DND_ACTION_NONE;
1402 :
1403 : // search the container where to add the items
1404 0 : FmFilterItems* pTargetItems = getTargetItems(pDropTarget);
1405 0 : SelectAll(false);
1406 0 : SvTreeListEntry* pEntry = FindEntry(pTargetItems);
1407 0 : Select(pEntry, true);
1408 0 : SetCurEntry(pEntry);
1409 :
1410 0 : insertFilterItem(m_aControlExchange->getDraggedEntries(),pTargetItems,DND_ACTION_COPY == rEvt.mnAction);
1411 :
1412 0 : return sal_True;
1413 : }
1414 :
1415 :
1416 0 : void FmFilterNavigator::InitEntry(SvTreeListEntry* pEntry,
1417 : const OUString& rStr,
1418 : const Image& rImg1,
1419 : const Image& rImg2,
1420 : SvLBoxButtonKind eButtonKind)
1421 : {
1422 0 : SvTreeListBox::InitEntry( pEntry, rStr, rImg1, rImg2, eButtonKind );
1423 0 : SvLBoxString* pString = NULL;
1424 :
1425 0 : if (((FmFilterData*)pEntry->GetUserData())->ISA(FmFilterItem))
1426 0 : pString = new FmFilterString(pEntry, 0, rStr, ((FmFilterItem*)pEntry->GetUserData())->GetFieldName());
1427 0 : else if (((FmFilterData*)pEntry->GetUserData())->ISA(FmFilterItems))
1428 0 : pString = new FmFilterItemsString(pEntry, 0, rStr );
1429 :
1430 0 : if (pString)
1431 0 : pEntry->ReplaceItem( pString, 1 );
1432 0 : }
1433 :
1434 :
1435 0 : bool FmFilterNavigator::Select( SvTreeListEntry* pEntry, bool bSelect )
1436 : {
1437 0 : if (bSelect == IsSelected(pEntry)) // das passiert manchmal, ich glaube, die Basisklasse geht zu sehr auf Nummer sicher ;)
1438 0 : return true;
1439 :
1440 0 : if (SvTreeListBox::Select(pEntry, bSelect))
1441 : {
1442 0 : if (bSelect)
1443 : {
1444 0 : FmFormItem* pFormItem = NULL;
1445 0 : if (((FmFilterData*)pEntry->GetUserData())->ISA(FmFilterItem))
1446 0 : pFormItem = static_cast<FmFormItem*>(static_cast<FmFilterItem*>(pEntry->GetUserData())->GetParent()->GetParent());
1447 0 : else if (((FmFilterData*)pEntry->GetUserData())->ISA(FmFilterItems))
1448 0 : pFormItem = static_cast<FmFormItem*>(static_cast<FmFilterItem*>(pEntry->GetUserData())->GetParent()->GetParent());
1449 0 : else if (((FmFilterData*)pEntry->GetUserData())->ISA(FmFormItem))
1450 0 : pFormItem = (FmFormItem*)pEntry->GetUserData();
1451 :
1452 0 : if (pFormItem)
1453 : {
1454 : // will the controller be exchanged?
1455 0 : if (static_cast<FmFilterData*>(pEntry->GetUserData())->ISA(FmFilterItem))
1456 0 : m_pModel->SetCurrentItems(static_cast<FmFilterItems*>(static_cast<FmFilterItem*>(pEntry->GetUserData())->GetParent()));
1457 0 : else if (static_cast<FmFilterData*>(pEntry->GetUserData())->ISA(FmFilterItems))
1458 0 : m_pModel->SetCurrentItems((FmFilterItems*)pEntry->GetUserData());
1459 0 : else if (static_cast<FmFilterData*>(pEntry->GetUserData())->ISA(FmFormItem))
1460 0 : m_pModel->SetCurrentController(static_cast<FmFormItem*>(pEntry->GetUserData())->GetController());
1461 : }
1462 : }
1463 0 : return true;
1464 : }
1465 : else
1466 0 : return false;
1467 : }
1468 :
1469 0 : void FmFilterNavigator::Notify( SfxBroadcaster& /*rBC*/, const SfxHint& rHint )
1470 : {
1471 0 : if (const FmFilterInsertedHint* pInsertHint = dynamic_cast<const FmFilterInsertedHint*>(&rHint))
1472 : {
1473 0 : Insert(pInsertHint->GetData(), pInsertHint->GetPos());
1474 : }
1475 0 : else if( dynamic_cast<const FilterClearingHint*>(&rHint) )
1476 : {
1477 0 : SvTreeListBox::Clear();
1478 : }
1479 0 : else if (const FmFilterRemovedHint* pRemoveHint = dynamic_cast<const FmFilterRemovedHint*>(&rHint))
1480 : {
1481 0 : Remove(pRemoveHint->GetData());
1482 : }
1483 0 : else if (const FmFilterTextChangedHint *pChangeHint = dynamic_cast<const FmFilterTextChangedHint*>(&rHint))
1484 : {
1485 0 : SvTreeListEntry* pEntry = FindEntry(pChangeHint->GetData());
1486 0 : if (pEntry)
1487 0 : SetEntryText( pEntry, pChangeHint->GetData()->GetText());
1488 : }
1489 0 : else if( dynamic_cast<const FmFilterCurrentChangedHint*>(&rHint) )
1490 : {
1491 : // invalidate the entries
1492 0 : for (SvTreeListEntry* pEntry = First(); pEntry != NULL;
1493 0 : pEntry = Next(pEntry))
1494 0 : GetModel()->InvalidateEntry( pEntry );
1495 : }
1496 0 : }
1497 :
1498 0 : SvTreeListEntry* FmFilterNavigator::FindEntry(const FmFilterData* pItem) const
1499 : {
1500 0 : SvTreeListEntry* pEntry = NULL;
1501 0 : if (pItem)
1502 : {
1503 0 : for (pEntry = First(); pEntry != NULL; pEntry = Next( pEntry ))
1504 : {
1505 0 : FmFilterData* pEntryItem = (FmFilterData*)pEntry->GetUserData();
1506 0 : if (pEntryItem == pItem)
1507 0 : break;
1508 : }
1509 : }
1510 0 : return pEntry;
1511 : }
1512 :
1513 :
1514 0 : void FmFilterNavigator::Insert(FmFilterData* pItem, sal_uLong nPos)
1515 : {
1516 0 : const FmParentData* pParent = pItem->GetParent() ? pItem->GetParent() : GetFilterModel();
1517 :
1518 : // insert the item
1519 0 : SvTreeListEntry* pParentEntry = FindEntry( pParent );
1520 0 : InsertEntry( pItem->GetText(), pItem->GetImage(), pItem->GetImage(), pParentEntry, false, nPos, pItem );
1521 0 : if ( pParentEntry )
1522 0 : Expand( pParentEntry );
1523 0 : }
1524 :
1525 :
1526 0 : void FmFilterNavigator::Remove(FmFilterData* pItem)
1527 : {
1528 : // der Entry zu den Daten
1529 0 : SvTreeListEntry* pEntry = FindEntry(pItem);
1530 :
1531 0 : if (pEntry == m_pEditingCurrently)
1532 : // cancel editing
1533 0 : EndEditing(true);
1534 :
1535 0 : if (pEntry)
1536 0 : GetModel()->Remove( pEntry );
1537 0 : }
1538 :
1539 0 : FmFormItem* FmFilterNavigator::getSelectedFilterItems(::std::vector<FmFilterItem*>& _rItemList)
1540 : {
1541 : // be sure that the data is only used within only one form!
1542 0 : FmFormItem* pFirstItem = NULL;
1543 :
1544 0 : bool bHandled = true;
1545 0 : bool bFoundSomething = false;
1546 0 : for (SvTreeListEntry* pEntry = FirstSelected();
1547 0 : bHandled && pEntry != NULL;
1548 0 : pEntry = NextSelected(pEntry))
1549 : {
1550 0 : FmFilterItem* pFilter = PTR_CAST(FmFilterItem, (FmFilterData*)pEntry->GetUserData());
1551 0 : if (pFilter)
1552 : {
1553 0 : FmFormItem* pForm = PTR_CAST(FmFormItem,pFilter->GetParent()->GetParent());
1554 0 : if (!pForm)
1555 0 : bHandled = false;
1556 0 : else if (!pFirstItem)
1557 0 : pFirstItem = pForm;
1558 0 : else if (pFirstItem != pForm)
1559 0 : bHandled = false;
1560 :
1561 0 : if (bHandled)
1562 : {
1563 0 : _rItemList.push_back(pFilter);
1564 0 : bFoundSomething = true;
1565 : }
1566 : }
1567 : }
1568 0 : if ( !bHandled || !bFoundSomething )
1569 0 : pFirstItem = NULL;
1570 0 : return pFirstItem;
1571 : }
1572 :
1573 0 : void FmFilterNavigator::insertFilterItem(const ::std::vector<FmFilterItem*>& _rFilterList,FmFilterItems* _pTargetItems,bool _bCopy)
1574 : {
1575 0 : ::std::vector<FmFilterItem*>::const_iterator aEnd = _rFilterList.end();
1576 0 : for ( ::std::vector< FmFilterItem* >::const_iterator i = _rFilterList.begin();
1577 : i != aEnd;
1578 : ++i
1579 : )
1580 : {
1581 0 : FmFilterItem* pLookupItem( *i );
1582 0 : if ( pLookupItem->GetParent() == _pTargetItems )
1583 0 : continue;
1584 :
1585 0 : FmFilterItem* pFilterItem = _pTargetItems->Find( pLookupItem->GetComponentIndex() );
1586 0 : OUString aText = pLookupItem->GetText();
1587 0 : if ( !pFilterItem )
1588 : {
1589 0 : pFilterItem = new FmFilterItem( _pTargetItems, pLookupItem->GetFieldName(), aText, pLookupItem->GetComponentIndex() );
1590 0 : m_pModel->Append( _pTargetItems, pFilterItem );
1591 : }
1592 :
1593 0 : if ( !_bCopy )
1594 0 : m_pModel->Remove( pLookupItem );
1595 :
1596 : // now set the text for the new dragged item
1597 0 : m_pModel->SetTextForItem( pFilterItem, aText );
1598 0 : }
1599 :
1600 0 : m_pModel->EnsureEmptyFilterRows( *_pTargetItems->GetParent() );
1601 0 : }
1602 :
1603 :
1604 0 : void FmFilterNavigator::StartDrag( sal_Int8 /*_nAction*/, const Point& /*_rPosPixel*/ )
1605 : {
1606 0 : EndSelection();
1607 :
1608 : // be sure that the data is only used within a only one form!
1609 0 : m_aControlExchange.prepareDrag();
1610 :
1611 0 : ::std::vector<FmFilterItem*> aItemList;
1612 0 : if ( FmFormItem* pFirstItem = getSelectedFilterItems(aItemList) )
1613 : {
1614 0 : m_aControlExchange->setDraggedEntries(aItemList);
1615 0 : m_aControlExchange->setFormItem(pFirstItem);
1616 0 : m_aControlExchange.startDrag( DND_ACTION_COPYMOVE );
1617 0 : }
1618 0 : }
1619 :
1620 :
1621 0 : void FmFilterNavigator::Command( const CommandEvent& rEvt )
1622 : {
1623 0 : bool bHandled = false;
1624 0 : switch (rEvt.GetCommand())
1625 : {
1626 : case COMMAND_CONTEXTMENU:
1627 : {
1628 : // die Stelle, an der geklickt wurde
1629 0 : Point aWhere;
1630 0 : SvTreeListEntry* pClicked = NULL;
1631 0 : if (rEvt.IsMouseEvent())
1632 : {
1633 0 : aWhere = rEvt.GetMousePosPixel();
1634 0 : pClicked = GetEntry(aWhere);
1635 0 : if (pClicked == NULL)
1636 0 : break;
1637 :
1638 0 : if (!IsSelected(pClicked))
1639 : {
1640 0 : SelectAll(false);
1641 0 : Select(pClicked, true);
1642 0 : SetCurEntry(pClicked);
1643 : }
1644 : }
1645 : else
1646 : {
1647 0 : pClicked = GetCurEntry();
1648 0 : if (!pClicked)
1649 0 : break;
1650 0 : aWhere = GetEntryPosition( pClicked );
1651 : }
1652 :
1653 0 : ::std::vector<FmFilterData*> aSelectList;
1654 0 : for (SvTreeListEntry* pEntry = FirstSelected();
1655 : pEntry != NULL;
1656 0 : pEntry = NextSelected(pEntry))
1657 : {
1658 : // don't delete forms
1659 0 : FmFormItem* pForm = PTR_CAST(FmFormItem, (FmFilterData*)pEntry->GetUserData());
1660 0 : if (!pForm)
1661 0 : aSelectList.push_back((FmFilterData*)pEntry->GetUserData());
1662 : }
1663 0 : if (aSelectList.size() == 1)
1664 : {
1665 : // don't delete the only empty row of a form
1666 0 : FmFilterItems* pFilterItems = PTR_CAST(FmFilterItems, aSelectList[0]);
1667 0 : if (pFilterItems && pFilterItems->GetChildren().empty()
1668 0 : && pFilterItems->GetParent()->GetChildren().size() == 1)
1669 0 : aSelectList.clear();
1670 : }
1671 :
1672 0 : PopupMenu aContextMenu(SVX_RES(RID_FM_FILTER_MENU));
1673 :
1674 : // every condition could be deleted except the first one if its the only one
1675 0 : aContextMenu.EnableItem( SID_FM_DELETE, !aSelectList.empty() );
1676 :
1677 :
1678 0 : bool bEdit = PTR_CAST(FmFilterItem, (FmFilterData*)pClicked->GetUserData()) != NULL &&
1679 0 : IsSelected(pClicked) && GetSelectionCount() == 1;
1680 :
1681 : aContextMenu.EnableItem( SID_FM_FILTER_EDIT,
1682 0 : bEdit );
1683 : aContextMenu.EnableItem( SID_FM_FILTER_IS_NULL,
1684 0 : bEdit );
1685 : aContextMenu.EnableItem( SID_FM_FILTER_IS_NOT_NULL,
1686 0 : bEdit );
1687 :
1688 0 : aContextMenu.RemoveDisabledEntries(true, true);
1689 0 : sal_uInt16 nSlotId = aContextMenu.Execute( this, aWhere );
1690 0 : switch( nSlotId )
1691 : {
1692 : case SID_FM_FILTER_EDIT:
1693 : {
1694 0 : EditEntry( pClicked );
1695 0 : } break;
1696 : case SID_FM_FILTER_IS_NULL:
1697 : case SID_FM_FILTER_IS_NOT_NULL:
1698 : {
1699 0 : OUString aErrorMsg;
1700 0 : OUString aText;
1701 0 : if (nSlotId == SID_FM_FILTER_IS_NULL)
1702 0 : aText = "IS NULL";
1703 : else
1704 0 : aText = "IS NOT NULL";
1705 :
1706 0 : m_pModel->ValidateText((FmFilterItem*)pClicked->GetUserData(),
1707 0 : aText, aErrorMsg);
1708 0 : m_pModel->SetTextForItem((FmFilterItem*)pClicked->GetUserData(), aText);
1709 0 : } break;
1710 : case SID_FM_DELETE:
1711 : {
1712 0 : DeleteSelection();
1713 0 : } break;
1714 : }
1715 0 : bHandled = true;
1716 0 : } break;
1717 : }
1718 :
1719 0 : if (!bHandled)
1720 0 : SvTreeListBox::Command( rEvt );
1721 0 : }
1722 :
1723 0 : SvTreeListEntry* FmFilterNavigator::getNextEntry(SvTreeListEntry* _pStartWith)
1724 : {
1725 0 : SvTreeListEntry* pEntry = _pStartWith ? _pStartWith : LastSelected();
1726 0 : pEntry = Next(pEntry);
1727 : // we need the next filter entry
1728 0 : while( pEntry && GetChildCount( pEntry ) == 0 && pEntry != Last() )
1729 0 : pEntry = Next(pEntry);
1730 0 : return pEntry;
1731 : }
1732 :
1733 0 : SvTreeListEntry* FmFilterNavigator::getPrevEntry(SvTreeListEntry* _pStartWith)
1734 : {
1735 0 : SvTreeListEntry* pEntry = _pStartWith ? _pStartWith : FirstSelected();
1736 0 : pEntry = Prev(pEntry);
1737 : // check if the previous entry is a filter, if so get the next prev
1738 0 : if ( pEntry && GetChildCount( pEntry ) != 0 )
1739 : {
1740 0 : pEntry = Prev(pEntry);
1741 : // if the entry is still no leaf return
1742 0 : if ( pEntry && GetChildCount( pEntry ) != 0 )
1743 0 : pEntry = NULL;
1744 : }
1745 0 : return pEntry;
1746 : }
1747 :
1748 0 : void FmFilterNavigator::KeyInput(const KeyEvent& rKEvt)
1749 : {
1750 0 : const vcl::KeyCode& rKeyCode = rKEvt.GetKeyCode();
1751 :
1752 0 : switch ( rKeyCode.GetCode() )
1753 : {
1754 : case KEY_UP:
1755 : case KEY_DOWN:
1756 : {
1757 0 : if ( !rKeyCode.IsMod1() || !rKeyCode.IsMod2() || rKeyCode.IsShift() )
1758 0 : break;
1759 :
1760 0 : ::std::vector<FmFilterItem*> aItemList;
1761 0 : if ( !getSelectedFilterItems( aItemList ) )
1762 0 : break;
1763 :
1764 0 : ::std::mem_fun1_t<SvTreeListEntry*,FmFilterNavigator,SvTreeListEntry*> getter = ::std::mem_fun(&FmFilterNavigator::getNextEntry);
1765 0 : if ( rKeyCode.GetCode() == KEY_UP )
1766 0 : getter = ::std::mem_fun(&FmFilterNavigator::getPrevEntry);
1767 :
1768 0 : SvTreeListEntry* pTarget = getter( this, NULL );
1769 0 : if ( !pTarget )
1770 0 : break;
1771 :
1772 0 : FmFilterItems* pTargetItems = getTargetItems( pTarget );
1773 0 : if ( !pTargetItems )
1774 0 : break;
1775 :
1776 0 : ::std::vector<FmFilterItem*>::const_iterator aEnd = aItemList.end();
1777 0 : bool bNextTargetItem = true;
1778 0 : while ( bNextTargetItem )
1779 : {
1780 0 : ::std::vector<FmFilterItem*>::const_iterator i = aItemList.begin();
1781 0 : for (; i != aEnd; ++i)
1782 : {
1783 0 : if ( (*i)->GetParent() == pTargetItems )
1784 : {
1785 0 : pTarget = getter(this,pTarget);
1786 0 : if ( !pTarget )
1787 0 : return;
1788 0 : pTargetItems = getTargetItems( pTarget );
1789 0 : break;
1790 : }
1791 : else
1792 : {
1793 0 : FmFilterItem* pFilterItem = pTargetItems->Find( (*i)->GetComponentIndex() );
1794 : // we found the text component so jump above
1795 0 : if ( pFilterItem )
1796 : {
1797 0 : pTarget = getter( this, pTarget );
1798 0 : if ( !pTarget )
1799 0 : return;
1800 :
1801 0 : pTargetItems = getTargetItems( pTarget );
1802 0 : break;
1803 : }
1804 : }
1805 : }
1806 0 : bNextTargetItem = i != aEnd && pTargetItems;
1807 : }
1808 :
1809 0 : if ( pTargetItems )
1810 : {
1811 0 : insertFilterItem( aItemList, pTargetItems );
1812 0 : return;
1813 0 : }
1814 : }
1815 0 : break;
1816 :
1817 : case KEY_DELETE:
1818 : {
1819 0 : if ( rKeyCode.GetModifier() )
1820 0 : break;
1821 :
1822 0 : if ( !IsSelected( First() ) || GetEntryCount() > 1 )
1823 0 : DeleteSelection();
1824 0 : return;
1825 : }
1826 : }
1827 :
1828 0 : SvTreeListBox::KeyInput(rKEvt);
1829 : }
1830 :
1831 :
1832 0 : void FmFilterNavigator::DeleteSelection()
1833 : {
1834 : // to avoid the deletion of an entry twice (e.g. deletion of a parent and afterward
1835 : // the deletion of its child, i have to shrink the selecton list
1836 0 : ::std::vector<SvTreeListEntry*> aEntryList;
1837 0 : for (SvTreeListEntry* pEntry = FirstSelected();
1838 0 : pEntry != NULL;
1839 0 : pEntry = NextSelected(pEntry))
1840 : {
1841 0 : FmFilterItem* pFilterItem = PTR_CAST(FmFilterItem, (FmFilterData*)pEntry->GetUserData());
1842 0 : if (pFilterItem && IsSelected(GetParent(pEntry)))
1843 0 : continue;
1844 :
1845 0 : FmFormItem* pForm = PTR_CAST(FmFormItem, (FmFilterData*)pEntry->GetUserData());
1846 0 : if (!pForm)
1847 0 : aEntryList.push_back(pEntry);
1848 : }
1849 :
1850 : // Remove the selection
1851 0 : SelectAll(false);
1852 :
1853 0 : for (::std::vector<SvTreeListEntry*>::reverse_iterator i = aEntryList.rbegin();
1854 : // link problems with operator ==
1855 0 : i.base() != aEntryList.rend().base(); ++i)
1856 : {
1857 0 : m_pModel->Remove((FmFilterData*)(*i)->GetUserData());
1858 0 : }
1859 0 : }
1860 :
1861 0 : FmFilterNavigatorWin::FmFilterNavigatorWin( SfxBindings* _pBindings, SfxChildWindow* _pMgr,
1862 : vcl::Window* _pParent )
1863 : :SfxDockingWindow( _pBindings, _pMgr, _pParent, WinBits(WB_STDMODELESS|WB_SIZEABLE|WB_ROLLABLE|WB_3DLOOK|WB_DOCKABLE) )
1864 0 : ,SfxControllerItem( SID_FM_FILTER_NAVIGATOR_CONTROL, *_pBindings )
1865 : {
1866 0 : SetHelpId( HID_FILTER_NAVIGATOR_WIN );
1867 :
1868 0 : m_pNavigator = new FmFilterNavigator( this );
1869 0 : m_pNavigator->Show();
1870 0 : SetText( SVX_RES(RID_STR_FILTER_NAVIGATOR) );
1871 0 : SfxDockingWindow::SetFloatingSize( Size(200,200) );
1872 0 : }
1873 :
1874 :
1875 0 : FmFilterNavigatorWin::~FmFilterNavigatorWin()
1876 : {
1877 0 : delete m_pNavigator;
1878 0 : }
1879 :
1880 :
1881 0 : void FmFilterNavigatorWin::UpdateContent(FmFormShell* pFormShell)
1882 : {
1883 0 : if (!m_pNavigator)
1884 0 : return;
1885 :
1886 0 : if (!pFormShell)
1887 0 : m_pNavigator->UpdateContent( NULL, NULL );
1888 : else
1889 : {
1890 0 : Reference< XFormController > xController(pFormShell->GetImpl()->getActiveInternalController());
1891 0 : Reference< XIndexAccess > xContainer;
1892 0 : if (xController.is())
1893 : {
1894 0 : Reference< XChild > xChild(xController, UNO_QUERY);
1895 0 : for (Reference< XInterface > xParent(xChild->getParent());
1896 : xParent.is();
1897 0 : xParent = xChild.is() ? xChild->getParent() : Reference< XInterface > ())
1898 : {
1899 0 : xContainer = Reference< XIndexAccess > (xParent, UNO_QUERY);
1900 0 : xChild = Reference< XChild > (xParent, UNO_QUERY);
1901 0 : }
1902 : }
1903 0 : m_pNavigator->UpdateContent(xContainer, xController);
1904 : }
1905 : }
1906 :
1907 :
1908 0 : void FmFilterNavigatorWin::StateChanged( sal_uInt16 nSID, SfxItemState eState, const SfxPoolItem* pState )
1909 : {
1910 0 : if( !pState || SID_FM_FILTER_NAVIGATOR_CONTROL != nSID )
1911 0 : return;
1912 :
1913 0 : if( eState >= SfxItemState::DEFAULT )
1914 : {
1915 0 : FmFormShell* pShell = PTR_CAST( FmFormShell, static_cast<const SfxObjectItem*>(pState)->GetShell() );
1916 0 : UpdateContent( pShell );
1917 : }
1918 : else
1919 0 : UpdateContent( NULL );
1920 : }
1921 :
1922 :
1923 0 : bool FmFilterNavigatorWin::Close()
1924 : {
1925 0 : if ( m_pNavigator && m_pNavigator->IsEditingActive() )
1926 0 : m_pNavigator->EndEditing();
1927 :
1928 0 : if ( m_pNavigator && m_pNavigator->IsEditingActive() )
1929 : // the EndEditing was vetoed (perhaps of an syntax error or such)
1930 0 : return false;
1931 :
1932 0 : UpdateContent( NULL );
1933 0 : return SfxDockingWindow::Close();
1934 : }
1935 :
1936 :
1937 0 : void FmFilterNavigatorWin::FillInfo( SfxChildWinInfo& rInfo ) const
1938 : {
1939 0 : SfxDockingWindow::FillInfo( rInfo );
1940 0 : rInfo.bVisible = false;
1941 0 : }
1942 :
1943 :
1944 0 : Size FmFilterNavigatorWin::CalcDockingSize( SfxChildAlignment eAlign )
1945 : {
1946 0 : if ( ( eAlign == SFX_ALIGN_TOP ) || ( eAlign == SFX_ALIGN_BOTTOM ) )
1947 0 : return Size();
1948 :
1949 0 : return SfxDockingWindow::CalcDockingSize( eAlign );
1950 : }
1951 :
1952 :
1953 0 : SfxChildAlignment FmFilterNavigatorWin::CheckAlignment( SfxChildAlignment eActAlign, SfxChildAlignment eAlign )
1954 : {
1955 0 : switch (eAlign)
1956 : {
1957 : case SFX_ALIGN_LEFT:
1958 : case SFX_ALIGN_RIGHT:
1959 : case SFX_ALIGN_NOALIGNMENT:
1960 0 : return (eAlign);
1961 : default:
1962 0 : break;
1963 : }
1964 :
1965 0 : return (eActAlign);
1966 : }
1967 :
1968 :
1969 0 : void FmFilterNavigatorWin::Resize()
1970 : {
1971 0 : SfxDockingWindow::Resize();
1972 :
1973 0 : Size aLogOutputSize = PixelToLogic( GetOutputSizePixel(), MAP_APPFONT );
1974 0 : Size aLogExplSize = aLogOutputSize;
1975 0 : aLogExplSize.Width() -= 6;
1976 0 : aLogExplSize.Height() -= 6;
1977 :
1978 0 : Point aExplPos = LogicToPixel( Point(3,3), MAP_APPFONT );
1979 0 : Size aExplSize = LogicToPixel( aLogExplSize, MAP_APPFONT );
1980 :
1981 0 : m_pNavigator->SetPosSizePixel( aExplPos, aExplSize );
1982 0 : }
1983 :
1984 0 : void FmFilterNavigatorWin::GetFocus()
1985 : {
1986 : // oj #97405#
1987 0 : if ( m_pNavigator )
1988 0 : m_pNavigator->GrabFocus();
1989 0 : }
1990 :
1991 170 : SFX_IMPL_DOCKINGWINDOW( FmFilterNavigatorWinMgr, SID_FM_FILTER_NAVIGATOR )
1992 :
1993 :
1994 0 : FmFilterNavigatorWinMgr::FmFilterNavigatorWinMgr( vcl::Window *_pParent, sal_uInt16 _nId,
1995 : SfxBindings *_pBindings, SfxChildWinInfo* _pInfo )
1996 0 : :SfxChildWindow( _pParent, _nId )
1997 : {
1998 0 : pWindow = new FmFilterNavigatorWin( _pBindings, this, _pParent );
1999 0 : eChildAlignment = SFX_ALIGN_NOALIGNMENT;
2000 0 : static_cast<SfxDockingWindow*>(pWindow)->Initialize( _pInfo );
2001 0 : }
2002 :
2003 :
2004 594 : } // namespace svxform
2005 :
2006 :
2007 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
