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