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