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