sc/source/ui/vba/vbaformat.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 #include "vbaformat.hxx"
  20 #include <ooo/vba/excel/XFont.hpp>
  21 #include <ooo/vba/excel/XStyle.hpp>
  22 #include <ooo/vba/excel/XlVAlign.hpp>
  23 #include <ooo/vba/excel/XlHAlign.hpp>
  24 #include <ooo/vba/excel/XlOrientation.hpp>
  25 #include <ooo/vba/excel/Constants.hpp>
  26 #include <ooo/vba/excel/XRange.hpp>
  27 #include <com/sun/star/table/CellVertJustify2.hpp>
  28 #include <com/sun/star/table/CellHoriJustify.hpp>
  29 #include <com/sun/star/table/CellOrientation.hpp>
  30 #include <com/sun/star/table/XCellRange.hpp>
  31 #include <com/sun/star/text/WritingMode.hpp>
  32 #include <com/sun/star/util/CellProtection.hpp>
  33 #include <com/sun/star/util/XNumberFormatsSupplier.hpp>
  34 #include <com/sun/star/util/XNumberFormats.hpp>
  35 #include <com/sun/star/util/XNumberFormatTypes.hpp>
  36 #include <com/sun/star/frame/XModel.hpp>
  37
  38 #include <basic/sberrors.hxx>
  39 #include <rtl/math.hxx>
  40
  41 #include "excelvbahelper.hxx"
  42 #include "vbaborders.hxx"
  43 #include "vbapalette.hxx"
  44 #include "vbafont.hxx"
  45 #include "vbainterior.hxx"
  46
  47 #include <docsh.hxx>
  48 #include <unonames.hxx>
  49 #include <cellsuno.hxx>
  50 #include <scitems.hxx>
  51 #include <attrib.hxx>
  52 #include <utility>
  53
  54 using namespace ::ooo::vba;
  55 using namespace ::com::sun::star;
  56
  57 constexpr OUString FORMATSTRING = u"FormatString"_ustr;
  58 constexpr OUString LOCALE = u"Locale"_ustr;
  59
  60 template< typename... Ifc >
  61 ScVbaFormat< Ifc... >::ScVbaFormat( const uno::Reference< XHelperInterface >& xParent,
  62                                     const uno::Reference< uno::XComponentContext > & xContext,
  63                                     uno::Reference< beans::XPropertySet >  _xPropertySet,
  64                                     uno::Reference< frame::XModel > xModel,
  65                                     bool bCheckAmbiguoity )
  66     : ScVbaFormat_BASE( xParent, xContext ),
  67       m_aDefaultLocale( u"en"_ustr, u"US"_ustr, OUString() ),
  68       mxPropertySet(std::move( _xPropertySet )),
  69       mxModel(std::move( xModel )),
  70       mbCheckAmbiguoity( bCheckAmbiguoity ),
  71       mbAddIndent( false )
  72 {
  73     try
  74     {
  75         if ( !mxModel.is() )
  76             DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, u"XModel Interface could not be retrieved" );
  77         // mxServiceInfo is unused,
  78         // mxNumberFormatsSupplier is initialized when needed in initializeNumberFormats.
  79     }
  80     catch (const uno::Exception& )
  81     {
  82         DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {} );
  83     }
  84 }
  85
  86 template< typename... Ifc >
  87 void SAL_CALL
  88 ScVbaFormat< Ifc... >::setVerticalAlignment( const uno::Any& _oAlignment)
  89 {
  90     try
  91     {
  92         uno::Any aVal;
  93         sal_Int32 nAlignment = 0;
  94         if ( !(_oAlignment >>= nAlignment ))
  95             throw uno::RuntimeException();
  96         switch (nAlignment)
  97         {
  98             case excel::XlVAlign::xlVAlignBottom :
  99                 aVal <<= table::CellVertJustify2::BOTTOM;
 100                 break;
 101             case excel::XlVAlign::xlVAlignCenter :
 102                 aVal <<= table::CellVertJustify2::CENTER;
 103                 break;
 104             case excel::XlVAlign::xlVAlignDistributed:
 105             case excel::XlVAlign::xlVAlignJustify:
 106                 aVal <<= table::CellVertJustify2::STANDARD;
 107                 break;
 108
 109             case excel::XlVAlign::xlVAlignTop:
 110                 aVal <<= table::CellVertJustify2::TOP;
 111                 break;
 112             default:
 113                 aVal <<= table::CellVertJustify2::STANDARD;
 114                 break;
 115         }
 116         mxPropertySet->setPropertyValue( SC_UNONAME_CELLVJUS, aVal );
 117     }
 118     catch (const uno::Exception&)
 119     {
 120         DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {});
 121     }
 122 }
 123
 124 template< typename... Ifc >
 125 uno::Any SAL_CALL
 126 ScVbaFormat< Ifc... >::getVerticalAlignment(  )
 127 {
 128     uno::Any aResult = aNULL();
 129     try
 130     {
 131         if (!isAmbiguous( SC_UNONAME_CELLVJUS ) )
 132         {
 133             sal_Int32 aAPIAlignment = table::CellVertJustify2::STANDARD;
 134             mxPropertySet->getPropertyValue( SC_UNONAME_CELLVJUS ) >>= aAPIAlignment;
 135             switch( aAPIAlignment )
 136             {
 137                 case table::CellVertJustify2::BOTTOM:
 138                 case table::CellVertJustify2::STANDARD:
 139                     aResult <<= excel::XlVAlign::xlVAlignBottom;
 140                     break;
 141                 case table::CellVertJustify2::CENTER:
 142                     aResult <<= excel::XlVAlign::xlVAlignCenter;
 143                     break;
 144                 case table::CellVertJustify2::TOP:
 145                     aResult <<= excel::XlVAlign::xlVAlignTop;
 146                     break;
 147                 default:
 148                     break;
 149             }
 150         }
 151     }
 152     catch (const uno::Exception& )
 153     {
 154         DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {});
 155     }
 156     return aResult;
 157 }
 158
 159 template< typename... Ifc >
 160 void SAL_CALL
 161 ScVbaFormat< Ifc... >::setHorizontalAlignment( const uno::Any& HorizontalAlignment )
 162 {
 163     try
 164     {
 165         uno::Any aVal;
 166         sal_Int32 nAlignment = 0;
 167         if ( !( HorizontalAlignment >>= nAlignment ) )
 168             throw uno::RuntimeException();
 169         switch ( nAlignment )
 170         {
 171             case excel::XlHAlign::xlHAlignJustify:
 172             case excel::XlHAlign::xlHAlignDistributed:
 173                 aVal <<= table::CellHoriJustify_BLOCK;
 174                 break;
 175             case excel::XlHAlign::xlHAlignCenter:
 176                 aVal <<= table::CellHoriJustify_CENTER;
 177                 break;
 178             case excel::XlHAlign::xlHAlignLeft:
 179                 aVal <<= table::CellHoriJustify_LEFT;
 180                 break;
 181             case excel::XlHAlign::xlHAlignRight:
 182                 aVal <<= table::CellHoriJustify_RIGHT;
 183                 break;
 184         }
 185         // #FIXME what about the default case above?
 186         // shouldn't need the test below
 187         if ( aVal.hasValue() )
 188             mxPropertySet->setPropertyValue( SC_UNONAME_CELLHJUS, aVal );
 189     }
 190     catch (const uno::Exception& )
 191     {
 192         DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {} );
 193     }
 194
 195 }
 196
 197 template< typename... Ifc >
 198 uno::Any SAL_CALL
 199 ScVbaFormat< Ifc... >::getHorizontalAlignment(  )
 200 {
 201     uno::Any NRetAlignment = aNULL();
 202     try
 203     {
 204         OUString sHoriJust( SC_UNONAME_CELLHJUS );
 205         if (!isAmbiguous(sHoriJust))
 206         {
 207             table::CellHoriJustify aAPIAlignment = table::CellHoriJustify_BLOCK;
 208
 209             if ( mxPropertySet->getPropertyValue(sHoriJust) >>= aAPIAlignment )
 210             {
 211                 switch( aAPIAlignment )
 212                 {
 213                     case table::CellHoriJustify_BLOCK:
 214                         NRetAlignment <<= excel::XlHAlign::xlHAlignJustify;
 215                         break;
 216                     case table::CellHoriJustify_CENTER:
 217                         NRetAlignment <<= excel::XlHAlign::xlHAlignCenter;
 218                         break;
 219                     case table::CellHoriJustify_LEFT:
 220                         NRetAlignment <<= excel::XlHAlign::xlHAlignLeft;
 221                         break;
 222                     case table::CellHoriJustify_RIGHT:
 223                         NRetAlignment <<= excel::XlHAlign::xlHAlignRight;
 224                         break;
 225                      default: // handle those other cases with a NULL return
 226                         break;
 227                 }
 228             }
 229         }
 230     }
 231     catch (const uno::Exception& )
 232     {
 233         DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {} );
 234     }
 235     return NRetAlignment;
 236 }
 237
 238 template< typename... Ifc >
 239 void SAL_CALL
 240 ScVbaFormat< Ifc... >::setOrientation( const uno::Any& _aOrientation )
 241 {
 242     try
 243     {
 244         sal_Int32 nOrientation = 0;
 245         if ( !( _aOrientation >>= nOrientation ) )
 246             throw uno::RuntimeException();
 247         uno::Any aVal;
 248         switch( nOrientation )
 249         {
 250             case excel::XlOrientation::xlDownward:
 251                 aVal <<= table::CellOrientation_TOPBOTTOM;
 252                 break;
 253             case excel::XlOrientation::xlHorizontal:
 254                 aVal <<= table::CellOrientation_STANDARD;
 255                 mxPropertySet->setPropertyValue( SC_UNONAME_ROTANG, uno::Any( sal_Int32(0) ) );
 256                 break;
 257             case excel::XlOrientation::xlUpward:
 258                 aVal <<= table::CellOrientation_BOTTOMTOP;
 259                 break;
 260             case excel::XlOrientation::xlVertical:
 261                 aVal <<= table::CellOrientation_STACKED;
 262                 break;
 263         }
 264         // #FIXME what about the default case above?
 265         // shouldn't need the test below
 266         if ( aVal.hasValue() )
 267             mxPropertySet->setPropertyValue( SC_UNONAME_CELLORI, aVal );
 268
 269     }
 270     catch (const uno::Exception& )
 271     {
 272         DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {} );
 273     }
 274 }
 275 template< typename... Ifc >
 276 uno::Any SAL_CALL
 277 ScVbaFormat< Ifc... >::getOrientation(  )
 278 {
 279     uno::Any NRetOrientation = aNULL();
 280     try
 281     {
 282         if (!isAmbiguous(SC_UNONAME_CELLORI))
 283         {
 284             table::CellOrientation aOrientation = table::CellOrientation_STANDARD;
 285             if ( !(  mxPropertySet->getPropertyValue( SC_UNONAME_CELLORI ) >>= aOrientation ) )
 286                 throw uno::RuntimeException();
 287
 288             switch(aOrientation)
 289             {
 290                 case table::CellOrientation_STANDARD:
 291                     NRetOrientation <<= excel::XlOrientation::xlHorizontal;
 292                     break;
 293                 case table::CellOrientation_BOTTOMTOP:
 294                     NRetOrientation <<= excel::XlOrientation::xlUpward;
 295                     break;
 296                 case table::CellOrientation_TOPBOTTOM:
 297                     NRetOrientation <<= excel::XlOrientation::xlDownward;
 298                     break;
 299                 case table::CellOrientation_STACKED:
 300                     NRetOrientation <<= excel::XlOrientation::xlVertical;
 301                     break;
 302                 default:
 303                     NRetOrientation <<= excel::XlOrientation::xlHorizontal;
 304             }
 305         }
 306     }
 307     catch (const uno::Exception& )
 308     {
 309         DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {});
 310     }
 311     return NRetOrientation;
 312 }
 313
 314 template< typename... Ifc >
 315 void SAL_CALL
 316 ScVbaFormat< Ifc... >::setWrapText( const uno::Any& _aWrapText )
 317 {
 318     try
 319     {
 320         mxPropertySet->setPropertyValue( SC_UNONAME_WRAP, _aWrapText);
 321     }
 322     catch (const uno::Exception& )
 323     {
 324         DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {} );
 325     }
 326 }
 327
 328 template< typename... Ifc >
 329 uno::Any SAL_CALL
 330 ScVbaFormat< Ifc... >::getWrapText(  )
 331 {
 332     uno::Any aWrap = aNULL();
 333     try
 334     {
 335         OUString aPropName( SC_UNONAME_WRAP );
 336         if (!isAmbiguous( aPropName ))
 337         {
 338             aWrap = mxPropertySet->getPropertyValue(aPropName);
 339         }
 340     }
 341     catch (const uno::Exception&)
 342     {
 343         DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {} );
 344     }
 345     return aWrap;
 346 }
 347
 348 template< typename... Ifc >
 349 uno::Any SAL_CALL
 350 ScVbaFormat< Ifc... >::Borders( const uno::Any& Index )
 351 {
 352     ScVbaPalette aPalette( excel::getDocShell( mxModel ) );
 353     uno::Reference< XCollection > xColl =  new ScVbaBorders( thisHelperIface(), ScVbaFormat_BASE::mxContext, uno::Reference< table::XCellRange >( mxPropertySet, uno::UNO_QUERY_THROW ), aPalette );
 354
 355     if ( Index.hasValue() )
 356     {
 357         return xColl->Item( Index, uno::Any() );
 358     }
 359     return uno::Any( xColl );
 360 }
 361
 362 template< typename... Ifc >
 363 uno::Reference< excel::XFont > SAL_CALL
 364 ScVbaFormat< Ifc... >::Font(  )
 365 {
 366     ScVbaPalette aPalette( excel::getDocShell( mxModel ) );
 367     return new ScVbaFont( thisHelperIface(), ScVbaFormat_BASE::mxContext, aPalette, mxPropertySet );
 368 }
 369
 370 template< typename... Ifc >
 371 uno::Reference< excel::XInterior > SAL_CALL
 372 ScVbaFormat< Ifc... >::Interior(  )
 373 {
 374     return new ScVbaInterior( thisHelperIface(), ScVbaFormat_BASE::mxContext, mxPropertySet );
 375 }
 376
 377 template< typename... Ifc >
 378 uno::Any SAL_CALL
 379 ScVbaFormat< Ifc... >::getNumberFormatLocal(  )
 380 {
 381     uno::Any aRet{ OUString() };
 382     try
 383     {
 384         OUString sPropName( SC_UNO_DP_NUMBERFO );
 385         if (!isAmbiguous( sPropName ))
 386         {
 387
 388             initializeNumberFormats();
 389
 390             sal_Int32 nFormat = 0;
 391             if ( ! (mxPropertySet->getPropertyValue( sPropName ) >>= nFormat ) )
 392                 throw uno::RuntimeException();
 393
 394             OUString sFormat;
 395             xNumberFormats->getByKey(nFormat)->getPropertyValue( FORMATSTRING ) >>= sFormat;
 396             aRet <<= sFormat.toAsciiLowerCase();
 397
 398         }
 399     }
 400     catch (const uno::Exception&)
 401     {
 402         DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {});
 403     }
 404     return aRet;
 405
 406 }
 407
 408 template< typename... Ifc >
 409 void SAL_CALL
 410 ScVbaFormat< Ifc... >::setNumberFormatLocal( const uno::Any& _oLocalFormatString )
 411 {
 412     try
 413     {
 414         OUString sLocalFormatString;
 415         sal_Int32 nFormat = -1;
 416         OUString sNumFormat( SC_UNO_DP_NUMBERFO );
 417         if ( !(_oLocalFormatString >>= sLocalFormatString )
 418         || !( mxPropertySet->getPropertyValue(sNumFormat) >>= nFormat ) )
 419             throw uno::RuntimeException();
 420
 421         sLocalFormatString = sLocalFormatString.toAsciiUpperCase();
 422         initializeNumberFormats();
 423         lang::Locale aRangeLocale;
 424         xNumberFormats->getByKey(nFormat)->getPropertyValue( LOCALE ) >>= aRangeLocale;
 425         sal_Int32 nNewFormat = xNumberFormats->queryKey(sLocalFormatString, aRangeLocale, true);
 426
 427         if (nNewFormat == -1)
 428             nNewFormat = xNumberFormats->addNew(sLocalFormatString, aRangeLocale);
 429         mxPropertySet->setPropertyValue(sNumFormat, uno::Any( nNewFormat ));
 430     }
 431     catch (const uno::Exception& )
 432     {
 433         DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {} );
 434     }
 435 }
 436
 437 template< typename... Ifc >
 438 void SAL_CALL
 439 ScVbaFormat< Ifc... >::setNumberFormat( const uno::Any& _oFormatString )
 440 {
 441     try
 442     {
 443         OUString sFormatString;
 444         if ( !( _oFormatString >>= sFormatString ) )
 445             throw uno::RuntimeException();
 446
 447         sFormatString = sFormatString.toAsciiUpperCase();
 448
 449         lang::Locale aDefaultLocale = m_aDefaultLocale;
 450         initializeNumberFormats();
 451         sal_Int32 nFormat = xNumberFormats->queryKey(sFormatString, aDefaultLocale, true);
 452
 453         if (nFormat == -1)
 454             nFormat = xNumberFormats->addNew(sFormatString, aDefaultLocale);
 455
 456         lang::Locale aRangeLocale;
 457         xNumberFormats->getByKey(nFormat)->getPropertyValue( LOCALE ) >>= aRangeLocale;
 458         sal_Int32 nNewFormat = xNumberFormatTypes->getFormatForLocale(nFormat, aRangeLocale);
 459         mxPropertySet->setPropertyValue( SC_UNO_DP_NUMBERFO, uno::Any( nNewFormat));
 460     }
 461     catch (const uno::Exception& )
 462     {
 463         DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {});
 464     }
 465
 466 }
 467
 468 template< typename... Ifc >
 469 void SAL_CALL
 470 ScVbaFormat< Ifc... >::setIndentLevel( const uno::Any& _aLevel )
 471 {
 472     try
 473     {
 474         sal_Int32 nLevel = 0;
 475         if ( !(_aLevel >>= nLevel ) )
 476             throw uno::RuntimeException();
 477         table::CellHoriJustify aAPIAlignment = table::CellHoriJustify_STANDARD;
 478
 479         OUString sHoriJust( SC_UNONAME_CELLHJUS );
 480         if ( !( mxPropertySet->getPropertyValue(sHoriJust) >>= aAPIAlignment ) )
 481             throw uno::RuntimeException();
 482         if (aAPIAlignment == table::CellHoriJustify_STANDARD)
 483             mxPropertySet->setPropertyValue( sHoriJust, uno::Any( table::CellHoriJustify_LEFT) ) ;
 484         mxPropertySet->setPropertyValue( SC_UNONAME_PINDENT, uno::Any( sal_Int16(nLevel * 352.8) ) );
 485     }
 486     catch (const uno::Exception&)
 487     {
 488         DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {});
 489     }
 490 }
 491
 492 template< typename... Ifc >
 493 uno::Any SAL_CALL
 494 ScVbaFormat< Ifc... >::getIndentLevel(  )
 495 {
 496     uno::Any NRetIndentLevel = aNULL();
 497     try
 498     {
 499         OUString sParaIndent( SC_UNONAME_PINDENT );
 500         if (!isAmbiguous(sParaIndent))
 501         {
 502             sal_Int16 IndentLevel = 0;
 503             if ( mxPropertySet->getPropertyValue(sParaIndent) >>= IndentLevel )
 504                 NRetIndentLevel <<= sal_Int32( rtl::math::round(static_cast<double>( IndentLevel ) / 352.8));
 505             else
 506                 NRetIndentLevel <<= sal_Int32(0);
 507         }
 508     }
 509     catch (const uno::Exception&)
 510     {
 511         DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {});
 512     }
 513     return NRetIndentLevel;
 514 }
 515
 516 template< typename... Ifc >
 517 void SAL_CALL
 518 ScVbaFormat< Ifc... >::setLocked( const uno::Any& _aLocked )
 519 {
 520     try
 521     {
 522         bool bIsLocked = false;
 523         if ( !( _aLocked >>= bIsLocked ) )
 524             throw uno::RuntimeException();
 525         util::CellProtection aCellProtection;
 526         OUString sCellProt( SC_UNONAME_CELLPRO );
 527         mxPropertySet->getPropertyValue(sCellProt) >>= aCellProtection;
 528         aCellProtection.IsLocked = bIsLocked;
 529         mxPropertySet->setPropertyValue(sCellProt, uno::Any( aCellProtection ) );
 530     }
 531     catch (const uno::Exception&)
 532     {
 533         DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {} );
 534     }
 535 }
 536
 537 template< typename... Ifc >
 538 void SAL_CALL
 539 ScVbaFormat< Ifc... >::setFormulaHidden( const uno::Any& FormulaHidden )
 540 {
 541     try
 542     {
 543         bool bIsFormulaHidden = false;
 544         FormulaHidden >>= bIsFormulaHidden;
 545         util::CellProtection aCellProtection;
 546         OUString sCellProt( SC_UNONAME_CELLPRO );
 547         mxPropertySet->getPropertyValue(sCellProt) >>= aCellProtection;
 548         aCellProtection.IsFormulaHidden = bIsFormulaHidden;
 549         mxPropertySet->setPropertyValue(sCellProt,uno::Any(aCellProtection));
 550     }
 551     catch (const uno::Exception&)
 552     {
 553         DebugHelper::basicexception( ERRCODE_BASIC_METHOD_FAILED, {} );
 554     }
 555 }
 556
 557 template< typename... Ifc >
 558 uno::Any SAL_CALL
 559 ScVbaFormat< Ifc... >::getLocked(  )
 560 {
 561     uno::Any aCellProtection = aNULL();
 562     try
 563     {
 564         OUString sCellProt( SC_UNONAME_CELLPRO );
 565
 566         if (!isAmbiguous(sCellProt))
 567         {
 568             SfxItemSet* pDataSet = getCurrentDataSet();
 569             if ( pDataSet )
 570             {
 571                 const ScProtectionAttr& rProtAttr = pDataSet->Get(ATTR_PROTECTION);
 572                 SfxItemState eState = pDataSet->GetItemState(ATTR_PROTECTION);
 573                 if(eState != SfxItemState::INVALID)
 574                     aCellProtection <<= rProtAttr.GetProtection();
 575             }
 576             else // fallback to propertyset
 577             {
 578                 util::CellProtection cellProtection;
 579                 mxPropertySet->getPropertyValue(sCellProt) >>= cellProtection;
 580                 aCellProtection <<= cellProtection.IsLocked;
 581             }
 582         }
 583     }
 584     catch (const uno::Exception&)
 585     {
 586         DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {});
 587     }
 588     return aCellProtection;
 589 }
 590
 591 template< typename... Ifc >
 592 uno::Any SAL_CALL
 593 ScVbaFormat< Ifc... >::getFormulaHidden(  )
 594 {
 595     uno::Any aBoolRet = aNULL();
 596     try
 597     {
 598         OUString sCellProt( SC_UNONAME_CELLPRO );
 599         if (!isAmbiguous(sCellProt))
 600         {
 601             SfxItemSet* pDataSet = getCurrentDataSet();
 602             if ( pDataSet )
 603             {
 604                 const ScProtectionAttr& rProtAttr = pDataSet->Get(ATTR_PROTECTION);
 605                 SfxItemState eState = pDataSet->GetItemState(ATTR_PROTECTION);
 606                 if(eState != SfxItemState::INVALID)
 607                     aBoolRet <<= rProtAttr.GetHideFormula();
 608             }
 609             else
 610             {
 611                 util::CellProtection aCellProtection;
 612                 mxPropertySet->getPropertyValue(sCellProt) >>= aCellProtection;
 613                 aBoolRet <<= aCellProtection.IsFormulaHidden;
 614             }
 615         }
 616     }
 617     catch (const uno::Exception&)
 618     {
 619         DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {});
 620     }
 621     return aBoolRet;
 622 }
 623
 624 template< typename... Ifc >
 625 void SAL_CALL
 626 ScVbaFormat< Ifc... >::setShrinkToFit( const uno::Any& ShrinkToFit )
 627 {
 628     try
 629     {
 630         mxPropertySet->setPropertyValue( SC_UNONAME_SHRINK_TO_FIT, ShrinkToFit);
 631     }
 632     catch (const uno::Exception& )
 633     {
 634         DebugHelper::basicexception(ERRCODE_BASIC_NOT_IMPLEMENTED, {} );
 635     }
 636
 637 }
 638
 639 template< typename... Ifc >
 640 uno::Any SAL_CALL
 641 ScVbaFormat< Ifc... >::getShrinkToFit(  )
 642 {
 643     uno::Any aRet = aNULL();
 644     try
 645     {
 646         OUString sShrinkToFit( SC_UNONAME_SHRINK_TO_FIT );
 647         if (!isAmbiguous(sShrinkToFit))
 648             aRet = mxPropertySet->getPropertyValue(sShrinkToFit);
 649     }
 650     catch (const uno::Exception& )
 651     {
 652         DebugHelper::basicexception(ERRCODE_BASIC_NOT_IMPLEMENTED, {});
 653     }
 654     return aRet;
 655 }
 656
 657 template< typename... Ifc >
 658 void SAL_CALL
 659 ScVbaFormat< Ifc... >::setReadingOrder( const uno::Any& ReadingOrder )
 660 {
 661     try
 662     {
 663         sal_Int32 nReadingOrder = 0;
 664         if ( !(ReadingOrder >>= nReadingOrder ))
 665             throw uno::RuntimeException();
 666         uno::Any aVal = aNULL();
 667         switch(nReadingOrder)
 668         {
 669             case excel::Constants::xlLTR:
 670                 aVal <<= sal_Int16(text::WritingMode_LR_TB);
 671                 break;
 672             case excel::Constants::xlRTL:
 673                 aVal <<= sal_Int16(text::WritingMode_RL_TB);
 674                 break;
 675             case excel::Constants::xlContext:
 676                 // TODO implement xlContext
 677                 // Reading order has to depend on the language of the first letter
 678                 // written.
 679                 aVal <<= sal_Int16(text::WritingMode_LR_TB);
 680                 break;
 681             default:
 682                 DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {});
 683         }
 684         mxPropertySet->setPropertyValue( SC_UNONAME_WRITING, aVal );
 685     }
 686     catch (const uno::Exception& )
 687     {
 688         DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {});
 689     }
 690
 691 }
 692
 693 template< typename... Ifc >
 694 uno::Any SAL_CALL
 695 ScVbaFormat< Ifc... >::getReadingOrder(  )
 696 {
 697     uno::Any NRetReadingOrder = aNULL();
 698     try
 699     {
 700         OUString sWritingMode( SC_UNONAME_WRITING );
 701         if (!isAmbiguous(sWritingMode))
 702         {
 703             text::WritingMode aWritingMode = text::WritingMode_LR_TB;
 704             if ( ( mxPropertySet->getPropertyValue(sWritingMode) ) >>= aWritingMode )
 705                 switch (aWritingMode)
 706                 {
 707                     case text::WritingMode_LR_TB:
 708                         NRetReadingOrder <<= excel::Constants::xlLTR;
 709                         break;
 710                     case text::WritingMode_RL_TB:
 711                         NRetReadingOrder <<= excel::Constants::xlRTL;
 712                         break;
 713                     default:
 714                         NRetReadingOrder <<= excel::Constants::xlRTL;
 715                 }
 716         }
 717     }
 718     catch (const uno::Exception& )
 719     {
 720         DebugHelper::basicexception(ERRCODE_BASIC_NOT_IMPLEMENTED, {});
 721     }
 722     return NRetReadingOrder;
 723
 724 }
 725
 726 template< typename... Ifc >
 727 uno::Any SAL_CALL
 728 ScVbaFormat< Ifc... >::getNumberFormat(  )
 729 {
 730     uno::Any aFormat = aNULL();
 731     try
 732     {
 733         sal_Int32 nFormat = -1;
 734         OUString sNumFormat( SC_UNO_DP_NUMBERFO );
 735         if (!isAmbiguous(sNumFormat) &&
 736             ( mxPropertySet->getPropertyValue(sNumFormat) >>= nFormat) )
 737         {
 738             initializeNumberFormats();
 739
 740             sal_Int32 nNewFormat = xNumberFormatTypes->getFormatForLocale(nFormat, m_aDefaultLocale );
 741             OUString sFormat;
 742             xNumberFormats->getByKey(nNewFormat)->getPropertyValue( FORMATSTRING ) >>= sFormat;
 743             aFormat <<= sFormat;
 744         }
 745     }
 746     catch (const uno::Exception& )
 747     {
 748         DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {});
 749     }
 750     return aFormat;
 751 }
 752
 753 template< typename... Ifc >
 754 bool
 755 ScVbaFormat< Ifc... >::isAmbiguous(const OUString& _sPropertyName)
 756 {
 757     bool bResult = false;
 758     try
 759     {
 760         if (mbCheckAmbiguoity)
 761             bResult = ( getXPropertyState()->getPropertyState(_sPropertyName) == beans::PropertyState_AMBIGUOUS_VALUE );
 762     }
 763     catch (const uno::Exception& )
 764     {
 765         DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, {});
 766     }
 767     return bResult;
 768 }
 769
 770 template< typename... Ifc >
 771 void
 772 ScVbaFormat< Ifc... >::initializeNumberFormats()
 773 {
 774     if ( !xNumberFormats.is() )
 775     {
 776         mxNumberFormatsSupplier.set( mxModel, uno::UNO_QUERY_THROW );
 777         xNumberFormats = mxNumberFormatsSupplier->getNumberFormats();
 778         xNumberFormatTypes.set( xNumberFormats, uno::UNO_QUERY ); // _THROW?
 779     }
 780 }
 781
 782 template< typename... Ifc >
 783 uno::Reference< beans::XPropertyState > const &
 784 ScVbaFormat< Ifc... >::getXPropertyState()
 785 {
 786     if ( !xPropertyState.is() )
 787         xPropertyState.set( mxPropertySet, uno::UNO_QUERY_THROW );
 788     return xPropertyState;
 789 }
 790
 791 template< typename... Ifc >
 792 ScCellRangesBase*
 793 ScVbaFormat< Ifc... >::getCellRangesBase()
 794 {
 795     return dynamic_cast<ScCellRangesBase*>( mxPropertySet.get() );
 796 }
 797
 798 template< typename... Ifc >
 799 SfxItemSet*
 800 ScVbaFormat< Ifc... >::getCurrentDataSet()
 801 {
 802     SfxItemSet* pDataSet = excel::ScVbaCellRangeAccess::GetDataSet( getCellRangesBase() );
 803     if ( !pDataSet )
 804         throw uno::RuntimeException(u"Can't access Itemset for XPropertySet"_ustr );
 805     return pDataSet;
 806 }
 807
 808 template class ScVbaFormat< excel::XStyle >;
 809 template class ScVbaFormat< excel::XRange >;
 810
 811 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */