298 lines
9.9 KiB
C++
298 lines
9.9 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 <com/sun/star/table/CellAddress.hpp>
|
|
#include <com/sun/star/table/CellRangeAddress.hpp>
|
|
#include <cppuhelper/supportsservice.hxx>
|
|
|
|
#include <svl/itemprop.hxx>
|
|
#include <vcl/svapp.hxx>
|
|
|
|
#include <docsh.hxx>
|
|
#include <unonames.hxx>
|
|
#include <miscuno.hxx>
|
|
#include <convuno.hxx>
|
|
#include <addruno.hxx>
|
|
|
|
using namespace com::sun::star;
|
|
|
|
ScAddressConversionObj::ScAddressConversionObj(ScDocShell* pDocSh, bool _bIsRange) :
|
|
pDocShell( pDocSh ),
|
|
nRefSheet( 0 ),
|
|
bIsRange( _bIsRange )
|
|
{
|
|
pDocShell->GetDocument().AddUnoObject(*this);
|
|
}
|
|
|
|
ScAddressConversionObj::~ScAddressConversionObj()
|
|
{
|
|
SolarMutexGuard g;
|
|
|
|
if (pDocShell)
|
|
pDocShell->GetDocument().RemoveUnoObject(*this);
|
|
}
|
|
|
|
void ScAddressConversionObj::Notify( SfxBroadcaster&, const SfxHint& rHint )
|
|
{
|
|
if ( rHint.GetId() == SfxHintId::Dying )
|
|
{
|
|
pDocShell = nullptr; // invalid
|
|
}
|
|
}
|
|
|
|
bool ScAddressConversionObj::ParseUIString( const OUString& rUIString, ::formula::FormulaGrammar::AddressConvention eConv )
|
|
{
|
|
if (!pDocShell)
|
|
return false;
|
|
|
|
ScDocument& rDoc = pDocShell->GetDocument();
|
|
bool bSuccess = false;
|
|
if ( bIsRange )
|
|
{
|
|
ScRefFlags nResult = aRange.ParseAny( rUIString, rDoc, eConv );
|
|
if ( nResult & ScRefFlags::VALID )
|
|
{
|
|
if ( ( nResult & ScRefFlags::TAB_3D ) == ScRefFlags::ZERO )
|
|
aRange.aStart.SetTab( static_cast<SCTAB>(nRefSheet) );
|
|
if ( ( nResult & ScRefFlags::TAB2_3D ) == ScRefFlags::ZERO )
|
|
aRange.aEnd.SetTab( aRange.aStart.Tab() );
|
|
// different sheets are not supported in CellRangeAddress
|
|
if ( aRange.aStart.Tab() == aRange.aEnd.Tab() )
|
|
bSuccess = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ScRefFlags nResult = aRange.aStart.Parse( rUIString, rDoc, eConv );
|
|
if ( nResult & ScRefFlags::VALID )
|
|
{
|
|
if ( ( nResult & ScRefFlags::TAB_3D ) == ScRefFlags::ZERO )
|
|
aRange.aStart.SetTab( static_cast<SCTAB>(nRefSheet) );
|
|
bSuccess = true;
|
|
}
|
|
}
|
|
return bSuccess;
|
|
}
|
|
|
|
// XPropertySet
|
|
|
|
uno::Reference<beans::XPropertySetInfo> SAL_CALL ScAddressConversionObj::getPropertySetInfo()
|
|
{
|
|
SolarMutexGuard aGuard;
|
|
|
|
if ( bIsRange )
|
|
{
|
|
static const SfxItemPropertyMapEntry aPropertyMap[] =
|
|
{
|
|
{ SC_UNONAME_ADDRESS, 0, cppu::UnoType<table::CellRangeAddress>::get(), 0, 0 },
|
|
{ SC_UNONAME_PERSREPR, 0, cppu::UnoType<OUString>::get(), 0, 0 },
|
|
{ SC_UNONAME_XLA1REPR, 0, cppu::UnoType<OUString>::get(), 0, 0 },
|
|
{ SC_UNONAME_REFSHEET, 0, cppu::UnoType<sal_Int32>::get(), 0, 0 },
|
|
{ SC_UNONAME_UIREPR, 0, cppu::UnoType<OUString>::get(), 0, 0 },
|
|
{ SC_UNONAME_XLA1REPR, 0, cppu::UnoType<OUString>::get(), 0, 0 },
|
|
};
|
|
static uno::Reference<beans::XPropertySetInfo> aRef(new SfxItemPropertySetInfo( aPropertyMap ));
|
|
return aRef;
|
|
}
|
|
else
|
|
{
|
|
static const SfxItemPropertyMapEntry aPropertyMap[] =
|
|
{
|
|
{ SC_UNONAME_ADDRESS, 0, cppu::UnoType<table::CellAddress>::get(), 0, 0 },
|
|
{ SC_UNONAME_PERSREPR, 0, cppu::UnoType<OUString>::get(), 0, 0 },
|
|
{ SC_UNONAME_XLA1REPR, 0, cppu::UnoType<OUString>::get(), 0, 0 },
|
|
{ SC_UNONAME_REFSHEET, 0, cppu::UnoType<sal_Int32>::get(), 0, 0 },
|
|
{ SC_UNONAME_UIREPR, 0, cppu::UnoType<OUString>::get(), 0, 0 },
|
|
{ SC_UNONAME_XLA1REPR, 0, cppu::UnoType<OUString>::get(), 0, 0 },
|
|
};
|
|
static uno::Reference<beans::XPropertySetInfo> aRef(new SfxItemPropertySetInfo( aPropertyMap ));
|
|
return aRef;
|
|
}
|
|
}
|
|
|
|
void SAL_CALL ScAddressConversionObj::setPropertyValue( const OUString& aPropertyName, const uno::Any& aValue )
|
|
{
|
|
if ( !pDocShell )
|
|
throw uno::RuntimeException();
|
|
|
|
bool bSuccess = false;
|
|
if ( aPropertyName == SC_UNONAME_ADDRESS )
|
|
{
|
|
// read the cell/range address from API struct
|
|
if ( bIsRange )
|
|
{
|
|
table::CellRangeAddress aRangeAddress;
|
|
if ( aValue >>= aRangeAddress )
|
|
{
|
|
ScUnoConversion::FillScRange( aRange, aRangeAddress );
|
|
bSuccess = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
table::CellAddress aCellAddress;
|
|
if ( aValue >>= aCellAddress )
|
|
{
|
|
ScUnoConversion::FillScAddress( aRange.aStart, aCellAddress );
|
|
bSuccess = true;
|
|
}
|
|
}
|
|
}
|
|
else if ( aPropertyName == SC_UNONAME_REFSHEET )
|
|
{
|
|
// set the reference sheet
|
|
sal_Int32 nIntVal = 0;
|
|
if ( aValue >>= nIntVal )
|
|
{
|
|
nRefSheet = nIntVal;
|
|
bSuccess = true;
|
|
}
|
|
}
|
|
else if ( aPropertyName == SC_UNONAME_UIREPR )
|
|
{
|
|
// parse the UI representation string
|
|
OUString sRepresentation;
|
|
if (aValue >>= sRepresentation)
|
|
{
|
|
bSuccess = ParseUIString( sRepresentation );
|
|
}
|
|
}
|
|
else if ( aPropertyName == SC_UNONAME_PERSREPR || aPropertyName == SC_UNONAME_XLA1REPR )
|
|
{
|
|
::formula::FormulaGrammar::AddressConvention eConv = aPropertyName == SC_UNONAME_XLA1REPR ?
|
|
::formula::FormulaGrammar::CONV_XL_A1 : ::formula::FormulaGrammar::CONV_OOO;
|
|
|
|
// parse the file format string
|
|
OUString sRepresentation;
|
|
if (aValue >>= sRepresentation)
|
|
{
|
|
OUString aUIString(sRepresentation);
|
|
|
|
// cell or range: strip a single "." at the start
|
|
if ( aUIString[0]== '.' )
|
|
aUIString = aUIString.copy( 1 );
|
|
|
|
if ( bIsRange )
|
|
{
|
|
// range: also strip a "." after the last colon
|
|
sal_Int32 nColon = aUIString.lastIndexOf( ':' );
|
|
if ( nColon >= 0 && nColon < aUIString.getLength() - 1 &&
|
|
aUIString[nColon+1] == '.' )
|
|
aUIString = aUIString.replaceAt( nColon+1, 1, u"" );
|
|
}
|
|
|
|
// parse the rest like a UI string
|
|
bSuccess = ParseUIString( aUIString, eConv );
|
|
}
|
|
}
|
|
else
|
|
throw beans::UnknownPropertyException(aPropertyName);
|
|
|
|
if ( !bSuccess )
|
|
throw lang::IllegalArgumentException();
|
|
}
|
|
|
|
uno::Any SAL_CALL ScAddressConversionObj::getPropertyValue( const OUString& aPropertyName )
|
|
{
|
|
if ( !pDocShell )
|
|
throw uno::RuntimeException();
|
|
|
|
ScDocument& rDoc = pDocShell->GetDocument();
|
|
uno::Any aRet;
|
|
|
|
if ( aPropertyName == SC_UNONAME_ADDRESS )
|
|
{
|
|
if ( bIsRange )
|
|
{
|
|
table::CellRangeAddress aRangeAddress;
|
|
ScUnoConversion::FillApiRange( aRangeAddress, aRange );
|
|
aRet <<= aRangeAddress;
|
|
}
|
|
else
|
|
{
|
|
table::CellAddress aCellAddress;
|
|
ScUnoConversion::FillApiAddress( aCellAddress, aRange.aStart );
|
|
aRet <<= aCellAddress;
|
|
}
|
|
}
|
|
else if ( aPropertyName == SC_UNONAME_REFSHEET )
|
|
{
|
|
aRet <<= nRefSheet;
|
|
}
|
|
else if ( aPropertyName == SC_UNONAME_UIREPR )
|
|
{
|
|
// generate UI representation string - include sheet only if different from ref sheet
|
|
OUString aFormatStr;
|
|
ScRefFlags nFlags = ScRefFlags::VALID;
|
|
if ( aRange.aStart.Tab() != nRefSheet )
|
|
nFlags |= ScRefFlags::TAB_3D;
|
|
if ( bIsRange )
|
|
aFormatStr = aRange.Format(rDoc, nFlags);
|
|
else
|
|
aFormatStr = aRange.aStart.Format(nFlags, &rDoc);
|
|
aRet <<= aFormatStr;
|
|
}
|
|
else if ( aPropertyName == SC_UNONAME_PERSREPR || aPropertyName == SC_UNONAME_XLA1REPR )
|
|
{
|
|
::formula::FormulaGrammar::AddressConvention eConv = aPropertyName == SC_UNONAME_XLA1REPR ?
|
|
::formula::FormulaGrammar::CONV_XL_A1 : ::formula::FormulaGrammar::CONV_OOO;
|
|
|
|
// generate file format string - always include sheet
|
|
OUString aFormatStr(aRange.aStart.Format(ScRefFlags::VALID | ScRefFlags::TAB_3D, &rDoc, eConv));
|
|
if ( bIsRange )
|
|
{
|
|
// manually concatenate range so both parts always have the sheet name
|
|
aFormatStr += ":";
|
|
ScRefFlags nFlags = ScRefFlags::VALID;
|
|
if( eConv != ::formula::FormulaGrammar::CONV_XL_A1 )
|
|
nFlags |= ScRefFlags::TAB_3D;
|
|
OUString aSecond(aRange.aEnd.Format(nFlags, &rDoc, eConv));
|
|
aFormatStr += aSecond ;
|
|
}
|
|
aRet <<= aFormatStr;
|
|
}
|
|
else
|
|
throw beans::UnknownPropertyException(aPropertyName);
|
|
|
|
return aRet;
|
|
}
|
|
|
|
SC_IMPL_DUMMY_PROPERTY_LISTENER( ScAddressConversionObj )
|
|
|
|
// lang::XServiceInfo
|
|
|
|
OUString SAL_CALL ScAddressConversionObj::getImplementationName()
|
|
{
|
|
return u"ScAddressConversionObj"_ustr;
|
|
}
|
|
|
|
sal_Bool SAL_CALL ScAddressConversionObj::supportsService( const OUString& rServiceName )
|
|
{
|
|
return cppu::supportsService(this, rServiceName);
|
|
}
|
|
|
|
uno::Sequence<OUString> SAL_CALL ScAddressConversionObj::getSupportedServiceNames()
|
|
{
|
|
if (bIsRange)
|
|
return {SC_SERVICENAME_RANGEADDRESS};
|
|
else
|
|
return {SC_SERVICENAME_CELLADDRESS};
|
|
}
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|