811 lines
25 KiB
C++
811 lines
25 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 "vbaformat.hxx"
|
|
#include <ooo/vba/excel/XFont.hpp>
|
|
#include <ooo/vba/excel/XStyle.hpp>
|
|
#include <ooo/vba/excel/XlVAlign.hpp>
|
|
#include <ooo/vba/excel/XlHAlign.hpp>
|
|
#include <ooo/vba/excel/XlOrientation.hpp>
|
|
#include <ooo/vba/excel/Constants.hpp>
|
|
#include <ooo/vba/excel/XRange.hpp>
|
|
#include <com/sun/star/table/CellVertJustify2.hpp>
|
|
#include <com/sun/star/table/CellHoriJustify.hpp>
|
|
#include <com/sun/star/table/CellOrientation.hpp>
|
|
#include <com/sun/star/table/XCellRange.hpp>
|
|
#include <com/sun/star/text/WritingMode.hpp>
|
|
#include <com/sun/star/util/CellProtection.hpp>
|
|
#include <com/sun/star/util/XNumberFormatsSupplier.hpp>
|
|
#include <com/sun/star/util/XNumberFormats.hpp>
|
|
#include <com/sun/star/util/XNumberFormatTypes.hpp>
|
|
#include <com/sun/star/frame/XModel.hpp>
|
|
|
|
#include <basic/sberrors.hxx>
|
|
#include <rtl/math.hxx>
|
|
|
|
#include "excelvbahelper.hxx"
|
|
#include "vbaborders.hxx"
|
|
#include "vbapalette.hxx"
|
|
#include "vbafont.hxx"
|
|
#include "vbainterior.hxx"
|
|
|
|
#include <docsh.hxx>
|
|
#include <unonames.hxx>
|
|
#include <cellsuno.hxx>
|
|
#include <scitems.hxx>
|
|
#include <attrib.hxx>
|
|
#include <utility>
|
|
|
|
using namespace ::ooo::vba;
|
|
using namespace ::com::sun::star;
|
|
|
|
constexpr OUString FORMATSTRING = u"FormatString"_ustr;
|
|
constexpr OUString LOCALE = u"Locale"_ustr;
|
|
|
|
template< typename... Ifc >
|
|
ScVbaFormat< Ifc... >::ScVbaFormat( const uno::Reference< XHelperInterface >& xParent,
|
|
const uno::Reference< uno::XComponentContext > & xContext,
|
|
uno::Reference< beans::XPropertySet > _xPropertySet,
|
|
uno::Reference< frame::XModel > xModel,
|
|
bool bCheckAmbiguoity )
|
|
: ScVbaFormat_BASE( xParent, xContext ),
|
|
m_aDefaultLocale( u"en"_ustr, u"US"_ustr, OUString() ),
|
|
mxPropertySet(std::move( _xPropertySet )),
|
|
mxModel(std::move( xModel )),
|
|
mbCheckAmbiguoity( bCheckAmbiguoity ),
|
|
mbAddIndent( false )
|
|
{
|
|
try
|
|
{
|
|
if ( !mxModel.is() )
|
|
DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, u"XModel Interface could not be retrieved" );
|
|
// mxServiceInfo is unused,
|
|
// mxNumberFormatsSupplier is initialized when needed in initializeNumberFormats.
|
|
}
|
|
catch (const uno::Exception& )
|
|
{
|
|
DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {} );
|
|
}
|
|
}
|
|
|
|
template< typename... Ifc >
|
|
void SAL_CALL
|
|
ScVbaFormat< Ifc... >::setVerticalAlignment( const uno::Any& _oAlignment)
|
|
{
|
|
try
|
|
{
|
|
uno::Any aVal;
|
|
sal_Int32 nAlignment = 0;
|
|
if ( !(_oAlignment >>= nAlignment ))
|
|
throw uno::RuntimeException();
|
|
switch (nAlignment)
|
|
{
|
|
case excel::XlVAlign::xlVAlignBottom :
|
|
aVal <<= table::CellVertJustify2::BOTTOM;
|
|
break;
|
|
case excel::XlVAlign::xlVAlignCenter :
|
|
aVal <<= table::CellVertJustify2::CENTER;
|
|
break;
|
|
case excel::XlVAlign::xlVAlignDistributed:
|
|
case excel::XlVAlign::xlVAlignJustify:
|
|
aVal <<= table::CellVertJustify2::STANDARD;
|
|
break;
|
|
|
|
case excel::XlVAlign::xlVAlignTop:
|
|
aVal <<= table::CellVertJustify2::TOP;
|
|
break;
|
|
default:
|
|
aVal <<= table::CellVertJustify2::STANDARD;
|
|
break;
|
|
}
|
|
mxPropertySet->setPropertyValue( SC_UNONAME_CELLVJUS, aVal );
|
|
}
|
|
catch (const uno::Exception&)
|
|
{
|
|
DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {});
|
|
}
|
|
}
|
|
|
|
template< typename... Ifc >
|
|
uno::Any SAL_CALL
|
|
ScVbaFormat< Ifc... >::getVerticalAlignment( )
|
|
{
|
|
uno::Any aResult = aNULL();
|
|
try
|
|
{
|
|
if (!isAmbiguous( SC_UNONAME_CELLVJUS ) )
|
|
{
|
|
sal_Int32 aAPIAlignment = table::CellVertJustify2::STANDARD;
|
|
mxPropertySet->getPropertyValue( SC_UNONAME_CELLVJUS ) >>= aAPIAlignment;
|
|
switch( aAPIAlignment )
|
|
{
|
|
case table::CellVertJustify2::BOTTOM:
|
|
case table::CellVertJustify2::STANDARD:
|
|
aResult <<= excel::XlVAlign::xlVAlignBottom;
|
|
break;
|
|
case table::CellVertJustify2::CENTER:
|
|
aResult <<= excel::XlVAlign::xlVAlignCenter;
|
|
break;
|
|
case table::CellVertJustify2::TOP:
|
|
aResult <<= excel::XlVAlign::xlVAlignTop;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
catch (const uno::Exception& )
|
|
{
|
|
DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {});
|
|
}
|
|
return aResult;
|
|
}
|
|
|
|
template< typename... Ifc >
|
|
void SAL_CALL
|
|
ScVbaFormat< Ifc... >::setHorizontalAlignment( const uno::Any& HorizontalAlignment )
|
|
{
|
|
try
|
|
{
|
|
uno::Any aVal;
|
|
sal_Int32 nAlignment = 0;
|
|
if ( !( HorizontalAlignment >>= nAlignment ) )
|
|
throw uno::RuntimeException();
|
|
switch ( nAlignment )
|
|
{
|
|
case excel::XlHAlign::xlHAlignJustify:
|
|
case excel::XlHAlign::xlHAlignDistributed:
|
|
aVal <<= table::CellHoriJustify_BLOCK;
|
|
break;
|
|
case excel::XlHAlign::xlHAlignCenter:
|
|
aVal <<= table::CellHoriJustify_CENTER;
|
|
break;
|
|
case excel::XlHAlign::xlHAlignLeft:
|
|
aVal <<= table::CellHoriJustify_LEFT;
|
|
break;
|
|
case excel::XlHAlign::xlHAlignRight:
|
|
aVal <<= table::CellHoriJustify_RIGHT;
|
|
break;
|
|
}
|
|
// #FIXME what about the default case above?
|
|
// shouldn't need the test below
|
|
if ( aVal.hasValue() )
|
|
mxPropertySet->setPropertyValue( SC_UNONAME_CELLHJUS, aVal );
|
|
}
|
|
catch (const uno::Exception& )
|
|
{
|
|
DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {} );
|
|
}
|
|
|
|
}
|
|
|
|
template< typename... Ifc >
|
|
uno::Any SAL_CALL
|
|
ScVbaFormat< Ifc... >::getHorizontalAlignment( )
|
|
{
|
|
uno::Any NRetAlignment = aNULL();
|
|
try
|
|
{
|
|
OUString sHoriJust( SC_UNONAME_CELLHJUS );
|
|
if (!isAmbiguous(sHoriJust))
|
|
{
|
|
table::CellHoriJustify aAPIAlignment = table::CellHoriJustify_BLOCK;
|
|
|
|
if ( mxPropertySet->getPropertyValue(sHoriJust) >>= aAPIAlignment )
|
|
{
|
|
switch( aAPIAlignment )
|
|
{
|
|
case table::CellHoriJustify_BLOCK:
|
|
NRetAlignment <<= excel::XlHAlign::xlHAlignJustify;
|
|
break;
|
|
case table::CellHoriJustify_CENTER:
|
|
NRetAlignment <<= excel::XlHAlign::xlHAlignCenter;
|
|
break;
|
|
case table::CellHoriJustify_LEFT:
|
|
NRetAlignment <<= excel::XlHAlign::xlHAlignLeft;
|
|
break;
|
|
case table::CellHoriJustify_RIGHT:
|
|
NRetAlignment <<= excel::XlHAlign::xlHAlignRight;
|
|
break;
|
|
default: // handle those other cases with a NULL return
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (const uno::Exception& )
|
|
{
|
|
DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {} );
|
|
}
|
|
return NRetAlignment;
|
|
}
|
|
|
|
template< typename... Ifc >
|
|
void SAL_CALL
|
|
ScVbaFormat< Ifc... >::setOrientation( const uno::Any& _aOrientation )
|
|
{
|
|
try
|
|
{
|
|
sal_Int32 nOrientation = 0;
|
|
if ( !( _aOrientation >>= nOrientation ) )
|
|
throw uno::RuntimeException();
|
|
uno::Any aVal;
|
|
switch( nOrientation )
|
|
{
|
|
case excel::XlOrientation::xlDownward:
|
|
aVal <<= table::CellOrientation_TOPBOTTOM;
|
|
break;
|
|
case excel::XlOrientation::xlHorizontal:
|
|
aVal <<= table::CellOrientation_STANDARD;
|
|
mxPropertySet->setPropertyValue( SC_UNONAME_ROTANG, uno::Any( sal_Int32(0) ) );
|
|
break;
|
|
case excel::XlOrientation::xlUpward:
|
|
aVal <<= table::CellOrientation_BOTTOMTOP;
|
|
break;
|
|
case excel::XlOrientation::xlVertical:
|
|
aVal <<= table::CellOrientation_STACKED;
|
|
break;
|
|
}
|
|
// #FIXME what about the default case above?
|
|
// shouldn't need the test below
|
|
if ( aVal.hasValue() )
|
|
mxPropertySet->setPropertyValue( SC_UNONAME_CELLORI, aVal );
|
|
|
|
}
|
|
catch (const uno::Exception& )
|
|
{
|
|
DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {} );
|
|
}
|
|
}
|
|
template< typename... Ifc >
|
|
uno::Any SAL_CALL
|
|
ScVbaFormat< Ifc... >::getOrientation( )
|
|
{
|
|
uno::Any NRetOrientation = aNULL();
|
|
try
|
|
{
|
|
if (!isAmbiguous(SC_UNONAME_CELLORI))
|
|
{
|
|
table::CellOrientation aOrientation = table::CellOrientation_STANDARD;
|
|
if ( !( mxPropertySet->getPropertyValue( SC_UNONAME_CELLORI ) >>= aOrientation ) )
|
|
throw uno::RuntimeException();
|
|
|
|
switch(aOrientation)
|
|
{
|
|
case table::CellOrientation_STANDARD:
|
|
NRetOrientation <<= excel::XlOrientation::xlHorizontal;
|
|
break;
|
|
case table::CellOrientation_BOTTOMTOP:
|
|
NRetOrientation <<= excel::XlOrientation::xlUpward;
|
|
break;
|
|
case table::CellOrientation_TOPBOTTOM:
|
|
NRetOrientation <<= excel::XlOrientation::xlDownward;
|
|
break;
|
|
case table::CellOrientation_STACKED:
|
|
NRetOrientation <<= excel::XlOrientation::xlVertical;
|
|
break;
|
|
default:
|
|
NRetOrientation <<= excel::XlOrientation::xlHorizontal;
|
|
}
|
|
}
|
|
}
|
|
catch (const uno::Exception& )
|
|
{
|
|
DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {});
|
|
}
|
|
return NRetOrientation;
|
|
}
|
|
|
|
template< typename... Ifc >
|
|
void SAL_CALL
|
|
ScVbaFormat< Ifc... >::setWrapText( const uno::Any& _aWrapText )
|
|
{
|
|
try
|
|
{
|
|
mxPropertySet->setPropertyValue( SC_UNONAME_WRAP, _aWrapText);
|
|
}
|
|
catch (const uno::Exception& )
|
|
{
|
|
DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {} );
|
|
}
|
|
}
|
|
|
|
template< typename... Ifc >
|
|
uno::Any SAL_CALL
|
|
ScVbaFormat< Ifc... >::getWrapText( )
|
|
{
|
|
uno::Any aWrap = aNULL();
|
|
try
|
|
{
|
|
OUString aPropName( SC_UNONAME_WRAP );
|
|
if (!isAmbiguous( aPropName ))
|
|
{
|
|
aWrap = mxPropertySet->getPropertyValue(aPropName);
|
|
}
|
|
}
|
|
catch (const uno::Exception&)
|
|
{
|
|
DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {} );
|
|
}
|
|
return aWrap;
|
|
}
|
|
|
|
template< typename... Ifc >
|
|
uno::Any SAL_CALL
|
|
ScVbaFormat< Ifc... >::Borders( const uno::Any& Index )
|
|
{
|
|
ScVbaPalette aPalette( excel::getDocShell( mxModel ) );
|
|
uno::Reference< XCollection > xColl = new ScVbaBorders( thisHelperIface(), ScVbaFormat_BASE::mxContext, uno::Reference< table::XCellRange >( mxPropertySet, uno::UNO_QUERY_THROW ), aPalette );
|
|
|
|
if ( Index.hasValue() )
|
|
{
|
|
return xColl->Item( Index, uno::Any() );
|
|
}
|
|
return uno::Any( xColl );
|
|
}
|
|
|
|
template< typename... Ifc >
|
|
uno::Reference< excel::XFont > SAL_CALL
|
|
ScVbaFormat< Ifc... >::Font( )
|
|
{
|
|
ScVbaPalette aPalette( excel::getDocShell( mxModel ) );
|
|
return new ScVbaFont( thisHelperIface(), ScVbaFormat_BASE::mxContext, aPalette, mxPropertySet );
|
|
}
|
|
|
|
template< typename... Ifc >
|
|
uno::Reference< excel::XInterior > SAL_CALL
|
|
ScVbaFormat< Ifc... >::Interior( )
|
|
{
|
|
return new ScVbaInterior( thisHelperIface(), ScVbaFormat_BASE::mxContext, mxPropertySet );
|
|
}
|
|
|
|
template< typename... Ifc >
|
|
uno::Any SAL_CALL
|
|
ScVbaFormat< Ifc... >::getNumberFormatLocal( )
|
|
{
|
|
uno::Any aRet{ OUString() };
|
|
try
|
|
{
|
|
OUString sPropName( SC_UNO_DP_NUMBERFO );
|
|
if (!isAmbiguous( sPropName ))
|
|
{
|
|
|
|
initializeNumberFormats();
|
|
|
|
sal_Int32 nFormat = 0;
|
|
if ( ! (mxPropertySet->getPropertyValue( sPropName ) >>= nFormat ) )
|
|
throw uno::RuntimeException();
|
|
|
|
OUString sFormat;
|
|
xNumberFormats->getByKey(nFormat)->getPropertyValue( FORMATSTRING ) >>= sFormat;
|
|
aRet <<= sFormat.toAsciiLowerCase();
|
|
|
|
}
|
|
}
|
|
catch (const uno::Exception&)
|
|
{
|
|
DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {});
|
|
}
|
|
return aRet;
|
|
|
|
}
|
|
|
|
template< typename... Ifc >
|
|
void SAL_CALL
|
|
ScVbaFormat< Ifc... >::setNumberFormatLocal( const uno::Any& _oLocalFormatString )
|
|
{
|
|
try
|
|
{
|
|
OUString sLocalFormatString;
|
|
sal_Int32 nFormat = -1;
|
|
OUString sNumFormat( SC_UNO_DP_NUMBERFO );
|
|
if ( !(_oLocalFormatString >>= sLocalFormatString )
|
|
|| !( mxPropertySet->getPropertyValue(sNumFormat) >>= nFormat ) )
|
|
throw uno::RuntimeException();
|
|
|
|
sLocalFormatString = sLocalFormatString.toAsciiUpperCase();
|
|
initializeNumberFormats();
|
|
lang::Locale aRangeLocale;
|
|
xNumberFormats->getByKey(nFormat)->getPropertyValue( LOCALE ) >>= aRangeLocale;
|
|
sal_Int32 nNewFormat = xNumberFormats->queryKey(sLocalFormatString, aRangeLocale, true);
|
|
|
|
if (nNewFormat == -1)
|
|
nNewFormat = xNumberFormats->addNew(sLocalFormatString, aRangeLocale);
|
|
mxPropertySet->setPropertyValue(sNumFormat, uno::Any( nNewFormat ));
|
|
}
|
|
catch (const uno::Exception& )
|
|
{
|
|
DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {} );
|
|
}
|
|
}
|
|
|
|
template< typename... Ifc >
|
|
void SAL_CALL
|
|
ScVbaFormat< Ifc... >::setNumberFormat( const uno::Any& _oFormatString )
|
|
{
|
|
try
|
|
{
|
|
OUString sFormatString;
|
|
if ( !( _oFormatString >>= sFormatString ) )
|
|
throw uno::RuntimeException();
|
|
|
|
sFormatString = sFormatString.toAsciiUpperCase();
|
|
|
|
lang::Locale aDefaultLocale = m_aDefaultLocale;
|
|
initializeNumberFormats();
|
|
sal_Int32 nFormat = xNumberFormats->queryKey(sFormatString, aDefaultLocale, true);
|
|
|
|
if (nFormat == -1)
|
|
nFormat = xNumberFormats->addNew(sFormatString, aDefaultLocale);
|
|
|
|
lang::Locale aRangeLocale;
|
|
xNumberFormats->getByKey(nFormat)->getPropertyValue( LOCALE ) >>= aRangeLocale;
|
|
sal_Int32 nNewFormat = xNumberFormatTypes->getFormatForLocale(nFormat, aRangeLocale);
|
|
mxPropertySet->setPropertyValue( SC_UNO_DP_NUMBERFO, uno::Any( nNewFormat));
|
|
}
|
|
catch (const uno::Exception& )
|
|
{
|
|
DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {});
|
|
}
|
|
|
|
}
|
|
|
|
template< typename... Ifc >
|
|
void SAL_CALL
|
|
ScVbaFormat< Ifc... >::setIndentLevel( const uno::Any& _aLevel )
|
|
{
|
|
try
|
|
{
|
|
sal_Int32 nLevel = 0;
|
|
if ( !(_aLevel >>= nLevel ) )
|
|
throw uno::RuntimeException();
|
|
table::CellHoriJustify aAPIAlignment = table::CellHoriJustify_STANDARD;
|
|
|
|
OUString sHoriJust( SC_UNONAME_CELLHJUS );
|
|
if ( !( mxPropertySet->getPropertyValue(sHoriJust) >>= aAPIAlignment ) )
|
|
throw uno::RuntimeException();
|
|
if (aAPIAlignment == table::CellHoriJustify_STANDARD)
|
|
mxPropertySet->setPropertyValue( sHoriJust, uno::Any( table::CellHoriJustify_LEFT) ) ;
|
|
mxPropertySet->setPropertyValue( SC_UNONAME_PINDENT, uno::Any( sal_Int16(nLevel * 352.8) ) );
|
|
}
|
|
catch (const uno::Exception&)
|
|
{
|
|
DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {});
|
|
}
|
|
}
|
|
|
|
template< typename... Ifc >
|
|
uno::Any SAL_CALL
|
|
ScVbaFormat< Ifc... >::getIndentLevel( )
|
|
{
|
|
uno::Any NRetIndentLevel = aNULL();
|
|
try
|
|
{
|
|
OUString sParaIndent( SC_UNONAME_PINDENT );
|
|
if (!isAmbiguous(sParaIndent))
|
|
{
|
|
sal_Int16 IndentLevel = 0;
|
|
if ( mxPropertySet->getPropertyValue(sParaIndent) >>= IndentLevel )
|
|
NRetIndentLevel <<= sal_Int32( rtl::math::round(static_cast<double>( IndentLevel ) / 352.8));
|
|
else
|
|
NRetIndentLevel <<= sal_Int32(0);
|
|
}
|
|
}
|
|
catch (const uno::Exception&)
|
|
{
|
|
DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {});
|
|
}
|
|
return NRetIndentLevel;
|
|
}
|
|
|
|
template< typename... Ifc >
|
|
void SAL_CALL
|
|
ScVbaFormat< Ifc... >::setLocked( const uno::Any& _aLocked )
|
|
{
|
|
try
|
|
{
|
|
bool bIsLocked = false;
|
|
if ( !( _aLocked >>= bIsLocked ) )
|
|
throw uno::RuntimeException();
|
|
util::CellProtection aCellProtection;
|
|
OUString sCellProt( SC_UNONAME_CELLPRO );
|
|
mxPropertySet->getPropertyValue(sCellProt) >>= aCellProtection;
|
|
aCellProtection.IsLocked = bIsLocked;
|
|
mxPropertySet->setPropertyValue(sCellProt, uno::Any( aCellProtection ) );
|
|
}
|
|
catch (const uno::Exception&)
|
|
{
|
|
DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {} );
|
|
}
|
|
}
|
|
|
|
template< typename... Ifc >
|
|
void SAL_CALL
|
|
ScVbaFormat< Ifc... >::setFormulaHidden( const uno::Any& FormulaHidden )
|
|
{
|
|
try
|
|
{
|
|
bool bIsFormulaHidden = false;
|
|
FormulaHidden >>= bIsFormulaHidden;
|
|
util::CellProtection aCellProtection;
|
|
OUString sCellProt( SC_UNONAME_CELLPRO );
|
|
mxPropertySet->getPropertyValue(sCellProt) >>= aCellProtection;
|
|
aCellProtection.IsFormulaHidden = bIsFormulaHidden;
|
|
mxPropertySet->setPropertyValue(sCellProt,uno::Any(aCellProtection));
|
|
}
|
|
catch (const uno::Exception&)
|
|
{
|
|
DebugHelper::basicexception( ERRCODE_BASIC_METHOD_FAILED, {} );
|
|
}
|
|
}
|
|
|
|
template< typename... Ifc >
|
|
uno::Any SAL_CALL
|
|
ScVbaFormat< Ifc... >::getLocked( )
|
|
{
|
|
uno::Any aCellProtection = aNULL();
|
|
try
|
|
{
|
|
OUString sCellProt( SC_UNONAME_CELLPRO );
|
|
|
|
if (!isAmbiguous(sCellProt))
|
|
{
|
|
SfxItemSet* pDataSet = getCurrentDataSet();
|
|
if ( pDataSet )
|
|
{
|
|
const ScProtectionAttr& rProtAttr = pDataSet->Get(ATTR_PROTECTION);
|
|
SfxItemState eState = pDataSet->GetItemState(ATTR_PROTECTION);
|
|
if(eState != SfxItemState::INVALID)
|
|
aCellProtection <<= rProtAttr.GetProtection();
|
|
}
|
|
else // fallback to propertyset
|
|
{
|
|
util::CellProtection cellProtection;
|
|
mxPropertySet->getPropertyValue(sCellProt) >>= cellProtection;
|
|
aCellProtection <<= cellProtection.IsLocked;
|
|
}
|
|
}
|
|
}
|
|
catch (const uno::Exception&)
|
|
{
|
|
DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {});
|
|
}
|
|
return aCellProtection;
|
|
}
|
|
|
|
template< typename... Ifc >
|
|
uno::Any SAL_CALL
|
|
ScVbaFormat< Ifc... >::getFormulaHidden( )
|
|
{
|
|
uno::Any aBoolRet = aNULL();
|
|
try
|
|
{
|
|
OUString sCellProt( SC_UNONAME_CELLPRO );
|
|
if (!isAmbiguous(sCellProt))
|
|
{
|
|
SfxItemSet* pDataSet = getCurrentDataSet();
|
|
if ( pDataSet )
|
|
{
|
|
const ScProtectionAttr& rProtAttr = pDataSet->Get(ATTR_PROTECTION);
|
|
SfxItemState eState = pDataSet->GetItemState(ATTR_PROTECTION);
|
|
if(eState != SfxItemState::INVALID)
|
|
aBoolRet <<= rProtAttr.GetHideFormula();
|
|
}
|
|
else
|
|
{
|
|
util::CellProtection aCellProtection;
|
|
mxPropertySet->getPropertyValue(sCellProt) >>= aCellProtection;
|
|
aBoolRet <<= aCellProtection.IsFormulaHidden;
|
|
}
|
|
}
|
|
}
|
|
catch (const uno::Exception&)
|
|
{
|
|
DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {});
|
|
}
|
|
return aBoolRet;
|
|
}
|
|
|
|
template< typename... Ifc >
|
|
void SAL_CALL
|
|
ScVbaFormat< Ifc... >::setShrinkToFit( const uno::Any& ShrinkToFit )
|
|
{
|
|
try
|
|
{
|
|
mxPropertySet->setPropertyValue( SC_UNONAME_SHRINK_TO_FIT, ShrinkToFit);
|
|
}
|
|
catch (const uno::Exception& )
|
|
{
|
|
DebugHelper::basicexception(ERRCODE_BASIC_NOT_IMPLEMENTED, {} );
|
|
}
|
|
|
|
}
|
|
|
|
template< typename... Ifc >
|
|
uno::Any SAL_CALL
|
|
ScVbaFormat< Ifc... >::getShrinkToFit( )
|
|
{
|
|
uno::Any aRet = aNULL();
|
|
try
|
|
{
|
|
OUString sShrinkToFit( SC_UNONAME_SHRINK_TO_FIT );
|
|
if (!isAmbiguous(sShrinkToFit))
|
|
aRet = mxPropertySet->getPropertyValue(sShrinkToFit);
|
|
}
|
|
catch (const uno::Exception& )
|
|
{
|
|
DebugHelper::basicexception(ERRCODE_BASIC_NOT_IMPLEMENTED, {});
|
|
}
|
|
return aRet;
|
|
}
|
|
|
|
template< typename... Ifc >
|
|
void SAL_CALL
|
|
ScVbaFormat< Ifc... >::setReadingOrder( const uno::Any& ReadingOrder )
|
|
{
|
|
try
|
|
{
|
|
sal_Int32 nReadingOrder = 0;
|
|
if ( !(ReadingOrder >>= nReadingOrder ))
|
|
throw uno::RuntimeException();
|
|
uno::Any aVal = aNULL();
|
|
switch(nReadingOrder)
|
|
{
|
|
case excel::Constants::xlLTR:
|
|
aVal <<= sal_Int16(text::WritingMode_LR_TB);
|
|
break;
|
|
case excel::Constants::xlRTL:
|
|
aVal <<= sal_Int16(text::WritingMode_RL_TB);
|
|
break;
|
|
case excel::Constants::xlContext:
|
|
// TODO implement xlContext
|
|
// Reading order has to depend on the language of the first letter
|
|
// written.
|
|
aVal <<= sal_Int16(text::WritingMode_LR_TB);
|
|
break;
|
|
default:
|
|
DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {});
|
|
}
|
|
mxPropertySet->setPropertyValue( SC_UNONAME_WRITING, aVal );
|
|
}
|
|
catch (const uno::Exception& )
|
|
{
|
|
DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {});
|
|
}
|
|
|
|
}
|
|
|
|
template< typename... Ifc >
|
|
uno::Any SAL_CALL
|
|
ScVbaFormat< Ifc... >::getReadingOrder( )
|
|
{
|
|
uno::Any NRetReadingOrder = aNULL();
|
|
try
|
|
{
|
|
OUString sWritingMode( SC_UNONAME_WRITING );
|
|
if (!isAmbiguous(sWritingMode))
|
|
{
|
|
text::WritingMode aWritingMode = text::WritingMode_LR_TB;
|
|
if ( ( mxPropertySet->getPropertyValue(sWritingMode) ) >>= aWritingMode )
|
|
switch (aWritingMode)
|
|
{
|
|
case text::WritingMode_LR_TB:
|
|
NRetReadingOrder <<= excel::Constants::xlLTR;
|
|
break;
|
|
case text::WritingMode_RL_TB:
|
|
NRetReadingOrder <<= excel::Constants::xlRTL;
|
|
break;
|
|
default:
|
|
NRetReadingOrder <<= excel::Constants::xlRTL;
|
|
}
|
|
}
|
|
}
|
|
catch (const uno::Exception& )
|
|
{
|
|
DebugHelper::basicexception(ERRCODE_BASIC_NOT_IMPLEMENTED, {});
|
|
}
|
|
return NRetReadingOrder;
|
|
|
|
}
|
|
|
|
template< typename... Ifc >
|
|
uno::Any SAL_CALL
|
|
ScVbaFormat< Ifc... >::getNumberFormat( )
|
|
{
|
|
uno::Any aFormat = aNULL();
|
|
try
|
|
{
|
|
sal_Int32 nFormat = -1;
|
|
OUString sNumFormat( SC_UNO_DP_NUMBERFO );
|
|
if (!isAmbiguous(sNumFormat) &&
|
|
( mxPropertySet->getPropertyValue(sNumFormat) >>= nFormat) )
|
|
{
|
|
initializeNumberFormats();
|
|
|
|
sal_Int32 nNewFormat = xNumberFormatTypes->getFormatForLocale(nFormat, m_aDefaultLocale );
|
|
OUString sFormat;
|
|
xNumberFormats->getByKey(nNewFormat)->getPropertyValue( FORMATSTRING ) >>= sFormat;
|
|
aFormat <<= sFormat;
|
|
}
|
|
}
|
|
catch (const uno::Exception& )
|
|
{
|
|
DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {});
|
|
}
|
|
return aFormat;
|
|
}
|
|
|
|
template< typename... Ifc >
|
|
bool
|
|
ScVbaFormat< Ifc... >::isAmbiguous(const OUString& _sPropertyName)
|
|
{
|
|
bool bResult = false;
|
|
try
|
|
{
|
|
if (mbCheckAmbiguoity)
|
|
bResult = ( getXPropertyState()->getPropertyState(_sPropertyName) == beans::PropertyState_AMBIGUOUS_VALUE );
|
|
}
|
|
catch (const uno::Exception& )
|
|
{
|
|
DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {});
|
|
}
|
|
return bResult;
|
|
}
|
|
|
|
template< typename... Ifc >
|
|
void
|
|
ScVbaFormat< Ifc... >::initializeNumberFormats()
|
|
{
|
|
if ( !xNumberFormats.is() )
|
|
{
|
|
mxNumberFormatsSupplier.set( mxModel, uno::UNO_QUERY_THROW );
|
|
xNumberFormats = mxNumberFormatsSupplier->getNumberFormats();
|
|
xNumberFormatTypes.set( xNumberFormats, uno::UNO_QUERY ); // _THROW?
|
|
}
|
|
}
|
|
|
|
template< typename... Ifc >
|
|
uno::Reference< beans::XPropertyState > const &
|
|
ScVbaFormat< Ifc... >::getXPropertyState()
|
|
{
|
|
if ( !xPropertyState.is() )
|
|
xPropertyState.set( mxPropertySet, uno::UNO_QUERY_THROW );
|
|
return xPropertyState;
|
|
}
|
|
|
|
template< typename... Ifc >
|
|
ScCellRangesBase*
|
|
ScVbaFormat< Ifc... >::getCellRangesBase()
|
|
{
|
|
return dynamic_cast<ScCellRangesBase*>( mxPropertySet.get() );
|
|
}
|
|
|
|
template< typename... Ifc >
|
|
SfxItemSet*
|
|
ScVbaFormat< Ifc... >::getCurrentDataSet()
|
|
{
|
|
SfxItemSet* pDataSet = excel::ScVbaCellRangeAccess::GetDataSet( getCellRangesBase() );
|
|
if ( !pDataSet )
|
|
throw uno::RuntimeException(u"Can't access Itemset for XPropertySet"_ustr );
|
|
return pDataSet;
|
|
}
|
|
|
|
template class ScVbaFormat< excel::XStyle >;
|
|
template class ScVbaFormat< excel::XRange >;
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|