forked from amazingfate/loongoffice
e57ca02849
...(for now, from LIBO_INTERNAL_CODE only). See the mail thread starting at <https://lists.freedesktop.org/archives/libreoffice/2017-January/076665.html> "Dynamic Exception Specifications" for details. Most changes have been done automatically by the rewriting loplugin:dynexcspec (after enabling the rewriting mode, to be committed shortly). The way it only removes exception specs from declarations if it also sees a definition, it identified some dead declarations-w/o-definitions (that have been removed manually) and some cases where a definition appeared in multiple include files (which have also been cleaned up manually). There's also been cases of macro paramters (that were used to abstract over exception specs) that have become unused now (and been removed). Furthermore, some code needed to be cleaned up manually (avmedia/source/quicktime/ and connectivity/source/drivers/kab/), as I had no configurations available that would actually build that code. Missing @throws documentation has not been applied in such manual clean-up. Change-Id: I3408691256c9b0c12bc5332de976743626e13960 Reviewed-on: https://gerrit.libreoffice.org/33574 Tested-by: Jenkins <ci@libreoffice.org> Reviewed-by: Stephan Bergmann <sbergman@redhat.com>
1025 lines
41 KiB
C++
1025 lines
41 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
|
|
/*
|
|
* This file is part of the LibreOffice project.
|
|
*
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
*
|
|
* This file incorporates work covered by the following license notice:
|
|
*
|
|
* Licensed to the Apache Software Foundation (ASF) under one or more
|
|
* contributor license agreements. See the NOTICE file distributed
|
|
* with this work for additional information regarding copyright
|
|
* ownership. The ASF licenses this file to you under the Apache
|
|
* License, Version 2.0 (the "License"); you may not use this file
|
|
* except in compliance with the License. You may obtain a copy of
|
|
* the License at http://www.apache.org/licenses/LICENSE-2.0 .
|
|
*/
|
|
#include "FormattedField.hxx"
|
|
#include "services.hxx"
|
|
#include "property.hrc"
|
|
#include "property.hxx"
|
|
#include "frm_resource.hxx"
|
|
#include "frm_resource.hrc"
|
|
#include "propertybaghelper.hxx"
|
|
#include <comphelper/sequence.hxx>
|
|
#include <comphelper/numbers.hxx>
|
|
#include <connectivity/dbtools.hxx>
|
|
#include <connectivity/dbconversion.hxx>
|
|
#include <o3tl/any.hxx>
|
|
#include <svl/zforlist.hxx>
|
|
#include <svl/numuno.hxx>
|
|
#include <vcl/svapp.hxx>
|
|
#include <vcl/settings.hxx>
|
|
#include <tools/debug.hxx>
|
|
#include <tools/wintypes.hxx>
|
|
#include <i18nlangtag/languagetag.hxx>
|
|
#include <rtl/textenc.h>
|
|
#include <com/sun/star/sdbc/DataType.hpp>
|
|
#include <com/sun/star/util/NumberFormat.hpp>
|
|
#include <com/sun/star/util/Date.hpp>
|
|
#include <com/sun/star/util/Time.hpp>
|
|
#include <com/sun/star/awt/MouseEvent.hpp>
|
|
#include <com/sun/star/form/XSubmit.hpp>
|
|
#include <com/sun/star/awt/XWindow.hpp>
|
|
#include <com/sun/star/awt/XKeyListener.hpp>
|
|
#include <com/sun/star/form/FormComponentType.hpp>
|
|
#include <com/sun/star/util/XNumberFormatsSupplier.hpp>
|
|
#include <com/sun/star/util/XNumberFormatTypes.hpp>
|
|
#include <com/sun/star/form/XForm.hpp>
|
|
#include <com/sun/star/container/XIndexAccess.hpp>
|
|
#include <osl/mutex.hxx>
|
|
// needed as long as we use the SolarMutex
|
|
#include <comphelper/streamsection.hxx>
|
|
#include <cppuhelper/weakref.hxx>
|
|
#include <unotools/desktopterminationobserver.hxx>
|
|
#include <list>
|
|
#include <algorithm>
|
|
|
|
|
|
using namespace dbtools;
|
|
using namespace css::uno;
|
|
using namespace css::sdb;
|
|
using namespace css::sdbc;
|
|
using namespace css::sdbcx;
|
|
using namespace css::beans;
|
|
using namespace css::container;
|
|
using namespace css::form;
|
|
using namespace css::awt;
|
|
using namespace css::io;
|
|
using namespace css::lang;
|
|
using namespace css::util;
|
|
using namespace css::form::binding;
|
|
|
|
namespace frm
|
|
{
|
|
class StandardFormatsSupplier : protected SvNumberFormatsSupplierObj, public ::utl::ITerminationListener
|
|
{
|
|
protected:
|
|
SvNumberFormatter* m_pMyPrivateFormatter;
|
|
static WeakReference< XNumberFormatsSupplier > s_xDefaultFormatsSupplier;
|
|
public:
|
|
static Reference< XNumberFormatsSupplier > get( const Reference< XComponentContext >& _rxORB );
|
|
using SvNumberFormatsSupplierObj::operator new;
|
|
using SvNumberFormatsSupplierObj::operator delete;
|
|
protected:
|
|
StandardFormatsSupplier(const Reference< XComponentContext >& _rxFactory,LanguageType _eSysLanguage);
|
|
virtual ~StandardFormatsSupplier() override;
|
|
protected:
|
|
virtual bool queryTermination() const override;
|
|
virtual void notifyTermination() override;
|
|
};
|
|
WeakReference< XNumberFormatsSupplier > StandardFormatsSupplier::s_xDefaultFormatsSupplier;
|
|
StandardFormatsSupplier::StandardFormatsSupplier(const Reference< XComponentContext > & _rxContext,LanguageType _eSysLanguage)
|
|
:SvNumberFormatsSupplierObj()
|
|
,m_pMyPrivateFormatter(new SvNumberFormatter(_rxContext, _eSysLanguage))
|
|
{
|
|
SetNumberFormatter(m_pMyPrivateFormatter);
|
|
// #i29147#
|
|
::utl::DesktopTerminationObserver::registerTerminationListener( this );
|
|
}
|
|
StandardFormatsSupplier::~StandardFormatsSupplier()
|
|
{
|
|
::utl::DesktopTerminationObserver::revokeTerminationListener( this );
|
|
DELETEZ( m_pMyPrivateFormatter );
|
|
}
|
|
Reference< XNumberFormatsSupplier > StandardFormatsSupplier::get( const Reference< XComponentContext >& _rxORB )
|
|
{
|
|
LanguageType eSysLanguage = LANGUAGE_SYSTEM;
|
|
{
|
|
::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() );
|
|
Reference< XNumberFormatsSupplier > xSupplier = s_xDefaultFormatsSupplier;
|
|
if ( xSupplier.is() )
|
|
return xSupplier;
|
|
// get the Office's locale
|
|
eSysLanguage = SvtSysLocale().GetLanguageTag().getLanguageType( false);
|
|
}
|
|
StandardFormatsSupplier* pSupplier = new StandardFormatsSupplier( _rxORB, eSysLanguage );
|
|
Reference< XNumberFormatsSupplier > xNewlyCreatedSupplier( pSupplier );
|
|
{
|
|
::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() );
|
|
Reference< XNumberFormatsSupplier > xSupplier = s_xDefaultFormatsSupplier;
|
|
if ( xSupplier.is() )
|
|
// somebody used the small time frame where the mutex was not locked to create and set
|
|
// the supplier
|
|
return xSupplier;
|
|
s_xDefaultFormatsSupplier = xNewlyCreatedSupplier;
|
|
}
|
|
return xNewlyCreatedSupplier;
|
|
}
|
|
bool StandardFormatsSupplier::queryTermination() const
|
|
{
|
|
return true;
|
|
}
|
|
void StandardFormatsSupplier::notifyTermination()
|
|
{
|
|
Reference< XNumberFormatsSupplier > xKeepAlive = this;
|
|
// when the application is terminating, release our static reference so that we are cleared/destructed
|
|
// earlier than upon unloading the library
|
|
// #i29147#
|
|
s_xDefaultFormatsSupplier = WeakReference< XNumberFormatsSupplier >( );
|
|
SetNumberFormatter( nullptr );
|
|
DELETEZ( m_pMyPrivateFormatter );
|
|
}
|
|
Sequence<Type> OFormattedControl::_getTypes()
|
|
{
|
|
return ::comphelper::concatSequences(
|
|
OFormattedControl_BASE::getTypes(),
|
|
OBoundControl::_getTypes()
|
|
);
|
|
}
|
|
Any SAL_CALL OFormattedControl::queryAggregation(const Type& _rType)
|
|
{
|
|
Any aReturn = OBoundControl::queryAggregation(_rType);
|
|
if (!aReturn.hasValue())
|
|
aReturn = OFormattedControl_BASE::queryInterface(_rType);
|
|
return aReturn;
|
|
}
|
|
OFormattedControl::OFormattedControl(const Reference<XComponentContext>& _rxFactory)
|
|
:OBoundControl(_rxFactory, VCL_CONTROL_FORMATTEDFIELD)
|
|
,m_nKeyEvent(nullptr)
|
|
{
|
|
osl_atomic_increment(&m_refCount);
|
|
{
|
|
Reference<XWindow> xComp;
|
|
if (query_aggregation(m_xAggregate, xComp))
|
|
{
|
|
xComp->addKeyListener(this);
|
|
}
|
|
}
|
|
osl_atomic_decrement(&m_refCount);
|
|
}
|
|
OFormattedControl::~OFormattedControl()
|
|
{
|
|
if( m_nKeyEvent )
|
|
Application::RemoveUserEvent( m_nKeyEvent );
|
|
if (!OComponentHelper::rBHelper.bDisposed)
|
|
{
|
|
acquire();
|
|
dispose();
|
|
}
|
|
}
|
|
|
|
// XKeyListener
|
|
void OFormattedControl::disposing(const EventObject& _rSource)
|
|
{
|
|
OBoundControl::disposing(_rSource);
|
|
}
|
|
void OFormattedControl::keyPressed(const css::awt::KeyEvent& e)
|
|
{
|
|
if( e.KeyCode != KEY_RETURN || e.Modifiers != 0 )
|
|
return;
|
|
// Is the control located in a form with a Submit URL?
|
|
Reference<css::beans::XPropertySet> xSet(getModel(), UNO_QUERY);
|
|
if( !xSet.is() )
|
|
return;
|
|
Reference<XFormComponent> xFComp(xSet, UNO_QUERY);
|
|
css::uno::Reference<css::uno::XInterface> xParent = xFComp->getParent();
|
|
if( !xParent.is() )
|
|
return;
|
|
Reference<css::beans::XPropertySet> xFormSet(xParent, UNO_QUERY);
|
|
if( !xFormSet.is() )
|
|
return;
|
|
Any aTmp(xFormSet->getPropertyValue( PROPERTY_TARGET_URL ));
|
|
if (!aTmp.has<OUString>() ||
|
|
getString(aTmp).isEmpty() )
|
|
return;
|
|
Reference<XIndexAccess> xElements(xParent, UNO_QUERY);
|
|
sal_Int32 nCount = xElements->getCount();
|
|
if( nCount > 1 )
|
|
{
|
|
Reference<css::beans::XPropertySet> xFCSet;
|
|
for( sal_Int32 nIndex=0; nIndex < nCount; nIndex++ )
|
|
{
|
|
// Any aElement(xElements->getByIndex(nIndex));
|
|
xElements->getByIndex(nIndex) >>= xFCSet;
|
|
if (hasProperty(PROPERTY_CLASSID, xFCSet) &&
|
|
getINT16(xFCSet->getPropertyValue(PROPERTY_CLASSID)) == FormComponentType::TEXTFIELD)
|
|
{
|
|
// Found another Edit -> Do not submit then
|
|
if (xFCSet != xSet)
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
// Because we're still in the Handler, execute submit asynchronously
|
|
if( m_nKeyEvent )
|
|
Application::RemoveUserEvent( m_nKeyEvent );
|
|
m_nKeyEvent = Application::PostUserEvent( LINK(this, OFormattedControl,
|
|
OnKeyPressed) );
|
|
}
|
|
|
|
void OFormattedControl::keyReleased(const css::awt::KeyEvent& /*e*/)
|
|
{
|
|
}
|
|
|
|
IMPL_LINK_NOARG(OFormattedControl, OnKeyPressed, void*, void)
|
|
{
|
|
m_nKeyEvent = nullptr;
|
|
Reference<XFormComponent> xFComp(getModel(), UNO_QUERY);
|
|
css::uno::Reference<css::uno::XInterface> xParent = xFComp->getParent();
|
|
Reference<XSubmit> xSubmit(xParent, UNO_QUERY);
|
|
if (xSubmit.is())
|
|
xSubmit->submit( Reference<XControl> (), css::awt::MouseEvent() );
|
|
}
|
|
|
|
css::uno::Sequence<OUString> OFormattedControl::getSupportedServiceNames()
|
|
{
|
|
css::uno::Sequence<OUString> aSupported = OBoundControl::getSupportedServiceNames();
|
|
aSupported.realloc(aSupported.getLength() + 2);
|
|
OUString*pArray = aSupported.getArray();
|
|
pArray[aSupported.getLength()-2] = FRM_SUN_CONTROL_FORMATTEDFIELD;
|
|
pArray[aSupported.getLength()-1] = STARDIV_ONE_FORM_CONTROL_FORMATTEDFIELD;
|
|
return aSupported;
|
|
}
|
|
|
|
void OFormattedModel::implConstruct()
|
|
{
|
|
// members
|
|
m_bOriginalNumeric = false;
|
|
m_bNumeric = false;
|
|
m_xOriginalFormatter = nullptr;
|
|
m_nKeyType = NumberFormat::UNDEFINED;
|
|
m_aNullDate = DBTypeConversion::getStandardDate();
|
|
m_nFieldType = DataType::OTHER;
|
|
// default our formats supplier
|
|
osl_atomic_increment(&m_refCount);
|
|
setPropertyToDefaultByHandle(PROPERTY_ID_FORMATSSUPPLIER);
|
|
osl_atomic_decrement(&m_refCount);
|
|
startAggregatePropertyListening( PROPERTY_FORMATKEY );
|
|
startAggregatePropertyListening( PROPERTY_FORMATSSUPPLIER );
|
|
}
|
|
OFormattedModel::OFormattedModel(const Reference<XComponentContext>& _rxFactory)
|
|
:OEditBaseModel(_rxFactory, VCL_CONTROLMODEL_FORMATTEDFIELD, FRM_SUN_CONTROL_FORMATTEDFIELD, true, true )
|
|
// use the old control name for compytibility reasons
|
|
,OErrorBroadcaster( OComponentHelper::rBHelper )
|
|
{
|
|
implConstruct();
|
|
m_nClassId = FormComponentType::TEXTFIELD;
|
|
initValueProperty( PROPERTY_EFFECTIVE_VALUE, PROPERTY_ID_EFFECTIVE_VALUE );
|
|
}
|
|
OFormattedModel::OFormattedModel( const OFormattedModel* _pOriginal, const Reference< XComponentContext >& _rxFactory )
|
|
:OEditBaseModel( _pOriginal, _rxFactory )
|
|
,OErrorBroadcaster( OComponentHelper::rBHelper )
|
|
{
|
|
implConstruct();
|
|
}
|
|
|
|
OFormattedModel::~OFormattedModel()
|
|
{
|
|
}
|
|
|
|
// XCloneable
|
|
IMPLEMENT_DEFAULT_CLONING( OFormattedModel )
|
|
|
|
void SAL_CALL OFormattedModel::disposing()
|
|
{
|
|
OErrorBroadcaster::disposing();
|
|
OEditBaseModel::disposing();
|
|
}
|
|
|
|
// XServiceInfo
|
|
css::uno::Sequence<OUString> OFormattedModel::getSupportedServiceNames()
|
|
{
|
|
css::uno::Sequence<OUString> aSupported = OEditBaseModel::getSupportedServiceNames();
|
|
sal_Int32 nOldLen = aSupported.getLength();
|
|
aSupported.realloc( nOldLen + 9 );
|
|
OUString* pStoreTo = aSupported.getArray() + nOldLen;
|
|
*pStoreTo++ = BINDABLE_CONTROL_MODEL;
|
|
*pStoreTo++ = DATA_AWARE_CONTROL_MODEL;
|
|
*pStoreTo++ = VALIDATABLE_CONTROL_MODEL;
|
|
*pStoreTo++ = BINDABLE_DATA_AWARE_CONTROL_MODEL;
|
|
*pStoreTo++ = VALIDATABLE_BINDABLE_CONTROL_MODEL;
|
|
*pStoreTo++ = FRM_SUN_COMPONENT_FORMATTEDFIELD;
|
|
*pStoreTo++ = FRM_SUN_COMPONENT_DATABASE_FORMATTEDFIELD;
|
|
*pStoreTo++ = BINDABLE_DATABASE_FORMATTED_FIELD;
|
|
*pStoreTo++ = FRM_COMPONENT_FORMATTEDFIELD;
|
|
return aSupported;
|
|
}
|
|
|
|
// XAggregation
|
|
Any SAL_CALL OFormattedModel::queryAggregation(const Type& _rType)
|
|
{
|
|
Any aReturn = OEditBaseModel::queryAggregation( _rType );
|
|
return aReturn.hasValue() ? aReturn : OErrorBroadcaster::queryInterface( _rType );
|
|
}
|
|
|
|
// XTypeProvider
|
|
Sequence< Type > OFormattedModel::_getTypes()
|
|
{
|
|
return ::comphelper::concatSequences(
|
|
OEditBaseModel::_getTypes(),
|
|
OErrorBroadcaster::getTypes()
|
|
);
|
|
}
|
|
|
|
// XPersistObject
|
|
OUString SAL_CALL OFormattedModel::getServiceName()
|
|
{
|
|
return OUString(FRM_COMPONENT_EDIT);
|
|
}
|
|
|
|
// XPropertySet
|
|
void OFormattedModel::describeFixedProperties( Sequence< Property >& _rProps ) const
|
|
{
|
|
BEGIN_DESCRIBE_PROPERTIES( 3, OEditBaseModel )
|
|
DECL_BOOL_PROP1(EMPTY_IS_NULL, BOUND);
|
|
DECL_PROP1(TABINDEX, sal_Int16, BOUND);
|
|
DECL_BOOL_PROP2(FILTERPROPOSAL, BOUND, MAYBEDEFAULT);
|
|
END_DESCRIBE_PROPERTIES();
|
|
}
|
|
|
|
void OFormattedModel::describeAggregateProperties( Sequence< Property >& _rAggregateProps ) const
|
|
{
|
|
OEditBaseModel::describeAggregateProperties( _rAggregateProps );
|
|
// TreatAsNumeric is not transient: we want to attach it to the UI
|
|
// This is necessary to make EffectiveDefault (which may be text or a number) meaningful
|
|
ModifyPropertyAttributes(_rAggregateProps, PROPERTY_TREATASNUMERIC, 0, PropertyAttribute::TRANSIENT);
|
|
// Same for FormatKey
|
|
// (though the paragraph above for the TreatAsNumeric does not hold anymore - we do not have an UI for this.
|
|
// But we have for the format key ...)
|
|
ModifyPropertyAttributes(_rAggregateProps, PROPERTY_FORMATKEY, 0, PropertyAttribute::TRANSIENT);
|
|
RemoveProperty(_rAggregateProps, PROPERTY_STRICTFORMAT);
|
|
// no strict format property for formatted fields: it does not make sense, 'cause
|
|
// there is no general way to decide which characters/sub strings are allowed during the input of an
|
|
// arbitrary formatted control
|
|
}
|
|
|
|
void OFormattedModel::setPropertyToDefaultByHandle(sal_Int32 nHandle)
|
|
{
|
|
if (nHandle == PROPERTY_ID_FORMATSSUPPLIER)
|
|
{
|
|
Reference<XNumberFormatsSupplier> xSupplier = calcDefaultFormatsSupplier();
|
|
DBG_ASSERT(m_xAggregateSet.is(), "OFormattedModel::setPropertyToDefaultByHandle(FORMATSSUPPLIER) : have no aggregate !");
|
|
if (m_xAggregateSet.is())
|
|
m_xAggregateSet->setPropertyValue(PROPERTY_FORMATSSUPPLIER, makeAny(xSupplier));
|
|
}
|
|
else
|
|
OEditBaseModel::setPropertyToDefaultByHandle(nHandle);
|
|
}
|
|
|
|
void OFormattedModel::setPropertyToDefault(const OUString& aPropertyName)
|
|
{
|
|
OPropertyArrayAggregationHelper& rPH = m_aPropertyBagHelper.getInfoHelper();
|
|
sal_Int32 nHandle = rPH.getHandleByName( aPropertyName );
|
|
if (nHandle == PROPERTY_ID_FORMATSSUPPLIER)
|
|
setPropertyToDefaultByHandle(PROPERTY_ID_FORMATSSUPPLIER);
|
|
else
|
|
OEditBaseModel::setPropertyToDefault(aPropertyName);
|
|
}
|
|
|
|
Any OFormattedModel::getPropertyDefaultByHandle( sal_Int32 nHandle ) const
|
|
{
|
|
if (nHandle == PROPERTY_ID_FORMATSSUPPLIER)
|
|
{
|
|
Reference<XNumberFormatsSupplier> xSupplier = calcDefaultFormatsSupplier();
|
|
return makeAny(xSupplier);
|
|
}
|
|
else
|
|
return OEditBaseModel::getPropertyDefaultByHandle(nHandle);
|
|
}
|
|
|
|
Any SAL_CALL OFormattedModel::getPropertyDefault( const OUString& aPropertyName )
|
|
{
|
|
OPropertyArrayAggregationHelper& rPH = m_aPropertyBagHelper.getInfoHelper();
|
|
sal_Int32 nHandle = rPH.getHandleByName( aPropertyName );
|
|
if (nHandle == PROPERTY_ID_FORMATSSUPPLIER)
|
|
return getPropertyDefaultByHandle(PROPERTY_ID_FORMATSSUPPLIER);
|
|
else
|
|
return OEditBaseModel::getPropertyDefault(aPropertyName);
|
|
}
|
|
|
|
void OFormattedModel::_propertyChanged( const css::beans::PropertyChangeEvent& evt )
|
|
{
|
|
// TODO: check how this works with external bindings
|
|
OSL_ENSURE( evt.Source == m_xAggregateSet, "OFormattedModel::_propertyChanged: where did this come from?" );
|
|
if ( evt.Source == m_xAggregateSet )
|
|
{
|
|
Reference< XPropertySet > xSourceSet( evt.Source, UNO_QUERY );
|
|
if ( evt.PropertyName == PROPERTY_FORMATKEY )
|
|
{
|
|
if ( evt.NewValue.getValueType().getTypeClass() == TypeClass_LONG )
|
|
{
|
|
try
|
|
{
|
|
::osl::MutexGuard aGuard( m_aMutex );
|
|
Reference<XNumberFormatsSupplier> xSupplier( calcFormatsSupplier() );
|
|
m_nKeyType = getNumberFormatType(xSupplier->getNumberFormats(), getINT32( evt.NewValue ) );
|
|
// as m_aSaveValue (which is used by commitControlValueToDbColumn) is format dependent we have
|
|
// to recalc it, which is done by translateDbColumnToControlValue
|
|
if ( m_xColumn.is() && m_xAggregateFastSet.is() && !m_xCursor->isBeforeFirst() && !m_xCursor->isAfterLast())
|
|
{
|
|
setControlValue( translateDbColumnToControlValue(), eOther );
|
|
}
|
|
// if we're connected to an external value binding, then re-calculate the type
|
|
// used to exchange the value - it depends on the format, too
|
|
if ( hasExternalValueBinding() )
|
|
{
|
|
calculateExternalValueType();
|
|
}
|
|
}
|
|
catch(const Exception&)
|
|
{
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
if ( evt.PropertyName == PROPERTY_FORMATSSUPPLIER )
|
|
{
|
|
updateFormatterNullDate();
|
|
return;
|
|
}
|
|
OBoundControlModel::_propertyChanged( evt );
|
|
}
|
|
}
|
|
|
|
void OFormattedModel::updateFormatterNullDate()
|
|
{
|
|
// calc the current NULL date
|
|
Reference< XNumberFormatsSupplier > xSupplier( calcFormatsSupplier() );
|
|
if ( xSupplier.is() )
|
|
xSupplier->getNumberFormatSettings()->getPropertyValue("NullDate") >>= m_aNullDate;
|
|
}
|
|
|
|
Reference< XNumberFormatsSupplier > OFormattedModel::calcFormatsSupplier() const
|
|
{
|
|
Reference<XNumberFormatsSupplier> xSupplier;
|
|
DBG_ASSERT(m_xAggregateSet.is(), "OFormattedModel::calcFormatsSupplier : have no aggregate !");
|
|
// Does my aggregate model have a FormatSupplier?
|
|
if( m_xAggregateSet.is() )
|
|
m_xAggregateSet->getPropertyValue(PROPERTY_FORMATSSUPPLIER) >>= xSupplier;
|
|
if (!xSupplier.is())
|
|
// check if my parent form has a supplier
|
|
xSupplier = calcFormFormatsSupplier();
|
|
if (!xSupplier.is())
|
|
xSupplier = calcDefaultFormatsSupplier();
|
|
DBG_ASSERT(xSupplier.is(), "OFormattedModel::calcFormatsSupplier : no supplier !");
|
|
// We should have one by now
|
|
return xSupplier;
|
|
}
|
|
|
|
Reference<XNumberFormatsSupplier> OFormattedModel::calcFormFormatsSupplier() const
|
|
{
|
|
Reference<XChild> xMe(
|
|
static_cast<XWeak*>(const_cast<OFormattedModel*>(this)),
|
|
css::uno::UNO_QUERY);
|
|
// By this we make sure that we get the right object even when aggregating
|
|
DBG_ASSERT(xMe.is(), "OFormattedModel::calcFormFormatsSupplier : I should have a content interface !");
|
|
// Iterate through until we reach a StartForm (starting with an own Parent)
|
|
Reference<XChild> xParent(xMe->getParent(), UNO_QUERY);
|
|
Reference<XForm> xNextParentForm(xParent, UNO_QUERY);
|
|
while (!xNextParentForm.is() && xParent.is())
|
|
{
|
|
xParent.set(xParent->getParent(), css::uno::UNO_QUERY);
|
|
xNextParentForm.set(xParent, css::uno::UNO_QUERY);
|
|
}
|
|
if (!xNextParentForm.is())
|
|
{
|
|
OSL_FAIL("OFormattedModel::calcFormFormatsSupplier : have no ancestor which is a form !");
|
|
return nullptr;
|
|
}
|
|
// The FormatSupplier of my ancestor (if it has one)
|
|
Reference< XRowSet > xRowSet( xNextParentForm, UNO_QUERY );
|
|
Reference< XNumberFormatsSupplier > xSupplier;
|
|
if (xRowSet.is())
|
|
xSupplier = getNumberFormats( getConnection(xRowSet), true, getContext() );
|
|
return xSupplier;
|
|
}
|
|
|
|
Reference< XNumberFormatsSupplier > OFormattedModel::calcDefaultFormatsSupplier() const
|
|
{
|
|
return StandardFormatsSupplier::get( getContext() );
|
|
}
|
|
|
|
// XBoundComponent
|
|
void OFormattedModel::loaded(const EventObject& rEvent)
|
|
{
|
|
// HACK: our onConnectedDbColumn accesses our NumberFormatter which locks the solar mutex (as it doesn't have
|
|
// an own one). To prevent deadlocks with other threads which may request a property from us in an
|
|
// UI-triggered action (e.g. an tooltip) we lock the solar mutex _here_ before our base class locks
|
|
// its own mutex (which is used for property requests)
|
|
// alternative a): we use two mutexes, one which is passed to the OPropertysetHelper and used for
|
|
// property requests and one for our own code. This would need a lot of code rewriting
|
|
// alternative b): The NumberFormatter has to be really threadsafe (with an own mutex), which is
|
|
// the only "clean" solution for me.
|
|
SolarMutexGuard aGuard;
|
|
OEditBaseModel::loaded(rEvent);
|
|
}
|
|
|
|
void OFormattedModel::onConnectedDbColumn( const Reference< XInterface >& _rxForm )
|
|
{
|
|
m_xOriginalFormatter = nullptr;
|
|
// get some properties of the field
|
|
m_nFieldType = DataType::OTHER;
|
|
Reference<XPropertySet> xField = getField();
|
|
if ( xField.is() )
|
|
xField->getPropertyValue( PROPERTY_FIELDTYPE ) >>= m_nFieldType;
|
|
sal_Int32 nFormatKey = 0;
|
|
DBG_ASSERT(m_xAggregateSet.is(), "OFormattedModel::onConnectedDbColumn : have no aggregate !");
|
|
if (m_xAggregateSet.is())
|
|
{ // all the following doesn't make any sense if we have no aggregate ...
|
|
Any aSupplier = m_xAggregateSet->getPropertyValue(PROPERTY_FORMATSSUPPLIER);
|
|
DBG_ASSERT( aSupplier.hasValue(), "OFormattedModel::onConnectedDbColumn : invalid property value !" );
|
|
// This should've been set to the correct value in the ctor or in the read
|
|
Any aFmtKey = m_xAggregateSet->getPropertyValue(PROPERTY_FORMATKEY);
|
|
if ( !(aFmtKey >>= nFormatKey ) )
|
|
{ // nobody gave us a format to use. So we examine the field we're bound to for a
|
|
// format key, and use it ourself, too
|
|
sal_Int32 nType = DataType::VARCHAR;
|
|
if (xField.is())
|
|
{
|
|
aFmtKey = xField->getPropertyValue(PROPERTY_FORMATKEY);
|
|
xField->getPropertyValue(PROPERTY_FIELDTYPE) >>= nType ;
|
|
}
|
|
Reference<XNumberFormatsSupplier> xSupplier = calcFormFormatsSupplier();
|
|
DBG_ASSERT(xSupplier.is(), "OFormattedModel::onConnectedDbColumn : bound to a field but no parent with a formatter ? how this ?");
|
|
if (xSupplier.is())
|
|
{
|
|
m_bOriginalNumeric = getBOOL(getPropertyValue(PROPERTY_TREATASNUMERIC));
|
|
if (!aFmtKey.hasValue())
|
|
{ // we aren't bound to a field (or this field's format is invalid)
|
|
// -> determine the standard text (or numeric) format of the supplier
|
|
Reference<XNumberFormatTypes> xTypes(xSupplier->getNumberFormats(), UNO_QUERY);
|
|
if (xTypes.is())
|
|
{
|
|
Locale aApplicationLocale = Application::GetSettings().GetUILanguageTag().getLocale();
|
|
if (m_bOriginalNumeric)
|
|
aFmtKey <<= (sal_Int32)xTypes->getStandardFormat(NumberFormat::NUMBER, aApplicationLocale);
|
|
else
|
|
aFmtKey <<= (sal_Int32)xTypes->getStandardFormat(NumberFormat::TEXT, aApplicationLocale);
|
|
}
|
|
}
|
|
aSupplier >>= m_xOriginalFormatter;
|
|
m_xAggregateSet->setPropertyValue(PROPERTY_FORMATSSUPPLIER, makeAny(xSupplier));
|
|
m_xAggregateSet->setPropertyValue(PROPERTY_FORMATKEY, aFmtKey);
|
|
// Adapt the NumericFalg to my bound field
|
|
if (xField.is())
|
|
{
|
|
m_bNumeric = false;
|
|
switch (nType)
|
|
{
|
|
case DataType::BIT:
|
|
case DataType::BOOLEAN:
|
|
case DataType::TINYINT:
|
|
case DataType::SMALLINT:
|
|
case DataType::INTEGER:
|
|
case DataType::BIGINT:
|
|
case DataType::FLOAT:
|
|
case DataType::REAL:
|
|
case DataType::DOUBLE:
|
|
case DataType::NUMERIC:
|
|
case DataType::DECIMAL:
|
|
case DataType::DATE:
|
|
case DataType::TIME:
|
|
case DataType::TIMESTAMP:
|
|
m_bNumeric = true;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
m_bNumeric = m_bOriginalNumeric;
|
|
setPropertyValue(PROPERTY_TREATASNUMERIC, makeAny(m_bNumeric));
|
|
OSL_VERIFY( aFmtKey >>= nFormatKey );
|
|
}
|
|
}
|
|
}
|
|
Reference<XNumberFormatsSupplier> xSupplier = calcFormatsSupplier();
|
|
m_bNumeric = getBOOL( getPropertyValue( PROPERTY_TREATASNUMERIC ) );
|
|
m_nKeyType = getNumberFormatType( xSupplier->getNumberFormats(), nFormatKey );
|
|
xSupplier->getNumberFormatSettings()->getPropertyValue("NullDate") >>= m_aNullDate;
|
|
OEditBaseModel::onConnectedDbColumn( _rxForm );
|
|
}
|
|
|
|
void OFormattedModel::onDisconnectedDbColumn()
|
|
{
|
|
OEditBaseModel::onDisconnectedDbColumn();
|
|
if (m_xOriginalFormatter.is())
|
|
{ // Our aggregated model does not hold any Format information
|
|
m_xAggregateSet->setPropertyValue(PROPERTY_FORMATSSUPPLIER, makeAny(m_xOriginalFormatter));
|
|
m_xAggregateSet->setPropertyValue(PROPERTY_FORMATKEY, Any());
|
|
setPropertyValue(PROPERTY_TREATASNUMERIC, makeAny(m_bOriginalNumeric));
|
|
m_xOriginalFormatter = nullptr;
|
|
}
|
|
m_nFieldType = DataType::OTHER;
|
|
m_nKeyType = NumberFormat::UNDEFINED;
|
|
m_aNullDate = DBTypeConversion::getStandardDate();
|
|
}
|
|
|
|
void OFormattedModel::write(const Reference<XObjectOutputStream>& _rxOutStream)
|
|
{
|
|
OEditBaseModel::write(_rxOutStream);
|
|
_rxOutStream->writeShort(0x0003);
|
|
DBG_ASSERT(m_xAggregateSet.is(), "OFormattedModel::write : have no aggregate !");
|
|
// Bring my Format (may be void) to a persistent Format.
|
|
// The Supplier together with the Key is already persistent, but that doesn't mean
|
|
// we have to save the Supplier (which would be quite some overhead)
|
|
Reference<XNumberFormatsSupplier> xSupplier;
|
|
Any aFmtKey;
|
|
bool bVoidKey = true;
|
|
if (m_xAggregateSet.is())
|
|
{
|
|
Any aSupplier = m_xAggregateSet->getPropertyValue(PROPERTY_FORMATSSUPPLIER);
|
|
if (aSupplier.getValueType().getTypeClass() != TypeClass_VOID)
|
|
{
|
|
OSL_VERIFY( aSupplier >>= xSupplier );
|
|
}
|
|
aFmtKey = m_xAggregateSet->getPropertyValue(PROPERTY_FORMATKEY);
|
|
bVoidKey = (!xSupplier.is() || !aFmtKey.hasValue()) || (isLoaded() && m_xOriginalFormatter.is());
|
|
// (no Format and/or Key) OR (loaded and faked Formatter)
|
|
}
|
|
_rxOutStream->writeBoolean(!bVoidKey);
|
|
if (!bVoidKey)
|
|
{
|
|
// Create persistent values from the FormatKey and the Formatter
|
|
Any aKey = m_xAggregateSet->getPropertyValue(PROPERTY_FORMATKEY);
|
|
sal_Int32 nKey = aKey.hasValue() ? getINT32(aKey) : 0;
|
|
Reference<XNumberFormats> xFormats = xSupplier->getNumberFormats();
|
|
OUString sFormatDescription;
|
|
LanguageType eFormatLanguage = LANGUAGE_DONTKNOW;
|
|
static const char s_aLocaleProp[] = "Locale";
|
|
Reference<css::beans::XPropertySet> xFormat = xFormats->getByKey(nKey);
|
|
if (hasProperty(s_aLocaleProp, xFormat))
|
|
{
|
|
Any aLocale = xFormat->getPropertyValue(s_aLocaleProp);
|
|
DBG_ASSERT(aLocale.has<Locale>(), "OFormattedModel::write : invalid language property !");
|
|
if (auto pLocale = o3tl::tryAccess<Locale>(aLocale))
|
|
{
|
|
eFormatLanguage = LanguageTag::convertToLanguageType( *pLocale, false);
|
|
}
|
|
}
|
|
static const char s_aFormatStringProp[] = "FormatString";
|
|
if (hasProperty(s_aFormatStringProp, xFormat))
|
|
xFormat->getPropertyValue(s_aFormatStringProp) >>= sFormatDescription;
|
|
_rxOutStream->writeUTF(sFormatDescription);
|
|
_rxOutStream->writeLong((sal_Int32)eFormatLanguage);
|
|
}
|
|
// version 2 : write the properties common to all OEditBaseModels
|
|
writeCommonEditProperties(_rxOutStream);
|
|
// version 3 : write the effective value property of the aggregate
|
|
// Due to a bug within the UnoControlFormattedFieldModel implementation (our default aggregate)
|
|
// this props value isn't correctly read and this can't be corrected without being incompatible.
|
|
// so we have our own handling.
|
|
// and to be a little bit more compatible we make the following section skippable
|
|
{
|
|
OStreamSection aDownCompat(_rxOutStream);
|
|
// a sub version within the skippable block
|
|
_rxOutStream->writeShort(0x0000);
|
|
// version 0: the effective value of the aggregate
|
|
Any aEffectiveValue;
|
|
if (m_xAggregateSet.is())
|
|
{
|
|
try { aEffectiveValue = m_xAggregateSet->getPropertyValue(PROPERTY_EFFECTIVE_VALUE); } catch(const Exception&) { }
|
|
}
|
|
{
|
|
OStreamSection aDownCompat2(_rxOutStream);
|
|
switch (aEffectiveValue.getValueType().getTypeClass())
|
|
{
|
|
case TypeClass_STRING:
|
|
_rxOutStream->writeShort(0x0000);
|
|
_rxOutStream->writeUTF(::comphelper::getString(aEffectiveValue));
|
|
break;
|
|
case TypeClass_DOUBLE:
|
|
_rxOutStream->writeShort(0x0001);
|
|
_rxOutStream->writeDouble(::comphelper::getDouble(aEffectiveValue));
|
|
break;
|
|
default: // void and all unknown states
|
|
DBG_ASSERT(!aEffectiveValue.hasValue(), "FmXFormattedModel::write : unknown property value type !");
|
|
_rxOutStream->writeShort(0x0002);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void OFormattedModel::read(const Reference<XObjectInputStream>& _rxInStream)
|
|
{
|
|
OEditBaseModel::read(_rxInStream);
|
|
sal_uInt16 nVersion = _rxInStream->readShort();
|
|
Reference<XNumberFormatsSupplier> xSupplier;
|
|
sal_Int32 nKey = -1;
|
|
switch (nVersion)
|
|
{
|
|
case 0x0001 :
|
|
case 0x0002 :
|
|
case 0x0003 :
|
|
{
|
|
bool bNonVoidKey = _rxInStream->readBoolean();
|
|
if (bNonVoidKey)
|
|
{
|
|
// read string and language...
|
|
OUString sFormatDescription = _rxInStream->readUTF();
|
|
LanguageType eDescriptionLanguage = (LanguageType)_rxInStream->readLong();
|
|
// and let a formatter roll dice based on that to create a key...
|
|
xSupplier = calcFormatsSupplier();
|
|
// calcFormatsSupplier first takes the one from the model, then one from the starform, then a new one...
|
|
Reference<XNumberFormats> xFormats = xSupplier->getNumberFormats();
|
|
if (xFormats.is())
|
|
{
|
|
Locale aDescriptionLanguage( LanguageTag::convertToLocale(eDescriptionLanguage));
|
|
nKey = xFormats->queryKey(sFormatDescription, aDescriptionLanguage, false);
|
|
if (nKey == (sal_Int32)-1)
|
|
{ // does not yet exist in my formatter...
|
|
nKey = xFormats->addNew(sFormatDescription, aDescriptionLanguage);
|
|
}
|
|
}
|
|
}
|
|
if ((nVersion == 0x0002) || (nVersion == 0x0003))
|
|
readCommonEditProperties(_rxInStream);
|
|
if (nVersion == 0x0003)
|
|
{ // since version 3 there is a "skippable" block at this position
|
|
OStreamSection aDownCompat(_rxInStream);
|
|
sal_Int16 nSubVersion = _rxInStream->readShort();
|
|
(void)nSubVersion;
|
|
// version 0 and higher : the "effective value" property
|
|
Any aEffectiveValue;
|
|
{
|
|
OStreamSection aDownCompat2(_rxInStream);
|
|
switch (_rxInStream->readShort())
|
|
{
|
|
case 0: // String
|
|
aEffectiveValue <<= _rxInStream->readUTF();
|
|
break;
|
|
case 1: // double
|
|
aEffectiveValue <<= _rxInStream->readDouble();
|
|
break;
|
|
case 2:
|
|
break;
|
|
case 3:
|
|
OSL_FAIL("FmXFormattedModel::read : unknown effective value type !");
|
|
}
|
|
}
|
|
// this property is only to be set if we have no control source : in all other cases the base class did a
|
|
// reset after it's read and this set the effective value to a default value
|
|
if ( m_xAggregateSet.is() && getControlSource().isEmpty() )
|
|
{
|
|
try
|
|
{
|
|
m_xAggregateSet->setPropertyValue(PROPERTY_EFFECTIVE_VALUE, aEffectiveValue);
|
|
}
|
|
catch(const Exception&)
|
|
{
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
default :
|
|
OSL_FAIL("OFormattedModel::read : unknown version !");
|
|
// then the format of the aggregated set stay like it was during creation: void
|
|
defaultCommonEditProperties();
|
|
break;
|
|
}
|
|
if ((nKey != -1) && m_xAggregateSet.is())
|
|
{
|
|
m_xAggregateSet->setPropertyValue(PROPERTY_FORMATSSUPPLIER, makeAny(xSupplier));
|
|
m_xAggregateSet->setPropertyValue(PROPERTY_FORMATKEY, makeAny((sal_Int32)nKey));
|
|
}
|
|
else
|
|
{
|
|
setPropertyToDefault(PROPERTY_FORMATSSUPPLIER);
|
|
setPropertyToDefault(PROPERTY_FORMATKEY);
|
|
}
|
|
}
|
|
|
|
sal_uInt16 OFormattedModel::getPersistenceFlags() const
|
|
{
|
|
return (OEditBaseModel::getPersistenceFlags() & ~PF_HANDLE_COMMON_PROPS);
|
|
// a) we do our own call to writeCommonEditProperties
|
|
}
|
|
|
|
bool OFormattedModel::commitControlValueToDbColumn( bool /*_bPostReset*/ )
|
|
{
|
|
Any aControlValue( m_xAggregateFastSet->getFastPropertyValue( getValuePropertyAggHandle() ) );
|
|
if ( aControlValue != m_aSaveValue )
|
|
{
|
|
// empty string + EmptyIsNull = void
|
|
if ( !aControlValue.hasValue()
|
|
|| ( ( aControlValue.getValueType().getTypeClass() == TypeClass_STRING )
|
|
&& getString( aControlValue ).isEmpty()
|
|
&& m_bEmptyIsNull
|
|
)
|
|
)
|
|
m_xColumnUpdate->updateNull();
|
|
else
|
|
{
|
|
try
|
|
{
|
|
double f = 0.0;
|
|
if ( aControlValue.getValueType().getTypeClass() == TypeClass_DOUBLE || (aControlValue >>= f)) // #i110323
|
|
{
|
|
DBTypeConversion::setValue( m_xColumnUpdate, m_aNullDate, getDouble( aControlValue ), m_nKeyType );
|
|
}
|
|
else
|
|
{
|
|
DBG_ASSERT( aControlValue.getValueType().getTypeClass() == TypeClass_STRING, "OFormattedModel::commitControlValueToDbColumn: invalid value type!" );
|
|
m_xColumnUpdate->updateString( getString( aControlValue ) );
|
|
}
|
|
}
|
|
catch(const Exception&)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
m_aSaveValue = aControlValue;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void OFormattedModel::onConnectedExternalValue( )
|
|
{
|
|
OEditBaseModel::onConnectedExternalValue();
|
|
updateFormatterNullDate();
|
|
}
|
|
|
|
Any OFormattedModel::translateExternalValueToControlValue( const Any& _rExternalValue ) const
|
|
{
|
|
Any aControlValue;
|
|
switch( _rExternalValue.getValueTypeClass() )
|
|
{
|
|
case TypeClass_VOID:
|
|
break;
|
|
case TypeClass_STRING:
|
|
aControlValue = _rExternalValue;
|
|
break;
|
|
case TypeClass_BOOLEAN:
|
|
{
|
|
bool bExternalValue = false;
|
|
_rExternalValue >>= bExternalValue;
|
|
aControlValue <<= (double)( bExternalValue ? 1 : 0 );
|
|
}
|
|
break;
|
|
default:
|
|
{
|
|
if ( _rExternalValue.getValueType().equals( cppu::UnoType< css::util::Date >::get() ) )
|
|
{
|
|
css::util::Date aDate;
|
|
_rExternalValue >>= aDate;
|
|
aControlValue <<= DBTypeConversion::toDouble( aDate, m_aNullDate );
|
|
}
|
|
else if ( _rExternalValue.getValueType().equals( cppu::UnoType< css::util::Time >::get() ) )
|
|
{
|
|
css::util::Time aTime;
|
|
_rExternalValue >>= aTime;
|
|
aControlValue <<= DBTypeConversion::toDouble( aTime );
|
|
}
|
|
else if ( _rExternalValue.getValueType().equals( cppu::UnoType< css::util::DateTime >::get() ) )
|
|
{
|
|
css::util::DateTime aDateTime;
|
|
_rExternalValue >>= aDateTime;
|
|
aControlValue <<= DBTypeConversion::toDouble( aDateTime, m_aNullDate );
|
|
}
|
|
else
|
|
{
|
|
OSL_ENSURE( _rExternalValue.getValueTypeClass() == TypeClass_DOUBLE,
|
|
"OFormattedModel::translateExternalValueToControlValue: don't know how to translate this type!" );
|
|
double fValue = 0;
|
|
OSL_VERIFY( _rExternalValue >>= fValue );
|
|
aControlValue <<= fValue;
|
|
}
|
|
}
|
|
}
|
|
return aControlValue;
|
|
}
|
|
|
|
Any OFormattedModel::translateControlValueToExternalValue( ) const
|
|
{
|
|
OSL_PRECOND( hasExternalValueBinding(),
|
|
"OFormattedModel::translateControlValueToExternalValue: precondition not met!" );
|
|
Any aControlValue( getControlValue() );
|
|
if ( !aControlValue.hasValue() )
|
|
return aControlValue;
|
|
Any aExternalValue;
|
|
// translate into the external value type
|
|
Type aExternalValueType( getExternalValueType() );
|
|
switch ( aExternalValueType.getTypeClass() )
|
|
{
|
|
case TypeClass_STRING:
|
|
{
|
|
OUString sString;
|
|
if ( aControlValue >>= sString )
|
|
{
|
|
aExternalValue <<= sString;
|
|
break;
|
|
}
|
|
SAL_FALLTHROUGH;
|
|
}
|
|
case TypeClass_BOOLEAN:
|
|
{
|
|
double fValue = 0;
|
|
OSL_VERIFY( aControlValue >>= fValue );
|
|
// if this asserts ... well, the somebody set the TreatAsNumeric property to false,
|
|
// and the control value is a string. This implies some weird misconfiguration
|
|
// of the FormattedModel, so we won't care for it for the moment.
|
|
aExternalValue <<= fValue != 0.0;
|
|
}
|
|
break;
|
|
default:
|
|
{
|
|
double fValue = 0;
|
|
OSL_VERIFY( aControlValue >>= fValue );
|
|
// if this asserts ... well, the somebody set the TreatAsNumeric property to false,
|
|
// and the control value is a string. This implies some weird misconfiguration
|
|
// of the FormattedModel, so we won't care for it for the moment.
|
|
if ( aExternalValueType.equals( cppu::UnoType< css::util::Date >::get() ) )
|
|
{
|
|
aExternalValue <<= DBTypeConversion::toDate( fValue, m_aNullDate );
|
|
}
|
|
else if ( aExternalValueType.equals( cppu::UnoType< css::util::Time >::get() ) )
|
|
{
|
|
aExternalValue <<= DBTypeConversion::toTime( fValue );
|
|
}
|
|
else if ( aExternalValueType.equals( cppu::UnoType< css::util::DateTime >::get() ) )
|
|
{
|
|
aExternalValue <<= DBTypeConversion::toDateTime( fValue, m_aNullDate );
|
|
}
|
|
else
|
|
{
|
|
OSL_ENSURE( aExternalValueType.equals( cppu::UnoType< double >::get() ),
|
|
"OFormattedModel::translateControlValueToExternalValue: don't know how to translate this type!" );
|
|
aExternalValue <<= fValue;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
return aExternalValue;
|
|
}
|
|
|
|
Any OFormattedModel::translateDbColumnToControlValue()
|
|
{
|
|
if ( m_bNumeric )
|
|
m_aSaveValue <<= DBTypeConversion::getValue( m_xColumn, m_aNullDate ); // #100056# OJ
|
|
else
|
|
m_aSaveValue <<= m_xColumn->getString();
|
|
if ( m_xColumn->wasNull() )
|
|
m_aSaveValue.clear();
|
|
return m_aSaveValue;
|
|
}
|
|
|
|
Sequence< Type > OFormattedModel::getSupportedBindingTypes()
|
|
{
|
|
::std::list< Type > aTypes;
|
|
aTypes.push_back( cppu::UnoType< double >::get() );
|
|
switch ( m_nKeyType & ~NumberFormat::DEFINED )
|
|
{
|
|
case NumberFormat::DATE:
|
|
aTypes.push_front(cppu::UnoType< css::util::Date >::get() );
|
|
break;
|
|
case NumberFormat::TIME:
|
|
aTypes.push_front(cppu::UnoType< css::util::Time >::get() );
|
|
break;
|
|
case NumberFormat::DATETIME:
|
|
aTypes.push_front(cppu::UnoType< css::util::DateTime >::get() );
|
|
break;
|
|
case NumberFormat::TEXT:
|
|
aTypes.push_front(cppu::UnoType< OUString >::get() );
|
|
break;
|
|
case NumberFormat::LOGICAL:
|
|
aTypes.push_front(cppu::UnoType< sal_Bool >::get() );
|
|
break;
|
|
}
|
|
return comphelper::containerToSequence(aTypes);
|
|
}
|
|
|
|
Any OFormattedModel::getDefaultForReset() const
|
|
{
|
|
return m_xAggregateSet->getPropertyValue( PROPERTY_EFFECTIVE_DEFAULT );
|
|
}
|
|
|
|
void OFormattedModel::resetNoBroadcast()
|
|
{
|
|
OEditBaseModel::resetNoBroadcast();
|
|
m_aSaveValue.clear();
|
|
}
|
|
|
|
}
|
|
|
|
extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface* SAL_CALL
|
|
com_sun_star_form_OFormattedControl_get_implementation(css::uno::XComponentContext* component,
|
|
css::uno::Sequence<css::uno::Any> const &)
|
|
{
|
|
return cppu::acquire(new frm::OFormattedControl(component));
|
|
}
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|