svx/source/fmcomp/gridcell.cxx

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