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