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