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