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 :
21 : #include <sal/macros.h>
22 : #include "fmprop.hrc"
23 : #include "svx/fmresids.hrc"
24 : #include "svx/fmtools.hxx"
25 : #include "gridcell.hxx"
26 : #include "gridcols.hxx"
27 : #include "sdbdatacolumn.hxx"
28 :
29 : #include <com/sun/star/awt/LineEndFormat.hpp>
30 : #include <com/sun/star/awt/MouseWheelBehavior.hpp>
31 : #include <com/sun/star/awt/VisualEffect.hpp>
32 : #include <com/sun/star/container/XChild.hpp>
33 : #include <com/sun/star/container/XNamed.hpp>
34 : #include <com/sun/star/form/FormComponentType.hpp>
35 : #include <com/sun/star/form/XBoundComponent.hpp>
36 : #include <com/sun/star/script/XEventAttacherManager.hpp>
37 : #include <com/sun/star/sdb/XSQLQueryComposerFactory.hpp>
38 : #include <com/sun/star/sdbcx/XTablesSupplier.hpp>
39 : #include <com/sun/star/sdbcx/XColumnsSupplier.hpp>
40 : #include <com/sun/star/sdbc/ColumnValue.hpp>
41 : #include <com/sun/star/sdbc/DataType.hpp>
42 : #include <com/sun/star/sdbc/XStatement.hpp>
43 : #include <com/sun/star/util/NumberFormat.hpp>
44 : #include <com/sun/star/util/XNumberFormatsSupplier.hpp>
45 : #include <com/sun/star/util/Time.hpp>
46 : #include <com/sun/star/util/Date.hpp>
47 :
48 : #include <comphelper/numbers.hxx>
49 : #include <comphelper/property.hxx>
50 : #include <comphelper/servicehelper.hxx>
51 : #include <comphelper/string.hxx>
52 : #include <connectivity/formattedcolumnvalue.hxx>
53 : #include <cppuhelper/typeprovider.hxx>
54 : #include <i18nlangtag/lang.h>
55 :
56 : #include <rtl/math.hxx>
57 : #include <svtools/calendar.hxx>
58 : #include <svtools/fmtfield.hxx>
59 : #include <svl/numuno.hxx>
60 : #include <svtools/svmedit.hxx>
61 : #include <svx/dialmgr.hxx>
62 : #include <toolkit/helper/vclunohelper.hxx>
63 : #include <tools/diagnose_ex.h>
64 : #include <vcl/longcurr.hxx>
65 : #include <vcl/settings.hxx>
66 : #include <connectivity/dbtools.hxx>
67 : #include <connectivity/dbconversion.hxx>
68 :
69 : #include <math.h>
70 : #include <stdio.h>
71 :
72 : using namespace ::connectivity;
73 : using namespace ::connectivity::simple;
74 : using namespace ::svxform;
75 : using namespace ::comphelper;
76 : using namespace ::svt;
77 : using namespace ::com::sun::star;
78 : using namespace ::com::sun::star::uno;
79 : using namespace ::com::sun::star::sdbc;
80 : using namespace ::com::sun::star::sdbcx;
81 : using namespace ::com::sun::star::sdb;
82 : using namespace ::com::sun::star::beans;
83 : using namespace ::com::sun::star::form;
84 : using namespace ::dbtools::DBTypeConversion;
85 : using namespace ::dbtools;
86 :
87 : using ::com::sun::star::util::XNumberFormatter;
88 : namespace MouseWheelBehavior = ::com::sun::star::awt::MouseWheelBehavior;
89 :
90 : const char INVALIDTEXT[] = "###";
91 : const char OBJECTTEXT[] = "<OBJECT>";
92 :
93 :
94 : //= helper
95 :
96 : namespace
97 : {
98 0 : static LineEnd getModelLineEndSetting( const Reference< XPropertySet >& _rxModel )
99 : {
100 0 : LineEnd eFormat = LINEEND_LF;
101 :
102 : try
103 : {
104 0 : sal_Int16 nLineEndFormat = awt::LineEndFormat::LINE_FEED;
105 :
106 0 : Reference< XPropertySetInfo > xPSI;
107 0 : if ( _rxModel.is() )
108 0 : xPSI = _rxModel->getPropertySetInfo();
109 :
110 : OSL_ENSURE( xPSI.is(), "getModelLineEndSetting: invalid column model!" );
111 0 : if ( xPSI.is() && xPSI->hasPropertyByName( FM_PROP_LINEENDFORMAT ) )
112 : {
113 0 : OSL_VERIFY( _rxModel->getPropertyValue( FM_PROP_LINEENDFORMAT ) >>= nLineEndFormat );
114 :
115 0 : switch ( nLineEndFormat )
116 : {
117 0 : case awt::LineEndFormat::CARRIAGE_RETURN: eFormat = LINEEND_CR; break;
118 0 : case awt::LineEndFormat::LINE_FEED: eFormat = LINEEND_LF; break;
119 0 : case awt::LineEndFormat::CARRIAGE_RETURN_LINE_FEED: eFormat = LINEEND_CRLF; break;
120 : default:
121 : OSL_FAIL( "getModelLineEndSetting: what's this?" );
122 : }
123 0 : }
124 : }
125 0 : catch( const Exception& )
126 : {
127 : OSL_FAIL( "getModelLineEndSetting: caught an exception!" );
128 : DBG_UNHANDLED_EXCEPTION();
129 : }
130 0 : return eFormat;
131 : }
132 : }
133 :
134 :
135 : //= DbGridColumn
136 :
137 :
138 217 : CellControllerRef DbGridColumn::s_xEmptyController;
139 :
140 :
141 62 : void DbGridColumn::CreateControl(sal_Int32 _nFieldPos, const Reference< ::com::sun::star::beans::XPropertySet >& xField, sal_Int32 nTypeId)
142 : {
143 62 : Clear();
144 :
145 62 : m_nTypeId = (sal_Int16)nTypeId;
146 62 : if (xField != m_xField)
147 : {
148 : // Grundeinstellung
149 62 : m_xField = xField;
150 62 : xField->getPropertyValue(FM_PROP_FORMATKEY) >>= m_nFormatKey;
151 62 : m_nFieldPos = (sal_Int16)_nFieldPos;
152 62 : m_bReadOnly = ::comphelper::getBOOL(xField->getPropertyValue(FM_PROP_ISREADONLY));
153 62 : m_bAutoValue = ::comphelper::getBOOL(xField->getPropertyValue(FM_PROP_AUTOINCREMENT));
154 62 : m_nFieldType = (sal_Int16)::comphelper::getINT32(xField->getPropertyValue(FM_PROP_FIELDTYPE));
155 :
156 62 : switch (m_nFieldType)
157 : {
158 : case DataType::DATE:
159 : case DataType::TIME:
160 : case DataType::TIMESTAMP:
161 0 : m_bDateTime = true;
162 : //fall-through
163 : case DataType::BIT:
164 : case DataType::BOOLEAN:
165 : case DataType::TINYINT:
166 : case DataType::SMALLINT:
167 : case DataType::INTEGER:
168 : case DataType::BIGINT:
169 : case DataType::FLOAT:
170 : case DataType::REAL:
171 : case DataType::DOUBLE:
172 : case DataType::NUMERIC:
173 : case DataType::DECIMAL:
174 0 : m_nAlign = ::com::sun::star::awt::TextAlign::RIGHT;
175 0 : m_bNumeric = true;
176 0 : break;
177 : default:
178 62 : m_nAlign = ::com::sun::star::awt::TextAlign::LEFT;
179 62 : break;
180 : }
181 : }
182 :
183 62 : DbCellControl* pCellControl = NULL;
184 62 : if (m_rParent.IsFilterMode())
185 : {
186 0 : pCellControl = new DbFilterField(m_rParent.getContext(),*this);
187 : }
188 : else
189 : {
190 :
191 62 : switch (nTypeId)
192 : {
193 0 : case TYPE_CHECKBOX: pCellControl = new DbCheckBox(*this); break;
194 0 : case TYPE_COMBOBOX: pCellControl = new DbComboBox(*this); break;
195 0 : case TYPE_CURRENCYFIELD: pCellControl = new DbCurrencyField(*this); break;
196 0 : case TYPE_DATEFIELD: pCellControl = new DbDateField(*this); break;
197 0 : case TYPE_LISTBOX: pCellControl = new DbListBox(*this); break;
198 0 : case TYPE_NUMERICFIELD: pCellControl = new DbNumericField(*this); break;
199 0 : case TYPE_PATTERNFIELD: pCellControl = new DbPatternField( *this, m_rParent.getContext() ); break;
200 34 : case TYPE_TEXTFIELD: pCellControl = new DbTextField(*this); break;
201 0 : case TYPE_TIMEFIELD: pCellControl = new DbTimeField(*this); break;
202 28 : case TYPE_FORMATTEDFIELD: pCellControl = new DbFormattedField(*this); break;
203 : default:
204 : OSL_FAIL("DbGridColumn::CreateControl: Unknown Column");
205 62 : return;
206 : }
207 :
208 : }
209 62 : Reference< XRowSet > xCur;
210 62 : if (m_rParent.getDataSource())
211 62 : xCur = Reference< XRowSet > (Reference< XInterface >(*m_rParent.getDataSource()), UNO_QUERY);
212 : // TODO : the cursor wrapper should use an XRowSet interface, too
213 :
214 62 : pCellControl->Init( m_rParent.GetDataWindow(), xCur );
215 :
216 : // now create the control wrapper
217 62 : if (m_rParent.IsFilterMode())
218 0 : m_pCell = new FmXFilterCell(this, pCellControl);
219 : else
220 : {
221 62 : switch (nTypeId)
222 : {
223 0 : case TYPE_CHECKBOX: m_pCell = new FmXCheckBoxCell( this, *pCellControl ); break;
224 0 : case TYPE_LISTBOX: m_pCell = new FmXListBoxCell( this, *pCellControl ); break;
225 0 : case TYPE_COMBOBOX: m_pCell = new FmXComboBoxCell( this, *pCellControl ); break;
226 : default:
227 62 : m_pCell = new FmXEditCell( this, *pCellControl );
228 : }
229 : }
230 62 : m_pCell->acquire();
231 62 : m_pCell->init();
232 :
233 62 : impl_toggleScriptManager_nothrow( true );
234 :
235 : // only if we use have a bound field, we use a a controller for displaying the
236 : // window in the grid
237 62 : if (m_xField.is())
238 62 : m_xController = pCellControl->CreateController();
239 : }
240 :
241 :
242 124 : void DbGridColumn::impl_toggleScriptManager_nothrow( bool _bAttach )
243 : {
244 : try
245 : {
246 124 : Reference< container::XChild > xChild( m_xModel, UNO_QUERY_THROW );
247 248 : Reference< script::XEventAttacherManager > xManager( xChild->getParent(), UNO_QUERY_THROW );
248 248 : Reference< container::XIndexAccess > xContainer( xChild->getParent(), UNO_QUERY_THROW );
249 :
250 124 : sal_Int32 nIndexInParent( getElementPos( xContainer, m_xModel ) );
251 :
252 248 : Reference< XInterface > xCellInterface( *m_pCell, UNO_QUERY );
253 124 : if ( _bAttach )
254 62 : xManager->attach( nIndexInParent, xCellInterface, makeAny( xCellInterface ) );
255 : else
256 186 : xManager->detach( nIndexInParent, xCellInterface );
257 : }
258 0 : catch( const Exception& )
259 : {
260 : DBG_UNHANDLED_EXCEPTION();
261 : }
262 124 : }
263 :
264 :
265 2 : void DbGridColumn::UpdateFromField(const DbGridRow* pRow, const Reference< XNumberFormatter >& xFormatter)
266 : {
267 2 : if (m_pCell && m_pCell->ISA(FmXFilterCell))
268 0 : PTR_CAST(FmXFilterCell, m_pCell)->Update();
269 2 : else if (pRow && pRow->IsValid() && m_nFieldPos >= 0 && m_pCell && pRow->HasField(m_nFieldPos))
270 : {
271 2 : PTR_CAST(FmXDataCell, m_pCell)->UpdateFromField( pRow->GetField( m_nFieldPos ).getColumn(), xFormatter );
272 : }
273 2 : }
274 :
275 :
276 0 : bool DbGridColumn::Commit()
277 : {
278 0 : bool bResult = true;
279 0 : if (!m_bInSave && m_pCell)
280 : {
281 0 : m_bInSave = true;
282 0 : bResult = m_pCell->Commit();
283 :
284 : // store the data into the model
285 0 : FmXDataCell* pDataCell = PTR_CAST(FmXDataCell, m_pCell);
286 0 : if (bResult && pDataCell)
287 : {
288 0 : Reference< ::com::sun::star::form::XBoundComponent > xComp(m_xModel, UNO_QUERY);
289 0 : if (xComp.is())
290 0 : bResult = xComp->commit();
291 : }
292 0 : m_bInSave = false;
293 : }
294 0 : return bResult;
295 : }
296 :
297 :
298 280 : DbGridColumn::~DbGridColumn()
299 : {
300 140 : Clear();
301 140 : }
302 :
303 :
304 202 : void DbGridColumn::setModel(::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet > _xModel)
305 : {
306 202 : if ( m_pCell )
307 0 : impl_toggleScriptManager_nothrow( false );
308 :
309 202 : m_xModel = _xModel;
310 :
311 202 : if ( m_pCell )
312 0 : impl_toggleScriptManager_nothrow( true );
313 202 : }
314 :
315 :
316 326 : void DbGridColumn::Clear()
317 : {
318 326 : if ( m_pCell )
319 : {
320 62 : impl_toggleScriptManager_nothrow( false );
321 :
322 62 : m_pCell->dispose();
323 62 : m_pCell->release();
324 62 : m_pCell = NULL;
325 : }
326 :
327 326 : m_xController = NULL;
328 326 : m_xField = NULL;
329 :
330 326 : m_nFormatKey = 0;
331 326 : m_nFieldPos = -1;
332 326 : m_bReadOnly = true;
333 326 : m_bAutoValue = false;
334 326 : m_nFieldType = DataType::OTHER;
335 326 : }
336 :
337 :
338 62 : sal_Int16 DbGridColumn::SetAlignment(sal_Int16 _nAlign)
339 : {
340 62 : if (_nAlign == -1)
341 : { // 'Standard'
342 0 : if (m_xField.is())
343 : {
344 0 : sal_Int32 nType = 0;
345 0 : m_xField->getPropertyValue(FM_PROP_FIELDTYPE) >>= nType;
346 :
347 0 : switch (nType)
348 : {
349 : case DataType::NUMERIC:
350 : case DataType::DECIMAL:
351 : case DataType::DOUBLE:
352 : case DataType::REAL:
353 : case DataType::BIGINT:
354 : case DataType::INTEGER:
355 : case DataType::SMALLINT:
356 : case DataType::TINYINT:
357 : case DataType::DATE:
358 : case DataType::TIME:
359 : case DataType::TIMESTAMP:
360 0 : _nAlign = ::com::sun::star::awt::TextAlign::RIGHT;
361 0 : break;
362 : case DataType::BIT:
363 : case DataType::BOOLEAN:
364 0 : _nAlign = ::com::sun::star::awt::TextAlign::CENTER;
365 0 : break;
366 : default:
367 0 : _nAlign = ::com::sun::star::awt::TextAlign::LEFT;
368 0 : break;
369 : }
370 : }
371 : else
372 0 : _nAlign = ::com::sun::star::awt::TextAlign::LEFT;
373 : }
374 :
375 62 : m_nAlign = _nAlign;
376 62 : if (m_pCell && m_pCell->isAlignedController())
377 0 : m_pCell->AlignControl(m_nAlign);
378 :
379 62 : return m_nAlign;
380 : }
381 :
382 :
383 62 : sal_Int16 DbGridColumn::SetAlignmentFromModel(sal_Int16 nStandardAlign)
384 : {
385 62 : Any aAlign( m_xModel->getPropertyValue(FM_PROP_ALIGN));
386 62 : if (aAlign.hasValue())
387 : {
388 62 : sal_Int16 nTest = sal_Int16();
389 62 : if (aAlign >>= nTest)
390 62 : nStandardAlign = nTest;
391 : }
392 62 : return SetAlignment(nStandardAlign);
393 : }
394 :
395 :
396 0 : void DbGridColumn::setLock(bool _bLock)
397 : {
398 0 : if (m_bLocked == _bLock)
399 0 : return;
400 0 : m_bLocked = _bLock;
401 :
402 : // is the column we represent active ?
403 0 : if (m_bHidden)
404 0 : return; // no, it isn't (or at least it shouldn't be ...)
405 :
406 0 : if (m_rParent.GetCurColumnId() == m_nId)
407 : {
408 0 : m_rParent.DeactivateCell();
409 0 : m_rParent.ActivateCell(m_rParent.GetCurRow(), m_rParent.GetCurColumnId());
410 : }
411 : }
412 :
413 :
414 0 : OUString DbGridColumn::GetCellText(const DbGridRow* pRow, const Reference< XNumberFormatter >& xFormatter) const
415 : {
416 0 : OUString aText;
417 0 : if (m_pCell && m_pCell->ISA(FmXFilterCell))
418 0 : return aText;
419 :
420 0 : if (!pRow || !pRow->IsValid())
421 0 : aText = OUString(INVALIDTEXT);
422 0 : else if (pRow->HasField(m_nFieldPos))
423 : {
424 0 : aText = GetCellText( pRow->GetField( m_nFieldPos ).getColumn(), xFormatter );
425 : }
426 0 : return aText;
427 : }
428 :
429 :
430 0 : OUString DbGridColumn::GetCellText(const Reference< ::com::sun::star::sdb::XColumn >& xField, const Reference< XNumberFormatter >& xFormatter) const
431 : {
432 0 : OUString aText;
433 0 : if (xField.is())
434 : {
435 0 : FmXTextCell* pTextCell = PTR_CAST(FmXTextCell, m_pCell);
436 0 : if (pTextCell)
437 0 : aText = pTextCell->GetText(xField, xFormatter);
438 0 : else if (m_bObject)
439 0 : aText = OUString(OBJECTTEXT);
440 : }
441 0 : return aText;
442 : }
443 :
444 :
445 0 : Reference< ::com::sun::star::sdb::XColumn > DbGridColumn::GetCurrentFieldValue() const
446 : {
447 0 : Reference< ::com::sun::star::sdb::XColumn > xField;
448 0 : const DbGridRowRef xRow = m_rParent.GetCurrentRow();
449 0 : if (xRow.Is() && xRow->HasField(m_nFieldPos))
450 : {
451 0 : xField = xRow->GetField(m_nFieldPos).getColumn();
452 : }
453 0 : return xField;
454 : }
455 :
456 :
457 78 : void DbGridColumn::Paint(OutputDevice& rDev,
458 : const Rectangle& rRect,
459 : const DbGridRow* pRow,
460 : const Reference< XNumberFormatter >& xFormatter)
461 : {
462 78 : bool bEnabled = ( rDev.GetOutDevType() != OUTDEV_WINDOW )
463 78 : || ( static_cast< vcl::Window& >( rDev ).IsEnabled() );
464 :
465 78 : FmXDataCell* pDataCell = PTR_CAST(FmXDataCell, m_pCell);
466 78 : if (pDataCell)
467 : {
468 78 : if (!pRow || !pRow->IsValid())
469 : {
470 0 : sal_uInt16 nStyle = TEXT_DRAW_CLIP | TEXT_DRAW_CENTER;
471 0 : if ( !bEnabled )
472 0 : nStyle |= TEXT_DRAW_DISABLE;
473 :
474 0 : rDev.DrawText(rRect, OUString(INVALIDTEXT), nStyle);
475 : }
476 78 : else if (m_bAutoValue && pRow->IsNew())
477 : {
478 0 : sal_uInt16 nStyle = TEXT_DRAW_CLIP | TEXT_DRAW_VCENTER;
479 0 : if ( !bEnabled )
480 0 : nStyle |= TEXT_DRAW_DISABLE;
481 :
482 0 : switch (GetAlignment())
483 : {
484 : case ::com::sun::star::awt::TextAlign::RIGHT:
485 0 : nStyle |= TEXT_DRAW_RIGHT;
486 0 : break;
487 : case ::com::sun::star::awt::TextAlign::CENTER:
488 0 : nStyle |= TEXT_DRAW_CENTER;
489 0 : break;
490 : default:
491 0 : nStyle |= TEXT_DRAW_LEFT;
492 : }
493 :
494 0 : rDev.DrawText(rRect, SVX_RESSTR(RID_STR_AUTOFIELD), nStyle);
495 : }
496 78 : else if (pRow->HasField(m_nFieldPos))
497 : {
498 78 : pDataCell->PaintFieldToCell(rDev, rRect, pRow->GetField( m_nFieldPos ).getColumn(), xFormatter);
499 : }
500 : }
501 0 : else if (!m_pCell)
502 : {
503 0 : if (!pRow || !pRow->IsValid())
504 : {
505 0 : sal_uInt16 nStyle = TEXT_DRAW_CLIP | TEXT_DRAW_CENTER;
506 0 : if ( !bEnabled )
507 0 : nStyle |= TEXT_DRAW_DISABLE;
508 :
509 0 : rDev.DrawText(rRect, OUString(INVALIDTEXT), nStyle);
510 : }
511 0 : else if (pRow->HasField(m_nFieldPos) && m_bObject)
512 : {
513 0 : sal_uInt16 nStyle = TEXT_DRAW_CLIP | TEXT_DRAW_CENTER;
514 0 : if ( !bEnabled )
515 0 : nStyle |= TEXT_DRAW_DISABLE;
516 0 : rDev.DrawText(rRect, OUString(OBJECTTEXT), nStyle);
517 : }
518 : }
519 0 : else if ( m_pCell->ISA( FmXFilterCell ) )
520 0 : static_cast< FmXFilterCell* >( m_pCell )->PaintCell( rDev, rRect );
521 78 : }
522 :
523 :
524 232 : void DbGridColumn::ImplInitWindow( vcl::Window& rParent, const InitWindowFacet _eInitWhat )
525 : {
526 232 : if ( m_pCell )
527 0 : m_pCell->ImplInitWindow( rParent, _eInitWhat );
528 232 : }
529 :
530 :
531 : //= cell controls
532 :
533 56 : TYPEINIT0( DbCellControl )
534 56 : TYPEINIT1( DbLimitedLengthField, DbCellControl )
535 164 : TYPEINIT1( DbTextField, DbLimitedLengthField )
536 84 : TYPEINIT1( DbFormattedField, DbLimitedLengthField )
537 0 : TYPEINIT1( DbCheckBox, DbCellControl )
538 0 : TYPEINIT1( DbComboBox, DbCellControl )
539 0 : TYPEINIT1( DbListBox, DbCellControl )
540 0 : TYPEINIT1( DbPatternField, DbCellControl )
541 0 : TYPEINIT1( DbSpinField, DbCellControl )
542 0 : TYPEINIT1( DbDateField, DbSpinField )
543 0 : TYPEINIT1( DbTimeField, DbSpinField )
544 0 : TYPEINIT1( DbCurrencyField, DbSpinField )
545 0 : TYPEINIT1( DbNumericField, DbSpinField )
546 0 : TYPEINIT1( DbFilterField, DbCellControl )
547 :
548 :
549 62 : DbCellControl::DbCellControl( DbGridColumn& _rColumn, bool /*_bText*/ )
550 : :OPropertyChangeListener(m_aMutex)
551 : ,m_pModelChangeBroadcaster(NULL)
552 : ,m_pFieldChangeBroadcaster(NULL)
553 : ,m_bTransparent( false )
554 : ,m_bAlignedController( true )
555 : ,m_bAccessingValueProperty( false )
556 : ,m_rColumn( _rColumn )
557 : ,m_pPainter( NULL )
558 62 : ,m_pWindow( NULL )
559 : {
560 62 : Reference< XPropertySet > xColModelProps( _rColumn.getModel(), UNO_QUERY );
561 62 : if ( xColModelProps.is() )
562 : {
563 : // if our model's format key changes we want to propagate the new value to our windows
564 62 : m_pModelChangeBroadcaster = new ::comphelper::OPropertyChangeMultiplexer(this, Reference< ::com::sun::star::beans::XPropertySet > (_rColumn.getModel(), UNO_QUERY));
565 62 : m_pModelChangeBroadcaster->acquire();
566 :
567 : // be listener for some common properties
568 62 : implDoPropertyListening( FM_PROP_READONLY, false );
569 62 : implDoPropertyListening( FM_PROP_ENABLED, false );
570 :
571 : // add as listener for all know "value" properties
572 62 : implDoPropertyListening( FM_PROP_VALUE, false );
573 62 : implDoPropertyListening( FM_PROP_STATE, false );
574 62 : implDoPropertyListening( FM_PROP_TEXT, false );
575 62 : implDoPropertyListening( FM_PROP_EFFECTIVE_VALUE, false );
576 :
577 : // be listener at the bound field as well
578 : try
579 : {
580 62 : Reference< XPropertySetInfo > xPSI( xColModelProps->getPropertySetInfo(), UNO_SET_THROW );
581 62 : if ( xPSI->hasPropertyByName( FM_PROP_BOUNDFIELD ) )
582 : {
583 62 : Reference< XPropertySet > xField;
584 62 : xColModelProps->getPropertyValue( FM_PROP_BOUNDFIELD ) >>= xField;
585 62 : if ( xField.is() )
586 : {
587 62 : m_pFieldChangeBroadcaster = new ::comphelper::OPropertyChangeMultiplexer(this, xField);
588 62 : m_pFieldChangeBroadcaster->acquire();
589 62 : m_pFieldChangeBroadcaster->addProperty( FM_PROP_ISREADONLY );
590 62 : }
591 62 : }
592 : }
593 0 : catch( const Exception& )
594 : {
595 : OSL_FAIL( "DbCellControl::doPropertyListening: caught an exception!" );
596 : DBG_UNHANDLED_EXCEPTION();
597 : }
598 62 : }
599 62 : }
600 :
601 :
602 462 : void DbCellControl::implDoPropertyListening(const OUString& _rPropertyName, bool _bWarnIfNotExistent)
603 : {
604 : try
605 : {
606 462 : Reference< XPropertySet > xColModelProps( m_rColumn.getModel(), UNO_QUERY );
607 924 : Reference< XPropertySetInfo > xPSI;
608 462 : if ( xColModelProps.is() )
609 462 : xPSI = xColModelProps->getPropertySetInfo();
610 :
611 : DBG_ASSERT( !_bWarnIfNotExistent || ( xPSI.is() && xPSI->hasPropertyByName( _rPropertyName ) ),
612 : "DbCellControl::doPropertyListening: no property set info or non-existent property!" );
613 : (void)_bWarnIfNotExistent;
614 :
615 462 : if ( xPSI.is() && xPSI->hasPropertyByName( _rPropertyName ) )
616 766 : m_pModelChangeBroadcaster->addProperty( _rPropertyName );
617 : }
618 0 : catch( const Exception& )
619 : {
620 : OSL_FAIL( "DbCellControl::doPropertyListening: caught an exception!" );
621 : DBG_UNHANDLED_EXCEPTION();
622 : }
623 462 : }
624 :
625 :
626 90 : void DbCellControl::doPropertyListening(const OUString& _rPropertyName)
627 : {
628 90 : implDoPropertyListening( _rPropertyName );
629 90 : }
630 :
631 124 : static void lcl_clearBroadCaster(::comphelper::OPropertyChangeMultiplexer*& _pBroadcaster)
632 : {
633 124 : if ( _pBroadcaster )
634 : {
635 124 : _pBroadcaster->dispose();
636 124 : _pBroadcaster->release();
637 124 : _pBroadcaster = NULL;
638 : // no delete, this is done implicitly
639 : }
640 124 : }
641 :
642 124 : DbCellControl::~DbCellControl()
643 : {
644 62 : lcl_clearBroadCaster(m_pModelChangeBroadcaster);
645 62 : lcl_clearBroadCaster(m_pFieldChangeBroadcaster);
646 :
647 62 : delete m_pWindow;
648 62 : delete m_pPainter;
649 62 : }
650 :
651 :
652 0 : void DbCellControl::implValuePropertyChanged( )
653 : {
654 : OSL_ENSURE( !isValuePropertyLocked(),
655 : "DbCellControl::implValuePropertyChanged: not to be called with the value property locked!" );
656 :
657 0 : if ( m_pWindow )
658 : {
659 0 : if ( m_rColumn.getModel().is() )
660 0 : updateFromModel( m_rColumn.getModel() );
661 : }
662 0 : }
663 :
664 :
665 0 : void DbCellControl::implAdjustGenericFieldSetting( const Reference< XPropertySet >& /*_rxModel*/ )
666 : {
667 : // nothing to to here
668 0 : }
669 :
670 :
671 0 : void DbCellControl::_propertyChanged(const PropertyChangeEvent& _rEvent) throw(RuntimeException)
672 : {
673 0 : SolarMutexGuard aGuard;
674 :
675 0 : Reference< XPropertySet > xSourceProps( _rEvent.Source, UNO_QUERY );
676 :
677 0 : if ( _rEvent.PropertyName.equals( FM_PROP_VALUE )
678 0 : || _rEvent.PropertyName.equals( FM_PROP_STATE )
679 0 : || _rEvent.PropertyName.equals( FM_PROP_TEXT )
680 0 : || _rEvent.PropertyName.equals( FM_PROP_EFFECTIVE_VALUE )
681 : )
682 : { // it was one of the known "value" properties
683 0 : if ( !isValuePropertyLocked() )
684 : {
685 0 : implValuePropertyChanged( );
686 : }
687 : }
688 0 : else if ( _rEvent.PropertyName.equals( FM_PROP_READONLY ) )
689 : {
690 0 : implAdjustReadOnly( xSourceProps, true);
691 : }
692 0 : else if ( _rEvent.PropertyName.equals( FM_PROP_ISREADONLY ) )
693 : {
694 0 : bool bReadOnly = true;
695 0 : _rEvent.NewValue >>= bReadOnly;
696 0 : m_rColumn.SetReadOnly(bReadOnly);
697 0 : implAdjustReadOnly( xSourceProps, false);
698 : }
699 0 : else if ( _rEvent.PropertyName.equals( FM_PROP_ENABLED ) )
700 : {
701 0 : implAdjustEnabled( xSourceProps );
702 : }
703 : else
704 0 : implAdjustGenericFieldSetting( xSourceProps );
705 0 : }
706 :
707 :
708 0 : bool DbCellControl::Commit()
709 : {
710 : // lock the listening for value property changes
711 0 : lockValueProperty();
712 : // commit the content of the control into the model's value property
713 0 : bool bReturn = false;
714 : try
715 : {
716 0 : bReturn = commitControl();
717 : }
718 0 : catch( const Exception& )
719 : {
720 : DBG_UNHANDLED_EXCEPTION();
721 : }
722 : // unlock the listening for value property changes
723 0 : unlockValueProperty();
724 : // outta here
725 0 : return bReturn;
726 : }
727 :
728 :
729 62 : void DbCellControl::ImplInitWindow( vcl::Window& rParent, const InitWindowFacet _eInitWhat )
730 : {
731 62 : vcl::Window* pWindows[] = { m_pPainter, m_pWindow };
732 :
733 62 : if ( ( _eInitWhat & InitWritingMode ) != 0 )
734 : {
735 186 : for ( size_t i=0; i < sizeof( pWindows ) / sizeof( pWindows[0] ); ++i )
736 : {
737 124 : if ( pWindows[i] )
738 124 : pWindows[i]->EnableRTL( rParent.IsRTLEnabled() );
739 : }
740 : }
741 :
742 62 : if ( ( _eInitWhat & InitFontFacet ) != 0 )
743 : {
744 186 : for (size_t i=0; i < sizeof(pWindows)/sizeof(pWindows[0]); ++i)
745 : {
746 124 : if ( !pWindows[i] )
747 0 : continue;
748 :
749 124 : pWindows[i]->SetZoom( rParent.GetZoom() );
750 :
751 124 : const StyleSettings& rStyleSettings = pWindows[i]->GetSettings().GetStyleSettings();
752 124 : vcl::Font aFont = rStyleSettings.GetFieldFont();
753 124 : aFont.SetTransparent( isTransparent() );
754 :
755 124 : if ( rParent.IsControlFont() )
756 : {
757 0 : pWindows[i]->SetControlFont( rParent.GetControlFont() );
758 0 : aFont.Merge( rParent.GetControlFont() );
759 : }
760 : else
761 124 : pWindows[i]->SetControlFont();
762 :
763 124 : pWindows[i]->SetZoomedPointFont( aFont );
764 124 : }
765 : }
766 :
767 62 : if ( ( ( _eInitWhat & InitFontFacet ) != 0 )
768 0 : || ( ( _eInitWhat & InitForeground ) != 0 )
769 : )
770 : {
771 62 : Color aTextColor( rParent.IsControlForeground() ? rParent.GetControlForeground() : rParent.GetTextColor() );
772 :
773 62 : bool bTextLineColor = rParent.IsTextLineColor();
774 62 : Color aTextLineColor( rParent.GetTextLineColor() );
775 :
776 186 : for (size_t i=0; i < sizeof(pWindows)/sizeof(pWindows[0]); ++i)
777 : {
778 124 : if ( pWindows[i] )
779 : {
780 124 : pWindows[i]->SetTextColor(aTextColor);
781 124 : if (rParent.IsControlForeground())
782 0 : pWindows[i]->SetControlForeground(aTextColor);
783 :
784 124 : if (bTextLineColor)
785 0 : pWindows[i]->SetTextLineColor();
786 : else
787 124 : pWindows[i]->SetTextLineColor(aTextLineColor);
788 : }
789 : }
790 : }
791 :
792 62 : if ( ( _eInitWhat & InitBackground ) != 0 )
793 : {
794 62 : if (rParent.IsControlBackground())
795 : {
796 0 : Color aColor( rParent.GetControlBackground());
797 0 : for (size_t i=0; i < sizeof(pWindows)/sizeof(pWindows[0]); ++i)
798 : {
799 0 : if ( pWindows[i] )
800 : {
801 0 : if ( isTransparent() )
802 0 : pWindows[i]->SetBackground();
803 : else
804 : {
805 0 : pWindows[i]->SetBackground(aColor);
806 0 : pWindows[i]->SetControlBackground(aColor);
807 : }
808 0 : pWindows[i]->SetFillColor(aColor);
809 : }
810 : }
811 : }
812 : else
813 : {
814 62 : if (m_pPainter)
815 : {
816 62 : if ( isTransparent() )
817 0 : m_pPainter->SetBackground();
818 : else
819 62 : m_pPainter->SetBackground(rParent.GetBackground());
820 62 : m_pPainter->SetFillColor(rParent.GetFillColor());
821 : }
822 :
823 62 : if (m_pWindow)
824 : {
825 62 : if ( isTransparent() )
826 0 : m_pWindow->SetBackground(rParent.GetBackground());
827 : else
828 62 : m_pWindow->SetFillColor(rParent.GetFillColor());
829 : }
830 : }
831 : }
832 62 : }
833 :
834 :
835 62 : void DbCellControl::implAdjustReadOnly( const Reference< XPropertySet >& _rxModel,bool i_bReadOnly )
836 : {
837 : DBG_ASSERT( m_pWindow, "DbCellControl::implAdjustReadOnly: not to be called without window!" );
838 : DBG_ASSERT( _rxModel.is(), "DbCellControl::implAdjustReadOnly: invalid model!" );
839 62 : if ( m_pWindow && _rxModel.is() )
840 : {
841 62 : Edit* pEditWindow = dynamic_cast< Edit* >( m_pWindow );
842 62 : if ( pEditWindow )
843 : {
844 62 : bool bReadOnly = m_rColumn.IsReadOnly();
845 62 : if ( !bReadOnly )
846 : {
847 62 : _rxModel->getPropertyValue( i_bReadOnly ? OUString(FM_PROP_READONLY) : OUString(FM_PROP_ISREADONLY)) >>= bReadOnly;
848 : }
849 62 : static_cast< Edit* >( m_pWindow )->SetReadOnly( bReadOnly );
850 : }
851 : }
852 62 : }
853 :
854 :
855 62 : void DbCellControl::implAdjustEnabled( const Reference< XPropertySet >& _rxModel )
856 : {
857 : DBG_ASSERT( m_pWindow, "DbCellControl::implAdjustEnabled: not to be called without window!" );
858 : DBG_ASSERT( _rxModel.is(), "DbCellControl::implAdjustEnabled: invalid model!" );
859 62 : if ( m_pWindow && _rxModel.is() )
860 : {
861 62 : bool bEnable = true;
862 62 : _rxModel->getPropertyValue( FM_PROP_ENABLED ) >>= bEnable;
863 62 : m_pWindow->Enable( bEnable );
864 : }
865 62 : }
866 :
867 :
868 62 : void DbCellControl::Init( vcl::Window& rParent, const Reference< XRowSet >& _rxCursor )
869 : {
870 62 : ImplInitWindow( rParent, InitAll );
871 :
872 62 : if ( m_pWindow )
873 : {
874 : // align the control
875 62 : if ( isAlignedController() )
876 62 : AlignControl( m_rColumn.GetAlignment() );
877 :
878 : try
879 : {
880 : // some other common properties
881 62 : Reference< XPropertySet > xModel( m_rColumn.getModel(), UNO_SET_THROW );
882 124 : Reference< XPropertySetInfo > xModelPSI( xModel->getPropertySetInfo(), UNO_SET_THROW );
883 :
884 62 : if ( xModelPSI->hasPropertyByName( FM_PROP_READONLY ) )
885 : {
886 62 : implAdjustReadOnly( xModel,true );
887 : }
888 :
889 62 : if ( xModelPSI->hasPropertyByName( FM_PROP_ENABLED ) )
890 : {
891 62 : implAdjustEnabled( xModel );
892 : }
893 :
894 62 : if ( xModelPSI->hasPropertyByName( FM_PROP_MOUSE_WHEEL_BEHAVIOR ) )
895 : {
896 28 : sal_Int16 nWheelBehavior = MouseWheelBehavior::SCROLL_FOCUS_ONLY;
897 28 : OSL_VERIFY( xModel->getPropertyValue( FM_PROP_MOUSE_WHEEL_BEHAVIOR ) >>= nWheelBehavior );
898 28 : sal_uInt16 nVclSetting = MOUSE_WHEEL_FOCUS_ONLY;
899 28 : switch ( nWheelBehavior )
900 : {
901 28 : case MouseWheelBehavior::SCROLL_DISABLED: nVclSetting = MOUSE_WHEEL_DISABLE; break;
902 0 : case MouseWheelBehavior::SCROLL_FOCUS_ONLY: nVclSetting = MOUSE_WHEEL_FOCUS_ONLY; break;
903 0 : case MouseWheelBehavior::SCROLL_ALWAYS: nVclSetting = MOUSE_WHEEL_ALWAYS; break;
904 : default:
905 : OSL_FAIL( "DbCellControl::Init: invalid MouseWheelBehavior!" );
906 0 : break;
907 : }
908 :
909 28 : AllSettings aSettings = m_pWindow->GetSettings();
910 56 : MouseSettings aMouseSettings = aSettings.GetMouseSettings();
911 28 : aMouseSettings.SetWheelBehavior( nVclSetting );
912 28 : aSettings.SetMouseSettings( aMouseSettings );
913 56 : m_pWindow->SetSettings( aSettings, true );
914 62 : }
915 : }
916 0 : catch( const Exception& )
917 : {
918 : DBG_UNHANDLED_EXCEPTION();
919 : }
920 : }
921 62 : m_xCursor = _rxCursor;
922 62 : }
923 :
924 :
925 0 : void DbCellControl::SetTextLineColor()
926 : {
927 0 : if (m_pWindow)
928 0 : m_pWindow->SetTextLineColor();
929 0 : if (m_pPainter)
930 0 : m_pPainter->SetTextLineColor();
931 0 : }
932 :
933 :
934 0 : void DbCellControl::SetTextLineColor(const Color& _rColor)
935 : {
936 0 : if (m_pWindow)
937 0 : m_pWindow->SetTextLineColor(_rColor);
938 0 : if (m_pPainter)
939 0 : m_pPainter->SetTextLineColor(_rColor);
940 0 : }
941 :
942 : namespace
943 : {
944 124 : static void lcl_implAlign( vcl::Window* _pWindow, WinBits _nAlignmentBit )
945 : {
946 124 : WinBits nStyle = _pWindow->GetStyle();
947 124 : nStyle &= ~(WB_LEFT | WB_RIGHT | WB_CENTER);
948 124 : _pWindow->SetStyle( nStyle | _nAlignmentBit );
949 124 : }
950 : }
951 :
952 :
953 62 : void DbCellControl::AlignControl(sal_Int16 nAlignment)
954 : {
955 62 : WinBits nAlignmentBit = 0;
956 62 : switch (nAlignment)
957 : {
958 : case ::com::sun::star::awt::TextAlign::RIGHT:
959 0 : nAlignmentBit = WB_RIGHT;
960 0 : break;
961 : case ::com::sun::star::awt::TextAlign::CENTER:
962 0 : nAlignmentBit = WB_CENTER;
963 0 : break;
964 : default:
965 62 : nAlignmentBit = WB_LEFT;
966 62 : break;
967 : }
968 62 : lcl_implAlign( m_pWindow, nAlignmentBit );
969 62 : if ( m_pPainter )
970 62 : lcl_implAlign( m_pPainter, nAlignmentBit );
971 62 : }
972 :
973 :
974 32 : void DbCellControl::PaintCell( OutputDevice& _rDev, const Rectangle& _rRect )
975 : {
976 32 : if ( m_pPainter->GetParent() == &_rDev )
977 : {
978 32 : m_pPainter->SetPaintTransparent( true );
979 32 : m_pPainter->SetBackground( );
980 32 : m_pPainter->SetControlBackground( _rDev.GetFillColor() );
981 32 : m_pPainter->SetControlForeground( _rDev.GetTextColor() );
982 32 : m_pPainter->SetTextColor( _rDev.GetTextColor() );
983 32 : m_pPainter->SetTextFillColor( _rDev.GetTextColor() );
984 :
985 32 : vcl::Font aFont( _rDev.GetFont() );
986 32 : aFont.SetTransparent( true );
987 32 : m_pPainter->SetFont( aFont );
988 :
989 32 : m_pPainter->SetPosSizePixel( _rRect.TopLeft(), _rRect.GetSize() );
990 32 : m_pPainter->Show();
991 32 : m_pPainter->Update();
992 32 : m_pPainter->SetParentUpdateMode( false );
993 32 : m_pPainter->Hide();
994 32 : m_pPainter->SetParentUpdateMode( true );
995 : }
996 : else
997 0 : m_pPainter->Draw( &_rDev, _rRect.TopLeft(), _rRect.GetSize(), 0 );
998 32 : }
999 :
1000 :
1001 32 : void DbCellControl::PaintFieldToCell( OutputDevice& _rDev, const Rectangle& _rRect, const Reference< XColumn >& _rxField, const Reference< XNumberFormatter >& _rxFormatter )
1002 : {
1003 32 : m_pPainter->SetText( GetFormatText( _rxField, _rxFormatter ) );
1004 32 : PaintCell( _rDev, _rRect );
1005 32 : }
1006 :
1007 :
1008 0 : double DbCellControl::GetValue(const Reference< ::com::sun::star::sdb::XColumn >& _rxField, const Reference< XNumberFormatter >& xFormatter) const
1009 : {
1010 0 : double fValue = 0;
1011 0 : if (m_rColumn.IsNumeric())
1012 : {
1013 : try
1014 : {
1015 0 : fValue = _rxField->getDouble();
1016 : }
1017 0 : catch(const Exception&) { }
1018 : }
1019 : else
1020 : {
1021 0 : bool bSuccess = false;
1022 : try
1023 : {
1024 0 : fValue = _rxField->getDouble();
1025 0 : bSuccess = true;
1026 : }
1027 0 : catch(const Exception&) { }
1028 0 : if (!bSuccess)
1029 : {
1030 : try
1031 : {
1032 0 : fValue = xFormatter->convertStringToNumber(m_rColumn.GetKey(), _rxField->getString());
1033 : }
1034 0 : catch(const Exception&) { }
1035 : }
1036 : }
1037 0 : return fValue;
1038 : }
1039 :
1040 :
1041 0 : void DbCellControl::invalidatedController()
1042 : {
1043 0 : m_rColumn.GetParent().refreshController(m_rColumn.GetId(), DbGridControl::GrantControlAccess());
1044 0 : }
1045 :
1046 : // CellModels
1047 :
1048 62 : DbLimitedLengthField::DbLimitedLengthField( DbGridColumn& _rColumn )
1049 62 : :DbCellControl( _rColumn )
1050 : {
1051 62 : doPropertyListening( FM_PROP_MAXTEXTLEN );
1052 62 : }
1053 :
1054 :
1055 62 : void DbLimitedLengthField::implAdjustGenericFieldSetting( const Reference< XPropertySet >& _rxModel )
1056 : {
1057 : DBG_ASSERT( m_pWindow, "DbLimitedLengthField::implAdjustGenericFieldSetting: not to be called without window!" );
1058 : DBG_ASSERT( _rxModel.is(), "DbLimitedLengthField::implAdjustGenericFieldSetting: invalid model!" );
1059 62 : if ( m_pWindow && _rxModel.is() )
1060 : {
1061 62 : sal_Int16 nMaxLen = 0;
1062 62 : _rxModel->getPropertyValue( FM_PROP_MAXTEXTLEN ) >>= nMaxLen;
1063 62 : implSetMaxTextLen( nMaxLen );
1064 : }
1065 62 : }
1066 :
1067 28 : void DbLimitedLengthField::implSetEffectiveMaxTextLen( sal_Int32 _nMaxLen )
1068 : {
1069 28 : dynamic_cast<Edit&>(*m_pWindow).SetMaxTextLen(_nMaxLen);
1070 28 : if (m_pPainter)
1071 28 : dynamic_cast<Edit&>(*m_pPainter).SetMaxTextLen(_nMaxLen);
1072 28 : }
1073 :
1074 34 : DbTextField::DbTextField(DbGridColumn& _rColumn)
1075 : :DbLimitedLengthField(_rColumn)
1076 : ,m_pEdit( NULL )
1077 : ,m_pPainterImplementation( NULL )
1078 34 : ,m_bIsSimpleEdit( true )
1079 : {
1080 34 : }
1081 :
1082 :
1083 102 : DbTextField::~DbTextField( )
1084 : {
1085 34 : DELETEZ( m_pPainterImplementation );
1086 34 : DELETEZ( m_pEdit );
1087 68 : }
1088 :
1089 :
1090 34 : void DbTextField::Init( vcl::Window& rParent, const Reference< XRowSet >& xCursor)
1091 : {
1092 34 : sal_Int16 nAlignment = m_rColumn.SetAlignmentFromModel(-1);
1093 :
1094 34 : Reference< XPropertySet > xModel( m_rColumn.getModel() );
1095 :
1096 34 : WinBits nStyle = WB_LEFT;
1097 34 : switch (nAlignment)
1098 : {
1099 : case awt::TextAlign::RIGHT:
1100 0 : nStyle = WB_RIGHT;
1101 0 : break;
1102 :
1103 : case awt::TextAlign::CENTER:
1104 0 : nStyle = WB_CENTER;
1105 0 : break;
1106 : }
1107 :
1108 : // is this a multi-line field?
1109 34 : bool bIsMultiLine = false;
1110 : try
1111 : {
1112 34 : if ( xModel.is() )
1113 : {
1114 34 : OSL_VERIFY( xModel->getPropertyValue( FM_PROP_MULTILINE ) >>= bIsMultiLine );
1115 : }
1116 : }
1117 0 : catch( const Exception& )
1118 : {
1119 : OSL_FAIL( "DbTextField::Init: caught an exception while determining the multi-line capabilities!" );
1120 : DBG_UNHANDLED_EXCEPTION();
1121 : }
1122 :
1123 34 : m_bIsSimpleEdit = !bIsMultiLine;
1124 34 : if ( bIsMultiLine )
1125 : {
1126 34 : m_pWindow = new MultiLineTextCell( &rParent, nStyle );
1127 34 : m_pEdit = new MultiLineEditImplementation( *static_cast< MultiLineTextCell* >( m_pWindow ) );
1128 :
1129 34 : m_pPainter = new MultiLineTextCell( &rParent, nStyle );
1130 34 : m_pPainterImplementation = new MultiLineEditImplementation( *static_cast< MultiLineTextCell* >( m_pPainter ) );
1131 : }
1132 : else
1133 : {
1134 0 : m_pWindow = new Edit( &rParent, nStyle );
1135 0 : m_pEdit = new EditImplementation( *static_cast< Edit* >( m_pWindow ) );
1136 :
1137 0 : m_pPainter = new Edit( &rParent, nStyle );
1138 0 : m_pPainterImplementation = new EditImplementation( *static_cast< Edit* >( m_pPainter ) );
1139 : }
1140 :
1141 34 : if ( WB_LEFT == nStyle )
1142 : {
1143 : // this is so that when getting the focus, the selection is oriented left-to-right
1144 34 : AllSettings aSettings = m_pWindow->GetSettings();
1145 68 : StyleSettings aStyleSettings = aSettings.GetStyleSettings();
1146 : aStyleSettings.SetSelectionOptions(
1147 34 : aStyleSettings.GetSelectionOptions() | SELECTION_OPTION_SHOWFIRST);
1148 34 : aSettings.SetStyleSettings(aStyleSettings);
1149 68 : m_pWindow->SetSettings(aSettings);
1150 : }
1151 :
1152 34 : implAdjustGenericFieldSetting( xModel );
1153 :
1154 34 : DbLimitedLengthField::Init( rParent, xCursor );
1155 34 : }
1156 :
1157 :
1158 34 : CellControllerRef DbTextField::CreateController() const
1159 : {
1160 34 : return new EditCellController( m_pEdit );
1161 : }
1162 :
1163 :
1164 32 : void DbTextField::PaintFieldToCell( OutputDevice& _rDev, const Rectangle& _rRect, const Reference< XColumn >& _rxField, const Reference< XNumberFormatter >& _rxFormatter )
1165 : {
1166 32 : if ( m_pPainterImplementation )
1167 32 : m_pPainterImplementation->SetText( GetFormatText( _rxField, _rxFormatter, NULL ) );
1168 :
1169 32 : DbLimitedLengthField::PaintFieldToCell( _rDev, _rRect, _rxField, _rxFormatter );
1170 32 : }
1171 :
1172 :
1173 64 : OUString DbTextField::GetFormatText(const Reference< XColumn >& _rxField, const Reference< XNumberFormatter >& xFormatter, Color** /*ppColor*/)
1174 : {
1175 64 : const com::sun::star::uno::Reference<com::sun::star::beans::XPropertySet> xPS(_rxField, UNO_QUERY);
1176 128 : FormattedColumnValue fmter( xFormatter, xPS );
1177 :
1178 128 : return fmter.getFormattedValue();
1179 : }
1180 :
1181 :
1182 0 : void DbTextField::UpdateFromField(const Reference< ::com::sun::star::sdb::XColumn >& _rxField, const Reference< XNumberFormatter >& xFormatter)
1183 : {
1184 0 : m_pEdit->SetText( GetFormatText( _rxField, xFormatter ) );
1185 0 : m_pEdit->SetSelection( Selection( SELECTION_MAX, SELECTION_MIN ) );
1186 0 : }
1187 :
1188 :
1189 0 : void DbTextField::updateFromModel( Reference< XPropertySet > _rxModel )
1190 : {
1191 : OSL_ENSURE( _rxModel.is() && m_pWindow, "DbTextField::updateFromModel: invalid call!" );
1192 :
1193 0 : OUString sText;
1194 0 : _rxModel->getPropertyValue( FM_PROP_TEXT ) >>= sText;
1195 :
1196 0 : sal_Int32 nMaxTextLen = m_pEdit->GetMaxTextLen();
1197 0 : if ( EDIT_NOLIMIT != nMaxTextLen && sText.getLength() > nMaxTextLen )
1198 : {
1199 0 : sal_Int32 nDiff = sText.getLength() - nMaxTextLen;
1200 0 : sText = sText.replaceAt(sText.getLength() - nDiff,nDiff, OUString());
1201 : }
1202 :
1203 :
1204 0 : m_pEdit->SetText( sText );
1205 0 : m_pEdit->SetSelection( Selection( SELECTION_MAX, SELECTION_MIN ) );
1206 0 : }
1207 :
1208 :
1209 0 : bool DbTextField::commitControl()
1210 : {
1211 0 : OUString aText( m_pEdit->GetText( getModelLineEndSetting( m_rColumn.getModel() ) ) );
1212 : // we have to check if the length before we can decide if the value was modified
1213 0 : sal_Int32 nMaxTextLen = m_pEdit->GetMaxTextLen();
1214 0 : if ( EDIT_NOLIMIT != nMaxTextLen )
1215 : {
1216 0 : OUString sOldValue;
1217 0 : m_rColumn.getModel()->getPropertyValue( FM_PROP_TEXT ) >>= sOldValue;
1218 : // if the new value didn't change we must set the old long value again
1219 0 : if ( sOldValue.getLength() > nMaxTextLen && sOldValue.compareTo(aText,nMaxTextLen) == 0 )
1220 0 : aText = sOldValue;
1221 : }
1222 0 : m_rColumn.getModel()->setPropertyValue( FM_PROP_TEXT, makeAny( aText ) );
1223 0 : return true;
1224 : }
1225 :
1226 :
1227 34 : void DbTextField::implSetEffectiveMaxTextLen( sal_Int32 _nMaxLen )
1228 : {
1229 34 : if ( m_pEdit )
1230 34 : m_pEdit->SetMaxTextLen( _nMaxLen );
1231 34 : if ( m_pPainterImplementation )
1232 34 : m_pPainterImplementation->SetMaxTextLen( _nMaxLen );
1233 34 : }
1234 :
1235 28 : DbFormattedField::DbFormattedField(DbGridColumn& _rColumn)
1236 : :DbLimitedLengthField(_rColumn)
1237 28 : ,m_nKeyType(::com::sun::star::util::NumberFormat::UNDEFINED)
1238 : {
1239 :
1240 : // if our model's format key changes we want to propagate the new value to our windows
1241 28 : doPropertyListening( FM_PROP_FORMATKEY );
1242 28 : }
1243 :
1244 :
1245 56 : DbFormattedField::~DbFormattedField()
1246 : {
1247 56 : }
1248 :
1249 :
1250 28 : void DbFormattedField::Init( vcl::Window& rParent, const Reference< XRowSet >& xCursor)
1251 : {
1252 28 : sal_Int16 nAlignment = m_rColumn.SetAlignmentFromModel(-1);
1253 :
1254 28 : Reference< ::com::sun::star::beans::XPropertySet > xUnoModel = m_rColumn.getModel();
1255 :
1256 28 : switch (nAlignment)
1257 : {
1258 : case ::com::sun::star::awt::TextAlign::RIGHT:
1259 0 : m_pWindow = new FormattedField( &rParent, WB_RIGHT );
1260 0 : m_pPainter = new FormattedField( &rParent, WB_RIGHT );
1261 0 : break;
1262 :
1263 : case ::com::sun::star::awt::TextAlign::CENTER:
1264 0 : m_pWindow = new FormattedField( &rParent, WB_CENTER );
1265 0 : m_pPainter = new FormattedField( &rParent, WB_CENTER );
1266 0 : break;
1267 : default:
1268 28 : m_pWindow = new FormattedField( &rParent, WB_LEFT );
1269 28 : m_pPainter = new FormattedField( &rParent, WB_LEFT );
1270 :
1271 : // Alles nur damit die Selektion bei Focuserhalt von rechts nach links geht
1272 28 : AllSettings aSettings = m_pWindow->GetSettings();
1273 56 : StyleSettings aStyleSettings = aSettings.GetStyleSettings();
1274 : aStyleSettings.SetSelectionOptions(
1275 28 : aStyleSettings.GetSelectionOptions() | SELECTION_OPTION_SHOWFIRST);
1276 28 : aSettings.SetStyleSettings(aStyleSettings);
1277 56 : m_pWindow->SetSettings(aSettings);
1278 : }
1279 :
1280 28 : implAdjustGenericFieldSetting( xUnoModel );
1281 :
1282 28 : static_cast< FormattedField* >( m_pWindow )->SetStrictFormat( false );
1283 28 : static_cast< FormattedField* >( m_pPainter )->SetStrictFormat( false );
1284 : // wenn man _irgendeine_ Formatierung zulaesst, kann man da sowieso keine Eingabe-Ueberpruefung
1285 : // machen (das FormattedField unterstuetzt das sowieso nicht, nur abgeleitete Klassen)
1286 :
1287 : // von dem Uno-Model den Formatter besorgen
1288 : // (Ich koennte theoretisch auch ueber den ::com::sun::star::util::NumberFormatter gehen, den mir der Cursor bestimmt
1289 : // liefern wuerde. Das Problem dabei ist, dass ich mich eigentlich nicht darauf verlassen
1290 : // kann, dass die beiden Formatter die selben sind, sauber ist das Ganze, wenn ich ueber das
1291 : // UNO-Model gehe.)
1292 28 : sal_Int32 nFormatKey = -1;
1293 :
1294 : // mal sehen, ob das Model einen hat ...
1295 : DBG_ASSERT(::comphelper::hasProperty(FM_PROP_FORMATSSUPPLIER, xUnoModel), "DbFormattedField::Init : invalid UNO model !");
1296 28 : Any aSupplier( xUnoModel->getPropertyValue(FM_PROP_FORMATSSUPPLIER));
1297 28 : if (aSupplier.hasValue())
1298 : {
1299 28 : m_xSupplier.set(aSupplier, css::uno::UNO_QUERY);
1300 28 : if (m_xSupplier.is())
1301 : {
1302 : // wenn wir den Supplier vom Model nehmen, dann auch den Key
1303 28 : Any aFmtKey( xUnoModel->getPropertyValue(FM_PROP_FORMATKEY));
1304 28 : if (aFmtKey.hasValue())
1305 : {
1306 : DBG_ASSERT(aFmtKey.getValueType().getTypeClass() == TypeClass_LONG, "DbFormattedField::Init : invalid format key property (no sal_Int32) !");
1307 28 : nFormatKey = ::comphelper::getINT32(aFmtKey);
1308 : }
1309 : else
1310 : {
1311 : DBG_WARNING("DbFormattedField::Init : my uno-model has no format-key, but a formats supplier !");
1312 : // the OFormattedModel which we usually are working with ensures that the model has a format key
1313 : // as soon as the form is loaded. Unfortunally this method here is called from within loaded, too.
1314 : // So if our LoadListener is called before the LoadListener of the model, this "else case" is
1315 : // allowed.
1316 : // Of course our property listener for the FormatKey property will notify us if the prop is changed,
1317 : // so this here isn't really bad ....
1318 0 : nFormatKey = 0;
1319 28 : }
1320 : }
1321 : }
1322 :
1323 : // nein ? vielleicht die ::com::sun::star::form::component::Form hinter dem Cursor ?
1324 28 : if (!m_xSupplier.is())
1325 : {
1326 0 : Reference< XRowSet > xCursorForm(xCursor, UNO_QUERY);
1327 0 : if (xCursorForm.is())
1328 : { // wenn wir vom Cursor den Formatter nehmen, dann auch den Key vom Feld, an das wir gebunden sind
1329 0 : m_xSupplier = getNumberFormats(getConnection(xCursorForm), false);
1330 :
1331 0 : if (m_rColumn.GetField().is())
1332 0 : nFormatKey = ::comphelper::getINT32(m_rColumn.GetField()->getPropertyValue(FM_PROP_FORMATKEY));
1333 0 : }
1334 : }
1335 :
1336 28 : SvNumberFormatter* pFormatterUsed = NULL;
1337 28 : if (m_xSupplier.is())
1338 : {
1339 28 : SvNumberFormatsSupplierObj* pImplmentation = SvNumberFormatsSupplierObj::getImplementation(m_xSupplier);
1340 28 : if (pImplmentation)
1341 28 : pFormatterUsed = pImplmentation->GetNumberFormatter();
1342 : else
1343 : // alles hingfaellig : der Supplier ist vom falschen Typ, dann koennen wir uns auch nicht darauf verlassen, dass
1344 : // ein Standard-Formatter den (eventuell nicht-Standard-)Key kennt.
1345 0 : nFormatKey = -1;
1346 : }
1347 :
1348 : // einen Standard-Formatter ...
1349 28 : if (pFormatterUsed == NULL)
1350 : {
1351 0 : pFormatterUsed = static_cast<FormattedField*>(m_pWindow)->StandardFormatter();
1352 : DBG_ASSERT(pFormatterUsed != NULL, "DbFormattedField::Init : no standard formatter given by the numeric field !");
1353 : }
1354 : // ... und einen Standard-Key
1355 28 : if (nFormatKey == -1)
1356 0 : nFormatKey = 0;
1357 :
1358 28 : m_nKeyType = comphelper::getNumberFormatType(m_xSupplier->getNumberFormats(), nFormatKey);
1359 :
1360 28 : static_cast<FormattedField*>(m_pWindow)->SetFormatter(pFormatterUsed);
1361 28 : static_cast<FormattedField*>(m_pPainter)->SetFormatter(pFormatterUsed);
1362 :
1363 28 : static_cast<FormattedField*>(m_pWindow)->SetFormatKey(nFormatKey);
1364 28 : static_cast<FormattedField*>(m_pPainter)->SetFormatKey(nFormatKey);
1365 :
1366 28 : static_cast<FormattedField*>(m_pWindow)->TreatAsNumber(m_rColumn.IsNumeric());
1367 28 : static_cast<FormattedField*>(m_pPainter)->TreatAsNumber(m_rColumn.IsNumeric());
1368 :
1369 : // Min- und Max-Werte
1370 28 : if (m_rColumn.IsNumeric())
1371 : {
1372 0 : bool bClearMin = true;
1373 0 : if (::comphelper::hasProperty(FM_PROP_EFFECTIVE_MIN, xUnoModel))
1374 : {
1375 0 : Any aMin( xUnoModel->getPropertyValue(FM_PROP_EFFECTIVE_MIN));
1376 0 : if (aMin.getValueType().getTypeClass() != TypeClass_VOID)
1377 : {
1378 : DBG_ASSERT(aMin.getValueType().getTypeClass() == TypeClass_DOUBLE, "DbFormattedField::Init : the model has an invalid min value !");
1379 0 : double dMin = ::comphelper::getDouble(aMin);
1380 0 : static_cast<FormattedField*>(m_pWindow)->SetMinValue(dMin);
1381 0 : static_cast<FormattedField*>(m_pPainter)->SetMinValue(dMin);
1382 0 : bClearMin = false;
1383 0 : }
1384 : }
1385 0 : if (bClearMin)
1386 : {
1387 0 : static_cast<FormattedField*>(m_pWindow)->ClearMinValue();
1388 0 : static_cast<FormattedField*>(m_pPainter)->ClearMinValue();
1389 : }
1390 0 : bool bClearMax = true;
1391 0 : if (::comphelper::hasProperty(FM_PROP_EFFECTIVE_MAX, xUnoModel))
1392 : {
1393 0 : Any aMin( xUnoModel->getPropertyValue(FM_PROP_EFFECTIVE_MAX));
1394 0 : if (aMin.getValueType().getTypeClass() != TypeClass_VOID)
1395 : {
1396 : DBG_ASSERT(aMin.getValueType().getTypeClass() == TypeClass_DOUBLE, "DbFormattedField::Init : the model has an invalid max value !");
1397 0 : double dMin = ::comphelper::getDouble(aMin);
1398 0 : static_cast<FormattedField*>(m_pWindow)->SetMaxValue(dMin);
1399 0 : static_cast<FormattedField*>(m_pPainter)->SetMaxValue(dMin);
1400 0 : bClearMax = false;
1401 0 : }
1402 : }
1403 0 : if (bClearMax)
1404 : {
1405 0 : static_cast<FormattedField*>(m_pWindow)->ClearMaxValue();
1406 0 : static_cast<FormattedField*>(m_pPainter)->ClearMaxValue();
1407 : }
1408 : }
1409 :
1410 : // den Default-Wert
1411 56 : Any aDefault( xUnoModel->getPropertyValue(FM_PROP_EFFECTIVE_DEFAULT));
1412 28 : if (aDefault.hasValue())
1413 : { // das Ding kann ein double oder ein String sein
1414 0 : switch (aDefault.getValueType().getTypeClass())
1415 : {
1416 : case TypeClass_DOUBLE:
1417 0 : if (m_rColumn.IsNumeric())
1418 : {
1419 0 : static_cast<FormattedField*>(m_pWindow)->SetDefaultValue(::comphelper::getDouble(aDefault));
1420 0 : static_cast<FormattedField*>(m_pPainter)->SetDefaultValue(::comphelper::getDouble(aDefault));
1421 : }
1422 : else
1423 : {
1424 0 : OUString sConverted;
1425 : Color* pDummy;
1426 0 : pFormatterUsed->GetOutputString(::comphelper::getDouble(aDefault), 0, sConverted, &pDummy);
1427 0 : static_cast<FormattedField*>(m_pWindow)->SetDefaultText(sConverted);
1428 0 : static_cast<FormattedField*>(m_pPainter)->SetDefaultText(sConverted);
1429 : }
1430 0 : break;
1431 : case TypeClass_STRING:
1432 : {
1433 0 : OUString sDefault( ::comphelper::getString(aDefault) );
1434 0 : if (m_rColumn.IsNumeric())
1435 : {
1436 : double dVal;
1437 0 : sal_uInt32 nTestFormat(0);
1438 0 : if (pFormatterUsed->IsNumberFormat(sDefault, nTestFormat, dVal))
1439 : {
1440 0 : static_cast<FormattedField*>(m_pWindow)->SetDefaultValue(dVal);
1441 0 : static_cast<FormattedField*>(m_pPainter)->SetDefaultValue(dVal);
1442 : }
1443 : }
1444 : else
1445 : {
1446 0 : static_cast<FormattedField*>(m_pWindow)->SetDefaultText(sDefault);
1447 0 : static_cast<FormattedField*>(m_pPainter)->SetDefaultText(sDefault);
1448 0 : }
1449 : }
1450 0 : break;
1451 : default:
1452 : OSL_FAIL( "DbFormattedField::Init: unexpected value type!" );
1453 0 : break;
1454 : }
1455 : }
1456 56 : DbLimitedLengthField::Init( rParent, xCursor );
1457 28 : }
1458 :
1459 :
1460 28 : CellControllerRef DbFormattedField::CreateController() const
1461 : {
1462 28 : return new ::svt::FormattedFieldCellController( static_cast< FormattedField* >( m_pWindow ) );
1463 : }
1464 :
1465 :
1466 0 : void DbFormattedField::_propertyChanged( const PropertyChangeEvent& _rEvent ) throw( RuntimeException )
1467 : {
1468 0 : if (_rEvent.PropertyName == FM_PROP_FORMATKEY )
1469 : {
1470 0 : sal_Int32 nNewKey = _rEvent.NewValue.hasValue() ? ::comphelper::getINT32(_rEvent.NewValue) : 0;
1471 0 : m_nKeyType = comphelper::getNumberFormatType(m_xSupplier->getNumberFormats(), nNewKey);
1472 :
1473 : DBG_ASSERT(m_pWindow && m_pPainter, "DbFormattedField::_propertyChanged : where are my windows ?");
1474 0 : if (m_pWindow)
1475 0 : static_cast< FormattedField* >( m_pWindow )->SetFormatKey( nNewKey );
1476 0 : if (m_pPainter)
1477 0 : static_cast< FormattedField* >( m_pPainter )->SetFormatKey( nNewKey );
1478 : }
1479 : else
1480 : {
1481 0 : DbLimitedLengthField::_propertyChanged( _rEvent );
1482 : }
1483 0 : }
1484 :
1485 :
1486 46 : OUString DbFormattedField::GetFormatText(const Reference< ::com::sun::star::sdb::XColumn >& _rxField, const Reference< XNumberFormatter >& /*xFormatter*/, Color** ppColor)
1487 : {
1488 : // defaultmaessig keine Farb-Angabe
1489 46 : if (ppColor != NULL)
1490 46 : *ppColor = NULL;
1491 :
1492 : // NULL-Wert -> leerer Text
1493 46 : if (!_rxField.is())
1494 0 : return OUString();
1495 :
1496 46 : OUString aText;
1497 : try
1498 : {
1499 46 : if (m_rColumn.IsNumeric())
1500 : {
1501 : // das IsNumeric an der Column sagt nichts aus ueber die Klasse des benutzen Formates, sondern
1502 : // ueber die des an die Column gebundenen Feldes. Wenn man also eine FormattedField-Spalte an
1503 : // ein double-Feld bindet und als Text formatiert, liefert m_rColumn.IsNumeric() sal_True. Das heisst
1504 : // also einfach, dass ich den Inhalt der Variant mittels getDouble abfragen kann, und dann kann
1505 : // ich den Rest (die Formatierung) dem FormattedField ueberlassen.
1506 0 : double dValue = getValue( _rxField, m_rColumn.GetParent().getNullDate() );
1507 0 : if (_rxField->wasNull())
1508 0 : return aText;
1509 0 : static_cast<FormattedField*>(m_pPainter)->SetValue(dValue);
1510 : }
1511 : else
1512 : {
1513 : // Hier kann ich nicht mit einem double arbeiten, da das Feld mir keines liefern kann.
1514 : // Also einfach den Text vom ::com::sun::star::util::NumberFormatter in die richtige ::com::sun::star::form::component::Form brinden lassen.
1515 46 : aText = _rxField->getString();
1516 46 : if (_rxField->wasNull())
1517 16 : return aText;
1518 30 : static_cast<FormattedField*>(m_pPainter)->SetTextFormatted(aText);
1519 : }
1520 : }
1521 0 : catch( const Exception& )
1522 : {
1523 : DBG_UNHANDLED_EXCEPTION();
1524 : }
1525 :
1526 30 : aText = m_pPainter->GetText();
1527 30 : if (ppColor != NULL)
1528 30 : *ppColor = static_cast<FormattedField*>(m_pPainter)->GetLastOutputColor();
1529 :
1530 30 : return aText;
1531 : }
1532 :
1533 :
1534 2 : void DbFormattedField::UpdateFromField(const Reference< ::com::sun::star::sdb::XColumn >& _rxField, const Reference< XNumberFormatter >& /*xFormatter*/)
1535 : {
1536 : try
1537 : {
1538 2 : FormattedField* pFormattedWindow = static_cast<FormattedField*>(m_pWindow);
1539 2 : if (!_rxField.is())
1540 : { // NULL-Wert -> leerer Text
1541 0 : m_pWindow->SetText(OUString());
1542 : }
1543 2 : else if (m_rColumn.IsNumeric())
1544 : {
1545 : // das IsNumeric an der Column sagt nichts aus ueber die Klasse des benutzen Formates, sondern
1546 : // ueber die des an die Column gebundenen Feldes. Wenn man also eine FormattedField-Spalte an
1547 : // ein double-Feld bindet und als Text formatiert, liefert m_rColumn.IsNumeric() sal_True. Das heisst
1548 : // also einfach, dass ich den Inhalt der Variant mittels getDouble abfragen kann, und dann kann
1549 : // ich den Rest (die Formatierung) dem FormattedField ueberlassen.
1550 0 : double dValue = getValue( _rxField, m_rColumn.GetParent().getNullDate() );
1551 0 : if (_rxField->wasNull())
1552 0 : m_pWindow->SetText(OUString());
1553 : else
1554 0 : pFormattedWindow->SetValue(dValue);
1555 : }
1556 : else
1557 : {
1558 : // Hier kann ich nicht mit einem double arbeiten, da das Feld mir keines liefern kann.
1559 : // Also einfach den Text vom ::com::sun::star::util::NumberFormatter in die richtige ::com::sun::star::form::component::Form brinden lassen.
1560 2 : OUString sText( _rxField->getString());
1561 :
1562 2 : pFormattedWindow->SetTextFormatted( sText );
1563 2 : pFormattedWindow->SetSelection( Selection( SELECTION_MAX, SELECTION_MIN ) );
1564 : }
1565 : }
1566 0 : catch( const Exception& )
1567 : {
1568 : DBG_UNHANDLED_EXCEPTION();
1569 : }
1570 2 : }
1571 :
1572 :
1573 0 : void DbFormattedField::updateFromModel( Reference< XPropertySet > _rxModel )
1574 : {
1575 : OSL_ENSURE( _rxModel.is() && m_pWindow, "DbFormattedField::updateFromModel: invalid call!" );
1576 :
1577 0 : FormattedField* pFormattedWindow = static_cast< FormattedField* >( m_pWindow );
1578 :
1579 0 : OUString sText;
1580 0 : Any aValue = _rxModel->getPropertyValue( FM_PROP_EFFECTIVE_VALUE );
1581 0 : if ( aValue >>= sText )
1582 : { // our effective value is transferred as string
1583 0 : pFormattedWindow->SetTextFormatted( sText );
1584 0 : pFormattedWindow->SetSelection( Selection( SELECTION_MAX, SELECTION_MIN ) );
1585 : }
1586 : else
1587 : {
1588 0 : double dValue = 0;
1589 0 : aValue >>= dValue;
1590 0 : pFormattedWindow->SetValue(dValue);
1591 0 : }
1592 0 : }
1593 :
1594 :
1595 0 : bool DbFormattedField::commitControl()
1596 : {
1597 0 : Any aNewVal;
1598 0 : FormattedField& rField = *static_cast<FormattedField*>(m_pWindow);
1599 : DBG_ASSERT(&rField == m_pWindow, "DbFormattedField::commitControl : can't work with a window other than my own !");
1600 0 : if (m_rColumn.IsNumeric())
1601 : {
1602 0 : if (!rField.GetText().isEmpty())
1603 0 : aNewVal <<= rField.GetValue();
1604 : // ein LeerString wird erst mal standardmaessig als void weitergereicht
1605 : }
1606 : else
1607 0 : aNewVal <<= OUString(rField.GetTextValue());
1608 :
1609 0 : m_rColumn.getModel()->setPropertyValue(FM_PROP_EFFECTIVE_VALUE, aNewVal);
1610 0 : return true;
1611 : }
1612 :
1613 0 : DbCheckBox::DbCheckBox( DbGridColumn& _rColumn )
1614 0 : :DbCellControl( _rColumn, true )
1615 : {
1616 0 : setAlignedController( false );
1617 0 : }
1618 :
1619 : namespace
1620 : {
1621 0 : void setCheckBoxStyle( vcl::Window* _pWindow, bool bMono )
1622 : {
1623 0 : AllSettings aSettings = _pWindow->GetSettings();
1624 0 : StyleSettings aStyleSettings = aSettings.GetStyleSettings();
1625 0 : if( bMono )
1626 0 : aStyleSettings.SetOptions( aStyleSettings.GetOptions() | STYLE_OPTION_MONO );
1627 : else
1628 0 : aStyleSettings.SetOptions( aStyleSettings.GetOptions() & (~STYLE_OPTION_MONO) );
1629 0 : aSettings.SetStyleSettings( aStyleSettings );
1630 0 : _pWindow->SetSettings( aSettings );
1631 0 : }
1632 : }
1633 :
1634 :
1635 0 : void DbCheckBox::Init( vcl::Window& rParent, const Reference< XRowSet >& xCursor )
1636 : {
1637 0 : setTransparent( true );
1638 :
1639 0 : m_pWindow = new CheckBoxControl( &rParent );
1640 0 : m_pPainter = new CheckBoxControl( &rParent );
1641 :
1642 0 : m_pWindow->SetPaintTransparent( true );
1643 0 : m_pPainter->SetPaintTransparent( true );
1644 :
1645 0 : m_pPainter->SetBackground();
1646 :
1647 : try
1648 : {
1649 0 : Reference< XPropertySet > xModel( m_rColumn.getModel(), UNO_SET_THROW );
1650 :
1651 0 : sal_Int16 nStyle = awt::VisualEffect::LOOK3D;
1652 0 : OSL_VERIFY( xModel->getPropertyValue( FM_PROP_VISUALEFFECT ) >>= nStyle );
1653 :
1654 0 : setCheckBoxStyle( m_pWindow, nStyle == awt::VisualEffect::FLAT );
1655 0 : setCheckBoxStyle( m_pPainter, nStyle == awt::VisualEffect::FLAT );
1656 :
1657 0 : bool bTristate = true;
1658 0 : OSL_VERIFY( xModel->getPropertyValue( FM_PROP_TRISTATE ) >>= bTristate );
1659 0 : static_cast< CheckBoxControl* >( m_pWindow )->GetBox().EnableTriState( bTristate );
1660 0 : static_cast< CheckBoxControl* >( m_pPainter )->GetBox().EnableTriState( bTristate );
1661 : }
1662 0 : catch( const Exception& )
1663 : {
1664 : DBG_UNHANDLED_EXCEPTION();
1665 : }
1666 :
1667 0 : DbCellControl::Init( rParent, xCursor );
1668 0 : }
1669 :
1670 :
1671 0 : CellControllerRef DbCheckBox::CreateController() const
1672 : {
1673 0 : return new CheckBoxCellController(static_cast<CheckBoxControl*>(m_pWindow));
1674 : }
1675 :
1676 0 : static void lcl_setCheckBoxState( const Reference< ::com::sun::star::sdb::XColumn >& _rxField,
1677 : CheckBoxControl* _pCheckBoxControl )
1678 : {
1679 0 : TriState eState = TRISTATE_INDET;
1680 0 : if (_rxField.is())
1681 : {
1682 : try
1683 : {
1684 0 : bool bValue = _rxField->getBoolean();
1685 0 : if (!_rxField->wasNull())
1686 0 : eState = bValue ? TRISTATE_TRUE : TRISTATE_FALSE;
1687 : }
1688 0 : catch( const Exception& )
1689 : {
1690 : DBG_UNHANDLED_EXCEPTION();
1691 : }
1692 : }
1693 0 : _pCheckBoxControl->GetBox().SetState(eState);
1694 0 : }
1695 :
1696 :
1697 0 : void DbCheckBox::UpdateFromField(const Reference< ::com::sun::star::sdb::XColumn >& _rxField, const Reference< XNumberFormatter >& /*xFormatter*/)
1698 : {
1699 0 : lcl_setCheckBoxState( _rxField, static_cast<CheckBoxControl*>(m_pWindow) );
1700 0 : }
1701 :
1702 :
1703 0 : void DbCheckBox::PaintFieldToCell(OutputDevice& rDev, const Rectangle& rRect,
1704 : const Reference< ::com::sun::star::sdb::XColumn >& _rxField,
1705 : const Reference< XNumberFormatter >& xFormatter)
1706 : {
1707 0 : lcl_setCheckBoxState( _rxField, static_cast<CheckBoxControl*>(m_pPainter) );
1708 0 : DbCellControl::PaintFieldToCell( rDev, rRect, _rxField, xFormatter );
1709 0 : }
1710 :
1711 :
1712 0 : void DbCheckBox::updateFromModel( Reference< XPropertySet > _rxModel )
1713 : {
1714 : OSL_ENSURE( _rxModel.is() && m_pWindow, "DbCheckBox::updateFromModel: invalid call!" );
1715 :
1716 0 : sal_Int16 nState = TRISTATE_INDET;
1717 0 : _rxModel->getPropertyValue( FM_PROP_STATE ) >>= nState;
1718 0 : static_cast< CheckBoxControl* >( m_pWindow )->GetBox().SetState( static_cast< TriState >( nState ) );
1719 0 : }
1720 :
1721 :
1722 0 : bool DbCheckBox::commitControl()
1723 : {
1724 0 : m_rColumn.getModel()->setPropertyValue( FM_PROP_STATE,
1725 0 : makeAny( (sal_Int16)( static_cast< CheckBoxControl* >( m_pWindow )->GetBox().GetState() ) ) );
1726 0 : return true;
1727 : }
1728 :
1729 :
1730 0 : OUString DbCheckBox::GetFormatText(const Reference< XColumn >& /*_rxField*/, const Reference< XNumberFormatter >& /*xFormatter*/, Color** /*ppColor*/)
1731 : {
1732 0 : return OUString();
1733 : }
1734 :
1735 0 : DbPatternField::DbPatternField( DbGridColumn& _rColumn, const Reference<XComponentContext>& _rContext )
1736 : :DbCellControl( _rColumn )
1737 0 : ,m_xContext( _rContext )
1738 : {
1739 0 : doPropertyListening( FM_PROP_LITERALMASK );
1740 0 : doPropertyListening( FM_PROP_EDITMASK );
1741 0 : doPropertyListening( FM_PROP_STRICTFORMAT );
1742 0 : }
1743 :
1744 :
1745 0 : void DbPatternField::implAdjustGenericFieldSetting( const Reference< XPropertySet >& _rxModel )
1746 : {
1747 : DBG_ASSERT( m_pWindow, "DbPatternField::implAdjustGenericFieldSetting: not to be called without window!" );
1748 : DBG_ASSERT( _rxModel.is(), "DbPatternField::implAdjustGenericFieldSetting: invalid model!" );
1749 0 : if ( m_pWindow && _rxModel.is() )
1750 : {
1751 0 : OUString aLitMask;
1752 0 : OUString aEditMask;
1753 0 : bool bStrict = false;
1754 :
1755 0 : _rxModel->getPropertyValue( FM_PROP_LITERALMASK ) >>= aLitMask;
1756 0 : _rxModel->getPropertyValue( FM_PROP_EDITMASK ) >>= aEditMask;
1757 0 : _rxModel->getPropertyValue( FM_PROP_STRICTFORMAT ) >>= bStrict;
1758 :
1759 0 : OString aAsciiEditMask(OUStringToOString(aEditMask, RTL_TEXTENCODING_ASCII_US));
1760 :
1761 0 : static_cast< PatternField* >( m_pWindow )->SetMask( aAsciiEditMask, aLitMask );
1762 0 : static_cast< PatternField* >( m_pPainter )->SetMask( aAsciiEditMask, aLitMask );
1763 0 : static_cast< PatternField* >( m_pWindow )->SetStrictFormat( bStrict );
1764 0 : static_cast< PatternField* >( m_pPainter )->SetStrictFormat( bStrict );
1765 : }
1766 0 : }
1767 :
1768 :
1769 0 : void DbPatternField::Init( vcl::Window& rParent, const Reference< XRowSet >& xCursor)
1770 : {
1771 0 : m_rColumn.SetAlignmentFromModel(-1);
1772 :
1773 0 : m_pWindow = new PatternField( &rParent, 0 );
1774 0 : m_pPainter= new PatternField( &rParent, 0 );
1775 :
1776 0 : Reference< XPropertySet > xModel( m_rColumn.getModel() );
1777 0 : implAdjustGenericFieldSetting( xModel );
1778 :
1779 0 : DbCellControl::Init( rParent, xCursor );
1780 0 : }
1781 :
1782 :
1783 0 : CellControllerRef DbPatternField::CreateController() const
1784 : {
1785 0 : return new SpinCellController( static_cast< PatternField* >( m_pWindow ) );
1786 : }
1787 :
1788 :
1789 0 : OUString DbPatternField::impl_formatText( const OUString& _rText )
1790 : {
1791 0 : m_pPainter->SetText( _rText );
1792 0 : static_cast< PatternField* >( m_pPainter )->ReformatAll();
1793 0 : return m_pPainter->GetText();
1794 : }
1795 :
1796 :
1797 0 : OUString DbPatternField::GetFormatText(const Reference< ::com::sun::star::sdb::XColumn >& _rxField, const Reference< XNumberFormatter >& /*xFormatter*/, Color** /*ppColor*/)
1798 : {
1799 0 : bool bIsForPaint = _rxField != m_rColumn.GetField();
1800 0 : ::std::unique_ptr< FormattedColumnValue >& rpFormatter = bIsForPaint ? m_pPaintFormatter : m_pValueFormatter;
1801 :
1802 0 : if ( !rpFormatter.get() )
1803 : {
1804 0 : DBToolsObjectFactory aFactory;
1805 0 : rpFormatter = aFactory.createFormattedColumnValue(
1806 0 : m_xContext, getCursor(), Reference< XPropertySet >( _rxField, UNO_QUERY ) );
1807 0 : OSL_ENSURE( rpFormatter.get(), "DbPatternField::Init: no value formatter!" );
1808 : }
1809 : else
1810 : OSL_ENSURE( rpFormatter->getColumn() == _rxField, "DbPatternField::GetFormatText: my value formatter is working for another field ...!" );
1811 : // re-creating the value formatter here every time would be quite expensive ...
1812 :
1813 0 : OUString sText;
1814 0 : if ( rpFormatter.get() )
1815 0 : sText = rpFormatter->getFormattedValue();
1816 :
1817 0 : return impl_formatText( sText );
1818 : }
1819 :
1820 :
1821 0 : void DbPatternField::UpdateFromField( const Reference< XColumn >& _rxField, const Reference< XNumberFormatter >& _rxFormatter )
1822 : {
1823 0 : static_cast< Edit* >( m_pWindow )->SetText( GetFormatText( _rxField, _rxFormatter ) );
1824 0 : static_cast< Edit* >( m_pWindow )->SetSelection( Selection( SELECTION_MAX, SELECTION_MIN ) );
1825 0 : }
1826 :
1827 :
1828 0 : void DbPatternField::updateFromModel( Reference< XPropertySet > _rxModel )
1829 : {
1830 : OSL_ENSURE( _rxModel.is() && m_pWindow, "DbPatternField::updateFromModel: invalid call!" );
1831 :
1832 0 : OUString sText;
1833 0 : _rxModel->getPropertyValue( FM_PROP_TEXT ) >>= sText;
1834 :
1835 0 : static_cast< Edit* >( m_pWindow )->SetText( impl_formatText( sText ) );
1836 0 : static_cast< Edit* >( m_pWindow )->SetSelection( Selection( SELECTION_MAX, SELECTION_MIN ) );
1837 0 : }
1838 :
1839 :
1840 0 : bool DbPatternField::commitControl()
1841 : {
1842 0 : OUString aText(m_pWindow->GetText());
1843 0 : m_rColumn.getModel()->setPropertyValue(FM_PROP_TEXT, makeAny(aText));
1844 0 : return true;
1845 : }
1846 :
1847 0 : DbSpinField::DbSpinField( DbGridColumn& _rColumn, sal_Int16 _nStandardAlign )
1848 : :DbCellControl( _rColumn )
1849 0 : ,m_nStandardAlign( _nStandardAlign )
1850 : {
1851 0 : }
1852 :
1853 :
1854 0 : void DbSpinField::Init( vcl::Window& _rParent, const Reference< XRowSet >& _rxCursor )
1855 : {
1856 0 : m_rColumn.SetAlignmentFromModel( m_nStandardAlign );
1857 :
1858 0 : Reference< XPropertySet > xModel( m_rColumn.getModel() );
1859 :
1860 : // determine the WinBits for the field
1861 0 : WinBits nFieldStyle = 0;
1862 0 : if ( ::comphelper::getBOOL( xModel->getPropertyValue( FM_PROP_SPIN ) ) )
1863 0 : nFieldStyle = WB_REPEAT | WB_SPIN;
1864 : // create the fields
1865 0 : m_pWindow = createField( &_rParent, nFieldStyle, xModel );
1866 0 : m_pPainter = createField( &_rParent, nFieldStyle, xModel );
1867 :
1868 : // adjust all other settings which depend on the property values
1869 0 : implAdjustGenericFieldSetting( xModel );
1870 :
1871 : // call the base class
1872 0 : DbCellControl::Init( _rParent, _rxCursor );
1873 0 : }
1874 :
1875 :
1876 0 : CellControllerRef DbSpinField::CreateController() const
1877 : {
1878 0 : return new SpinCellController( static_cast< SpinField* >( m_pWindow ) );
1879 : }
1880 :
1881 0 : DbNumericField::DbNumericField( DbGridColumn& _rColumn )
1882 0 : :DbSpinField( _rColumn )
1883 : {
1884 0 : doPropertyListening( FM_PROP_DECIMAL_ACCURACY );
1885 0 : doPropertyListening( FM_PROP_VALUEMIN );
1886 0 : doPropertyListening( FM_PROP_VALUEMAX );
1887 0 : doPropertyListening( FM_PROP_VALUESTEP );
1888 0 : doPropertyListening( FM_PROP_STRICTFORMAT );
1889 0 : doPropertyListening( FM_PROP_SHOWTHOUSANDSEP );
1890 0 : }
1891 :
1892 :
1893 0 : void DbNumericField::implAdjustGenericFieldSetting( const Reference< XPropertySet >& _rxModel )
1894 : {
1895 : DBG_ASSERT( m_pWindow, "DbNumericField::implAdjustGenericFieldSetting: not to be called without window!" );
1896 : DBG_ASSERT( _rxModel.is(), "DbNumericField::implAdjustGenericFieldSetting: invalid model!" );
1897 0 : if ( m_pWindow && _rxModel.is() )
1898 : {
1899 0 : sal_Int32 nMin = (sal_Int32)getDouble( _rxModel->getPropertyValue( FM_PROP_VALUEMIN ) );
1900 0 : sal_Int32 nMax = (sal_Int32)getDouble( _rxModel->getPropertyValue( FM_PROP_VALUEMAX ) );
1901 0 : sal_Int32 nStep = (sal_Int32)getDouble( _rxModel->getPropertyValue( FM_PROP_VALUESTEP ) );
1902 0 : bool bStrict = getBOOL( _rxModel->getPropertyValue( FM_PROP_STRICTFORMAT ) );
1903 0 : sal_Int16 nScale = getINT16( _rxModel->getPropertyValue( FM_PROP_DECIMAL_ACCURACY ) );
1904 0 : bool bThousand = getBOOL( _rxModel->getPropertyValue( FM_PROP_SHOWTHOUSANDSEP ) );
1905 :
1906 0 : static_cast< DoubleNumericField* >( m_pWindow )->SetMinValue(nMin);
1907 0 : static_cast< DoubleNumericField* >( m_pWindow )->SetMaxValue(nMax);
1908 0 : static_cast< DoubleNumericField* >( m_pWindow )->SetSpinSize(nStep);
1909 0 : static_cast< DoubleNumericField* >( m_pWindow )->SetStrictFormat(bStrict);
1910 :
1911 0 : static_cast< DoubleNumericField* >( m_pPainter )->SetMinValue(nMin);
1912 0 : static_cast< DoubleNumericField* >( m_pPainter )->SetMaxValue(nMax);
1913 0 : static_cast< DoubleNumericField* >( m_pPainter )->SetStrictFormat(bStrict);
1914 :
1915 :
1916 : // dem Field und dem Painter einen Formatter spendieren
1917 : // zuerst testen, ob ich von dem Service hinter einer Connection bekommen kann
1918 0 : Reference< ::com::sun::star::util::XNumberFormatsSupplier > xSupplier;
1919 0 : Reference< XRowSet > xForm;
1920 0 : if ( m_rColumn.GetParent().getDataSource() )
1921 0 : xForm = Reference< XRowSet >( Reference< XInterface >(*m_rColumn.GetParent().getDataSource()), UNO_QUERY );
1922 0 : if ( xForm.is() )
1923 0 : xSupplier = getNumberFormats( getConnection( xForm ), true );
1924 0 : SvNumberFormatter* pFormatterUsed = NULL;
1925 0 : if ( xSupplier.is() )
1926 : {
1927 0 : SvNumberFormatsSupplierObj* pImplmentation = SvNumberFormatsSupplierObj::getImplementation( xSupplier );
1928 0 : pFormatterUsed = pImplmentation ? pImplmentation->GetNumberFormatter() : NULL;
1929 : }
1930 0 : if ( NULL == pFormatterUsed )
1931 : { // der Cursor fuehrte nicht zum Erfolg -> Standard
1932 0 : pFormatterUsed = static_cast< DoubleNumericField* >( m_pWindow )->StandardFormatter();
1933 : DBG_ASSERT( pFormatterUsed != NULL, "DbNumericField::implAdjustGenericFieldSetting: no standard formatter given by the numeric field !" );
1934 : }
1935 0 : static_cast< DoubleNumericField* >( m_pWindow )->SetFormatter( pFormatterUsed );
1936 0 : static_cast< DoubleNumericField* >( m_pPainter )->SetFormatter( pFormatterUsed );
1937 :
1938 : // und dann ein Format generieren, dass die gewuenschten Nachkommastellen usw. hat
1939 0 : LanguageType aAppLanguage = Application::GetSettings().GetUILanguageTag().getLanguageType();
1940 0 : OUString sFormatString = pFormatterUsed->GenerateFormat(0, aAppLanguage, bThousand, false, nScale);
1941 :
1942 0 : static_cast< DoubleNumericField* >( m_pWindow )->SetFormat( sFormatString, aAppLanguage );
1943 0 : static_cast< DoubleNumericField* >( m_pPainter )->SetFormat( sFormatString, aAppLanguage );
1944 : }
1945 0 : }
1946 :
1947 :
1948 0 : SpinField* DbNumericField::createField( vcl::Window* _pParent, WinBits _nFieldStyle, const Reference< XPropertySet >& /*_rxModel*/ )
1949 : {
1950 0 : return new DoubleNumericField( _pParent, _nFieldStyle );
1951 : }
1952 :
1953 : namespace
1954 : {
1955 :
1956 0 : static OUString lcl_setFormattedNumeric_nothrow( DoubleNumericField& _rField, const DbCellControl& _rControl,
1957 : const Reference< XColumn >& _rxField, const Reference< XNumberFormatter >& _rxFormatter )
1958 : {
1959 0 : OUString sValue;
1960 0 : if ( _rxField.is() )
1961 : {
1962 : try
1963 : {
1964 0 : double fValue = _rControl.GetValue( _rxField, _rxFormatter );
1965 0 : if ( !_rxField->wasNull() )
1966 : {
1967 0 : _rField.SetValue( fValue );
1968 0 : sValue = _rField.GetText();
1969 : }
1970 : }
1971 0 : catch( const Exception& )
1972 : {
1973 : DBG_UNHANDLED_EXCEPTION();
1974 : }
1975 : }
1976 0 : return sValue;
1977 : }
1978 : }
1979 :
1980 :
1981 0 : OUString DbNumericField::GetFormatText(const Reference< ::com::sun::star::sdb::XColumn >& _rxField, const Reference< ::com::sun::star::util::XNumberFormatter >& _rxFormatter, Color** /*ppColor*/)
1982 : {
1983 0 : return lcl_setFormattedNumeric_nothrow(dynamic_cast<DoubleNumericField&>(*m_pPainter), *this, _rxField, _rxFormatter);
1984 : }
1985 :
1986 :
1987 0 : void DbNumericField::UpdateFromField(const Reference< ::com::sun::star::sdb::XColumn >& _rxField, const Reference< ::com::sun::star::util::XNumberFormatter >& _rxFormatter)
1988 : {
1989 0 : lcl_setFormattedNumeric_nothrow(dynamic_cast<DoubleNumericField&>(*m_pWindow), *this, _rxField, _rxFormatter);
1990 0 : }
1991 :
1992 :
1993 0 : void DbNumericField::updateFromModel( Reference< XPropertySet > _rxModel )
1994 : {
1995 : OSL_ENSURE( _rxModel.is() && m_pWindow, "DbNumericField::updateFromModel: invalid call!" );
1996 :
1997 0 : double dValue = 0;
1998 0 : if ( _rxModel->getPropertyValue( FM_PROP_VALUE ) >>= dValue )
1999 0 : static_cast< DoubleNumericField* >( m_pWindow )->SetValue( dValue );
2000 : else
2001 0 : m_pWindow->SetText( OUString() );
2002 0 : }
2003 :
2004 :
2005 0 : bool DbNumericField::commitControl()
2006 : {
2007 0 : OUString aText( m_pWindow->GetText());
2008 0 : Any aVal;
2009 :
2010 0 : if (!aText.isEmpty()) // not empty
2011 : {
2012 0 : double fValue = static_cast<DoubleNumericField*>(m_pWindow)->GetValue();
2013 0 : aVal <<= (double)fValue;
2014 : }
2015 0 : m_rColumn.getModel()->setPropertyValue(FM_PROP_VALUE, aVal);
2016 0 : return true;
2017 : }
2018 :
2019 0 : DbCurrencyField::DbCurrencyField(DbGridColumn& _rColumn)
2020 : :DbSpinField( _rColumn )
2021 0 : ,m_nScale( 0 )
2022 : {
2023 0 : doPropertyListening( FM_PROP_DECIMAL_ACCURACY );
2024 0 : doPropertyListening( FM_PROP_VALUEMIN );
2025 0 : doPropertyListening( FM_PROP_VALUEMAX );
2026 0 : doPropertyListening( FM_PROP_VALUESTEP );
2027 0 : doPropertyListening( FM_PROP_STRICTFORMAT );
2028 0 : doPropertyListening( FM_PROP_SHOWTHOUSANDSEP );
2029 0 : doPropertyListening( FM_PROP_CURRENCYSYMBOL );
2030 0 : }
2031 :
2032 :
2033 0 : void DbCurrencyField::implAdjustGenericFieldSetting( const Reference< XPropertySet >& _rxModel )
2034 : {
2035 : DBG_ASSERT( m_pWindow, "DbCurrencyField::implAdjustGenericFieldSetting: not to be called without window!" );
2036 : DBG_ASSERT( _rxModel.is(), "DbCurrencyField::implAdjustGenericFieldSetting: invalid model!" );
2037 0 : if ( m_pWindow && _rxModel.is() )
2038 : {
2039 0 : m_nScale = getINT16( _rxModel->getPropertyValue( FM_PROP_DECIMAL_ACCURACY ) );
2040 0 : double nMin = getDouble( _rxModel->getPropertyValue( FM_PROP_VALUEMIN ) );
2041 0 : double nMax = getDouble( _rxModel->getPropertyValue( FM_PROP_VALUEMAX ) );
2042 0 : double nStep = getDouble( _rxModel->getPropertyValue( FM_PROP_VALUESTEP ) );
2043 0 : bool bStrict = getBOOL( _rxModel->getPropertyValue( FM_PROP_STRICTFORMAT ) );
2044 0 : bool bThousand = getBOOL( _rxModel->getPropertyValue( FM_PROP_SHOWTHOUSANDSEP ) );
2045 0 : OUString aStr( getString( _rxModel->getPropertyValue(FM_PROP_CURRENCYSYMBOL ) ) );
2046 :
2047 : //fdo#42747 the min/max/first/last of vcl NumericFormatters needs to be
2048 : //multiplied by the no of decimal places. See also
2049 : //VclBuilder::mungeAdjustment
2050 0 : int nMul = rtl_math_pow10Exp(1, m_nScale);
2051 0 : nMin *= nMul;
2052 0 : nMax *= nMul;
2053 :
2054 0 : static_cast< LongCurrencyField* >( m_pWindow )->SetUseThousandSep( bThousand );
2055 0 : static_cast< LongCurrencyField* >( m_pWindow )->SetDecimalDigits( m_nScale );
2056 0 : static_cast< LongCurrencyField* >( m_pWindow )->SetCurrencySymbol( aStr );
2057 0 : static_cast< LongCurrencyField* >( m_pWindow )->SetFirst( nMin );
2058 0 : static_cast< LongCurrencyField* >( m_pWindow )->SetLast( nMax );
2059 0 : static_cast< LongCurrencyField* >( m_pWindow )->SetMin( nMin );
2060 0 : static_cast< LongCurrencyField* >( m_pWindow )->SetMax( nMax );
2061 0 : static_cast< LongCurrencyField* >( m_pWindow )->SetSpinSize( nStep );
2062 0 : static_cast< LongCurrencyField* >( m_pWindow )->SetStrictFormat( bStrict );
2063 :
2064 0 : static_cast< LongCurrencyField* >( m_pPainter )->SetUseThousandSep( bThousand );
2065 0 : static_cast< LongCurrencyField* >( m_pPainter )->SetDecimalDigits( m_nScale );
2066 0 : static_cast< LongCurrencyField* >( m_pPainter )->SetCurrencySymbol( aStr );
2067 0 : static_cast< LongCurrencyField* >( m_pPainter )->SetFirst( nMin );
2068 0 : static_cast< LongCurrencyField* >( m_pPainter )->SetLast( nMax );
2069 0 : static_cast< LongCurrencyField* >( m_pPainter )->SetMin( nMin );
2070 0 : static_cast< LongCurrencyField* >( m_pPainter )->SetMax( nMax );
2071 0 : static_cast< LongCurrencyField* >( m_pPainter )->SetStrictFormat( bStrict );
2072 : }
2073 0 : }
2074 :
2075 :
2076 0 : SpinField* DbCurrencyField::createField( vcl::Window* _pParent, WinBits _nFieldStyle, const Reference< XPropertySet >& /*_rxModel*/ )
2077 : {
2078 0 : return new LongCurrencyField( _pParent, _nFieldStyle );
2079 : }
2080 :
2081 :
2082 0 : double DbCurrencyField::GetCurrency(const Reference< ::com::sun::star::sdb::XColumn >& _rxField, const Reference< XNumberFormatter >& xFormatter) const
2083 : {
2084 0 : double fValue = GetValue(_rxField, xFormatter);
2085 0 : if (m_nScale)
2086 : {
2087 : // OSL_TRACE("double = %.64f ",fValue);
2088 0 : fValue = ::rtl::math::pow10Exp(fValue, m_nScale);
2089 0 : fValue = ::rtl::math::round(fValue, 0);
2090 : }
2091 0 : return fValue;
2092 : }
2093 :
2094 : namespace
2095 : {
2096 :
2097 0 : static OUString lcl_setFormattedCurrency_nothrow( LongCurrencyField& _rField, const DbCurrencyField& _rControl,
2098 : const Reference< XColumn >& _rxField, const Reference< XNumberFormatter >& _rxFormatter )
2099 : {
2100 0 : OUString sValue;
2101 0 : if ( _rxField.is() )
2102 : {
2103 : try
2104 : {
2105 0 : double fValue = _rControl.GetCurrency( _rxField, _rxFormatter );
2106 0 : if ( !_rxField->wasNull() )
2107 : {
2108 0 : _rField.SetValue( fValue );
2109 0 : sValue = _rField.GetText();
2110 : }
2111 : }
2112 0 : catch( const Exception& )
2113 : {
2114 : DBG_UNHANDLED_EXCEPTION();
2115 : }
2116 : }
2117 0 : return sValue;
2118 : }
2119 : }
2120 :
2121 :
2122 0 : OUString DbCurrencyField::GetFormatText(const Reference< ::com::sun::star::sdb::XColumn >& _rxField, const Reference< ::com::sun::star::util::XNumberFormatter >& _rxFormatter, Color** /*ppColor*/)
2123 : {
2124 0 : return lcl_setFormattedCurrency_nothrow( dynamic_cast< LongCurrencyField& >( *m_pPainter ), *this, _rxField, _rxFormatter );
2125 : }
2126 :
2127 :
2128 0 : void DbCurrencyField::UpdateFromField(const Reference< ::com::sun::star::sdb::XColumn >& _rxField, const Reference< ::com::sun::star::util::XNumberFormatter >& _rxFormatter)
2129 : {
2130 0 : lcl_setFormattedCurrency_nothrow( dynamic_cast< LongCurrencyField& >( *m_pWindow ), *this, _rxField, _rxFormatter );
2131 0 : }
2132 :
2133 :
2134 0 : void DbCurrencyField::updateFromModel( Reference< XPropertySet > _rxModel )
2135 : {
2136 : OSL_ENSURE( _rxModel.is() && m_pWindow, "DbCurrencyField::updateFromModel: invalid call!" );
2137 :
2138 0 : double dValue = 0;
2139 0 : if ( _rxModel->getPropertyValue( FM_PROP_VALUE ) >>= dValue )
2140 : {
2141 0 : if ( m_nScale )
2142 : {
2143 0 : dValue = ::rtl::math::pow10Exp( dValue, m_nScale );
2144 0 : dValue = ::rtl::math::round(dValue, 0);
2145 : }
2146 :
2147 0 : static_cast< LongCurrencyField* >( m_pWindow )->SetValue( dValue );
2148 : }
2149 : else
2150 0 : m_pWindow->SetText( OUString() );
2151 0 : }
2152 :
2153 :
2154 0 : bool DbCurrencyField::commitControl()
2155 : {
2156 0 : OUString aText(m_pWindow->GetText());
2157 0 : Any aVal;
2158 0 : if (!aText.isEmpty()) // not empty
2159 : {
2160 0 : double fValue = static_cast<LongCurrencyField*>(m_pWindow)->GetValue();
2161 0 : if (m_nScale)
2162 : {
2163 0 : fValue /= ::rtl::math::pow10Exp(1.0, m_nScale);
2164 : }
2165 0 : aVal <<= (double)fValue;
2166 : }
2167 0 : m_rColumn.getModel()->setPropertyValue(FM_PROP_VALUE, aVal);
2168 0 : return true;
2169 : }
2170 :
2171 0 : DbDateField::DbDateField( DbGridColumn& _rColumn )
2172 0 : :DbSpinField( _rColumn )
2173 : {
2174 0 : doPropertyListening( FM_PROP_DATEFORMAT );
2175 0 : doPropertyListening( FM_PROP_DATEMIN );
2176 0 : doPropertyListening( FM_PROP_DATEMAX );
2177 0 : doPropertyListening( FM_PROP_STRICTFORMAT );
2178 0 : doPropertyListening( FM_PROP_DATE_SHOW_CENTURY );
2179 0 : }
2180 :
2181 :
2182 0 : SpinField* DbDateField::createField( vcl::Window* _pParent, WinBits _nFieldStyle, const Reference< XPropertySet >& _rxModel )
2183 : {
2184 : // check if there is a DropDown property set to TRUE
2185 0 : bool bDropDown = !hasProperty( FM_PROP_DROPDOWN, _rxModel )
2186 0 : || getBOOL( _rxModel->getPropertyValue( FM_PROP_DROPDOWN ) );
2187 0 : if ( bDropDown )
2188 0 : _nFieldStyle |= WB_DROPDOWN;
2189 :
2190 0 : CalendarField* pField = new CalendarField( _pParent, _nFieldStyle );
2191 :
2192 0 : pField->EnableToday();
2193 0 : pField->EnableNone();
2194 :
2195 0 : return pField;
2196 : }
2197 :
2198 :
2199 0 : void DbDateField::implAdjustGenericFieldSetting( const Reference< XPropertySet >& _rxModel )
2200 : {
2201 : DBG_ASSERT( m_pWindow, "DbDateField::implAdjustGenericFieldSetting: not to be called without window!" );
2202 : DBG_ASSERT( _rxModel.is(), "DbDateField::implAdjustGenericFieldSetting: invalid model!" );
2203 0 : if ( m_pWindow && _rxModel.is() )
2204 : {
2205 0 : sal_Int16 nFormat = getINT16( _rxModel->getPropertyValue( FM_PROP_DATEFORMAT ) );
2206 0 : util::Date aMin;
2207 0 : OSL_VERIFY( _rxModel->getPropertyValue( FM_PROP_DATEMIN ) >>= aMin );
2208 0 : util::Date aMax;
2209 0 : OSL_VERIFY( _rxModel->getPropertyValue( FM_PROP_DATEMAX ) >>= aMax );
2210 0 : bool bStrict = getBOOL( _rxModel->getPropertyValue( FM_PROP_STRICTFORMAT ) );
2211 :
2212 0 : Any aCentury = _rxModel->getPropertyValue( FM_PROP_DATE_SHOW_CENTURY );
2213 0 : if ( aCentury.getValueType().getTypeClass() != TypeClass_VOID )
2214 : {
2215 0 : bool bShowDateCentury = getBOOL( aCentury );
2216 :
2217 0 : static_cast<DateField*>( m_pWindow )->SetShowDateCentury( bShowDateCentury );
2218 0 : static_cast<DateField*>( m_pPainter )->SetShowDateCentury( bShowDateCentury );
2219 : }
2220 :
2221 0 : static_cast< DateField* >( m_pWindow )->SetExtDateFormat( (ExtDateFieldFormat)nFormat );
2222 0 : static_cast< DateField* >( m_pWindow )->SetMin( aMin );
2223 0 : static_cast< DateField* >( m_pWindow )->SetMax( aMax );
2224 0 : static_cast< DateField* >( m_pWindow )->SetStrictFormat( bStrict );
2225 0 : static_cast< DateField* >( m_pWindow )->EnableEmptyFieldValue( true );
2226 :
2227 0 : static_cast< DateField* >( m_pPainter )->SetExtDateFormat( (ExtDateFieldFormat)nFormat );
2228 0 : static_cast< DateField* >( m_pPainter )->SetMin( aMin );
2229 0 : static_cast< DateField* >( m_pPainter )->SetMax( aMax );
2230 0 : static_cast< DateField* >( m_pPainter )->SetStrictFormat( bStrict );
2231 0 : static_cast< DateField* >( m_pPainter )->EnableEmptyFieldValue( true );
2232 : }
2233 0 : }
2234 :
2235 : namespace
2236 : {
2237 :
2238 0 : static OUString lcl_setFormattedDate_nothrow( DateField& _rField, const Reference< XColumn >& _rxField )
2239 : {
2240 0 : OUString sDate;
2241 0 : if ( _rxField.is() )
2242 : {
2243 : try
2244 : {
2245 0 : ::com::sun::star::util::Date aValue = _rxField->getDate();
2246 0 : if ( _rxField->wasNull() )
2247 0 : _rField.SetText( sDate );
2248 : else
2249 : {
2250 0 : _rField.SetDate( ::Date( aValue.Day, aValue.Month, aValue.Year ) );
2251 0 : sDate = _rField.GetText();
2252 : }
2253 : }
2254 0 : catch( const Exception& )
2255 : {
2256 : DBG_UNHANDLED_EXCEPTION();
2257 : }
2258 : }
2259 0 : return sDate;
2260 : }
2261 : }
2262 :
2263 0 : OUString DbDateField::GetFormatText(const Reference< ::com::sun::star::sdb::XColumn >& _rxField, const Reference< ::com::sun::star::util::XNumberFormatter >& /*xFormatter*/, Color** /*ppColor*/)
2264 : {
2265 0 : return lcl_setFormattedDate_nothrow(dynamic_cast<DateField&>(*m_pPainter), _rxField);
2266 : }
2267 :
2268 :
2269 0 : void DbDateField::UpdateFromField(const Reference< ::com::sun::star::sdb::XColumn >& _rxField, const Reference< XNumberFormatter >& /*xFormatter*/)
2270 : {
2271 0 : lcl_setFormattedDate_nothrow(dynamic_cast<DateField&>(*m_pWindow), _rxField);
2272 0 : }
2273 :
2274 :
2275 0 : void DbDateField::updateFromModel( Reference< XPropertySet > _rxModel )
2276 : {
2277 : OSL_ENSURE( _rxModel.is() && m_pWindow, "DbDateField::updateFromModel: invalid call!" );
2278 :
2279 0 : util::Date aDate;
2280 0 : if ( _rxModel->getPropertyValue( FM_PROP_DATE ) >>= aDate )
2281 0 : static_cast< DateField* >( m_pWindow )->SetDate( ::Date( aDate ) );
2282 : else
2283 0 : static_cast< DateField* >( m_pWindow )->SetText( OUString() );
2284 0 : }
2285 :
2286 :
2287 0 : bool DbDateField::commitControl()
2288 : {
2289 0 : OUString aText(m_pWindow->GetText());
2290 0 : Any aVal;
2291 0 : if (!aText.isEmpty())
2292 0 : aVal <<= static_cast<DateField*>(m_pWindow)->GetDate().GetUNODate();
2293 : else
2294 0 : aVal.clear();
2295 :
2296 0 : m_rColumn.getModel()->setPropertyValue(FM_PROP_DATE, aVal);
2297 0 : return true;
2298 : }
2299 :
2300 0 : DbTimeField::DbTimeField( DbGridColumn& _rColumn )
2301 0 : :DbSpinField( _rColumn, ::com::sun::star::awt::TextAlign::LEFT )
2302 : {
2303 0 : doPropertyListening( FM_PROP_TIMEFORMAT );
2304 0 : doPropertyListening( FM_PROP_TIMEMIN );
2305 0 : doPropertyListening( FM_PROP_TIMEMAX );
2306 0 : doPropertyListening( FM_PROP_STRICTFORMAT );
2307 0 : }
2308 :
2309 :
2310 0 : SpinField* DbTimeField::createField( vcl::Window* _pParent, WinBits _nFieldStyle, const Reference< XPropertySet >& /*_rxModel*/ )
2311 : {
2312 0 : return new TimeField( _pParent, _nFieldStyle );
2313 : }
2314 :
2315 :
2316 0 : void DbTimeField::implAdjustGenericFieldSetting( const Reference< XPropertySet >& _rxModel )
2317 : {
2318 : DBG_ASSERT( m_pWindow, "DbTimeField::implAdjustGenericFieldSetting: not to be called without window!" );
2319 : DBG_ASSERT( _rxModel.is(), "DbTimeField::implAdjustGenericFieldSetting: invalid model!" );
2320 0 : if ( m_pWindow && _rxModel.is() )
2321 : {
2322 0 : sal_Int16 nFormat = getINT16( _rxModel->getPropertyValue( FM_PROP_TIMEFORMAT ) );
2323 0 : util::Time aMin;
2324 0 : OSL_VERIFY( _rxModel->getPropertyValue( FM_PROP_TIMEMIN ) >>= aMin );
2325 0 : util::Time aMax;
2326 0 : OSL_VERIFY( _rxModel->getPropertyValue( FM_PROP_TIMEMAX ) >>= aMax );
2327 0 : bool bStrict = getBOOL( _rxModel->getPropertyValue( FM_PROP_STRICTFORMAT ) );
2328 :
2329 0 : static_cast< TimeField* >( m_pWindow )->SetExtFormat( (ExtTimeFieldFormat)nFormat );
2330 0 : static_cast< TimeField* >( m_pWindow )->SetMin( aMin );
2331 0 : static_cast< TimeField* >( m_pWindow )->SetMax( aMax );
2332 0 : static_cast< TimeField* >( m_pWindow )->SetStrictFormat( bStrict );
2333 0 : static_cast< TimeField* >( m_pWindow )->EnableEmptyFieldValue( true );
2334 :
2335 0 : static_cast< TimeField* >( m_pPainter )->SetExtFormat( (ExtTimeFieldFormat)nFormat );
2336 0 : static_cast< TimeField* >( m_pPainter )->SetMin( aMin );
2337 0 : static_cast< TimeField* >( m_pPainter )->SetMax( aMax );
2338 0 : static_cast< TimeField* >( m_pPainter )->SetStrictFormat( bStrict );
2339 0 : static_cast< TimeField* >( m_pPainter )->EnableEmptyFieldValue( true );
2340 : }
2341 0 : }
2342 :
2343 : namespace
2344 : {
2345 :
2346 0 : static OUString lcl_setFormattedTime_nothrow( TimeField& _rField, const Reference< XColumn >& _rxField )
2347 : {
2348 0 : OUString sTime;
2349 0 : if ( _rxField.is() )
2350 : {
2351 : try
2352 : {
2353 0 : ::com::sun::star::util::Time aValue = _rxField->getTime();
2354 0 : if ( _rxField->wasNull() )
2355 0 : _rField.SetText( sTime );
2356 : else
2357 : {
2358 0 : _rField.SetTime( ::tools::Time( aValue.Hours, aValue.Minutes, aValue.Seconds, aValue.NanoSeconds ) );
2359 0 : sTime = _rField.GetText();
2360 : }
2361 : }
2362 0 : catch( const Exception& )
2363 : {
2364 : DBG_UNHANDLED_EXCEPTION();
2365 : }
2366 : }
2367 0 : return sTime;
2368 : }
2369 : }
2370 :
2371 0 : OUString DbTimeField::GetFormatText(const Reference< ::com::sun::star::sdb::XColumn >& _rxField, const Reference< ::com::sun::star::util::XNumberFormatter >& /*xFormatter*/, Color** /*ppColor*/)
2372 : {
2373 0 : return lcl_setFormattedTime_nothrow( *static_cast< TimeField* >( m_pPainter ), _rxField );
2374 : }
2375 :
2376 :
2377 0 : void DbTimeField::UpdateFromField(const Reference< ::com::sun::star::sdb::XColumn >& _rxField, const Reference< XNumberFormatter >& /*xFormatter*/)
2378 : {
2379 0 : lcl_setFormattedTime_nothrow( *static_cast< TimeField* >( m_pWindow ), _rxField );
2380 0 : }
2381 :
2382 :
2383 0 : void DbTimeField::updateFromModel( Reference< XPropertySet > _rxModel )
2384 : {
2385 : OSL_ENSURE( _rxModel.is() && m_pWindow, "DbTimeField::updateFromModel: invalid call!" );
2386 :
2387 0 : util::Time aTime;
2388 0 : if ( _rxModel->getPropertyValue( FM_PROP_DATE ) >>= aTime )
2389 0 : static_cast< TimeField* >( m_pWindow )->SetTime( ::tools::Time( aTime ) );
2390 : else
2391 0 : static_cast< TimeField* >( m_pWindow )->SetText( OUString() );
2392 0 : }
2393 :
2394 :
2395 0 : bool DbTimeField::commitControl()
2396 : {
2397 0 : OUString aText(m_pWindow->GetText());
2398 0 : Any aVal;
2399 0 : if (!aText.isEmpty())
2400 0 : aVal <<= static_cast<TimeField*>(m_pWindow)->GetTime().GetUNOTime();
2401 : else
2402 0 : aVal.clear();
2403 :
2404 0 : m_rColumn.getModel()->setPropertyValue(FM_PROP_TIME, aVal);
2405 0 : return true;
2406 : }
2407 :
2408 0 : DbComboBox::DbComboBox(DbGridColumn& _rColumn)
2409 : :DbCellControl(_rColumn)
2410 0 : ,m_nKeyType(::com::sun::star::util::NumberFormat::UNDEFINED)
2411 : {
2412 0 : setAlignedController( false );
2413 :
2414 0 : doPropertyListening( FM_PROP_STRINGITEMLIST );
2415 0 : doPropertyListening( FM_PROP_LINECOUNT );
2416 0 : }
2417 :
2418 :
2419 0 : void DbComboBox::_propertyChanged( const PropertyChangeEvent& _rEvent ) throw( RuntimeException )
2420 : {
2421 0 : if ( _rEvent.PropertyName.equals( FM_PROP_STRINGITEMLIST ) )
2422 : {
2423 0 : SetList(_rEvent.NewValue);
2424 : }
2425 : else
2426 : {
2427 0 : DbCellControl::_propertyChanged( _rEvent ) ;
2428 : }
2429 0 : }
2430 :
2431 :
2432 0 : void DbComboBox::SetList(const Any& rItems)
2433 : {
2434 0 : ComboBoxControl* pField = static_cast<ComboBoxControl*>(m_pWindow);
2435 0 : pField->Clear();
2436 :
2437 0 : ::comphelper::StringSequence aTest;
2438 0 : if (rItems >>= aTest)
2439 : {
2440 0 : const OUString* pStrings = aTest.getConstArray();
2441 0 : sal_Int32 nItems = aTest.getLength();
2442 0 : for (sal_Int32 i = 0; i < nItems; ++i, ++pStrings )
2443 0 : pField->InsertEntry(*pStrings, LISTBOX_APPEND);
2444 :
2445 : // tell the grid control that this controller is invalid and has to be re-initialized
2446 0 : invalidatedController();
2447 0 : }
2448 0 : }
2449 :
2450 :
2451 0 : void DbComboBox::implAdjustGenericFieldSetting( const Reference< XPropertySet >& _rxModel )
2452 : {
2453 : DBG_ASSERT( m_pWindow, "DbComboBox::implAdjustGenericFieldSetting: not to be called without window!" );
2454 : DBG_ASSERT( _rxModel.is(), "DbComboBox::implAdjustGenericFieldSetting: invalid model!" );
2455 0 : if ( m_pWindow && _rxModel.is() )
2456 : {
2457 0 : sal_Int16 nLines = getINT16( _rxModel->getPropertyValue( FM_PROP_LINECOUNT ) );
2458 0 : static_cast< ComboBoxControl* >( m_pWindow )->SetDropDownLineCount( nLines );
2459 : }
2460 0 : }
2461 :
2462 :
2463 0 : void DbComboBox::Init( vcl::Window& rParent, const Reference< XRowSet >& xCursor )
2464 : {
2465 0 : m_rColumn.SetAlignmentFromModel(::com::sun::star::awt::TextAlign::LEFT);
2466 :
2467 0 : m_pWindow = new ComboBoxControl( &rParent );
2468 :
2469 : // selection von rechts nach links
2470 0 : AllSettings aSettings = m_pWindow->GetSettings();
2471 0 : StyleSettings aStyleSettings = aSettings.GetStyleSettings();
2472 : aStyleSettings.SetSelectionOptions(
2473 0 : aStyleSettings.GetSelectionOptions() | SELECTION_OPTION_SHOWFIRST);
2474 0 : aSettings.SetStyleSettings(aStyleSettings);
2475 0 : m_pWindow->SetSettings(aSettings, true);
2476 :
2477 : // some initial properties
2478 0 : Reference< XPropertySet > xModel(m_rColumn.getModel());
2479 0 : SetList( xModel->getPropertyValue( FM_PROP_STRINGITEMLIST ) );
2480 0 : implAdjustGenericFieldSetting( xModel );
2481 :
2482 0 : if (m_rColumn.GetParent().getNumberFormatter().is())
2483 0 : m_nKeyType = comphelper::getNumberFormatType(m_rColumn.GetParent().getNumberFormatter()->getNumberFormatsSupplier()->getNumberFormats(), m_rColumn.GetKey());
2484 :
2485 0 : DbCellControl::Init( rParent, xCursor );
2486 0 : }
2487 :
2488 :
2489 0 : CellControllerRef DbComboBox::CreateController() const
2490 : {
2491 0 : return new ComboBoxCellController(static_cast<ComboBoxControl*>(m_pWindow));
2492 : }
2493 :
2494 :
2495 0 : OUString DbComboBox::GetFormatText(const Reference< ::com::sun::star::sdb::XColumn >& _rxField, const Reference< XNumberFormatter >& xFormatter, Color** /*ppColor*/)
2496 : {
2497 0 : OUString aString;
2498 0 : if (_rxField.is())
2499 : try
2500 : {
2501 0 : aString = getFormattedValue( _rxField, xFormatter, m_rColumn.GetParent().getNullDate(), m_rColumn.GetKey(), m_nKeyType );
2502 : }
2503 0 : catch( const Exception& )
2504 : {
2505 : DBG_UNHANDLED_EXCEPTION();
2506 : }
2507 0 : return aString;
2508 : }
2509 :
2510 :
2511 0 : void DbComboBox::UpdateFromField(const Reference< ::com::sun::star::sdb::XColumn >& _rxField, const Reference< XNumberFormatter >& xFormatter)
2512 : {
2513 0 : m_pWindow->SetText(GetFormatText(_rxField, xFormatter));
2514 0 : }
2515 :
2516 :
2517 0 : void DbComboBox::updateFromModel( Reference< XPropertySet > _rxModel )
2518 : {
2519 : OSL_ENSURE( _rxModel.is() && m_pWindow, "DbComboBox::updateFromModel: invalid call!" );
2520 :
2521 0 : OUString sText;
2522 0 : _rxModel->getPropertyValue( FM_PROP_TEXT ) >>= sText;
2523 :
2524 0 : static_cast< ComboBox* >( m_pWindow )->SetText( sText );
2525 0 : static_cast< ComboBox* >( m_pWindow )->SetSelection( Selection( SELECTION_MAX, SELECTION_MIN ) );
2526 0 : }
2527 :
2528 :
2529 0 : bool DbComboBox::commitControl()
2530 : {
2531 0 : OUString aText( m_pWindow->GetText());
2532 0 : m_rColumn.getModel()->setPropertyValue(FM_PROP_TEXT, makeAny(aText));
2533 0 : return true;
2534 : }
2535 :
2536 :
2537 0 : DbListBox::DbListBox(DbGridColumn& _rColumn)
2538 : :DbCellControl(_rColumn)
2539 0 : ,m_bBound(false)
2540 : {
2541 0 : setAlignedController( false );
2542 :
2543 0 : doPropertyListening( FM_PROP_STRINGITEMLIST );
2544 0 : doPropertyListening( FM_PROP_LINECOUNT );
2545 0 : }
2546 :
2547 :
2548 0 : void DbListBox::_propertyChanged( const ::com::sun::star::beans::PropertyChangeEvent& _rEvent ) throw( RuntimeException )
2549 : {
2550 0 : if ( _rEvent.PropertyName.equals( FM_PROP_STRINGITEMLIST ) )
2551 : {
2552 0 : SetList(_rEvent.NewValue);
2553 : }
2554 : else
2555 : {
2556 0 : DbCellControl::_propertyChanged( _rEvent ) ;
2557 : }
2558 0 : }
2559 :
2560 :
2561 0 : void DbListBox::SetList(const Any& rItems)
2562 : {
2563 0 : ListBoxControl* pField = static_cast<ListBoxControl*>(m_pWindow);
2564 :
2565 0 : pField->Clear();
2566 0 : m_bBound = false;
2567 :
2568 0 : ::comphelper::StringSequence aTest;
2569 0 : if (rItems >>= aTest)
2570 : {
2571 0 : const OUString* pStrings = aTest.getConstArray();
2572 0 : sal_Int32 nItems = aTest.getLength();
2573 0 : if (nItems)
2574 : {
2575 0 : for (sal_Int32 i = 0; i < nItems; ++i, ++pStrings )
2576 0 : pField->InsertEntry(*pStrings, LISTBOX_APPEND);
2577 :
2578 0 : m_rColumn.getModel()->getPropertyValue(FM_PROP_VALUE_SEQ) >>= m_aValueList;
2579 0 : m_bBound = m_aValueList.getLength() > 0;
2580 :
2581 : // tell the grid control that this controller is invalid and has to be re-initialized
2582 0 : invalidatedController();
2583 : }
2584 0 : }
2585 0 : }
2586 :
2587 :
2588 0 : void DbListBox::Init( vcl::Window& rParent, const Reference< XRowSet >& xCursor)
2589 : {
2590 0 : m_rColumn.SetAlignment(::com::sun::star::awt::TextAlign::LEFT);
2591 :
2592 0 : m_pWindow = new ListBoxControl( &rParent );
2593 :
2594 : // some initial properties
2595 0 : Reference< XPropertySet > xModel( m_rColumn.getModel() );
2596 0 : SetList( xModel->getPropertyValue( FM_PROP_STRINGITEMLIST ) );
2597 0 : implAdjustGenericFieldSetting( xModel );
2598 :
2599 0 : DbCellControl::Init( rParent, xCursor );
2600 0 : }
2601 :
2602 :
2603 0 : void DbListBox::implAdjustGenericFieldSetting( const Reference< XPropertySet >& _rxModel )
2604 : {
2605 : DBG_ASSERT( m_pWindow, "DbListBox::implAdjustGenericFieldSetting: not to be called without window!" );
2606 : DBG_ASSERT( _rxModel.is(), "DbListBox::implAdjustGenericFieldSetting: invalid model!" );
2607 0 : if ( m_pWindow && _rxModel.is() )
2608 : {
2609 0 : sal_Int16 nLines = getINT16( _rxModel->getPropertyValue( FM_PROP_LINECOUNT ) );
2610 0 : static_cast< ListBoxControl* >( m_pWindow )->SetDropDownLineCount( nLines );
2611 : }
2612 0 : }
2613 :
2614 :
2615 0 : CellControllerRef DbListBox::CreateController() const
2616 : {
2617 0 : return new ListBoxCellController(static_cast<ListBoxControl*>(m_pWindow));
2618 : }
2619 :
2620 :
2621 0 : OUString DbListBox::GetFormatText(const Reference< ::com::sun::star::sdb::XColumn >& _rxField, const Reference< XNumberFormatter >& /*xFormatter*/, Color** /*ppColor*/)
2622 : {
2623 0 : OUString sText;
2624 0 : if ( _rxField.is() )
2625 : {
2626 : try
2627 : {
2628 0 : sText = _rxField->getString();
2629 0 : if ( m_bBound )
2630 : {
2631 0 : Sequence< sal_Int16 > aPosSeq = ::comphelper::findValue( m_aValueList, sText, true );
2632 0 : if ( aPosSeq.getLength() )
2633 0 : sText = static_cast<ListBox*>(m_pWindow)->GetEntry(aPosSeq.getConstArray()[0]);
2634 : else
2635 0 : sText = "";
2636 : }
2637 : }
2638 0 : catch( const Exception& )
2639 : {
2640 : DBG_UNHANDLED_EXCEPTION();
2641 : }
2642 : }
2643 0 : return sText;
2644 : }
2645 :
2646 :
2647 0 : void DbListBox::UpdateFromField(const Reference< ::com::sun::star::sdb::XColumn >& _rxField, const Reference< XNumberFormatter >& xFormatter)
2648 : {
2649 0 : OUString sFormattedText( GetFormatText( _rxField, xFormatter ) );
2650 0 : if (!sFormattedText.isEmpty())
2651 0 : static_cast< ListBox* >( m_pWindow )->SelectEntry( sFormattedText );
2652 : else
2653 0 : static_cast< ListBox* >( m_pWindow )->SetNoSelection();
2654 0 : }
2655 :
2656 :
2657 0 : void DbListBox::updateFromModel( Reference< XPropertySet > _rxModel )
2658 : {
2659 : OSL_ENSURE( _rxModel.is() && m_pWindow, "DbListBox::updateFromModel: invalid call!" );
2660 :
2661 0 : Sequence< sal_Int16 > aSelection;
2662 0 : _rxModel->getPropertyValue( FM_PROP_SELECT_SEQ );
2663 :
2664 0 : sal_Int16 nSelection = -1;
2665 0 : if ( aSelection.getLength() > 0 )
2666 0 : nSelection = aSelection[ 0 ];
2667 :
2668 0 : ListBox* pListBox = static_cast< ListBox* >( m_pWindow );
2669 :
2670 0 : if ( ( nSelection >= 0 ) && ( nSelection < pListBox->GetEntryCount() ) )
2671 0 : pListBox->SelectEntryPos( nSelection );
2672 : else
2673 0 : pListBox->SetNoSelection( );
2674 0 : }
2675 :
2676 :
2677 0 : bool DbListBox::commitControl()
2678 : {
2679 0 : Any aVal;
2680 0 : Sequence<sal_Int16> aSelectSeq;
2681 0 : if (static_cast<ListBox*>(m_pWindow)->GetSelectEntryCount())
2682 : {
2683 0 : aSelectSeq.realloc(1);
2684 0 : *(sal_Int16 *)aSelectSeq.getArray() = (sal_Int16)static_cast<ListBox*>(m_pWindow)->GetSelectEntryPos();
2685 : }
2686 0 : aVal <<= aSelectSeq;
2687 0 : m_rColumn.getModel()->setPropertyValue(FM_PROP_SELECT_SEQ, aVal);
2688 0 : return true;
2689 : }
2690 :
2691 0 : DbFilterField::DbFilterField(const Reference< XComponentContext >& rxContext,DbGridColumn& _rColumn)
2692 : :DbCellControl(_rColumn)
2693 : ,OSQLParserClient(rxContext)
2694 : ,m_nControlClass(::com::sun::star::form::FormComponentType::TEXTFIELD)
2695 : ,m_bFilterList(false)
2696 : ,m_bFilterListFilled(false)
2697 0 : ,m_bBound(false)
2698 : {
2699 :
2700 0 : setAlignedController( false );
2701 0 : }
2702 :
2703 :
2704 0 : DbFilterField::~DbFilterField()
2705 : {
2706 0 : if (m_nControlClass == ::com::sun::star::form::FormComponentType::CHECKBOX)
2707 0 : static_cast<CheckBoxControl*>(m_pWindow)->SetClickHdl( Link() );
2708 :
2709 0 : }
2710 :
2711 :
2712 0 : void DbFilterField::PaintCell(OutputDevice& rDev, const Rectangle& rRect)
2713 : {
2714 : static sal_uInt16 nStyle = TEXT_DRAW_CLIP | TEXT_DRAW_VCENTER | TEXT_DRAW_LEFT;
2715 0 : switch (m_nControlClass)
2716 : {
2717 : case FormComponentType::CHECKBOX:
2718 0 : DbCellControl::PaintCell( rDev, rRect );
2719 0 : break;
2720 : case FormComponentType::LISTBOX:
2721 0 : rDev.DrawText(rRect, static_cast<ListBox*>(m_pWindow)->GetSelectEntry(), nStyle);
2722 0 : break;
2723 : default:
2724 0 : rDev.DrawText(rRect, m_aText, nStyle);
2725 : }
2726 0 : }
2727 :
2728 :
2729 0 : void DbFilterField::SetList(const Any& rItems, bool bComboBox)
2730 : {
2731 0 : ::comphelper::StringSequence aTest;
2732 0 : rItems >>= aTest;
2733 0 : const OUString* pStrings = aTest.getConstArray();
2734 0 : sal_Int32 nItems = aTest.getLength();
2735 0 : if (nItems)
2736 : {
2737 0 : if (bComboBox)
2738 : {
2739 0 : ComboBox* pField = static_cast<ComboBox*>(m_pWindow);
2740 0 : for (sal_Int32 i = 0; i < nItems; ++i, ++pStrings )
2741 0 : pField->InsertEntry(*pStrings, LISTBOX_APPEND);
2742 : }
2743 : else
2744 : {
2745 0 : ListBox* pField = static_cast<ListBox*>(m_pWindow);
2746 0 : for (sal_Int32 i = 0; i < nItems; ++i, ++pStrings )
2747 0 : pField->InsertEntry(*pStrings, LISTBOX_APPEND);
2748 :
2749 0 : m_rColumn.getModel()->getPropertyValue(FM_PROP_VALUE_SEQ) >>= m_aValueList;
2750 0 : m_bBound = m_aValueList.getLength() > 0;
2751 : }
2752 0 : }
2753 0 : }
2754 :
2755 :
2756 0 : void DbFilterField::CreateControl(vcl::Window* pParent, const Reference< ::com::sun::star::beans::XPropertySet >& xModel)
2757 : {
2758 0 : switch (m_nControlClass)
2759 : {
2760 : case ::com::sun::star::form::FormComponentType::CHECKBOX:
2761 0 : m_pWindow = new CheckBoxControl(pParent);
2762 0 : m_pWindow->SetPaintTransparent( true );
2763 0 : static_cast<CheckBoxControl*>(m_pWindow)->SetClickHdl( LINK( this, DbFilterField, OnClick ) );
2764 :
2765 0 : m_pPainter = new CheckBoxControl(pParent);
2766 0 : m_pPainter->SetPaintTransparent( true );
2767 0 : m_pPainter->SetBackground();
2768 0 : break;
2769 : case ::com::sun::star::form::FormComponentType::LISTBOX:
2770 : {
2771 0 : m_pWindow = new ListBoxControl(pParent);
2772 0 : sal_Int16 nLines = ::comphelper::getINT16(xModel->getPropertyValue(FM_PROP_LINECOUNT));
2773 0 : Any aItems = xModel->getPropertyValue(FM_PROP_STRINGITEMLIST);
2774 0 : SetList(aItems, m_nControlClass == ::com::sun::star::form::FormComponentType::COMBOBOX);
2775 0 : static_cast<ListBox*>(m_pWindow)->SetDropDownLineCount(nLines);
2776 0 : } break;
2777 : case ::com::sun::star::form::FormComponentType::COMBOBOX:
2778 : {
2779 0 : m_pWindow = new ComboBoxControl(pParent);
2780 :
2781 0 : AllSettings aSettings = m_pWindow->GetSettings();
2782 0 : StyleSettings aStyleSettings = aSettings.GetStyleSettings();
2783 : aStyleSettings.SetSelectionOptions(
2784 0 : aStyleSettings.GetSelectionOptions() | SELECTION_OPTION_SHOWFIRST);
2785 0 : aSettings.SetStyleSettings(aStyleSettings);
2786 0 : m_pWindow->SetSettings(aSettings, true);
2787 :
2788 0 : if (!m_bFilterList)
2789 : {
2790 0 : sal_Int16 nLines = ::comphelper::getINT16(xModel->getPropertyValue(FM_PROP_LINECOUNT));
2791 0 : Any aItems = xModel->getPropertyValue(FM_PROP_STRINGITEMLIST);
2792 0 : SetList(aItems, m_nControlClass == ::com::sun::star::form::FormComponentType::COMBOBOX);
2793 0 : static_cast<ComboBox*>(m_pWindow)->SetDropDownLineCount(nLines);
2794 : }
2795 : else
2796 0 : static_cast<ComboBox*>(m_pWindow)->SetDropDownLineCount(5);
2797 :
2798 0 : } break;
2799 : default:
2800 : {
2801 0 : m_pWindow = new Edit(pParent, WB_LEFT);
2802 0 : AllSettings aSettings = m_pWindow->GetSettings();
2803 0 : StyleSettings aStyleSettings = aSettings.GetStyleSettings();
2804 : aStyleSettings.SetSelectionOptions(
2805 0 : aStyleSettings.GetSelectionOptions() | SELECTION_OPTION_SHOWFIRST);
2806 0 : aSettings.SetStyleSettings(aStyleSettings);
2807 0 : m_pWindow->SetSettings(aSettings, true);
2808 : }
2809 : }
2810 0 : }
2811 :
2812 :
2813 0 : void DbFilterField::Init( vcl::Window& rParent, const Reference< XRowSet >& xCursor )
2814 : {
2815 0 : Reference< ::com::sun::star::beans::XPropertySet > xModel(m_rColumn.getModel());
2816 0 : m_rColumn.SetAlignment(::com::sun::star::awt::TextAlign::LEFT);
2817 :
2818 0 : if (xModel.is())
2819 : {
2820 0 : m_bFilterList = ::comphelper::hasProperty(FM_PROP_FILTERPROPOSAL, xModel) && ::comphelper::getBOOL(xModel->getPropertyValue(FM_PROP_FILTERPROPOSAL));
2821 0 : if (m_bFilterList)
2822 0 : m_nControlClass = ::com::sun::star::form::FormComponentType::COMBOBOX;
2823 : else
2824 : {
2825 0 : sal_Int16 nClassId = ::comphelper::getINT16(xModel->getPropertyValue(FM_PROP_CLASSID));
2826 0 : switch (nClassId)
2827 : {
2828 : case FormComponentType::CHECKBOX:
2829 : case FormComponentType::LISTBOX:
2830 : case FormComponentType::COMBOBOX:
2831 0 : m_nControlClass = nClassId;
2832 0 : break;
2833 : default:
2834 0 : if (m_bFilterList)
2835 0 : m_nControlClass = FormComponentType::COMBOBOX;
2836 : else
2837 0 : m_nControlClass = FormComponentType::TEXTFIELD;
2838 : }
2839 : }
2840 : }
2841 :
2842 0 : CreateControl( &rParent, xModel );
2843 0 : DbCellControl::Init( rParent, xCursor );
2844 :
2845 : // filter cells are never readonly
2846 0 : Edit* pAsEdit = dynamic_cast< Edit* >( m_pWindow );
2847 0 : if ( pAsEdit )
2848 0 : pAsEdit->SetReadOnly( false );
2849 0 : }
2850 :
2851 :
2852 0 : CellControllerRef DbFilterField::CreateController() const
2853 : {
2854 0 : CellControllerRef xController;
2855 0 : switch (m_nControlClass)
2856 : {
2857 : case ::com::sun::star::form::FormComponentType::CHECKBOX:
2858 0 : xController = new CheckBoxCellController(static_cast<CheckBoxControl*>(m_pWindow));
2859 0 : break;
2860 : case ::com::sun::star::form::FormComponentType::LISTBOX:
2861 0 : xController = new ListBoxCellController(static_cast<ListBoxControl*>(m_pWindow));
2862 0 : break;
2863 : case ::com::sun::star::form::FormComponentType::COMBOBOX:
2864 0 : xController = new ComboBoxCellController(static_cast<ComboBoxControl*>(m_pWindow));
2865 0 : break;
2866 : default:
2867 0 : if (m_bFilterList)
2868 0 : xController = new ComboBoxCellController(static_cast<ComboBoxControl*>(m_pWindow));
2869 : else
2870 0 : xController = new EditCellController(static_cast<Edit*>(m_pWindow));
2871 : }
2872 0 : return xController;
2873 : }
2874 :
2875 :
2876 0 : void DbFilterField::updateFromModel( Reference< XPropertySet > _rxModel )
2877 : {
2878 : OSL_ENSURE( _rxModel.is() && m_pWindow, "DbFilterField::updateFromModel: invalid call!" );
2879 : (void)_rxModel;
2880 :
2881 : OSL_FAIL( "DbListBox::updateFromModel: not implemented yet (how the hell did you reach this?)!" );
2882 : // TODO: implement this.
2883 : // remember: updateFromModel should be some kind of opposite of commitControl
2884 0 : }
2885 :
2886 :
2887 0 : bool DbFilterField::commitControl()
2888 : {
2889 0 : OUString aText(m_aText);
2890 0 : switch (m_nControlClass)
2891 : {
2892 : case ::com::sun::star::form::FormComponentType::CHECKBOX:
2893 0 : return true;
2894 : case ::com::sun::star::form::FormComponentType::LISTBOX:
2895 0 : aText = OUString();
2896 0 : if (static_cast<ListBox*>(m_pWindow)->GetSelectEntryCount())
2897 : {
2898 0 : sal_Int16 nPos = (sal_Int16)static_cast<ListBox*>(m_pWindow)->GetSelectEntryPos();
2899 0 : if ( ( nPos >= 0 ) && ( nPos < m_aValueList.getLength() ) )
2900 0 : aText = m_aValueList.getConstArray()[nPos];
2901 : }
2902 :
2903 0 : if (m_aText != aText)
2904 : {
2905 0 : m_aText = aText;
2906 0 : m_aCommitLink.Call(this);
2907 : }
2908 0 : return true;
2909 : default:
2910 0 : aText = m_pWindow->GetText();
2911 : }
2912 :
2913 0 : if (m_aText != aText)
2914 : {
2915 : // check the text with the SQL-Parser
2916 0 : OUString aNewText(comphelper::string::stripEnd(aText, ' '));
2917 0 : if (!aNewText.isEmpty())
2918 : {
2919 0 : OUString aErrorMsg;
2920 0 : Reference< XNumberFormatter > xNumberFormatter(m_rColumn.GetParent().getNumberFormatter());
2921 :
2922 0 : ::rtl::Reference< ISQLParseNode > xParseNode = predicateTree(aErrorMsg, aNewText,xNumberFormatter, m_rColumn.GetField());
2923 0 : if (xParseNode.is())
2924 : {
2925 0 : OUString aPreparedText;
2926 :
2927 0 : ::com::sun::star::lang::Locale aAppLocale = Application::GetSettings().GetUILanguageTag().getLocale();
2928 :
2929 : Reference< XRowSet > xDataSourceRowSet(
2930 0 : Reference< XInterface >(*m_rColumn.GetParent().getDataSource()), UNO_QUERY);
2931 0 : Reference< XConnection > xConnection(getConnection(xDataSourceRowSet));
2932 :
2933 0 : xParseNode->parseNodeToPredicateStr(aPreparedText,
2934 : xConnection,
2935 : xNumberFormatter,
2936 0 : m_rColumn.GetField(),
2937 : OUString(),
2938 : aAppLocale,
2939 : '.',
2940 0 : getParseContext());
2941 0 : m_aText = aPreparedText;
2942 : }
2943 : else
2944 : {
2945 :
2946 0 : SQLException aError;
2947 0 : aError.Message = aErrorMsg;
2948 0 : displayException(aError, m_pWindow->GetParent());
2949 : // TODO: transport the title
2950 :
2951 0 : return false;
2952 0 : }
2953 : }
2954 : else
2955 0 : m_aText = aText;
2956 :
2957 0 : m_pWindow->SetText(m_aText);
2958 0 : m_aCommitLink.Call(this);
2959 : }
2960 0 : return true;
2961 : }
2962 :
2963 :
2964 0 : void DbFilterField::SetText(const OUString& rText)
2965 : {
2966 0 : m_aText = rText;
2967 0 : switch (m_nControlClass)
2968 : {
2969 : case ::com::sun::star::form::FormComponentType::CHECKBOX:
2970 : {
2971 : TriState eState;
2972 0 : if (rText == "1")
2973 0 : eState = TRISTATE_TRUE;
2974 0 : else if (rText == "0")
2975 0 : eState = TRISTATE_FALSE;
2976 : else
2977 0 : eState = TRISTATE_INDET;
2978 :
2979 0 : static_cast<CheckBoxControl*>(m_pWindow)->GetBox().SetState(eState);
2980 0 : static_cast<CheckBoxControl*>(m_pPainter)->GetBox().SetState(eState);
2981 0 : } break;
2982 : case ::com::sun::star::form::FormComponentType::LISTBOX:
2983 : {
2984 0 : Sequence<sal_Int16> aPosSeq = ::comphelper::findValue(m_aValueList, m_aText, true);
2985 0 : if (aPosSeq.getLength())
2986 0 : static_cast<ListBox*>(m_pWindow)->SelectEntryPos(aPosSeq.getConstArray()[0], true);
2987 : else
2988 0 : static_cast<ListBox*>(m_pWindow)->SetNoSelection();
2989 0 : } break;
2990 : default:
2991 0 : m_pWindow->SetText(m_aText);
2992 : }
2993 :
2994 : // now force a repaint on the window
2995 0 : m_rColumn.GetParent().RowModified(0,m_rColumn.GetId());
2996 0 : }
2997 :
2998 :
2999 0 : void DbFilterField::Update()
3000 : {
3001 : // should we fill the combobox with a filter proposal?
3002 0 : if (m_bFilterList && !m_bFilterListFilled)
3003 : {
3004 0 : m_bFilterListFilled = true;
3005 0 : Reference< ::com::sun::star::beans::XPropertySet > xField = m_rColumn.GetField();
3006 0 : if (!xField.is())
3007 0 : return;
3008 :
3009 0 : OUString aName;
3010 0 : xField->getPropertyValue(FM_PROP_NAME) >>= aName;
3011 :
3012 : // the columnmodel
3013 0 : Reference< ::com::sun::star::container::XChild > xModelAsChild(m_rColumn.getModel(), UNO_QUERY);
3014 : // the grid model
3015 0 : xModelAsChild = Reference< ::com::sun::star::container::XChild > (xModelAsChild->getParent(),UNO_QUERY);
3016 0 : Reference< XRowSet > xForm(xModelAsChild->getParent(), UNO_QUERY);
3017 0 : if (!xForm.is())
3018 0 : return;
3019 :
3020 0 : Reference<XPropertySet> xFormProp(xForm,UNO_QUERY);
3021 0 : Reference< XTablesSupplier > xSupTab;
3022 0 : xFormProp->getPropertyValue("SingleSelectQueryComposer") >>= xSupTab;
3023 :
3024 0 : Reference< XConnection > xConnection(getConnection(xForm));
3025 0 : if (!xSupTab.is())
3026 0 : return;
3027 :
3028 : // search the field
3029 0 : Reference< XColumnsSupplier > xSupCol(xSupTab,UNO_QUERY);
3030 0 : Reference< ::com::sun::star::container::XNameAccess > xFieldNames = xSupCol->getColumns();
3031 0 : if (!xFieldNames->hasByName(aName))
3032 0 : return;
3033 :
3034 0 : Reference< ::com::sun::star::container::XNameAccess > xTablesNames = xSupTab->getTables();
3035 0 : Reference< ::com::sun::star::beans::XPropertySet > xComposerFieldAsSet(xFieldNames->getByName(aName),UNO_QUERY);
3036 :
3037 0 : if (xComposerFieldAsSet.is() && ::comphelper::hasProperty(FM_PROP_TABLENAME, xComposerFieldAsSet) &&
3038 0 : ::comphelper::hasProperty(FM_PROP_FIELDSOURCE, xComposerFieldAsSet))
3039 : {
3040 0 : OUString aFieldName;
3041 0 : OUString aTableName;
3042 0 : xComposerFieldAsSet->getPropertyValue(FM_PROP_FIELDSOURCE) >>= aFieldName;
3043 0 : xComposerFieldAsSet->getPropertyValue(FM_PROP_TABLENAME) >>= aTableName;
3044 :
3045 : // no possibility to create a select statement
3046 : // looking for the complete table name
3047 0 : if (!xTablesNames->hasByName(aTableName))
3048 0 : return;
3049 :
3050 : // ein Statement aufbauen und abschicken als query
3051 : // Access to the connection
3052 0 : Reference< XStatement > xStatement;
3053 0 : Reference< XResultSet > xListCursor;
3054 0 : Reference< ::com::sun::star::sdb::XColumn > xDataField;
3055 :
3056 : try
3057 : {
3058 0 : Reference< XDatabaseMetaData > xMeta = xConnection->getMetaData();
3059 :
3060 0 : OUString aQuote(xMeta->getIdentifierQuoteString());
3061 0 : OUStringBuffer aStatement("SELECT DISTINCT ");
3062 0 : aStatement.append(quoteName(aQuote, aName));
3063 0 : if (!aFieldName.isEmpty() && aName != aFieldName)
3064 : {
3065 0 : aStatement.append(" AS ");
3066 0 : aStatement.append(quoteName(aQuote, aFieldName));
3067 : }
3068 :
3069 0 : aStatement.append(" FROM ");
3070 :
3071 0 : Reference< XPropertySet > xTableNameAccess(xTablesNames->getByName(aTableName), UNO_QUERY_THROW);
3072 0 : aStatement.append(composeTableNameForSelect(xConnection, xTableNameAccess));
3073 :
3074 0 : xStatement = xConnection->createStatement();
3075 0 : Reference< ::com::sun::star::beans::XPropertySet > xStatementProps(xStatement, UNO_QUERY);
3076 0 : xStatementProps->setPropertyValue(FM_PROP_ESCAPE_PROCESSING, makeAny(true));
3077 :
3078 0 : xListCursor = xStatement->executeQuery(aStatement.makeStringAndClear());
3079 :
3080 0 : Reference< ::com::sun::star::sdbcx::XColumnsSupplier > xSupplyCols(xListCursor, UNO_QUERY);
3081 0 : Reference< ::com::sun::star::container::XIndexAccess > xFields(xSupplyCols->getColumns(), UNO_QUERY);
3082 0 : xDataField.set(xFields->getByIndex(0), css::uno::UNO_QUERY);
3083 0 : if (!xDataField.is())
3084 0 : return;
3085 : }
3086 0 : catch(const Exception&)
3087 : {
3088 0 : ::comphelper::disposeComponent(xStatement);
3089 0 : return;
3090 : }
3091 :
3092 0 : sal_Int16 i = 0;
3093 0 : ::std::vector< OUString > aStringList;
3094 0 : aStringList.reserve(16);
3095 0 : OUString aStr;
3096 0 : com::sun::star::util::Date aNullDate = m_rColumn.GetParent().getNullDate();
3097 0 : sal_Int32 nFormatKey = m_rColumn.GetKey();
3098 0 : Reference< XNumberFormatter > xFormatter = m_rColumn.GetParent().getNumberFormatter();
3099 0 : sal_Int16 nKeyType = ::comphelper::getNumberFormatType(xFormatter->getNumberFormatsSupplier()->getNumberFormats(), nFormatKey);
3100 :
3101 0 : while (!xListCursor->isAfterLast() && i++ < SHRT_MAX) // max anzahl eintraege
3102 : {
3103 0 : aStr = getFormattedValue(xDataField, xFormatter, aNullDate, nFormatKey, nKeyType);
3104 0 : aStringList.push_back(aStr);
3105 0 : (void)xListCursor->next();
3106 : }
3107 :
3108 : // filling the entries for the combobox
3109 0 : for (::std::vector< OUString >::const_iterator iter = aStringList.begin();
3110 0 : iter != aStringList.end(); ++iter)
3111 0 : static_cast<ComboBox*>(m_pWindow)->InsertEntry(*iter, LISTBOX_APPEND);
3112 0 : }
3113 : }
3114 : }
3115 :
3116 :
3117 0 : OUString DbFilterField::GetFormatText(const Reference< XColumn >& /*_rxField*/, const Reference< XNumberFormatter >& /*xFormatter*/, Color** /*ppColor*/)
3118 : {
3119 0 : return OUString();
3120 : }
3121 :
3122 :
3123 0 : void DbFilterField::UpdateFromField(const Reference< XColumn >& /*_rxField*/, const Reference< XNumberFormatter >& /*xFormatter*/)
3124 : {
3125 : OSL_FAIL( "DbFilterField::UpdateFromField: cannot update a filter control from a field!" );
3126 0 : }
3127 :
3128 :
3129 0 : IMPL_LINK_NOARG(DbFilterField, OnClick)
3130 : {
3131 0 : TriState eState = static_cast<CheckBoxControl*>(m_pWindow)->GetBox().GetState();
3132 0 : OUString aText;
3133 :
3134 0 : switch (eState)
3135 : {
3136 : case TRISTATE_TRUE:
3137 0 : aText = "1";
3138 0 : break;
3139 : case TRISTATE_FALSE:
3140 0 : aText = "0";
3141 0 : break;
3142 : case TRISTATE_INDET:
3143 0 : break;
3144 : }
3145 :
3146 0 : if (m_aText != aText)
3147 : {
3148 0 : m_aText = aText;
3149 0 : m_aCommitLink.Call(this);
3150 : }
3151 0 : return 1;
3152 : }
3153 :
3154 4 : TYPEINIT0(FmXGridCell);
3155 :
3156 :
3157 :
3158 62 : FmXGridCell::FmXGridCell( DbGridColumn* pColumn, DbCellControl* _pControl )
3159 : :OComponentHelper(m_aMutex)
3160 : ,m_pColumn(pColumn)
3161 : ,m_pCellControl( _pControl )
3162 : ,m_aWindowListeners( m_aMutex )
3163 : ,m_aFocusListeners( m_aMutex )
3164 : ,m_aKeyListeners( m_aMutex )
3165 : ,m_aMouseListeners( m_aMutex )
3166 62 : ,m_aMouseMotionListeners( m_aMutex )
3167 : {
3168 62 : }
3169 :
3170 :
3171 62 : void FmXGridCell::init()
3172 : {
3173 62 : vcl::Window* pEventWindow( getEventWindow() );
3174 62 : if ( pEventWindow )
3175 62 : pEventWindow->AddEventListener( LINK( this, FmXGridCell, OnWindowEvent ) );
3176 62 : }
3177 :
3178 :
3179 62 : vcl::Window* FmXGridCell::getEventWindow() const
3180 : {
3181 62 : if ( m_pCellControl )
3182 62 : return &m_pCellControl->GetWindow();
3183 0 : return NULL;
3184 : }
3185 :
3186 :
3187 124 : FmXGridCell::~FmXGridCell()
3188 : {
3189 62 : if (!OComponentHelper::rBHelper.bDisposed)
3190 : {
3191 0 : acquire();
3192 0 : dispose();
3193 : }
3194 :
3195 62 : }
3196 :
3197 :
3198 0 : void FmXGridCell::SetTextLineColor()
3199 : {
3200 0 : if (m_pCellControl)
3201 0 : m_pCellControl->SetTextLineColor();
3202 0 : }
3203 :
3204 :
3205 0 : void FmXGridCell::SetTextLineColor(const Color& _rColor)
3206 : {
3207 0 : if (m_pCellControl)
3208 0 : m_pCellControl->SetTextLineColor(_rColor);
3209 0 : }
3210 :
3211 : // XTypeProvider
3212 :
3213 0 : Sequence< Type > SAL_CALL FmXGridCell::getTypes( ) throw (RuntimeException, std::exception)
3214 : {
3215 : Sequence< uno::Type > aTypes = ::comphelper::concatSequences(
3216 : ::cppu::OComponentHelper::getTypes(),
3217 : FmXGridCell_Base::getTypes()
3218 0 : );
3219 0 : if ( m_pCellControl )
3220 0 : aTypes = ::comphelper::concatSequences(
3221 : aTypes,
3222 : FmXGridCell_WindowBase::getTypes()
3223 0 : );
3224 0 : return aTypes;
3225 : }
3226 :
3227 :
3228 0 : IMPLEMENT_GET_IMPLEMENTATION_ID( FmXGridCell )
3229 :
3230 : // OComponentHelper
3231 :
3232 62 : void FmXGridCell::disposing()
3233 : {
3234 62 : lang::EventObject aEvent( *this );
3235 62 : m_aWindowListeners.disposeAndClear( aEvent );
3236 62 : m_aFocusListeners.disposeAndClear( aEvent );
3237 62 : m_aKeyListeners.disposeAndClear( aEvent );
3238 62 : m_aMouseListeners.disposeAndClear( aEvent );
3239 62 : m_aMouseMotionListeners.disposeAndClear( aEvent );
3240 :
3241 62 : OComponentHelper::disposing();
3242 62 : m_pColumn = NULL;
3243 62 : DELETEZ(m_pCellControl);
3244 62 : }
3245 :
3246 :
3247 248 : Any SAL_CALL FmXGridCell::queryAggregation( const ::com::sun::star::uno::Type& _rType ) throw(RuntimeException, std::exception)
3248 : {
3249 248 : Any aReturn = OComponentHelper::queryAggregation( _rType );
3250 :
3251 248 : if ( !aReturn.hasValue() )
3252 0 : aReturn = FmXGridCell_Base::queryInterface( _rType );
3253 :
3254 248 : if ( !aReturn.hasValue() && ( m_pCellControl != NULL ) )
3255 0 : aReturn = FmXGridCell_WindowBase::queryInterface( _rType );
3256 :
3257 248 : return aReturn;
3258 : }
3259 :
3260 : // ::com::sun::star::awt::XControl
3261 :
3262 0 : Reference< XInterface > FmXGridCell::getContext() throw( RuntimeException, std::exception )
3263 : {
3264 0 : return Reference< XInterface > ();
3265 : }
3266 :
3267 :
3268 0 : Reference< ::com::sun::star::awt::XControlModel > FmXGridCell::getModel() throw( ::com::sun::star::uno::RuntimeException, std::exception )
3269 : {
3270 0 : return Reference< ::com::sun::star::awt::XControlModel > (m_pColumn->getModel(), UNO_QUERY);
3271 : }
3272 :
3273 : // ::com::sun::star::form::XBoundControl
3274 :
3275 0 : sal_Bool FmXGridCell::getLock() throw( RuntimeException, std::exception )
3276 : {
3277 0 : return m_pColumn->isLocked();
3278 : }
3279 :
3280 :
3281 0 : void FmXGridCell::setLock(sal_Bool _bLock) throw( RuntimeException, std::exception )
3282 : {
3283 0 : if (getLock() == _bLock)
3284 0 : return;
3285 : else
3286 : {
3287 0 : ::osl::MutexGuard aGuard(m_aMutex);
3288 0 : m_pColumn->setLock(_bLock);
3289 : }
3290 : }
3291 :
3292 :
3293 0 : void SAL_CALL FmXGridCell::setPosSize( ::sal_Int32 _XX, ::sal_Int32 _Y, ::sal_Int32 _Width, ::sal_Int32 _Height, ::sal_Int16 _Flags ) throw (RuntimeException, std::exception)
3294 : {
3295 : OSL_FAIL( "FmXGridCell::setPosSize: not implemented" );
3296 : (void)_XX;
3297 : (void)_Y;
3298 : (void)_Width;
3299 : (void)_Height;
3300 : (void)_Flags;
3301 : // not allowed to tamper with this for a grid cell
3302 0 : }
3303 :
3304 :
3305 0 : awt::Rectangle SAL_CALL FmXGridCell::getPosSize( ) throw (RuntimeException, std::exception)
3306 : {
3307 : OSL_FAIL( "FmXGridCell::getPosSize: not implemented" );
3308 0 : return awt::Rectangle();
3309 : }
3310 :
3311 :
3312 0 : void SAL_CALL FmXGridCell::setVisible( sal_Bool _Visible ) throw (RuntimeException, std::exception)
3313 : {
3314 : OSL_FAIL( "FmXGridCell::setVisible: not implemented" );
3315 : (void)_Visible;
3316 : // not allowed to tamper with this for a grid cell
3317 0 : }
3318 :
3319 :
3320 0 : void SAL_CALL FmXGridCell::setEnable( sal_Bool _Enable ) throw (RuntimeException, std::exception)
3321 : {
3322 : OSL_FAIL( "FmXGridCell::setEnable: not implemented" );
3323 : (void)_Enable;
3324 : // not allowed to tamper with this for a grid cell
3325 0 : }
3326 :
3327 :
3328 0 : void SAL_CALL FmXGridCell::setFocus( ) throw (RuntimeException, std::exception)
3329 : {
3330 : OSL_FAIL( "FmXGridCell::setFocus: not implemented" );
3331 : // not allowed to tamper with this for a grid cell
3332 0 : }
3333 :
3334 :
3335 0 : void SAL_CALL FmXGridCell::addWindowListener( const Reference< awt::XWindowListener >& _rxListener ) throw (RuntimeException, std::exception)
3336 : {
3337 0 : m_aWindowListeners.addInterface( _rxListener );
3338 0 : }
3339 :
3340 :
3341 0 : void SAL_CALL FmXGridCell::removeWindowListener( const Reference< awt::XWindowListener >& _rxListener ) throw (RuntimeException, std::exception)
3342 : {
3343 0 : m_aWindowListeners.removeInterface( _rxListener );
3344 0 : }
3345 :
3346 :
3347 0 : void SAL_CALL FmXGridCell::addFocusListener( const Reference< awt::XFocusListener >& _rxListener ) throw (RuntimeException, std::exception)
3348 : {
3349 0 : m_aFocusListeners.addInterface( _rxListener );
3350 0 : }
3351 :
3352 :
3353 0 : void SAL_CALL FmXGridCell::removeFocusListener( const Reference< awt::XFocusListener >& _rxListener ) throw (RuntimeException, std::exception)
3354 : {
3355 0 : m_aFocusListeners.removeInterface( _rxListener );
3356 0 : }
3357 :
3358 :
3359 0 : void SAL_CALL FmXGridCell::addKeyListener( const Reference< awt::XKeyListener >& _rxListener ) throw (RuntimeException, std::exception)
3360 : {
3361 0 : m_aKeyListeners.addInterface( _rxListener );
3362 0 : }
3363 :
3364 :
3365 0 : void SAL_CALL FmXGridCell::removeKeyListener( const Reference< awt::XKeyListener >& _rxListener ) throw (RuntimeException, std::exception)
3366 : {
3367 0 : m_aKeyListeners.removeInterface( _rxListener );
3368 0 : }
3369 :
3370 :
3371 0 : void SAL_CALL FmXGridCell::addMouseListener( const Reference< awt::XMouseListener >& _rxListener ) throw (RuntimeException, std::exception)
3372 : {
3373 0 : m_aMouseListeners.addInterface( _rxListener );
3374 0 : }
3375 :
3376 :
3377 0 : void SAL_CALL FmXGridCell::removeMouseListener( const Reference< awt::XMouseListener >& _rxListener ) throw (RuntimeException, std::exception)
3378 : {
3379 0 : m_aMouseListeners.removeInterface( _rxListener );
3380 0 : }
3381 :
3382 :
3383 0 : void SAL_CALL FmXGridCell::addMouseMotionListener( const Reference< awt::XMouseMotionListener >& _rxListener ) throw (RuntimeException, std::exception)
3384 : {
3385 0 : m_aMouseMotionListeners.addInterface( _rxListener );
3386 0 : }
3387 :
3388 :
3389 0 : void SAL_CALL FmXGridCell::removeMouseMotionListener( const Reference< awt::XMouseMotionListener >& _rxListener ) throw (RuntimeException, std::exception)
3390 : {
3391 0 : m_aMouseMotionListeners.removeInterface( _rxListener );
3392 0 : }
3393 :
3394 :
3395 0 : void SAL_CALL FmXGridCell::addPaintListener( const Reference< awt::XPaintListener >& _rxListener ) throw (RuntimeException, std::exception)
3396 : {
3397 : OSL_FAIL( "FmXGridCell::addPaintListener: not implemented" );
3398 : (void)_rxListener;
3399 0 : }
3400 :
3401 :
3402 0 : void SAL_CALL FmXGridCell::removePaintListener( const Reference< awt::XPaintListener >& _rxListener ) throw (RuntimeException, std::exception)
3403 : {
3404 : OSL_FAIL( "FmXGridCell::removePaintListener: not implemented" );
3405 : (void)_rxListener;
3406 0 : }
3407 :
3408 :
3409 152 : IMPL_LINK( FmXGridCell, OnWindowEvent, VclWindowEvent*, _pEvent )
3410 : {
3411 76 : ENSURE_OR_THROW( _pEvent, "illegal event pointer" );
3412 76 : ENSURE_OR_THROW( _pEvent->GetWindow(), "illegal window" );
3413 76 : onWindowEvent( _pEvent->GetId(), *_pEvent->GetWindow(), _pEvent->GetData() );
3414 76 : return 1L;
3415 : }
3416 :
3417 :
3418 0 : void FmXGridCell::onFocusGained( const awt::FocusEvent& _rEvent )
3419 : {
3420 0 : m_aFocusListeners.notifyEach( &awt::XFocusListener::focusGained, _rEvent );
3421 0 : }
3422 :
3423 :
3424 0 : void FmXGridCell::onFocusLost( const awt::FocusEvent& _rEvent )
3425 : {
3426 0 : m_aFocusListeners.notifyEach( &awt::XFocusListener::focusLost, _rEvent );
3427 0 : }
3428 :
3429 :
3430 74 : void FmXGridCell::onWindowEvent( const sal_uIntPtr _nEventId, const vcl::Window& _rWindow, const void* _pEventData )
3431 : {
3432 74 : switch ( _nEventId )
3433 : {
3434 : case VCLEVENT_CONTROL_GETFOCUS:
3435 : case VCLEVENT_WINDOW_GETFOCUS:
3436 : case VCLEVENT_CONTROL_LOSEFOCUS:
3437 : case VCLEVENT_WINDOW_LOSEFOCUS:
3438 : {
3439 0 : if ( ( _rWindow.IsCompoundControl()
3440 0 : && ( _nEventId == VCLEVENT_CONTROL_GETFOCUS
3441 0 : || _nEventId == VCLEVENT_CONTROL_LOSEFOCUS
3442 : )
3443 : )
3444 0 : || ( !_rWindow.IsCompoundControl()
3445 0 : && ( _nEventId == VCLEVENT_WINDOW_GETFOCUS
3446 0 : || _nEventId == VCLEVENT_WINDOW_LOSEFOCUS
3447 : )
3448 : )
3449 : )
3450 : {
3451 0 : if ( !m_aFocusListeners.getLength() )
3452 0 : break;
3453 :
3454 0 : bool bFocusGained = ( _nEventId == VCLEVENT_CONTROL_GETFOCUS ) || ( _nEventId == VCLEVENT_WINDOW_GETFOCUS );
3455 :
3456 0 : awt::FocusEvent aEvent;
3457 0 : aEvent.Source = *this;
3458 0 : aEvent.FocusFlags = _rWindow.GetGetFocusFlags();
3459 0 : aEvent.Temporary = sal_False;
3460 :
3461 0 : if ( bFocusGained )
3462 0 : onFocusGained( aEvent );
3463 : else
3464 0 : onFocusLost( aEvent );
3465 : }
3466 : }
3467 0 : break;
3468 : case VCLEVENT_WINDOW_MOUSEBUTTONDOWN:
3469 : case VCLEVENT_WINDOW_MOUSEBUTTONUP:
3470 : {
3471 0 : if ( !m_aMouseListeners.getLength() )
3472 0 : break;
3473 :
3474 0 : const bool bButtonDown = ( _nEventId == VCLEVENT_WINDOW_MOUSEBUTTONDOWN );
3475 :
3476 0 : awt::MouseEvent aEvent( VCLUnoHelper::createMouseEvent( *static_cast< const ::MouseEvent* >( _pEventData ), *this ) );
3477 0 : m_aMouseListeners.notifyEach( bButtonDown ? &awt::XMouseListener::mousePressed : &awt::XMouseListener::mouseReleased, aEvent );
3478 : }
3479 0 : break;
3480 : case VCLEVENT_WINDOW_MOUSEMOVE:
3481 : {
3482 0 : const MouseEvent& rMouseEvent = *static_cast< const ::MouseEvent* >( _pEventData );
3483 0 : if ( rMouseEvent.IsEnterWindow() || rMouseEvent.IsLeaveWindow() )
3484 : {
3485 0 : if ( m_aMouseListeners.getLength() != 0 )
3486 : {
3487 0 : awt::MouseEvent aEvent( VCLUnoHelper::createMouseEvent( rMouseEvent, *this ) );
3488 0 : m_aMouseListeners.notifyEach( rMouseEvent.IsEnterWindow() ? &awt::XMouseListener::mouseEntered: &awt::XMouseListener::mouseExited, aEvent );
3489 : }
3490 : }
3491 0 : else if ( !rMouseEvent.IsEnterWindow() && !rMouseEvent.IsLeaveWindow() )
3492 : {
3493 0 : if ( m_aMouseMotionListeners.getLength() != 0 )
3494 : {
3495 0 : awt::MouseEvent aEvent( VCLUnoHelper::createMouseEvent( rMouseEvent, *this ) );
3496 0 : aEvent.ClickCount = 0;
3497 0 : const bool bSimpleMove = ( ( rMouseEvent.GetMode() & MOUSE_SIMPLEMOVE ) != 0 );
3498 0 : m_aMouseMotionListeners.notifyEach( bSimpleMove ? &awt::XMouseMotionListener::mouseMoved: &awt::XMouseMotionListener::mouseDragged, aEvent );
3499 : }
3500 : }
3501 : }
3502 0 : break;
3503 : case VCLEVENT_WINDOW_KEYINPUT:
3504 : case VCLEVENT_WINDOW_KEYUP:
3505 : {
3506 0 : if ( !m_aKeyListeners.getLength() )
3507 0 : break;
3508 :
3509 0 : const bool bKeyPressed = ( _nEventId == VCLEVENT_WINDOW_KEYINPUT );
3510 0 : awt::KeyEvent aEvent( VCLUnoHelper::createKeyEvent( *static_cast< const ::KeyEvent* >( _pEventData ), *this ) );
3511 0 : m_aKeyListeners.notifyEach( bKeyPressed ? &awt::XKeyListener::keyPressed: &awt::XKeyListener::keyReleased, aEvent );
3512 : }
3513 0 : break;
3514 : }
3515 74 : }
3516 :
3517 244 : TYPEINIT1(FmXDataCell, FmXGridCell);
3518 :
3519 32 : void FmXDataCell::PaintFieldToCell(OutputDevice& rDev, const Rectangle& rRect,
3520 : const Reference< ::com::sun::star::sdb::XColumn >& _rxField,
3521 : const Reference< XNumberFormatter >& xFormatter)
3522 : {
3523 32 : m_pCellControl->PaintFieldToCell( rDev, rRect, _rxField, xFormatter );
3524 32 : }
3525 :
3526 :
3527 0 : void FmXDataCell::UpdateFromColumn()
3528 : {
3529 0 : Reference< ::com::sun::star::sdb::XColumn > xField(m_pColumn->GetCurrentFieldValue());
3530 0 : if (xField.is())
3531 0 : m_pCellControl->UpdateFromField(xField, m_pColumn->GetParent().getNumberFormatter());
3532 0 : }
3533 :
3534 246 : TYPEINIT1(FmXTextCell, FmXDataCell);
3535 :
3536 62 : FmXTextCell::FmXTextCell( DbGridColumn* pColumn, DbCellControl& _rControl )
3537 : :FmXDataCell( pColumn, _rControl )
3538 62 : ,m_bFastPaint( true )
3539 : {
3540 62 : }
3541 :
3542 :
3543 78 : void FmXTextCell::PaintFieldToCell(OutputDevice& rDev,
3544 : const Rectangle& rRect,
3545 : const Reference< ::com::sun::star::sdb::XColumn >& _rxField,
3546 : const Reference< XNumberFormatter >& xFormatter)
3547 : {
3548 78 : if ( !m_bFastPaint )
3549 : {
3550 32 : FmXDataCell::PaintFieldToCell( rDev, rRect, _rxField, xFormatter );
3551 110 : return;
3552 : }
3553 :
3554 46 : sal_uInt16 nStyle = TEXT_DRAW_CLIP | TEXT_DRAW_VCENTER;
3555 46 : if ( ( rDev.GetOutDevType() == OUTDEV_WINDOW ) && !static_cast< vcl::Window& >( rDev ).IsEnabled() )
3556 0 : nStyle |= TEXT_DRAW_DISABLE;
3557 :
3558 46 : switch (m_pColumn->GetAlignment())
3559 : {
3560 : case ::com::sun::star::awt::TextAlign::RIGHT:
3561 0 : nStyle |= TEXT_DRAW_RIGHT;
3562 0 : break;
3563 : case ::com::sun::star::awt::TextAlign::CENTER:
3564 0 : nStyle |= TEXT_DRAW_CENTER;
3565 0 : break;
3566 : default:
3567 46 : nStyle |= TEXT_DRAW_LEFT;
3568 : }
3569 :
3570 46 : Color* pColor = NULL;
3571 46 : OUString aText = GetText(_rxField, xFormatter, &pColor);
3572 46 : if (pColor != NULL)
3573 : {
3574 0 : Color aOldTextColor( rDev.GetTextColor() );
3575 0 : rDev.SetTextColor( *pColor );
3576 0 : rDev.DrawText(rRect, aText, nStyle);
3577 0 : rDev.SetTextColor( aOldTextColor );
3578 : }
3579 : else
3580 46 : rDev.DrawText(rRect, aText, nStyle);
3581 : }
3582 :
3583 62 : FmXEditCell::FmXEditCell( DbGridColumn* pColumn, DbCellControl& _rControl )
3584 : :FmXTextCell( pColumn, _rControl )
3585 : ,m_aTextListeners(m_aMutex)
3586 : ,m_aChangeListeners( m_aMutex )
3587 : ,m_pEditImplementation( NULL )
3588 62 : ,m_bOwnEditImplementation( false )
3589 : {
3590 :
3591 62 : DbTextField* pTextField = PTR_CAST( DbTextField, &_rControl );
3592 62 : if ( pTextField )
3593 : {
3594 :
3595 34 : m_pEditImplementation = pTextField->GetEditImplementation();
3596 34 : if ( !pTextField->IsSimpleEdit() )
3597 34 : m_bFastPaint = false;
3598 : }
3599 : else
3600 : {
3601 28 : m_pEditImplementation = new EditImplementation( static_cast< Edit& >( _rControl.GetWindow() ) );
3602 28 : m_bOwnEditImplementation = true;
3603 : }
3604 62 : }
3605 :
3606 :
3607 186 : FmXEditCell::~FmXEditCell()
3608 : {
3609 62 : if (!OComponentHelper::rBHelper.bDisposed)
3610 : {
3611 0 : acquire();
3612 0 : dispose();
3613 : }
3614 :
3615 :
3616 124 : }
3617 :
3618 : // OComponentHelper
3619 :
3620 62 : void FmXEditCell::disposing()
3621 : {
3622 62 : ::com::sun::star::lang::EventObject aEvt(*this);
3623 62 : m_aTextListeners.disposeAndClear(aEvt);
3624 62 : m_aChangeListeners.disposeAndClear(aEvt);
3625 :
3626 62 : m_pEditImplementation->SetModifyHdl( Link() );
3627 62 : if ( m_bOwnEditImplementation )
3628 28 : delete m_pEditImplementation;
3629 62 : m_pEditImplementation = NULL;
3630 :
3631 62 : FmXDataCell::disposing();
3632 62 : }
3633 :
3634 :
3635 248 : Any SAL_CALL FmXEditCell::queryAggregation( const ::com::sun::star::uno::Type& _rType ) throw(RuntimeException, std::exception)
3636 : {
3637 248 : Any aReturn = FmXTextCell::queryAggregation( _rType );
3638 :
3639 248 : if ( !aReturn.hasValue() )
3640 0 : aReturn = FmXEditCell_Base::queryInterface( _rType );
3641 :
3642 248 : return aReturn;
3643 : }
3644 :
3645 :
3646 0 : Sequence< ::com::sun::star::uno::Type > SAL_CALL FmXEditCell::getTypes( ) throw(RuntimeException, std::exception)
3647 : {
3648 : return ::comphelper::concatSequences(
3649 : FmXTextCell::getTypes(),
3650 : FmXEditCell_Base::getTypes()
3651 0 : );
3652 : }
3653 :
3654 :
3655 0 : IMPLEMENT_GET_IMPLEMENTATION_ID( FmXEditCell )
3656 :
3657 : // ::com::sun::star::awt::XTextComponent
3658 :
3659 0 : void SAL_CALL FmXEditCell::addTextListener(const Reference< ::com::sun::star::awt::XTextListener >& l) throw( RuntimeException, std::exception )
3660 : {
3661 0 : m_aTextListeners.addInterface( l );
3662 0 : }
3663 :
3664 :
3665 0 : void SAL_CALL FmXEditCell::removeTextListener(const Reference< ::com::sun::star::awt::XTextListener >& l) throw( RuntimeException, std::exception )
3666 : {
3667 0 : m_aTextListeners.removeInterface( l );
3668 0 : }
3669 :
3670 :
3671 0 : void SAL_CALL FmXEditCell::setText( const OUString& aText ) throw( RuntimeException, std::exception )
3672 : {
3673 0 : ::osl::MutexGuard aGuard( m_aMutex );
3674 :
3675 0 : if ( m_pEditImplementation )
3676 : {
3677 0 : m_pEditImplementation->SetText( aText );
3678 :
3679 : // In JAVA wird auch ein textChanged ausgeloest, in VCL nicht.
3680 : // ::com::sun::star::awt::Toolkit soll JAVA-komform sein...
3681 0 : onTextChanged();
3682 0 : }
3683 0 : }
3684 :
3685 :
3686 0 : void SAL_CALL FmXEditCell::insertText(const ::com::sun::star::awt::Selection& rSel, const OUString& aText) throw(RuntimeException, std::exception)
3687 : {
3688 0 : ::osl::MutexGuard aGuard( m_aMutex );
3689 :
3690 0 : if ( m_pEditImplementation )
3691 : {
3692 0 : m_pEditImplementation->SetSelection( Selection( rSel.Min, rSel.Max ) );
3693 0 : m_pEditImplementation->ReplaceSelected( aText );
3694 0 : }
3695 0 : }
3696 :
3697 :
3698 0 : OUString SAL_CALL FmXEditCell::getText() throw( RuntimeException, std::exception )
3699 : {
3700 0 : ::osl::MutexGuard aGuard( m_aMutex );
3701 :
3702 0 : OUString aText;
3703 0 : if ( m_pEditImplementation )
3704 : {
3705 0 : if ( m_pEditImplementation->GetControl().IsVisible() && m_pColumn->GetParent().getDisplaySynchron())
3706 : {
3707 : // if the display isn't sync with the cursor we can't ask the edit field
3708 0 : LineEnd eLineEndFormat = getModelLineEndSetting( m_pColumn->getModel() );
3709 0 : aText = m_pEditImplementation->GetText( eLineEndFormat );
3710 : }
3711 : else
3712 : {
3713 0 : Reference< ::com::sun::star::sdb::XColumn > xField(m_pColumn->GetCurrentFieldValue());
3714 0 : if (xField.is())
3715 0 : aText = GetText(xField, m_pColumn->GetParent().getNumberFormatter());
3716 : }
3717 : }
3718 0 : return aText;
3719 : }
3720 :
3721 :
3722 0 : OUString SAL_CALL FmXEditCell::getSelectedText( void ) throw( RuntimeException, std::exception )
3723 : {
3724 0 : ::osl::MutexGuard aGuard( m_aMutex );
3725 :
3726 0 : OUString aText;
3727 0 : if ( m_pEditImplementation )
3728 : {
3729 0 : LineEnd eLineEndFormat = m_pColumn ? getModelLineEndSetting( m_pColumn->getModel() ) : LINEEND_LF;
3730 0 : aText = m_pEditImplementation->GetSelected( eLineEndFormat );
3731 : }
3732 0 : return aText;
3733 : }
3734 :
3735 :
3736 0 : void SAL_CALL FmXEditCell::setSelection( const ::com::sun::star::awt::Selection& aSelection ) throw( RuntimeException, std::exception )
3737 : {
3738 0 : ::osl::MutexGuard aGuard( m_aMutex );
3739 :
3740 0 : if ( m_pEditImplementation )
3741 0 : m_pEditImplementation->SetSelection( Selection( aSelection.Min, aSelection.Max ) );
3742 0 : }
3743 :
3744 :
3745 0 : ::com::sun::star::awt::Selection SAL_CALL FmXEditCell::getSelection( void ) throw( RuntimeException, std::exception )
3746 : {
3747 0 : ::osl::MutexGuard aGuard( m_aMutex );
3748 :
3749 0 : Selection aSel;
3750 0 : if ( m_pEditImplementation )
3751 0 : aSel = m_pEditImplementation->GetSelection();
3752 :
3753 0 : return ::com::sun::star::awt::Selection(aSel.Min(), aSel.Max());
3754 : }
3755 :
3756 :
3757 0 : sal_Bool SAL_CALL FmXEditCell::isEditable( void ) throw( RuntimeException, std::exception )
3758 : {
3759 0 : ::osl::MutexGuard aGuard( m_aMutex );
3760 :
3761 0 : return ( m_pEditImplementation && !m_pEditImplementation->IsReadOnly() && m_pEditImplementation->GetControl().IsEnabled() ) ? sal_True : sal_False;
3762 : }
3763 :
3764 :
3765 0 : void SAL_CALL FmXEditCell::setEditable( sal_Bool bEditable ) throw( RuntimeException, std::exception )
3766 : {
3767 0 : ::osl::MutexGuard aGuard( m_aMutex );
3768 :
3769 0 : if ( m_pEditImplementation )
3770 0 : m_pEditImplementation->SetReadOnly( !bEditable );
3771 0 : }
3772 :
3773 :
3774 0 : sal_Int16 SAL_CALL FmXEditCell::getMaxTextLen() throw( RuntimeException, std::exception )
3775 : {
3776 0 : ::osl::MutexGuard aGuard( m_aMutex );
3777 :
3778 0 : return m_pEditImplementation ? m_pEditImplementation->GetMaxTextLen() : 0;
3779 : }
3780 :
3781 :
3782 0 : void SAL_CALL FmXEditCell::setMaxTextLen( sal_Int16 nLen ) throw( RuntimeException, std::exception )
3783 : {
3784 0 : ::osl::MutexGuard aGuard( m_aMutex );
3785 :
3786 0 : if ( m_pEditImplementation )
3787 0 : m_pEditImplementation->SetMaxTextLen( nLen );
3788 0 : }
3789 :
3790 :
3791 0 : void SAL_CALL FmXEditCell::addChangeListener( const Reference< form::XChangeListener >& _Listener ) throw (RuntimeException, std::exception)
3792 : {
3793 0 : m_aChangeListeners.addInterface( _Listener );
3794 0 : }
3795 :
3796 :
3797 0 : void SAL_CALL FmXEditCell::removeChangeListener( const Reference< form::XChangeListener >& _Listener ) throw (RuntimeException, std::exception)
3798 : {
3799 0 : m_aChangeListeners.removeInterface( _Listener );
3800 0 : }
3801 :
3802 :
3803 0 : void FmXEditCell::onTextChanged()
3804 : {
3805 0 : ::com::sun::star::awt::TextEvent aEvent;
3806 0 : aEvent.Source = *this;
3807 0 : m_aTextListeners.notifyEach( &awt::XTextListener::textChanged, aEvent );
3808 0 : }
3809 :
3810 :
3811 0 : void FmXEditCell::onFocusGained( const awt::FocusEvent& _rEvent )
3812 : {
3813 0 : FmXTextCell::onFocusGained( _rEvent );
3814 0 : m_sValueOnEnter = getText();
3815 0 : }
3816 :
3817 :
3818 0 : void FmXEditCell::onFocusLost( const awt::FocusEvent& _rEvent )
3819 : {
3820 0 : FmXTextCell::onFocusLost( _rEvent );
3821 :
3822 0 : if ( getText() != m_sValueOnEnter )
3823 : {
3824 0 : lang::EventObject aEvent( *this );
3825 0 : m_aChangeListeners.notifyEach( &XChangeListener::changed, aEvent );
3826 : }
3827 0 : }
3828 :
3829 :
3830 76 : void FmXEditCell::onWindowEvent( const sal_uIntPtr _nEventId, const vcl::Window& _rWindow, const void* _pEventData )
3831 : {
3832 76 : switch ( _nEventId )
3833 : {
3834 : case VCLEVENT_EDIT_MODIFY:
3835 : {
3836 2 : if ( m_pEditImplementation && m_aTextListeners.getLength() )
3837 0 : onTextChanged();
3838 78 : return;
3839 : }
3840 : }
3841 :
3842 74 : FmXTextCell::onWindowEvent( _nEventId, _rWindow, _pEventData );
3843 : }
3844 :
3845 0 : FmXCheckBoxCell::FmXCheckBoxCell( DbGridColumn* pColumn, DbCellControl& _rControl )
3846 : :FmXDataCell( pColumn, _rControl )
3847 : ,m_aItemListeners(m_aMutex)
3848 : ,m_aActionListeners( m_aMutex )
3849 0 : ,m_pBox( & static_cast< CheckBoxControl& >( _rControl.GetWindow() ).GetBox() )
3850 : {
3851 0 : }
3852 :
3853 :
3854 0 : FmXCheckBoxCell::~FmXCheckBoxCell()
3855 : {
3856 0 : if (!OComponentHelper::rBHelper.bDisposed)
3857 : {
3858 0 : acquire();
3859 0 : dispose();
3860 : }
3861 :
3862 0 : }
3863 :
3864 : // OComponentHelper
3865 :
3866 0 : void FmXCheckBoxCell::disposing()
3867 : {
3868 0 : ::com::sun::star::lang::EventObject aEvt(*this);
3869 0 : m_aItemListeners.disposeAndClear(aEvt);
3870 0 : m_aActionListeners.disposeAndClear(aEvt);
3871 :
3872 0 : static_cast< CheckBoxControl& >( m_pCellControl->GetWindow() ).SetClickHdl(Link());
3873 0 : m_pBox = NULL;
3874 :
3875 0 : FmXDataCell::disposing();
3876 0 : }
3877 :
3878 :
3879 0 : Any SAL_CALL FmXCheckBoxCell::queryAggregation( const ::com::sun::star::uno::Type& _rType ) throw(RuntimeException, std::exception)
3880 : {
3881 0 : Any aReturn = FmXDataCell::queryAggregation( _rType );
3882 :
3883 0 : if ( !aReturn.hasValue() )
3884 0 : aReturn = FmXCheckBoxCell_Base::queryInterface( _rType );
3885 :
3886 0 : return aReturn;
3887 : }
3888 :
3889 :
3890 0 : Sequence< ::com::sun::star::uno::Type > SAL_CALL FmXCheckBoxCell::getTypes( ) throw(RuntimeException, std::exception)
3891 : {
3892 : return ::comphelper::concatSequences(
3893 : FmXDataCell::getTypes(),
3894 : FmXCheckBoxCell_Base::getTypes()
3895 0 : );
3896 : }
3897 :
3898 :
3899 0 : IMPLEMENT_GET_IMPLEMENTATION_ID( FmXCheckBoxCell )
3900 :
3901 :
3902 0 : void SAL_CALL FmXCheckBoxCell::addItemListener( const Reference< ::com::sun::star::awt::XItemListener >& l ) throw( RuntimeException, std::exception )
3903 : {
3904 0 : m_aItemListeners.addInterface( l );
3905 0 : }
3906 :
3907 :
3908 0 : void SAL_CALL FmXCheckBoxCell::removeItemListener( const Reference< ::com::sun::star::awt::XItemListener >& l ) throw( RuntimeException, std::exception )
3909 : {
3910 0 : m_aItemListeners.removeInterface( l );
3911 0 : }
3912 :
3913 :
3914 0 : void SAL_CALL FmXCheckBoxCell::setState( short n ) throw( RuntimeException, std::exception )
3915 : {
3916 0 : ::osl::MutexGuard aGuard( m_aMutex );
3917 :
3918 0 : if (m_pBox)
3919 : {
3920 0 : UpdateFromColumn();
3921 0 : m_pBox->SetState( (TriState)n );
3922 0 : }
3923 0 : }
3924 :
3925 :
3926 0 : short SAL_CALL FmXCheckBoxCell::getState() throw( RuntimeException, std::exception )
3927 : {
3928 0 : ::osl::MutexGuard aGuard( m_aMutex );
3929 :
3930 0 : if (m_pBox)
3931 : {
3932 0 : UpdateFromColumn();
3933 0 : return (short)m_pBox->GetState();
3934 : }
3935 0 : return TRISTATE_INDET;
3936 : }
3937 :
3938 :
3939 0 : void SAL_CALL FmXCheckBoxCell::enableTriState( sal_Bool b ) throw( RuntimeException, std::exception )
3940 : {
3941 0 : ::osl::MutexGuard aGuard( m_aMutex );
3942 :
3943 0 : if (m_pBox)
3944 0 : m_pBox->EnableTriState( b );
3945 0 : }
3946 :
3947 :
3948 0 : void SAL_CALL FmXCheckBoxCell::addActionListener( const Reference< awt::XActionListener >& _Listener ) throw (RuntimeException, std::exception)
3949 : {
3950 0 : m_aActionListeners.addInterface( _Listener );
3951 0 : }
3952 :
3953 :
3954 0 : void SAL_CALL FmXCheckBoxCell::removeActionListener( const Reference< awt::XActionListener >& _Listener ) throw (RuntimeException, std::exception)
3955 : {
3956 0 : m_aActionListeners.removeInterface( _Listener );
3957 0 : }
3958 :
3959 :
3960 0 : void SAL_CALL FmXCheckBoxCell::setLabel( const OUString& _Label ) throw (RuntimeException, std::exception)
3961 : {
3962 0 : SolarMutexGuard aGuard;
3963 0 : if ( m_pColumn )
3964 : {
3965 0 : DbGridControl& rGrid( m_pColumn->GetParent() );
3966 0 : rGrid.SetColumnTitle( rGrid.GetColumnId( m_pColumn->GetFieldPos() ), _Label );
3967 0 : }
3968 0 : }
3969 :
3970 :
3971 0 : void SAL_CALL FmXCheckBoxCell::setActionCommand( const OUString& _Command ) throw (RuntimeException, std::exception)
3972 : {
3973 0 : m_aActionCommand = _Command;
3974 0 : }
3975 :
3976 :
3977 0 : vcl::Window* FmXCheckBoxCell::getEventWindow() const
3978 : {
3979 0 : return m_pBox;
3980 : }
3981 :
3982 :
3983 0 : void FmXCheckBoxCell::onWindowEvent( const sal_uIntPtr _nEventId, const vcl::Window& _rWindow, const void* _pEventData )
3984 : {
3985 0 : switch ( _nEventId )
3986 : {
3987 : case VCLEVENT_CHECKBOX_TOGGLE:
3988 : {
3989 : // check boxes are to be committed immediately (this holds for ordinary check box controls in
3990 : // documents, and this must hold for check boxes in grid columns, too
3991 : // 91210 - 22.08.2001 - frank.schoenheit@sun.com
3992 0 : m_pCellControl->Commit();
3993 :
3994 0 : Reference< XWindow > xKeepAlive( this );
3995 0 : if ( m_aItemListeners.getLength() && m_pBox )
3996 : {
3997 0 : awt::ItemEvent aEvent;
3998 0 : aEvent.Source = *this;
3999 0 : aEvent.Highlighted = sal_False;
4000 0 : aEvent.Selected = m_pBox->GetState();
4001 0 : m_aItemListeners.notifyEach( &awt::XItemListener::itemStateChanged, aEvent );
4002 : }
4003 0 : if ( m_aActionListeners.getLength() )
4004 : {
4005 0 : awt::ActionEvent aEvent;
4006 0 : aEvent.Source = *this;
4007 0 : aEvent.ActionCommand = m_aActionCommand;
4008 0 : m_aActionListeners.notifyEach( &awt::XActionListener::actionPerformed, aEvent );
4009 0 : }
4010 : }
4011 0 : break;
4012 :
4013 : default:
4014 0 : FmXDataCell::onWindowEvent( _nEventId, _rWindow, _pEventData );
4015 0 : break;
4016 : }
4017 0 : }
4018 :
4019 0 : FmXListBoxCell::FmXListBoxCell(DbGridColumn* pColumn, DbCellControl& _rControl)
4020 : :FmXTextCell( pColumn, _rControl )
4021 : ,m_aItemListeners(m_aMutex)
4022 : ,m_aActionListeners(m_aMutex)
4023 0 : ,m_pBox( &static_cast< ListBox& >( _rControl.GetWindow() ) )
4024 : {
4025 :
4026 0 : m_pBox->SetDoubleClickHdl( LINK( this, FmXListBoxCell, OnDoubleClick ) );
4027 0 : }
4028 :
4029 :
4030 0 : FmXListBoxCell::~FmXListBoxCell()
4031 : {
4032 0 : if (!OComponentHelper::rBHelper.bDisposed)
4033 : {
4034 0 : acquire();
4035 0 : dispose();
4036 : }
4037 :
4038 0 : }
4039 :
4040 : // OComponentHelper
4041 :
4042 0 : void FmXListBoxCell::disposing()
4043 : {
4044 0 : ::com::sun::star::lang::EventObject aEvt(*this);
4045 0 : m_aItemListeners.disposeAndClear(aEvt);
4046 0 : m_aActionListeners.disposeAndClear(aEvt);
4047 :
4048 0 : m_pBox->SetSelectHdl( Link() );
4049 0 : m_pBox->SetDoubleClickHdl( Link() );
4050 0 : m_pBox = NULL;
4051 :
4052 0 : FmXTextCell::disposing();
4053 0 : }
4054 :
4055 :
4056 0 : Any SAL_CALL FmXListBoxCell::queryAggregation( const ::com::sun::star::uno::Type& _rType ) throw(RuntimeException, std::exception)
4057 : {
4058 0 : Any aReturn = FmXTextCell::queryAggregation(_rType);
4059 :
4060 0 : if ( !aReturn.hasValue() )
4061 0 : aReturn = FmXListBoxCell_Base::queryInterface( _rType );
4062 :
4063 0 : return aReturn;
4064 : }
4065 :
4066 :
4067 0 : Sequence< ::com::sun::star::uno::Type > SAL_CALL FmXListBoxCell::getTypes( ) throw(RuntimeException, std::exception)
4068 : {
4069 : return ::comphelper::concatSequences(
4070 : FmXTextCell::getTypes(),
4071 : FmXListBoxCell_Base::getTypes()
4072 0 : );
4073 : }
4074 :
4075 :
4076 0 : IMPLEMENT_GET_IMPLEMENTATION_ID( FmXListBoxCell )
4077 :
4078 :
4079 0 : void SAL_CALL FmXListBoxCell::addItemListener(const Reference< ::com::sun::star::awt::XItemListener >& l) throw( RuntimeException, std::exception )
4080 : {
4081 0 : m_aItemListeners.addInterface( l );
4082 0 : }
4083 :
4084 :
4085 0 : void SAL_CALL FmXListBoxCell::removeItemListener(const Reference< ::com::sun::star::awt::XItemListener >& l) throw( RuntimeException, std::exception )
4086 : {
4087 0 : m_aItemListeners.removeInterface( l );
4088 0 : }
4089 :
4090 :
4091 0 : void SAL_CALL FmXListBoxCell::addActionListener(const Reference< ::com::sun::star::awt::XActionListener >& l) throw( RuntimeException, std::exception )
4092 : {
4093 0 : m_aActionListeners.addInterface( l );
4094 0 : }
4095 :
4096 :
4097 0 : void SAL_CALL FmXListBoxCell::removeActionListener(const Reference< ::com::sun::star::awt::XActionListener >& l) throw( RuntimeException, std::exception )
4098 : {
4099 0 : m_aActionListeners.removeInterface( l );
4100 0 : }
4101 :
4102 :
4103 0 : void SAL_CALL FmXListBoxCell::addItem(const OUString& aItem, sal_Int16 nPos) throw( RuntimeException, std::exception )
4104 : {
4105 0 : ::osl::MutexGuard aGuard( m_aMutex );
4106 0 : if (m_pBox)
4107 0 : m_pBox->InsertEntry( aItem, nPos );
4108 0 : }
4109 :
4110 :
4111 0 : void SAL_CALL FmXListBoxCell::addItems(const ::comphelper::StringSequence& aItems, sal_Int16 nPos) throw( RuntimeException, std::exception )
4112 : {
4113 0 : ::osl::MutexGuard aGuard( m_aMutex );
4114 0 : if (m_pBox)
4115 : {
4116 0 : sal_uInt16 nP = nPos;
4117 0 : for ( sal_uInt16 n = 0; n < aItems.getLength(); n++ )
4118 : {
4119 0 : m_pBox->InsertEntry( aItems.getConstArray()[n], nP );
4120 0 : if ( nPos != -1 ) // Nicht wenn 0xFFFF, weil LIST_APPEND
4121 0 : nP++;
4122 : }
4123 0 : }
4124 0 : }
4125 :
4126 :
4127 0 : void SAL_CALL FmXListBoxCell::removeItems(sal_Int16 nPos, sal_Int16 nCount) throw( RuntimeException, std::exception )
4128 : {
4129 0 : ::osl::MutexGuard aGuard( m_aMutex );
4130 0 : if ( m_pBox )
4131 : {
4132 0 : for ( sal_uInt16 n = nCount; n; )
4133 0 : m_pBox->RemoveEntry( nPos + (--n) );
4134 0 : }
4135 0 : }
4136 :
4137 :
4138 0 : sal_Int16 SAL_CALL FmXListBoxCell::getItemCount() throw( RuntimeException, std::exception )
4139 : {
4140 0 : ::osl::MutexGuard aGuard( m_aMutex );
4141 0 : return m_pBox ? m_pBox->GetEntryCount() : 0;
4142 : }
4143 :
4144 :
4145 0 : OUString SAL_CALL FmXListBoxCell::getItem(sal_Int16 nPos) throw( RuntimeException, std::exception )
4146 : {
4147 0 : ::osl::MutexGuard aGuard( m_aMutex );
4148 0 : return m_pBox ? OUString(m_pBox->GetEntry(nPos)) : OUString();
4149 : }
4150 :
4151 0 : ::comphelper::StringSequence SAL_CALL FmXListBoxCell::getItems() throw( RuntimeException, std::exception )
4152 : {
4153 0 : ::osl::MutexGuard aGuard( m_aMutex );
4154 :
4155 0 : ::comphelper::StringSequence aSeq;
4156 0 : if (m_pBox)
4157 : {
4158 0 : sal_uInt16 nEntries = m_pBox ->GetEntryCount();
4159 0 : aSeq = ::comphelper::StringSequence( nEntries );
4160 0 : for ( sal_uInt16 n = nEntries; n; )
4161 : {
4162 0 : --n;
4163 0 : aSeq.getArray()[n] = m_pBox ->GetEntry( n );
4164 : }
4165 : }
4166 0 : return aSeq;
4167 : }
4168 :
4169 :
4170 0 : sal_Int16 SAL_CALL FmXListBoxCell::getSelectedItemPos() throw( RuntimeException, std::exception )
4171 : {
4172 0 : ::osl::MutexGuard aGuard( m_aMutex );
4173 0 : if (m_pBox)
4174 : {
4175 0 : UpdateFromColumn();
4176 0 : sal_Int32 nPos = m_pBox->GetSelectEntryPos();
4177 0 : if (nPos > SHRT_MAX || nPos < SHRT_MIN)
4178 0 : throw std::out_of_range("awt::XListBox::getSelectedItemPos can only return a short");
4179 0 : return nPos;
4180 : }
4181 0 : return 0;
4182 : }
4183 :
4184 :
4185 0 : Sequence< sal_Int16 > SAL_CALL FmXListBoxCell::getSelectedItemsPos() throw( RuntimeException, std::exception )
4186 : {
4187 0 : ::osl::MutexGuard aGuard( m_aMutex );
4188 0 : Sequence<sal_Int16> aSeq;
4189 :
4190 0 : if (m_pBox)
4191 : {
4192 0 : UpdateFromColumn();
4193 0 : sal_uInt16 nSelEntries = m_pBox->GetSelectEntryCount();
4194 0 : aSeq = Sequence<sal_Int16>( nSelEntries );
4195 0 : for ( sal_uInt16 n = 0; n < nSelEntries; n++ )
4196 0 : aSeq.getArray()[n] = m_pBox->GetSelectEntryPos( n );
4197 : }
4198 0 : return aSeq;
4199 : }
4200 :
4201 0 : OUString SAL_CALL FmXListBoxCell::getSelectedItem() throw( RuntimeException, std::exception )
4202 : {
4203 0 : ::osl::MutexGuard aGuard( m_aMutex );
4204 :
4205 0 : OUString aItem;
4206 :
4207 0 : if (m_pBox)
4208 : {
4209 0 : UpdateFromColumn();
4210 0 : aItem = m_pBox->GetSelectEntry();
4211 : }
4212 :
4213 0 : return aItem;
4214 : }
4215 :
4216 :
4217 0 : ::comphelper::StringSequence SAL_CALL FmXListBoxCell::getSelectedItems() throw( RuntimeException, std::exception )
4218 : {
4219 0 : ::osl::MutexGuard aGuard( m_aMutex );
4220 :
4221 0 : ::comphelper::StringSequence aSeq;
4222 :
4223 0 : if (m_pBox)
4224 : {
4225 0 : UpdateFromColumn();
4226 0 : sal_uInt16 nSelEntries = m_pBox->GetSelectEntryCount();
4227 0 : aSeq = ::comphelper::StringSequence( nSelEntries );
4228 0 : for ( sal_uInt16 n = 0; n < nSelEntries; n++ )
4229 0 : aSeq.getArray()[n] = m_pBox->GetSelectEntry( n );
4230 : }
4231 0 : return aSeq;
4232 : }
4233 :
4234 :
4235 0 : void SAL_CALL FmXListBoxCell::selectItemPos(sal_Int16 nPos, sal_Bool bSelect) throw( RuntimeException, std::exception )
4236 : {
4237 0 : ::osl::MutexGuard aGuard( m_aMutex );
4238 :
4239 0 : if (m_pBox)
4240 0 : m_pBox->SelectEntryPos( nPos, bSelect );
4241 0 : }
4242 :
4243 :
4244 0 : void SAL_CALL FmXListBoxCell::selectItemsPos(const Sequence< sal_Int16 >& aPositions, sal_Bool bSelect) throw( RuntimeException, std::exception )
4245 : {
4246 0 : ::osl::MutexGuard aGuard( m_aMutex );
4247 :
4248 0 : if (m_pBox)
4249 : {
4250 0 : for ( sal_uInt16 n = (sal_uInt16)aPositions.getLength(); n; )
4251 0 : m_pBox->SelectEntryPos( (sal_uInt16) aPositions.getConstArray()[--n], bSelect );
4252 0 : }
4253 0 : }
4254 :
4255 :
4256 0 : void SAL_CALL FmXListBoxCell::selectItem(const OUString& aItem, sal_Bool bSelect) throw( RuntimeException, std::exception )
4257 : {
4258 0 : ::osl::MutexGuard aGuard( m_aMutex );
4259 :
4260 0 : if (m_pBox)
4261 0 : m_pBox->SelectEntry( aItem, bSelect );
4262 0 : }
4263 :
4264 :
4265 0 : sal_Bool SAL_CALL FmXListBoxCell::isMutipleMode() throw( RuntimeException, std::exception )
4266 : {
4267 0 : ::osl::MutexGuard aGuard( m_aMutex );
4268 :
4269 0 : bool bMulti = false;
4270 0 : if (m_pBox)
4271 0 : bMulti = m_pBox->IsMultiSelectionEnabled();
4272 0 : return bMulti;
4273 : }
4274 :
4275 :
4276 0 : void SAL_CALL FmXListBoxCell::setMultipleMode(sal_Bool bMulti) throw( RuntimeException, std::exception )
4277 : {
4278 0 : ::osl::MutexGuard aGuard( m_aMutex );
4279 :
4280 0 : if (m_pBox)
4281 0 : m_pBox->EnableMultiSelection( bMulti );
4282 0 : }
4283 :
4284 :
4285 0 : sal_Int16 SAL_CALL FmXListBoxCell::getDropDownLineCount() throw( RuntimeException, std::exception )
4286 : {
4287 0 : ::osl::MutexGuard aGuard( m_aMutex );
4288 :
4289 0 : sal_Int16 nLines = 0;
4290 0 : if (m_pBox)
4291 0 : nLines = m_pBox->GetDropDownLineCount();
4292 :
4293 0 : return nLines;
4294 : }
4295 :
4296 :
4297 0 : void SAL_CALL FmXListBoxCell::setDropDownLineCount(sal_Int16 nLines) throw( RuntimeException, std::exception )
4298 : {
4299 0 : ::osl::MutexGuard aGuard( m_aMutex );
4300 :
4301 0 : if (m_pBox)
4302 0 : m_pBox->SetDropDownLineCount( nLines );
4303 0 : }
4304 :
4305 :
4306 0 : void SAL_CALL FmXListBoxCell::makeVisible(sal_Int16 nEntry) throw( RuntimeException, std::exception )
4307 : {
4308 0 : ::osl::MutexGuard aGuard( m_aMutex );
4309 :
4310 0 : if (m_pBox)
4311 0 : m_pBox->SetTopEntry( nEntry );
4312 0 : }
4313 :
4314 :
4315 0 : void FmXListBoxCell::onWindowEvent( const sal_uIntPtr _nEventId, const vcl::Window& _rWindow, const void* _pEventData )
4316 : {
4317 0 : if ( ( &_rWindow == m_pBox )
4318 0 : && ( _nEventId == VCLEVENT_LISTBOX_SELECT )
4319 : )
4320 : {
4321 0 : OnDoubleClick( NULL );
4322 :
4323 0 : ::com::sun::star::awt::ItemEvent aEvent;
4324 0 : aEvent.Source = *this;
4325 0 : aEvent.Highlighted = sal_False;
4326 :
4327 : // Bei Mehrfachselektion 0xFFFF, sonst die ID
4328 0 : aEvent.Selected = (m_pBox->GetSelectEntryCount() == 1 )
4329 0 : ? m_pBox->GetSelectEntryPos() : 0xFFFF;
4330 :
4331 0 : m_aItemListeners.notifyEach( &awt::XItemListener::itemStateChanged, aEvent );
4332 0 : return;
4333 : }
4334 :
4335 0 : FmXTextCell::onWindowEvent( _nEventId, _rWindow, _pEventData );
4336 : }
4337 :
4338 :
4339 :
4340 0 : IMPL_LINK_NOARG(FmXListBoxCell, OnDoubleClick)
4341 : {
4342 0 : if (m_pBox)
4343 : {
4344 0 : ::cppu::OInterfaceIteratorHelper aIt( m_aActionListeners );
4345 :
4346 0 : ::com::sun::star::awt::ActionEvent aEvent;
4347 0 : aEvent.Source = *this;
4348 0 : aEvent.ActionCommand = m_pBox->GetSelectEntry();
4349 :
4350 0 : while( aIt.hasMoreElements() )
4351 0 : static_cast< ::com::sun::star::awt::XActionListener *>(aIt.next())->actionPerformed( aEvent );
4352 : }
4353 0 : return 1;
4354 : }
4355 :
4356 0 : FmXComboBoxCell::FmXComboBoxCell( DbGridColumn* pColumn, DbCellControl& _rControl )
4357 : :FmXTextCell( pColumn, _rControl )
4358 : ,m_aItemListeners( m_aMutex )
4359 : ,m_aActionListeners( m_aMutex )
4360 0 : ,m_pComboBox( &static_cast< ComboBox& >( _rControl.GetWindow() ) )
4361 : {
4362 0 : }
4363 :
4364 :
4365 0 : FmXComboBoxCell::~FmXComboBoxCell()
4366 : {
4367 0 : if ( !OComponentHelper::rBHelper.bDisposed )
4368 : {
4369 0 : acquire();
4370 0 : dispose();
4371 : }
4372 :
4373 0 : }
4374 :
4375 :
4376 0 : void FmXComboBoxCell::disposing()
4377 : {
4378 0 : ::com::sun::star::lang::EventObject aEvt(*this);
4379 0 : m_aItemListeners.disposeAndClear(aEvt);
4380 0 : m_aActionListeners.disposeAndClear(aEvt);
4381 :
4382 0 : FmXTextCell::disposing();
4383 0 : }
4384 :
4385 :
4386 0 : Any SAL_CALL FmXComboBoxCell::queryAggregation( const ::com::sun::star::uno::Type& _rType ) throw(RuntimeException, std::exception)
4387 : {
4388 0 : Any aReturn = FmXTextCell::queryAggregation(_rType);
4389 :
4390 0 : if ( !aReturn.hasValue() )
4391 0 : aReturn = FmXComboBoxCell_Base::queryInterface( _rType );
4392 :
4393 0 : return aReturn;
4394 : }
4395 :
4396 :
4397 0 : Sequence< Type > SAL_CALL FmXComboBoxCell::getTypes( ) throw(RuntimeException, std::exception)
4398 : {
4399 : return ::comphelper::concatSequences(
4400 : FmXTextCell::getTypes(),
4401 : FmXComboBoxCell_Base::getTypes()
4402 0 : );
4403 : }
4404 :
4405 :
4406 0 : IMPLEMENT_GET_IMPLEMENTATION_ID( FmXComboBoxCell )
4407 :
4408 :
4409 0 : void SAL_CALL FmXComboBoxCell::addItemListener(const Reference< awt::XItemListener >& l) throw( RuntimeException, std::exception )
4410 : {
4411 0 : m_aItemListeners.addInterface( l );
4412 0 : }
4413 :
4414 :
4415 0 : void SAL_CALL FmXComboBoxCell::removeItemListener(const Reference< awt::XItemListener >& l) throw( RuntimeException, std::exception )
4416 : {
4417 0 : m_aItemListeners.removeInterface( l );
4418 0 : }
4419 :
4420 :
4421 0 : void SAL_CALL FmXComboBoxCell::addActionListener(const Reference< awt::XActionListener >& l) throw( RuntimeException, std::exception )
4422 : {
4423 0 : m_aActionListeners.addInterface( l );
4424 0 : }
4425 :
4426 :
4427 0 : void SAL_CALL FmXComboBoxCell::removeActionListener(const Reference< awt::XActionListener >& l) throw( RuntimeException, std::exception )
4428 : {
4429 0 : m_aActionListeners.removeInterface( l );
4430 0 : }
4431 :
4432 :
4433 0 : void SAL_CALL FmXComboBoxCell::addItem( const OUString& _Item, sal_Int16 _Pos ) throw( RuntimeException, std::exception )
4434 : {
4435 0 : ::osl::MutexGuard aGuard( m_aMutex );
4436 0 : if ( m_pComboBox )
4437 0 : m_pComboBox->InsertEntry( _Item, _Pos );
4438 0 : }
4439 :
4440 :
4441 0 : void SAL_CALL FmXComboBoxCell::addItems( const Sequence< OUString >& _Items, sal_Int16 _Pos ) throw( RuntimeException, std::exception )
4442 : {
4443 0 : ::osl::MutexGuard aGuard( m_aMutex );
4444 0 : if ( m_pComboBox )
4445 : {
4446 0 : sal_uInt16 nP = _Pos;
4447 0 : for ( sal_uInt16 n = 0; n < _Items.getLength(); n++ )
4448 : {
4449 0 : m_pComboBox->InsertEntry( _Items.getConstArray()[n], nP );
4450 0 : if ( _Pos != -1 )
4451 0 : nP++;
4452 : }
4453 0 : }
4454 0 : }
4455 :
4456 :
4457 0 : void SAL_CALL FmXComboBoxCell::removeItems( sal_Int16 _Pos, sal_Int16 _Count ) throw( RuntimeException, std::exception )
4458 : {
4459 0 : ::osl::MutexGuard aGuard( m_aMutex );
4460 0 : if ( m_pComboBox )
4461 : {
4462 0 : for ( sal_uInt16 n = _Count; n; )
4463 0 : m_pComboBox->RemoveEntryAt( _Pos + (--n) );
4464 0 : }
4465 0 : }
4466 :
4467 :
4468 0 : sal_Int16 SAL_CALL FmXComboBoxCell::getItemCount() throw( RuntimeException, std::exception )
4469 : {
4470 0 : ::osl::MutexGuard aGuard( m_aMutex );
4471 0 : return m_pComboBox ? m_pComboBox->GetEntryCount() : 0;
4472 : }
4473 :
4474 :
4475 0 : OUString SAL_CALL FmXComboBoxCell::getItem( sal_Int16 _Pos ) throw( RuntimeException, std::exception )
4476 : {
4477 0 : ::osl::MutexGuard aGuard( m_aMutex );
4478 0 : return m_pComboBox ? OUString(m_pComboBox->GetEntry(_Pos)) : OUString();
4479 : }
4480 :
4481 0 : Sequence< OUString > SAL_CALL FmXComboBoxCell::getItems() throw( RuntimeException, std::exception )
4482 : {
4483 0 : ::osl::MutexGuard aGuard( m_aMutex );
4484 :
4485 0 : Sequence< OUString > aItems;
4486 0 : if ( m_pComboBox )
4487 : {
4488 0 : sal_uInt16 nEntries = m_pComboBox->GetEntryCount();
4489 0 : aItems.realloc( nEntries );
4490 0 : OUString* pItem = aItems.getArray();
4491 0 : for ( sal_uInt16 n=0; n<nEntries; ++n, ++pItem )
4492 0 : *pItem = m_pComboBox->GetEntry( n );
4493 : }
4494 0 : return aItems;
4495 : }
4496 :
4497 :
4498 0 : sal_Int16 SAL_CALL FmXComboBoxCell::getDropDownLineCount() throw( RuntimeException, std::exception )
4499 : {
4500 0 : ::osl::MutexGuard aGuard( m_aMutex );
4501 :
4502 0 : sal_Int16 nLines = 0;
4503 0 : if ( m_pComboBox )
4504 0 : nLines = m_pComboBox->GetDropDownLineCount();
4505 :
4506 0 : return nLines;
4507 : }
4508 :
4509 :
4510 0 : void SAL_CALL FmXComboBoxCell::setDropDownLineCount(sal_Int16 nLines) throw( RuntimeException, std::exception )
4511 : {
4512 0 : ::osl::MutexGuard aGuard( m_aMutex );
4513 0 : if ( m_pComboBox )
4514 0 : m_pComboBox->SetDropDownLineCount( nLines );
4515 0 : }
4516 :
4517 :
4518 0 : void FmXComboBoxCell::onWindowEvent( const sal_uIntPtr _nEventId, const vcl::Window& _rWindow, const void* _pEventData )
4519 : {
4520 :
4521 0 : switch ( _nEventId )
4522 : {
4523 : case VCLEVENT_COMBOBOX_SELECT:
4524 : {
4525 0 : awt::ItemEvent aEvent;
4526 0 : aEvent.Source = *this;
4527 0 : aEvent.Highlighted = sal_False;
4528 :
4529 : // Bei Mehrfachselektion 0xFFFF, sonst die ID
4530 0 : aEvent.Selected = ( m_pComboBox->GetSelectEntryCount() == 1 )
4531 0 : ? m_pComboBox->GetSelectEntryPos()
4532 0 : : 0xFFFF;
4533 0 : m_aItemListeners.notifyEach( &awt::XItemListener::itemStateChanged, aEvent );
4534 : }
4535 0 : break;
4536 :
4537 : default:
4538 0 : FmXTextCell::onWindowEvent( _nEventId, _rWindow, _pEventData );
4539 0 : break;
4540 : }
4541 0 : }
4542 :
4543 2 : TYPEINIT1(FmXFilterCell, FmXGridCell);
4544 :
4545 0 : FmXFilterCell::FmXFilterCell(DbGridColumn* pColumn, DbCellControl* pControl )
4546 : :FmXGridCell( pColumn, pControl )
4547 0 : ,m_aTextListeners(m_aMutex)
4548 : {
4549 :
4550 : DBG_ASSERT( m_pCellControl->ISA( DbFilterField ), "FmXFilterCell::FmXFilterCell: invalid cell control!" );
4551 0 : static_cast< DbFilterField* >( m_pCellControl )->SetCommitHdl( LINK( this, FmXFilterCell, OnCommit ) );
4552 0 : }
4553 :
4554 :
4555 0 : FmXFilterCell::~FmXFilterCell()
4556 : {
4557 0 : if (!OComponentHelper::rBHelper.bDisposed)
4558 : {
4559 0 : acquire();
4560 0 : dispose();
4561 : }
4562 :
4563 0 : }
4564 :
4565 : // XUnoTunnel
4566 :
4567 0 : sal_Int64 SAL_CALL FmXFilterCell::getSomething( const Sequence< sal_Int8 >& _rIdentifier ) throw(RuntimeException, std::exception)
4568 : {
4569 0 : sal_Int64 nReturn(0);
4570 :
4571 0 : if ( (_rIdentifier.getLength() == 16)
4572 0 : && (0 == memcmp( getUnoTunnelId().getConstArray(), _rIdentifier.getConstArray(), 16 ))
4573 : )
4574 : {
4575 0 : nReturn = reinterpret_cast<sal_Int64>(this);
4576 : }
4577 :
4578 0 : return nReturn;
4579 : }
4580 :
4581 : namespace
4582 : {
4583 : class theFmXFilterCellUnoTunnelId : public rtl::Static< UnoTunnelIdInit, theFmXFilterCellUnoTunnelId > {};
4584 : }
4585 :
4586 0 : const Sequence<sal_Int8>& FmXFilterCell::getUnoTunnelId()
4587 : {
4588 0 : return theFmXFilterCellUnoTunnelId::get().getSeq();
4589 : }
4590 :
4591 :
4592 0 : void FmXFilterCell::PaintCell( OutputDevice& rDev, const Rectangle& rRect )
4593 : {
4594 0 : static_cast< DbFilterField* >( m_pCellControl )->PaintCell( rDev, rRect );
4595 0 : }
4596 :
4597 : // OComponentHelper
4598 :
4599 0 : void FmXFilterCell::disposing()
4600 : {
4601 0 : ::com::sun::star::lang::EventObject aEvt(*this);
4602 0 : m_aTextListeners.disposeAndClear(aEvt);
4603 :
4604 0 : static_cast<DbFilterField*>(m_pCellControl)->SetCommitHdl(Link());
4605 :
4606 0 : FmXGridCell::disposing();
4607 0 : }
4608 :
4609 :
4610 0 : Any SAL_CALL FmXFilterCell::queryAggregation( const ::com::sun::star::uno::Type& _rType ) throw(RuntimeException, std::exception)
4611 : {
4612 0 : Any aReturn = FmXGridCell::queryAggregation(_rType);
4613 :
4614 0 : if ( !aReturn.hasValue() )
4615 0 : aReturn = FmXFilterCell_Base::queryInterface( _rType );
4616 :
4617 0 : return aReturn;
4618 : }
4619 :
4620 :
4621 0 : Sequence< ::com::sun::star::uno::Type > SAL_CALL FmXFilterCell::getTypes( ) throw(RuntimeException, std::exception)
4622 : {
4623 : return ::comphelper::concatSequences(
4624 : FmXGridCell::getTypes(),
4625 : FmXFilterCell_Base::getTypes()
4626 0 : );
4627 : }
4628 :
4629 :
4630 0 : IMPLEMENT_GET_IMPLEMENTATION_ID( FmXFilterCell )
4631 :
4632 : // ::com::sun::star::awt::XTextComponent
4633 :
4634 0 : void SAL_CALL FmXFilterCell::addTextListener(const Reference< ::com::sun::star::awt::XTextListener >& l) throw( RuntimeException, std::exception )
4635 : {
4636 0 : m_aTextListeners.addInterface( l );
4637 0 : }
4638 :
4639 :
4640 0 : void SAL_CALL FmXFilterCell::removeTextListener(const Reference< ::com::sun::star::awt::XTextListener >& l) throw( RuntimeException, std::exception )
4641 : {
4642 0 : m_aTextListeners.removeInterface( l );
4643 0 : }
4644 :
4645 :
4646 0 : void SAL_CALL FmXFilterCell::setText( const OUString& aText ) throw( RuntimeException, std::exception )
4647 : {
4648 0 : ::osl::MutexGuard aGuard( m_aMutex );
4649 0 : static_cast<DbFilterField*>(m_pCellControl)->SetText(aText);
4650 0 : }
4651 :
4652 :
4653 0 : void SAL_CALL FmXFilterCell::insertText( const ::com::sun::star::awt::Selection& /*rSel*/, const OUString& /*aText*/ ) throw( RuntimeException, std::exception )
4654 : {
4655 0 : }
4656 :
4657 :
4658 0 : OUString SAL_CALL FmXFilterCell::getText() throw( RuntimeException, std::exception )
4659 : {
4660 0 : ::osl::MutexGuard aGuard( m_aMutex );
4661 0 : return static_cast<DbFilterField*>(m_pCellControl)->GetText();
4662 : }
4663 :
4664 :
4665 0 : OUString SAL_CALL FmXFilterCell::getSelectedText( void ) throw( RuntimeException, std::exception )
4666 : {
4667 0 : return getText();
4668 : }
4669 :
4670 :
4671 0 : void SAL_CALL FmXFilterCell::setSelection( const ::com::sun::star::awt::Selection& /*aSelection*/ ) throw( RuntimeException, std::exception )
4672 : {
4673 0 : }
4674 :
4675 :
4676 0 : ::com::sun::star::awt::Selection SAL_CALL FmXFilterCell::getSelection( void ) throw( RuntimeException, std::exception )
4677 : {
4678 0 : return ::com::sun::star::awt::Selection();
4679 : }
4680 :
4681 :
4682 0 : sal_Bool SAL_CALL FmXFilterCell::isEditable( void ) throw( RuntimeException, std::exception )
4683 : {
4684 0 : return sal_True;
4685 : }
4686 :
4687 :
4688 0 : void SAL_CALL FmXFilterCell::setEditable( sal_Bool /*bEditable*/ ) throw( RuntimeException, std::exception )
4689 : {
4690 0 : }
4691 :
4692 :
4693 0 : sal_Int16 SAL_CALL FmXFilterCell::getMaxTextLen() throw( RuntimeException, std::exception )
4694 : {
4695 0 : return 0;
4696 : }
4697 :
4698 :
4699 0 : void SAL_CALL FmXFilterCell::setMaxTextLen( sal_Int16 /*nLen*/ ) throw( RuntimeException, std::exception )
4700 : {
4701 0 : }
4702 :
4703 :
4704 0 : IMPL_LINK_NOARG(FmXFilterCell, OnCommit)
4705 : {
4706 0 : ::cppu::OInterfaceIteratorHelper aIt( m_aTextListeners );
4707 0 : ::com::sun::star::awt::TextEvent aEvt;
4708 0 : aEvt.Source = *this;
4709 0 : while( aIt.hasMoreElements() )
4710 0 : static_cast< ::com::sun::star::awt::XTextListener *>(aIt.next())->textChanged( aEvt );
4711 0 : return 1;
4712 651 : }
4713 :
4714 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
