sc/source/ui/unoobj/addruno.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 #include <com/sun/star/table/CellAddress.hpp>
  21 #include <com/sun/star/table/CellRangeAddress.hpp>
  22 #include <cppuhelper/supportsservice.hxx>
  23
  24 #include <svl/itemprop.hxx>
  25 #include <vcl/svapp.hxx>
  26
  27 #include <docsh.hxx>
  28 #include <unonames.hxx>
  29 #include <miscuno.hxx>
  30 #include <convuno.hxx>
  31 #include <addruno.hxx>
  32
  33 using namespace com::sun::star;
  34
  35 ScAddressConversionObj::ScAddressConversionObj(ScDocShell* pDocSh, bool _bIsRange) :
  36     pDocShell( pDocSh ),
  37     nRefSheet( 0 ),
  38     bIsRange( _bIsRange )
  39 {
  40     pDocShell->GetDocument().AddUnoObject(*this);
  41 }
  42
  43 ScAddressConversionObj::~ScAddressConversionObj()
  44 {
  45     SolarMutexGuard g;
  46
  47     if (pDocShell)
  48         pDocShell->GetDocument().RemoveUnoObject(*this);
  49 }
  50
  51 void ScAddressConversionObj::Notify( SfxBroadcaster&, const SfxHint& rHint )
  52 {
  53     if ( rHint.GetId() == SfxHintId::Dying )
  54     {
  55         pDocShell = nullptr;       // invalid
  56     }
  57 }
  58
  59 bool ScAddressConversionObj::ParseUIString( const OUString& rUIString, ::formula::FormulaGrammar::AddressConvention eConv )
  60 {
  61     if (!pDocShell)
  62         return false;
  63
  64     ScDocument& rDoc = pDocShell->GetDocument();
  65     bool bSuccess = false;
  66     if ( bIsRange )
  67     {
  68         ScRefFlags nResult = aRange.ParseAny( rUIString, rDoc, eConv );
  69         if ( nResult & ScRefFlags::VALID )
  70         {
  71             if ( ( nResult & ScRefFlags::TAB_3D ) == ScRefFlags::ZERO )
  72                 aRange.aStart.SetTab( static_cast<SCTAB>(nRefSheet) );
  73             if ( ( nResult & ScRefFlags::TAB2_3D ) == ScRefFlags::ZERO )
  74                 aRange.aEnd.SetTab( aRange.aStart.Tab() );
  75             // different sheets are not supported in CellRangeAddress
  76             if ( aRange.aStart.Tab() == aRange.aEnd.Tab() )
  77                 bSuccess = true;
  78         }
  79     }
  80     else
  81     {
  82         ScRefFlags nResult = aRange.aStart.Parse( rUIString, rDoc, eConv );
  83         if ( nResult & ScRefFlags::VALID )
  84         {
  85             if ( ( nResult & ScRefFlags::TAB_3D ) == ScRefFlags::ZERO )
  86                 aRange.aStart.SetTab( static_cast<SCTAB>(nRefSheet) );
  87             bSuccess = true;
  88         }
  89     }
  90     return bSuccess;
  91 }
  92
  93 // XPropertySet
  94
  95 uno::Reference<beans::XPropertySetInfo> SAL_CALL ScAddressConversionObj::getPropertySetInfo()
  96 {
  97     SolarMutexGuard aGuard;
  98
  99     if ( bIsRange )
 100     {
 101         static const SfxItemPropertyMapEntry aPropertyMap[] =
 102         {
 103             { SC_UNONAME_ADDRESS,  0,  cppu::UnoType<table::CellRangeAddress>::get(), 0, 0 },
 104             { SC_UNONAME_PERSREPR, 0,  cppu::UnoType<OUString>::get(),    0, 0 },
 105             { SC_UNONAME_XLA1REPR, 0,  cppu::UnoType<OUString>::get(),    0, 0 },
 106             { SC_UNONAME_REFSHEET, 0,  cppu::UnoType<sal_Int32>::get(),        0, 0 },
 107             { SC_UNONAME_UIREPR,   0,  cppu::UnoType<OUString>::get(),    0, 0 },
 108             { SC_UNONAME_XLA1REPR, 0,  cppu::UnoType<OUString>::get(),    0, 0 },
 109         };
 110         static uno::Reference<beans::XPropertySetInfo> aRef(new SfxItemPropertySetInfo( aPropertyMap ));
 111         return aRef;
 112     }
 113     else
 114     {
 115         static const SfxItemPropertyMapEntry aPropertyMap[] =
 116         {
 117             { SC_UNONAME_ADDRESS,  0,  cppu::UnoType<table::CellAddress>::get(), 0, 0 },
 118             { SC_UNONAME_PERSREPR, 0,  cppu::UnoType<OUString>::get(),    0, 0 },
 119             { SC_UNONAME_XLA1REPR, 0,  cppu::UnoType<OUString>::get(),    0, 0 },
 120             { SC_UNONAME_REFSHEET, 0,  cppu::UnoType<sal_Int32>::get(),        0, 0 },
 121             { SC_UNONAME_UIREPR,   0,  cppu::UnoType<OUString>::get(),    0, 0 },
 122             { SC_UNONAME_XLA1REPR, 0,  cppu::UnoType<OUString>::get(),    0, 0 },
 123         };
 124         static uno::Reference<beans::XPropertySetInfo> aRef(new SfxItemPropertySetInfo( aPropertyMap ));
 125         return aRef;
 126     }
 127 }
 128
 129 void SAL_CALL ScAddressConversionObj::setPropertyValue( const OUString& aPropertyName, const uno::Any& aValue )
 130 {
 131     if ( !pDocShell )
 132         throw uno::RuntimeException();
 133
 134     bool bSuccess = false;
 135     if ( aPropertyName == SC_UNONAME_ADDRESS )
 136     {
 137         //  read the cell/range address from API struct
 138         if ( bIsRange )
 139         {
 140             table::CellRangeAddress aRangeAddress;
 141             if ( aValue >>= aRangeAddress )
 142             {
 143                 ScUnoConversion::FillScRange( aRange, aRangeAddress );
 144                 bSuccess = true;
 145             }
 146         }
 147         else
 148         {
 149             table::CellAddress aCellAddress;
 150             if ( aValue >>= aCellAddress )
 151             {
 152                 ScUnoConversion::FillScAddress( aRange.aStart, aCellAddress );
 153                 bSuccess = true;
 154             }
 155         }
 156     }
 157     else if ( aPropertyName == SC_UNONAME_REFSHEET )
 158     {
 159         //  set the reference sheet
 160         sal_Int32 nIntVal = 0;
 161         if ( aValue >>= nIntVal )
 162         {
 163             nRefSheet = nIntVal;
 164             bSuccess = true;
 165         }
 166     }
 167     else if ( aPropertyName == SC_UNONAME_UIREPR )
 168     {
 169         //  parse the UI representation string
 170         OUString sRepresentation;
 171         if (aValue >>= sRepresentation)
 172         {
 173             bSuccess = ParseUIString( sRepresentation );
 174         }
 175     }
 176     else if ( aPropertyName == SC_UNONAME_PERSREPR || aPropertyName == SC_UNONAME_XLA1REPR )
 177     {
 178         ::formula::FormulaGrammar::AddressConvention eConv = aPropertyName == SC_UNONAME_XLA1REPR ?
 179             ::formula::FormulaGrammar::CONV_XL_A1 : ::formula::FormulaGrammar::CONV_OOO;
 180
 181         //  parse the file format string
 182         OUString sRepresentation;
 183         if (aValue >>= sRepresentation)
 184         {
 185             OUString aUIString(sRepresentation);
 186
 187             //  cell or range: strip a single "." at the start
 188             if ( aUIString[0]== '.' )
 189                 aUIString = aUIString.copy( 1 );
 190
 191             if ( bIsRange )
 192             {
 193                 //  range: also strip a "." after the last colon
 194                 sal_Int32 nColon = aUIString.lastIndexOf( ':' );
 195                 if ( nColon >= 0 && nColon < aUIString.getLength() - 1 &&
 196                      aUIString[nColon+1] == '.' )
 197                     aUIString = aUIString.replaceAt( nColon+1, 1, u"" );
 198             }
 199
 200             //  parse the rest like a UI string
 201             bSuccess = ParseUIString( aUIString, eConv );
 202         }
 203     }
 204     else
 205         throw beans::UnknownPropertyException(aPropertyName);
 206
 207     if ( !bSuccess )
 208         throw lang::IllegalArgumentException();
 209 }
 210
 211 uno::Any SAL_CALL ScAddressConversionObj::getPropertyValue( const OUString& aPropertyName )
 212 {
 213     if ( !pDocShell )
 214         throw uno::RuntimeException();
 215
 216     ScDocument& rDoc = pDocShell->GetDocument();
 217     uno::Any aRet;
 218
 219     if ( aPropertyName == SC_UNONAME_ADDRESS )
 220     {
 221         if ( bIsRange )
 222         {
 223             table::CellRangeAddress aRangeAddress;
 224             ScUnoConversion::FillApiRange( aRangeAddress, aRange );
 225             aRet <<= aRangeAddress;
 226         }
 227         else
 228         {
 229             table::CellAddress aCellAddress;
 230             ScUnoConversion::FillApiAddress( aCellAddress, aRange.aStart );
 231             aRet <<= aCellAddress;
 232         }
 233     }
 234     else if ( aPropertyName == SC_UNONAME_REFSHEET )
 235     {
 236         aRet <<= nRefSheet;
 237     }
 238     else if ( aPropertyName == SC_UNONAME_UIREPR )
 239     {
 240         //  generate UI representation string - include sheet only if different from ref sheet
 241         OUString aFormatStr;
 242         ScRefFlags nFlags = ScRefFlags::VALID;
 243         if ( aRange.aStart.Tab() != nRefSheet )
 244             nFlags |= ScRefFlags::TAB_3D;
 245         if ( bIsRange )
 246             aFormatStr = aRange.Format(rDoc, nFlags);
 247         else
 248             aFormatStr = aRange.aStart.Format(nFlags, &rDoc);
 249         aRet <<= aFormatStr;
 250     }
 251     else if ( aPropertyName == SC_UNONAME_PERSREPR || aPropertyName == SC_UNONAME_XLA1REPR )
 252     {
 253         ::formula::FormulaGrammar::AddressConvention eConv = aPropertyName == SC_UNONAME_XLA1REPR ?
 254             ::formula::FormulaGrammar::CONV_XL_A1 : ::formula::FormulaGrammar::CONV_OOO;
 255
 256         //  generate file format string - always include sheet
 257         OUString aFormatStr(aRange.aStart.Format(ScRefFlags::VALID | ScRefFlags::TAB_3D, &rDoc, eConv));
 258         if ( bIsRange )
 259         {
 260             //  manually concatenate range so both parts always have the sheet name
 261             aFormatStr += ":";
 262             ScRefFlags nFlags = ScRefFlags::VALID;
 263             if( eConv != ::formula::FormulaGrammar::CONV_XL_A1 )
 264                 nFlags |= ScRefFlags::TAB_3D;
 265             OUString aSecond(aRange.aEnd.Format(nFlags, &rDoc, eConv));
 266             aFormatStr += aSecond ;
 267         }
 268         aRet <<= aFormatStr;
 269     }
 270     else
 271         throw beans::UnknownPropertyException(aPropertyName);
 272
 273     return aRet;
 274 }
 275
 276 SC_IMPL_DUMMY_PROPERTY_LISTENER( ScAddressConversionObj )
 277
 278 // lang::XServiceInfo
 279
 280 OUString SAL_CALL ScAddressConversionObj::getImplementationName()
 281 {
 282     return u"ScAddressConversionObj"_ustr;
 283 }
 284
 285 sal_Bool SAL_CALL ScAddressConversionObj::supportsService( const OUString& rServiceName )
 286 {
 287     return cppu::supportsService(this, rServiceName);
 288 }
 289
 290 uno::Sequence<OUString> SAL_CALL ScAddressConversionObj::getSupportedServiceNames()
 291 {
 292     if (bIsRange)
 293         return {SC_SERVICENAME_RANGEADDRESS};
 294     else
 295         return {SC_SERVICENAME_CELLADDRESS};
 296 }
 297
 298 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */