sc/source/ui/vba/vbaformat.cxx

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