LCOV - code coverage report
Current view: top level - sc/source/ui/unoobj - afmtuno.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 392 0.0 %
Date: 2014-04-14 Functions: 0 67 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : #include "scitems.hxx"
      21             : #include <editeng/memberids.hrc>
      22             : #include <tools/shl.hxx>
      23             : #include <svl/poolitem.hxx>
      24             : #include <vcl/svapp.hxx>
      25             : #include <svx/unomid.hxx>
      26             : #include "unowids.hxx"
      27             : #include <comphelper/servicehelper.hxx>
      28             : #include <com/sun/star/table/BorderLine.hpp>
      29             : #include <com/sun/star/table/CellVertJustify2.hpp>
      30             : #include <com/sun/star/table/ShadowLocation.hpp>
      31             : #include <com/sun/star/table/TableBorder.hpp>
      32             : #include <com/sun/star/table/ShadowFormat.hpp>
      33             : #include <com/sun/star/table/CellRangeAddress.hpp>
      34             : #include <com/sun/star/table/CellContentType.hpp>
      35             : #include <com/sun/star/table/TableOrientation.hpp>
      36             : #include <com/sun/star/table/CellHoriJustify.hpp>
      37             : #include <com/sun/star/util/SortField.hpp>
      38             : #include <com/sun/star/util/SortFieldType.hpp>
      39             : #include <com/sun/star/table/CellOrientation.hpp>
      40             : #include <com/sun/star/table/CellAddress.hpp>
      41             : #include <com/sun/star/awt/SimpleFontMetric.hpp>
      42             : #include <com/sun/star/awt/FontWeight.hpp>
      43             : #include <com/sun/star/awt/FontSlant.hpp>
      44             : #include <com/sun/star/awt/CharSet.hpp>
      45             : #include <com/sun/star/awt/FontDescriptor.hpp>
      46             : #include <com/sun/star/awt/FontWidth.hpp>
      47             : #include <com/sun/star/awt/XFont.hpp>
      48             : #include <com/sun/star/awt/FontType.hpp>
      49             : #include <com/sun/star/awt/FontUnderline.hpp>
      50             : #include <com/sun/star/awt/FontStrikeout.hpp>
      51             : #include <com/sun/star/awt/FontFamily.hpp>
      52             : #include <com/sun/star/awt/FontPitch.hpp>
      53             : 
      54             : #include "afmtuno.hxx"
      55             : #include "miscuno.hxx"
      56             : #include "autoform.hxx"
      57             : #include "scdll.hxx"
      58             : #include "unonames.hxx"
      59             : #include "cellsuno.hxx"
      60             : 
      61             : using namespace ::com::sun::star;
      62             : 
      63             : //  ein AutoFormat hat immer 16 Eintraege
      64             : #define SC_AF_FIELD_COUNT 16
      65             : 
      66             : //  AutoFormat-Map nur fuer PropertySetInfo, ohne Which-IDs
      67             : 
      68           0 : static const SfxItemPropertyMapEntry* lcl_GetAutoFormatMap()
      69             : {
      70             :     static const SfxItemPropertyMapEntry aAutoFormatMap_Impl[] =
      71             :     {
      72           0 :         { OUString(SC_UNONAME_INCBACK),  0,  ::getBooleanCppuType(),    0, 0 },
      73           0 :         { OUString(SC_UNONAME_INCBORD),  0,  ::getBooleanCppuType(),    0, 0 },
      74           0 :         { OUString(SC_UNONAME_INCFONT),  0,  ::getBooleanCppuType(),    0, 0 },
      75           0 :         { OUString(SC_UNONAME_INCJUST),  0,  ::getBooleanCppuType(),    0, 0 },
      76           0 :         { OUString(SC_UNONAME_INCNUM),   0,  ::getBooleanCppuType(),    0, 0 },
      77           0 :         { OUString(SC_UNONAME_INCWIDTH), 0,  ::getBooleanCppuType(),    0, 0 },
      78             :         { OUString(), 0, css::uno::Type(), 0, 0 }
      79           0 :     };
      80           0 :     return aAutoFormatMap_Impl;
      81             : }
      82             : 
      83             : //! Zahlformat (String/Language) ??? (in XNumberFormat nur ReadOnly)
      84             : //! table::TableBorder ??!?
      85             : 
      86           0 : static const SfxItemPropertyMapEntry* lcl_GetAutoFieldMap()
      87             : {
      88             :     static const SfxItemPropertyMapEntry aAutoFieldMap_Impl[] =
      89             :     {
      90           0 :         {OUString(SC_UNONAME_CELLBACK), ATTR_BACKGROUND,        ::getCppuType((const sal_Int32*)0),        0, MID_BACK_COLOR },
      91           0 :         {OUString(SC_UNONAME_CCOLOR),   ATTR_FONT_COLOR,        ::getCppuType((const sal_Int32*)0),        0, 0 },
      92           0 :         {OUString(SC_UNONAME_COUTL),    ATTR_FONT_CONTOUR,      ::getBooleanCppuType(),                    0, 0 },
      93           0 :         {OUString(SC_UNONAME_CCROSS),   ATTR_FONT_CROSSEDOUT,   ::getBooleanCppuType(),                    0, MID_CROSSED_OUT },
      94           0 :         {OUString(SC_UNONAME_CFONT),    ATTR_FONT,              ::getCppuType((const sal_Int16*)0),        0, MID_FONT_FAMILY },
      95           0 :         {OUString(SC_UNONAME_CFCHARS),  ATTR_FONT,              ::getCppuType((sal_Int16*)0),              0, MID_FONT_CHAR_SET },
      96           0 :         {OUString(SC_UNO_CJK_CFCHARS),  ATTR_CJK_FONT,          ::getCppuType((sal_Int16*)0),              0, MID_FONT_CHAR_SET },
      97           0 :         {OUString(SC_UNO_CTL_CFCHARS),  ATTR_CTL_FONT,          ::getCppuType((sal_Int16*)0),              0, MID_FONT_CHAR_SET },
      98           0 :         {OUString(SC_UNONAME_CFFAMIL),  ATTR_FONT,              ::getCppuType((sal_Int16*)0),              0, MID_FONT_FAMILY },
      99           0 :         {OUString(SC_UNO_CJK_CFFAMIL),  ATTR_CJK_FONT,          ::getCppuType((sal_Int16*)0),              0, MID_FONT_FAMILY },
     100           0 :         {OUString(SC_UNO_CTL_CFFAMIL),  ATTR_CTL_FONT,          ::getCppuType((sal_Int16*)0),              0, MID_FONT_FAMILY },
     101           0 :         {OUString(SC_UNONAME_CFNAME),   ATTR_FONT,              ::getCppuType((OUString*)0),          0, MID_FONT_FAMILY_NAME },
     102           0 :         {OUString(SC_UNO_CJK_CFNAME),   ATTR_CJK_FONT,          ::getCppuType((OUString*)0),          0, MID_FONT_FAMILY_NAME },
     103           0 :         {OUString(SC_UNO_CTL_CFNAME),   ATTR_CTL_FONT,          ::getCppuType((OUString*)0),          0, MID_FONT_FAMILY_NAME },
     104           0 :         {OUString(SC_UNONAME_CFPITCH),  ATTR_FONT,              ::getCppuType((sal_Int16*)0),              0, MID_FONT_PITCH },
     105           0 :         {OUString(SC_UNO_CJK_CFPITCH),  ATTR_CJK_FONT,          ::getCppuType((sal_Int16*)0),              0, MID_FONT_PITCH },
     106           0 :         {OUString(SC_UNO_CTL_CFPITCH),  ATTR_CTL_FONT,          ::getCppuType((sal_Int16*)0),              0, MID_FONT_PITCH },
     107           0 :         {OUString(SC_UNONAME_CFSTYLE),  ATTR_FONT,              ::getCppuType((OUString*)0),          0, MID_FONT_STYLE_NAME },
     108           0 :         {OUString(SC_UNO_CJK_CFSTYLE),  ATTR_CJK_FONT,          ::getCppuType((OUString*)0),          0, MID_FONT_STYLE_NAME },
     109           0 :         {OUString(SC_UNO_CTL_CFSTYLE),  ATTR_CTL_FONT,          ::getCppuType((OUString*)0),          0, MID_FONT_STYLE_NAME },
     110           0 :         {OUString(SC_UNONAME_CHEIGHT),  ATTR_FONT_HEIGHT,       ::getCppuType((float*)0),                  0, MID_FONTHEIGHT | CONVERT_TWIPS },
     111           0 :         {OUString(SC_UNO_CJK_CHEIGHT),  ATTR_CJK_FONT_HEIGHT,   ::getCppuType((float*)0),                  0, MID_FONTHEIGHT | CONVERT_TWIPS },
     112           0 :         {OUString(SC_UNO_CTL_CHEIGHT),  ATTR_CTL_FONT_HEIGHT,   ::getCppuType((float*)0),                  0, MID_FONTHEIGHT | CONVERT_TWIPS },
     113           0 :         {OUString(SC_UNONAME_COVER),    ATTR_FONT_OVERLINE,     ::getCppuType((const sal_Int16*)0),        0, MID_TL_STYLE },
     114           0 :         {OUString(SC_UNONAME_CPOST),    ATTR_FONT_POSTURE,      ::getCppuType((awt::FontSlant*)0),         0, MID_POSTURE },
     115           0 :         {OUString(SC_UNO_CJK_CPOST),    ATTR_CJK_FONT_POSTURE,  ::getCppuType((awt::FontSlant*)0),         0, MID_POSTURE },
     116           0 :         {OUString(SC_UNO_CTL_CPOST),    ATTR_CTL_FONT_POSTURE,  ::getCppuType((awt::FontSlant*)0),         0, MID_POSTURE },
     117           0 :         {OUString(SC_UNONAME_CSHADD),   ATTR_FONT_SHADOWED,     ::getBooleanCppuType(),                    0, 0 },
     118           0 :         {OUString(SC_UNONAME_TBLBORD),  SC_WID_UNO_TBLBORD,     ::getCppuType((table::TableBorder*)0),     0, 0 | CONVERT_TWIPS },
     119           0 :         {OUString(SC_UNONAME_TBLBORD2),  SC_WID_UNO_TBLBORD2,     ::getCppuType((table::TableBorder2*)0),     0, 0 | CONVERT_TWIPS },
     120           0 :         {OUString(SC_UNONAME_CUNDER),   ATTR_FONT_UNDERLINE,    ::getCppuType((const sal_Int16*)0),        0, MID_TL_STYLE },
     121           0 :         {OUString(SC_UNONAME_CWEIGHT),  ATTR_FONT_WEIGHT,       ::getCppuType((float*)0),                  0, MID_WEIGHT },
     122           0 :         {OUString(SC_UNO_CJK_CWEIGHT),  ATTR_CJK_FONT_WEIGHT,   ::getCppuType((float*)0),                  0, MID_WEIGHT },
     123           0 :         {OUString(SC_UNO_CTL_CWEIGHT),  ATTR_CTL_FONT_WEIGHT,   ::getCppuType((float*)0),                  0, MID_WEIGHT },
     124           0 :         {OUString(SC_UNONAME_CELLHJUS), ATTR_HOR_JUSTIFY,       ::getCppuType((const table::CellHoriJustify*)0),   0, 0 },
     125           0 :         {OUString(SC_UNONAME_CELLHJUS_METHOD), ATTR_HOR_JUSTIFY_METHOD, ::getCppuType((const sal_Int32*)0),   0, 0 },
     126           0 :         {OUString(SC_UNONAME_CELLTRAN), ATTR_BACKGROUND,        ::getBooleanCppuType(),                    0, MID_GRAPHIC_TRANSPARENT },
     127           0 :         {OUString(SC_UNONAME_WRAP),     ATTR_LINEBREAK,         ::getBooleanCppuType(),                    0, 0 },
     128           0 :         {OUString(SC_UNONAME_CELLORI),  ATTR_STACKED,           ::getCppuType((const table::CellOrientation*)0),   0, 0 },
     129           0 :         {OUString(SC_UNONAME_PBMARGIN), ATTR_MARGIN,            ::getCppuType((const sal_Int32*)0),        0, MID_MARGIN_LO_MARGIN | CONVERT_TWIPS },
     130           0 :         {OUString(SC_UNONAME_PLMARGIN), ATTR_MARGIN,            ::getCppuType((const sal_Int32*)0),        0, MID_MARGIN_L_MARGIN  | CONVERT_TWIPS },
     131           0 :         {OUString(SC_UNONAME_PRMARGIN), ATTR_MARGIN,            ::getCppuType((const sal_Int32*)0),        0, MID_MARGIN_R_MARGIN  | CONVERT_TWIPS },
     132           0 :         {OUString(SC_UNONAME_PTMARGIN), ATTR_MARGIN,            ::getCppuType((const sal_Int32*)0),        0, MID_MARGIN_UP_MARGIN | CONVERT_TWIPS },
     133           0 :         {OUString(SC_UNONAME_ROTANG),   ATTR_ROTATE_VALUE,      ::getCppuType((const sal_Int32*)0),        0, 0 },
     134           0 :         {OUString(SC_UNONAME_ROTREF),   ATTR_ROTATE_MODE,       ::getCppuType((const sal_Int32*)0),   0, 0 },
     135           0 :         {OUString(SC_UNONAME_CELLVJUS), ATTR_VER_JUSTIFY,       ::getCppuType((const sal_Int32*)0),   0, 0 },
     136           0 :         {OUString(SC_UNONAME_CELLVJUS_METHOD), ATTR_VER_JUSTIFY_METHOD, ::getCppuType((const sal_Int32*)0),   0, 0 },
     137             :         { OUString(), 0, css::uno::Type(), 0, 0 }
     138           0 :     };
     139           0 :     return aAutoFieldMap_Impl;
     140             : }
     141             : 
     142             : #define SCAUTOFORMATSOBJ_SERVICE    "com.sun.star.sheet.TableAutoFormats"
     143             : 
     144           0 : SC_SIMPLE_SERVICE_INFO( ScAutoFormatFieldObj, "ScAutoFormatFieldObj", "com.sun.star.sheet.TableAutoFormatField" )
     145           0 : SC_SIMPLE_SERVICE_INFO( ScAutoFormatObj, "ScAutoFormatObj", "com.sun.star.sheet.TableAutoFormat" )
     146           0 : SC_SIMPLE_SERVICE_INFO( ScAutoFormatsObj, "ScAutoFormatsObj", SCAUTOFORMATSOBJ_SERVICE )
     147             : 
     148           0 : static bool lcl_FindAutoFormatIndex( const ScAutoFormat& rFormats, const OUString& rName, sal_uInt16& rOutIndex )
     149             : {
     150           0 :     ScAutoFormat::const_iterator itBeg = rFormats.begin(), itEnd = rFormats.end();
     151           0 :     for (ScAutoFormat::const_iterator it = itBeg; it != itEnd; ++it)
     152             :     {
     153           0 :         const ScAutoFormatData* pEntry = it->second;
     154           0 :         const OUString& aEntryName = pEntry->GetName();
     155           0 :         if ( aEntryName.equals(rName) )
     156             :         {
     157           0 :             size_t nPos = std::distance(itBeg, it);
     158           0 :             rOutIndex = nPos;
     159           0 :             return true;
     160             :         }
     161             :     }
     162           0 :     return false;       // is nich
     163             : }
     164             : 
     165           0 : ScAutoFormatsObj::ScAutoFormatsObj()
     166             : {
     167             :     //! Dieses Objekt darf es nur einmal geben, und es muss an den Auto-Format-Daten
     168             :     //! bekannt sein, damit Aenderungen gebroadcasted werden koennen
     169           0 : }
     170             : 
     171           0 : ScAutoFormatsObj::~ScAutoFormatsObj()
     172             : {
     173           0 : }
     174             : 
     175             : // stuff for exService_...
     176             : 
     177           0 : uno::Reference<uno::XInterface> SAL_CALL ScAutoFormatsObj_CreateInstance(
     178             :                         const uno::Reference<lang::XMultiServiceFactory>& )
     179             : {
     180           0 :     SolarMutexGuard aGuard;
     181           0 :     ScDLL::Init();
     182           0 :     static uno::Reference< uno::XInterface > xInst((::cppu::OWeakObject*) new ScAutoFormatsObj);
     183           0 :     return xInst;
     184             : }
     185             : 
     186           0 : OUString ScAutoFormatsObj::getImplementationName_Static()
     187             : {
     188           0 :     return OUString( "stardiv.StarCalc.ScAutoFormatsObj" );
     189             : }
     190             : 
     191           0 : uno::Sequence<OUString> ScAutoFormatsObj::getSupportedServiceNames_Static()
     192             : {
     193           0 :     uno::Sequence<OUString> aRet(1);
     194           0 :     OUString* pArray = aRet.getArray();
     195           0 :     pArray[0] = OUString( SCAUTOFORMATSOBJ_SERVICE );
     196           0 :     return aRet;
     197             : }
     198             : 
     199             : // XTableAutoFormats
     200             : 
     201           0 : ScAutoFormatObj* ScAutoFormatsObj::GetObjectByIndex_Impl(sal_uInt16 nIndex)
     202             : {
     203           0 :     if (nIndex < ScGlobal::GetOrCreateAutoFormat()->size())
     204           0 :         return new ScAutoFormatObj(nIndex);
     205             : 
     206           0 :     return NULL;    // falscher Index
     207             : }
     208             : 
     209           0 : ScAutoFormatObj* ScAutoFormatsObj::GetObjectByName_Impl(const OUString& aName)
     210             : {
     211           0 :     OUString aString(aName);
     212             :     sal_uInt16 nIndex;
     213           0 :     if (lcl_FindAutoFormatIndex(
     214           0 :             *ScGlobal::GetOrCreateAutoFormat(), aString, nIndex ))
     215           0 :         return GetObjectByIndex_Impl(nIndex);
     216           0 :     return NULL;
     217             : }
     218             : 
     219             : // container::XNameContainer
     220             : 
     221           0 : void SAL_CALL ScAutoFormatsObj::insertByName( const OUString& aName, const uno::Any& aElement )
     222             :                             throw (lang::IllegalArgumentException, container::ElementExistException,
     223             :                                    lang::WrappedTargetException, uno::RuntimeException,
     224             :                                    std::exception)
     225             : {
     226           0 :     SolarMutexGuard aGuard;
     227           0 :     sal_Bool bDone = false;
     228             :     //  Reflection muss nicht uno::XInterface sein, kann auch irgendein Interface sein...
     229           0 :     uno::Reference< uno::XInterface > xInterface(aElement, uno::UNO_QUERY);
     230           0 :     if ( xInterface.is() )
     231             :     {
     232           0 :         ScAutoFormatObj* pFormatObj = ScAutoFormatObj::getImplementation( xInterface );
     233           0 :         if ( pFormatObj && !pFormatObj->IsInserted() )  // noch nicht eingefuegt?
     234             :         {
     235           0 :             OUString aNameStr(aName);
     236           0 :             ScAutoFormat* pFormats = ScGlobal::GetOrCreateAutoFormat();
     237             : 
     238             :             sal_uInt16 nDummy;
     239           0 :             if (!lcl_FindAutoFormatIndex( *pFormats, aNameStr, nDummy ))
     240             :             {
     241           0 :                 ScAutoFormatData* pNew = new ScAutoFormatData();
     242           0 :                 pNew->SetName( aNameStr );
     243             : 
     244           0 :                 if (pFormats->insert(pNew))
     245             :                 {
     246             :                     //! Notify fuer andere Objekte
     247           0 :                     pFormats->Save();   // sofort speichern
     248             : 
     249             :                     sal_uInt16 nNewIndex;
     250           0 :                     if (lcl_FindAutoFormatIndex( *pFormats, aNameStr, nNewIndex ))
     251             :                     {
     252           0 :                         pFormatObj->InitFormat( nNewIndex );    // kann jetzt benutzt werden
     253           0 :                         bDone = sal_True;
     254             :                     }
     255             :                 }
     256             :                 else
     257             :                 {
     258             :                     OSL_FAIL("AutoFormat konnte nicht eingefuegt werden");
     259           0 :                     throw uno::RuntimeException();
     260             :                 }
     261             :             }
     262             :             else
     263             :             {
     264           0 :                 throw container::ElementExistException();
     265           0 :             }
     266             :         }
     267             :     }
     268             : 
     269           0 :     if (!bDone)
     270             :     {
     271             :         //  other errors are handled above
     272           0 :         throw lang::IllegalArgumentException();
     273           0 :     }
     274           0 : }
     275             : 
     276           0 : void SAL_CALL ScAutoFormatsObj::replaceByName( const OUString& aName, const uno::Any& aElement )
     277             :                             throw(lang::IllegalArgumentException, container::NoSuchElementException,
     278             :                                     lang::WrappedTargetException, uno::RuntimeException, std::exception)
     279             : {
     280           0 :     SolarMutexGuard aGuard;
     281             :     //! zusammenfassen?
     282           0 :     removeByName( aName );
     283           0 :     insertByName( aName, aElement );
     284           0 : }
     285             : 
     286           0 : void SAL_CALL ScAutoFormatsObj::removeByName( const OUString& aName )
     287             :                                 throw(container::NoSuchElementException,
     288             :                                     lang::WrappedTargetException, uno::RuntimeException, std::exception)
     289             : {
     290           0 :     SolarMutexGuard aGuard;
     291           0 :     ScAutoFormat* pFormats = ScGlobal::GetOrCreateAutoFormat();
     292             : 
     293           0 :     ScAutoFormat::iterator it = pFormats->find(aName);
     294           0 :     if (it != pFormats->end())
     295             :     {
     296           0 :         pFormats->erase(it);
     297             : 
     298             :         //! Notify fuer andere Objekte
     299           0 :         pFormats->Save();   // sofort speichern
     300             :     }
     301             :     else
     302             :     {
     303           0 :         throw container::NoSuchElementException();
     304           0 :     }
     305           0 : }
     306             : 
     307             : // container::XEnumerationAccess
     308             : 
     309           0 : uno::Reference<container::XEnumeration> SAL_CALL ScAutoFormatsObj::createEnumeration()
     310             :                                                     throw(uno::RuntimeException, std::exception)
     311             : {
     312           0 :     SolarMutexGuard aGuard;
     313           0 :     return new ScIndexEnumeration(this, OUString("com.sun.star.sheet.TableAutoFormatEnumeration"));
     314             : }
     315             : 
     316             : // container::XIndexAccess
     317             : 
     318           0 : sal_Int32 SAL_CALL ScAutoFormatsObj::getCount() throw(uno::RuntimeException, std::exception)
     319             : {
     320           0 :     SolarMutexGuard aGuard;
     321           0 :     return ScGlobal::GetOrCreateAutoFormat()->size();
     322             : }
     323             : 
     324           0 : uno::Any SAL_CALL ScAutoFormatsObj::getByIndex( sal_Int32 nIndex )
     325             :                             throw(lang::IndexOutOfBoundsException,
     326             :                                     lang::WrappedTargetException, uno::RuntimeException, std::exception)
     327             : {
     328           0 :     SolarMutexGuard aGuard;
     329           0 :     uno::Reference< container::XNamed >  xFormat(GetObjectByIndex_Impl((sal_uInt16)nIndex));
     330           0 :     if (!xFormat.is())
     331           0 :         throw lang::IndexOutOfBoundsException();
     332           0 :     return uno::makeAny(xFormat);
     333             : }
     334             : 
     335           0 : uno::Type SAL_CALL ScAutoFormatsObj::getElementType() throw(uno::RuntimeException, std::exception)
     336             : {
     337           0 :     SolarMutexGuard aGuard;
     338           0 :     return ::getCppuType((const uno::Reference< container::XNamed >*)0);    // muss zu getByIndex passen
     339             : }
     340             : 
     341           0 : sal_Bool SAL_CALL ScAutoFormatsObj::hasElements() throw(uno::RuntimeException, std::exception)
     342             : {
     343           0 :     SolarMutexGuard aGuard;
     344           0 :     return ( getCount() != 0 );
     345             : }
     346             : 
     347             : // container::XNameAccess
     348             : 
     349           0 : uno::Any SAL_CALL ScAutoFormatsObj::getByName( const OUString& aName )
     350             :             throw(container::NoSuchElementException,
     351             :                     lang::WrappedTargetException, uno::RuntimeException, std::exception)
     352             : {
     353           0 :     SolarMutexGuard aGuard;
     354           0 :     uno::Reference< container::XNamed >  xFormat(GetObjectByName_Impl(aName));
     355           0 :     if (!xFormat.is())
     356           0 :         throw container::NoSuchElementException();
     357           0 :     return uno::makeAny(xFormat);
     358             : }
     359             : 
     360           0 : uno::Sequence<OUString> SAL_CALL ScAutoFormatsObj::getElementNames()
     361             :                                                 throw(uno::RuntimeException, std::exception)
     362             : {
     363           0 :     SolarMutexGuard aGuard;
     364           0 :     ScAutoFormat* pFormats = ScGlobal::GetOrCreateAutoFormat();
     365           0 :     uno::Sequence<OUString> aSeq(pFormats->size());
     366           0 :     OUString* pAry = aSeq.getArray();
     367           0 :     ScAutoFormat::const_iterator it = pFormats->begin(), itEnd = pFormats->end();
     368           0 :     for (size_t i = 0; it != itEnd; ++it, ++i)
     369             :     {
     370           0 :         pAry[i] = it->second->GetName();
     371             :     }
     372           0 :     return aSeq;
     373             : }
     374             : 
     375           0 : sal_Bool SAL_CALL ScAutoFormatsObj::hasByName( const OUString& aName )
     376             :                                         throw(uno::RuntimeException, std::exception)
     377             : {
     378           0 :     SolarMutexGuard aGuard;
     379           0 :     OUString aString(aName);
     380             :     sal_uInt16 nDummy;
     381             :     return lcl_FindAutoFormatIndex(
     382           0 :         *ScGlobal::GetOrCreateAutoFormat(), aString, nDummy );
     383             : }
     384             : 
     385           0 : ScAutoFormatObj::ScAutoFormatObj(sal_uInt16 nIndex) :
     386             :     aPropSet( lcl_GetAutoFormatMap() ),
     387           0 :     nFormatIndex( nIndex )
     388             : {
     389             :     //! Listening !!!
     390           0 : }
     391             : 
     392           0 : ScAutoFormatObj::~ScAutoFormatObj()
     393             : {
     394             :     //  Wenn ein AutoFormat-Objekt losgelassen wird, werden eventuelle Aenderungen
     395             :     //  gespeichert, damit sie z.B. im Writer sichtbar sind
     396             : 
     397           0 :     if (IsInserted())
     398             :     {
     399           0 :         ScAutoFormat* pFormats = ScGlobal::GetAutoFormat();
     400           0 :         if ( pFormats && pFormats->IsSaveLater() )
     401           0 :             pFormats->Save();
     402             : 
     403             :         // Save() setzt SaveLater Flag zurueck
     404             :     }
     405           0 : }
     406             : 
     407           0 : void ScAutoFormatObj::InitFormat( sal_uInt16 nNewIndex )
     408             : {
     409             :     OSL_ENSURE( nFormatIndex == SC_AFMTOBJ_INVALID, "ScAutoFormatObj::InitFormat mehrfach" );
     410           0 :     nFormatIndex = nNewIndex;
     411             :     //! Listening !!!
     412           0 : }
     413             : 
     414             : // XUnoTunnel
     415             : 
     416           0 : sal_Int64 SAL_CALL ScAutoFormatObj::getSomething(
     417             :                 const uno::Sequence<sal_Int8 >& rId ) throw(uno::RuntimeException, std::exception)
     418             : {
     419           0 :     if ( rId.getLength() == 16 &&
     420           0 :           0 == memcmp( getUnoTunnelId().getConstArray(),
     421           0 :                                     rId.getConstArray(), 16 ) )
     422             :     {
     423           0 :         return sal::static_int_cast<sal_Int64>(reinterpret_cast<sal_IntPtr>(this));
     424             :     }
     425           0 :     return 0;
     426             : }
     427             : 
     428             : namespace
     429             : {
     430             :     class theScAutoFormatObjUnoTunnelId : public rtl::Static< UnoTunnelIdInit, theScAutoFormatObjUnoTunnelId> {};
     431             : }
     432             : 
     433           0 : const uno::Sequence<sal_Int8>& ScAutoFormatObj::getUnoTunnelId()
     434             : {
     435           0 :     return theScAutoFormatObjUnoTunnelId::get().getSeq();
     436             : }
     437             : 
     438           0 : ScAutoFormatObj* ScAutoFormatObj::getImplementation(
     439             :                         const uno::Reference<uno::XInterface> xObj )
     440             : {
     441           0 :     ScAutoFormatObj* pRet = NULL;
     442           0 :     uno::Reference<lang::XUnoTunnel> xUT( xObj, uno::UNO_QUERY );
     443           0 :     if (xUT.is())
     444           0 :         pRet = reinterpret_cast<ScAutoFormatObj*>(sal::static_int_cast<sal_IntPtr>(xUT->getSomething(getUnoTunnelId())));
     445           0 :     return pRet;
     446             : }
     447             : 
     448           0 : void ScAutoFormatObj::Notify( SfxBroadcaster& /* rBC */, const SfxHint& /* rHint */ )
     449             : {
     450             :     //  spaeter...
     451           0 : }
     452             : 
     453             : // XTableAutoFormat
     454             : 
     455           0 : ScAutoFormatFieldObj* ScAutoFormatObj::GetObjectByIndex_Impl(sal_uInt16 nIndex)
     456             : {
     457           0 :     if ( IsInserted() && nIndex < SC_AF_FIELD_COUNT )
     458           0 :         return new ScAutoFormatFieldObj( nFormatIndex, nIndex );
     459             : 
     460           0 :     return NULL;
     461             : }
     462             : 
     463             : // container::XEnumerationAccess
     464             : 
     465           0 : uno::Reference<container::XEnumeration> SAL_CALL ScAutoFormatObj::createEnumeration()
     466             :                                                     throw(uno::RuntimeException, std::exception)
     467             : {
     468           0 :     SolarMutexGuard aGuard;
     469           0 :     return new ScIndexEnumeration(this, OUString("com.sun.star.sheet.TableAutoFormatEnumeration"));
     470             : }
     471             : 
     472             : // container::XIndexAccess
     473             : 
     474           0 : sal_Int32 SAL_CALL ScAutoFormatObj::getCount() throw(uno::RuntimeException, std::exception)
     475             : {
     476           0 :     SolarMutexGuard aGuard;
     477           0 :     if (IsInserted())
     478           0 :         return SC_AF_FIELD_COUNT;   // immer 16 Elemente
     479             :     else
     480           0 :         return 0;
     481             : }
     482             : 
     483           0 : uno::Any SAL_CALL ScAutoFormatObj::getByIndex( sal_Int32 nIndex )
     484             :                             throw(lang::IndexOutOfBoundsException,
     485             :                                     lang::WrappedTargetException, uno::RuntimeException, std::exception)
     486             : {
     487           0 :     SolarMutexGuard aGuard;
     488             : 
     489           0 :     if ( nIndex < 0 || nIndex >= getCount() )
     490           0 :         throw lang::IndexOutOfBoundsException();
     491             : 
     492           0 :     if (IsInserted())
     493           0 :         return uno::makeAny(uno::Reference< beans::XPropertySet >(GetObjectByIndex_Impl((sal_uInt16)nIndex)));
     494           0 :     return uno::Any();
     495             : }
     496             : 
     497           0 : uno::Type SAL_CALL ScAutoFormatObj::getElementType() throw(uno::RuntimeException, std::exception)
     498             : {
     499           0 :     SolarMutexGuard aGuard;
     500           0 :     return ::getCppuType((const uno::Reference< beans::XPropertySet >*)0);  // muss zu getByIndex passen
     501             : }
     502             : 
     503           0 : sal_Bool SAL_CALL ScAutoFormatObj::hasElements() throw(uno::RuntimeException, std::exception)
     504             : {
     505           0 :     SolarMutexGuard aGuard;
     506           0 :     return ( getCount() != 0 );
     507             : }
     508             : 
     509             : // container::XNamed
     510             : 
     511           0 : OUString SAL_CALL ScAutoFormatObj::getName() throw(uno::RuntimeException, std::exception)
     512             : {
     513           0 :     SolarMutexGuard aGuard;
     514           0 :     ScAutoFormat* pFormats = ScGlobal::GetOrCreateAutoFormat();
     515           0 :     if (IsInserted() && nFormatIndex < pFormats->size())
     516           0 :         return pFormats->findByIndex(nFormatIndex)->GetName();
     517             : 
     518           0 :     return OUString();
     519             : }
     520             : 
     521           0 : void SAL_CALL ScAutoFormatObj::setName( const OUString& aNewName )
     522             :     throw (uno::RuntimeException, std::exception)
     523             : {
     524           0 :     SolarMutexGuard aGuard;
     525           0 :     OUString aNewString(aNewName);
     526           0 :     ScAutoFormat* pFormats = ScGlobal::GetOrCreateAutoFormat();
     527             : 
     528             :     sal_uInt16 nDummy;
     529           0 :     if (IsInserted() && nFormatIndex < pFormats->size() &&
     530           0 :         !lcl_FindAutoFormatIndex( *pFormats, aNewName, nDummy ))
     531             :     {
     532           0 :         ScAutoFormat::iterator it = pFormats->begin();
     533           0 :         std::advance(it, nFormatIndex);
     534           0 :         ScAutoFormatData* pData = it->second;
     535             :         OSL_ENSURE(pData,"AutoFormat Daten nicht da");
     536             : 
     537           0 :         ScAutoFormatData* pNew = new ScAutoFormatData(*pData);
     538           0 :         pNew->SetName( aNewString );
     539             : 
     540           0 :         pFormats->erase(it);
     541           0 :         if (pFormats->insert(pNew))
     542             :         {
     543           0 :             it = pFormats->find(pNew);
     544           0 :             ScAutoFormat::iterator itBeg = pFormats->begin();
     545           0 :             nFormatIndex = std::distance(itBeg, it);
     546             : 
     547             :             //! Notify fuer andere Objekte
     548           0 :             pFormats->SetSaveLater(true);
     549             :         }
     550             :         else
     551             :         {
     552             :             OSL_FAIL("AutoFormat konnte nicht eingefuegt werden");
     553           0 :             nFormatIndex = 0;       //! alter Index ist ungueltig
     554             :         }
     555             :     }
     556             :     else
     557             :     {
     558             :         //  not inserted or name exists
     559           0 :         throw uno::RuntimeException();
     560           0 :     }
     561           0 : }
     562             : 
     563             : // beans::XPropertySet
     564             : 
     565           0 : uno::Reference<beans::XPropertySetInfo> SAL_CALL ScAutoFormatObj::getPropertySetInfo()
     566             :                                                         throw(uno::RuntimeException, std::exception)
     567             : {
     568           0 :     SolarMutexGuard aGuard;
     569           0 :     static uno::Reference< beans::XPropertySetInfo > aRef(new SfxItemPropertySetInfo( aPropSet.getPropertyMap() ));
     570           0 :     return aRef;
     571             : }
     572             : 
     573           0 : void SAL_CALL ScAutoFormatObj::setPropertyValue(
     574             :                         const OUString& aPropertyName, const uno::Any& aValue )
     575             :                 throw(beans::UnknownPropertyException, beans::PropertyVetoException,
     576             :                         lang::IllegalArgumentException, lang::WrappedTargetException,
     577             :                         uno::RuntimeException, std::exception)
     578             : {
     579           0 :     SolarMutexGuard aGuard;
     580           0 :     ScAutoFormat* pFormats = ScGlobal::GetOrCreateAutoFormat();
     581           0 :     if (IsInserted() && nFormatIndex < pFormats->size())
     582             :     {
     583           0 :         ScAutoFormatData* pData = pFormats->findByIndex(nFormatIndex);
     584             :         OSL_ENSURE(pData,"AutoFormat Daten nicht da");
     585             : 
     586           0 :         OUString aPropString(aPropertyName);
     587           0 :         sal_Bool bBool = sal_Bool();
     588           0 :         if (aPropString.equalsAscii( SC_UNONAME_INCBACK ) && (aValue >>= bBool))
     589           0 :             pData->SetIncludeBackground( bBool );
     590           0 :         else if (aPropString.equalsAscii( SC_UNONAME_INCBORD ) && (aValue >>= bBool))
     591           0 :             pData->SetIncludeFrame( bBool );
     592           0 :         else if (aPropString.equalsAscii( SC_UNONAME_INCFONT ) && (aValue >>= bBool))
     593           0 :             pData->SetIncludeFont( bBool );
     594           0 :         else if (aPropString.equalsAscii( SC_UNONAME_INCJUST ) && (aValue >>= bBool))
     595           0 :             pData->SetIncludeJustify( bBool );
     596           0 :         else if (aPropString.equalsAscii( SC_UNONAME_INCNUM ) && (aValue >>= bBool))
     597           0 :             pData->SetIncludeValueFormat( bBool );
     598           0 :         else if (aPropString.equalsAscii( SC_UNONAME_INCWIDTH ) && (aValue >>= bBool))
     599           0 :             pData->SetIncludeWidthHeight( bBool );
     600             : 
     601             :         // else Fehler
     602             : 
     603             :         //! Notify fuer andere Objekte
     604           0 :         pFormats->SetSaveLater(true);
     605           0 :     }
     606           0 : }
     607             : 
     608           0 : uno::Any SAL_CALL ScAutoFormatObj::getPropertyValue( const OUString& aPropertyName )
     609             :                 throw(beans::UnknownPropertyException, lang::WrappedTargetException,
     610             :                         uno::RuntimeException, std::exception)
     611             : {
     612           0 :     SolarMutexGuard aGuard;
     613           0 :     uno::Any aAny;
     614             : 
     615           0 :     ScAutoFormat* pFormats = ScGlobal::GetOrCreateAutoFormat();
     616           0 :     if (IsInserted() && nFormatIndex < pFormats->size())
     617             :     {
     618           0 :         ScAutoFormatData* pData = pFormats->findByIndex(nFormatIndex);
     619             :         OSL_ENSURE(pData,"AutoFormat Daten nicht da");
     620             : 
     621             :         sal_Bool bValue;
     622           0 :         sal_Bool bError = false;
     623             : 
     624           0 :         if (aPropertyName.equalsAscii( SC_UNONAME_INCBACK ))
     625           0 :             bValue = pData->GetIncludeBackground();
     626           0 :         else if (aPropertyName.equalsAscii( SC_UNONAME_INCBORD ))
     627           0 :             bValue = pData->GetIncludeFrame();
     628           0 :         else if (aPropertyName.equalsAscii( SC_UNONAME_INCFONT ))
     629           0 :             bValue = pData->GetIncludeFont();
     630           0 :         else if (aPropertyName.equalsAscii( SC_UNONAME_INCJUST ))
     631           0 :             bValue = pData->GetIncludeJustify();
     632           0 :         else if (aPropertyName.equalsAscii( SC_UNONAME_INCNUM ))
     633           0 :             bValue = pData->GetIncludeValueFormat();
     634           0 :         else if (aPropertyName.equalsAscii( SC_UNONAME_INCWIDTH ))
     635           0 :             bValue = pData->GetIncludeWidthHeight();
     636             :         else
     637           0 :             bError = sal_True;      // unbekannte Property
     638             : 
     639           0 :         if (!bError)
     640           0 :             aAny <<= bValue;
     641             :     }
     642             : 
     643           0 :     return aAny;
     644             : }
     645             : 
     646           0 : SC_IMPL_DUMMY_PROPERTY_LISTENER( ScAutoFormatObj )
     647             : 
     648           0 : ScAutoFormatFieldObj::ScAutoFormatFieldObj(sal_uInt16 nFormat, sal_uInt16 nField) :
     649             :     aPropSet( lcl_GetAutoFieldMap() ),
     650             :     nFormatIndex( nFormat ),
     651           0 :     nFieldIndex( nField )
     652             : {
     653             :     //! Listening !!!
     654           0 : }
     655             : 
     656           0 : ScAutoFormatFieldObj::~ScAutoFormatFieldObj()
     657             : {
     658           0 : }
     659             : 
     660           0 : void ScAutoFormatFieldObj::Notify( SfxBroadcaster& /* rBC */, const SfxHint& /* rHint */ )
     661             : {
     662             :     //  spaeter...
     663           0 : }
     664             : 
     665             : // beans::XPropertySet
     666             : 
     667           0 : uno::Reference<beans::XPropertySetInfo> SAL_CALL ScAutoFormatFieldObj::getPropertySetInfo()
     668             :                                                         throw(uno::RuntimeException, std::exception)
     669             : {
     670           0 :     SolarMutexGuard aGuard;
     671           0 :     static uno::Reference< beans::XPropertySetInfo > aRef(new SfxItemPropertySetInfo( aPropSet.getPropertyMap() ));
     672           0 :     return aRef;
     673             : }
     674             : 
     675           0 : void SAL_CALL ScAutoFormatFieldObj::setPropertyValue(
     676             :                         const OUString& aPropertyName, const uno::Any& aValue )
     677             :                 throw(beans::UnknownPropertyException, beans::PropertyVetoException,
     678             :                         lang::IllegalArgumentException, lang::WrappedTargetException,
     679             :                         uno::RuntimeException, std::exception)
     680             : {
     681           0 :     SolarMutexGuard aGuard;
     682           0 :     ScAutoFormat* pFormats = ScGlobal::GetOrCreateAutoFormat();
     683             :     const SfxItemPropertySimpleEntry* pEntry =
     684           0 :             aPropSet.getPropertyMap().getByName( aPropertyName );
     685             : 
     686           0 :     if ( pEntry && pEntry->nWID && nFormatIndex < pFormats->size() )
     687             :     {
     688           0 :         ScAutoFormatData* pData = pFormats->findByIndex(nFormatIndex);
     689             : 
     690           0 :         if ( IsScItemWid( pEntry->nWID ) )
     691             :         {
     692           0 :             if( const SfxPoolItem* pItem = pData->GetItem( nFieldIndex, pEntry->nWID ) )
     693             :             {
     694           0 :                 sal_Bool bDone = false;
     695             : 
     696           0 :                 switch( pEntry->nWID )
     697             :                 {
     698             :                     case ATTR_STACKED:
     699             :                     {
     700             :                         table::CellOrientation eOrient;
     701           0 :                         if( aValue >>= eOrient )
     702             :                         {
     703           0 :                             switch( eOrient )
     704             :                             {
     705             :                                 case table::CellOrientation_STANDARD:
     706           0 :                                     pData->PutItem( nFieldIndex, SfxBoolItem( ATTR_STACKED, false ) );
     707           0 :                                 break;
     708             :                                 case table::CellOrientation_TOPBOTTOM:
     709           0 :                                     pData->PutItem( nFieldIndex, SfxBoolItem( ATTR_STACKED, false ) );
     710           0 :                                     pData->PutItem( nFieldIndex, SfxInt32Item( ATTR_ROTATE_VALUE, 27000 ) );
     711           0 :                                 break;
     712             :                                 case table::CellOrientation_BOTTOMTOP:
     713           0 :                                     pData->PutItem( nFieldIndex, SfxBoolItem( ATTR_STACKED, false ) );
     714           0 :                                     pData->PutItem( nFieldIndex, SfxInt32Item( ATTR_ROTATE_VALUE, 9000 ) );
     715           0 :                                 break;
     716             :                                 case table::CellOrientation_STACKED:
     717           0 :                                     pData->PutItem( nFieldIndex, SfxBoolItem( ATTR_STACKED, true ) );
     718           0 :                                 break;
     719             :                                 default:
     720             :                                 {
     721             :                                     // added to avoid warnings
     722             :                                 }
     723             :                             }
     724           0 :                             bDone = sal_True;
     725             :                         }
     726             :                     }
     727           0 :                     break;
     728             :                     default:
     729           0 :                         SfxPoolItem* pNewItem = pItem->Clone();
     730           0 :                         bDone = pNewItem->PutValue( aValue, pEntry->nMemberId );
     731           0 :                         if (bDone)
     732           0 :                             pData->PutItem( nFieldIndex, *pNewItem );
     733           0 :                         delete pNewItem;
     734             :                 }
     735             : 
     736           0 :                 if (bDone)
     737             :                     //! Notify fuer andere Objekte?
     738           0 :                     pFormats->SetSaveLater(true);
     739             :             }
     740             :         }
     741             :         else
     742             :         {
     743           0 :             switch (pEntry->nWID)
     744             :             {
     745             :                 case SC_WID_UNO_TBLBORD:
     746             :                     {
     747           0 :                         table::TableBorder aBorder;
     748           0 :                         if ( aValue >>= aBorder )   // empty = nothing to do
     749             :                         {
     750           0 :                             SvxBoxItem aOuter(ATTR_BORDER);
     751           0 :                             SvxBoxInfoItem aInner(ATTR_BORDER_INNER);
     752           0 :                             ScHelperFunctions::FillBoxItems( aOuter, aInner, aBorder );
     753           0 :                             pData->PutItem( nFieldIndex, aOuter );
     754             : 
     755             :                             //! Notify for other objects?
     756           0 :                             pFormats->SetSaveLater(true);
     757             :                         }
     758             :                     }
     759           0 :                     break;
     760             :                 case SC_WID_UNO_TBLBORD2:
     761             :                     {
     762           0 :                         table::TableBorder2 aBorder2;
     763           0 :                         if ( aValue >>= aBorder2 )   // empty = nothing to do
     764             :                         {
     765           0 :                             SvxBoxItem aOuter(ATTR_BORDER);
     766           0 :                             SvxBoxInfoItem aInner(ATTR_BORDER_INNER);
     767           0 :                             ScHelperFunctions::FillBoxItems( aOuter, aInner, aBorder2 );
     768           0 :                             pData->PutItem( nFieldIndex, aOuter );
     769             : 
     770             :                             //! Notify for other objects?
     771           0 :                             pFormats->SetSaveLater(true);
     772             :                         }
     773             :                     }
     774           0 :                     break;
     775             :             }
     776             :         }
     777           0 :     }
     778           0 : }
     779             : 
     780           0 : uno::Any SAL_CALL ScAutoFormatFieldObj::getPropertyValue( const OUString& aPropertyName )
     781             :                 throw(beans::UnknownPropertyException, lang::WrappedTargetException,
     782             :                         uno::RuntimeException, std::exception)
     783             : {
     784           0 :     SolarMutexGuard aGuard;
     785           0 :     uno::Any aVal;
     786             : 
     787           0 :     ScAutoFormat* pFormats = ScGlobal::GetOrCreateAutoFormat();
     788             :     const SfxItemPropertySimpleEntry* pEntry =
     789           0 :             aPropSet.getPropertyMap().getByName( aPropertyName );
     790             : 
     791           0 :     if ( pEntry && pEntry->nWID && nFormatIndex < pFormats->size() )
     792             :     {
     793           0 :         const ScAutoFormatData* pData = pFormats->findByIndex(nFormatIndex);
     794             : 
     795           0 :         if ( IsScItemWid( pEntry->nWID ) )
     796             :         {
     797           0 :             if( const SfxPoolItem* pItem = pData->GetItem( nFieldIndex, pEntry->nWID ) )
     798             :             {
     799           0 :                 switch( pEntry->nWID )
     800             :                 {
     801             :                     case ATTR_STACKED:
     802             :                     {
     803           0 :                         const SfxInt32Item* pRotItem = (const SfxInt32Item*)pData->GetItem( nFieldIndex, ATTR_ROTATE_VALUE );
     804           0 :                         sal_Int32 nRot = pRotItem ? pRotItem->GetValue() : 0;
     805           0 :                         sal_Bool bStacked = ((const SfxBoolItem*)pItem)->GetValue();
     806           0 :                         SvxOrientationItem( nRot, bStacked, 0 ).QueryValue( aVal );
     807             :                     }
     808           0 :                     break;
     809             :                     default:
     810           0 :                         pItem->QueryValue( aVal, pEntry->nMemberId );
     811             :                 }
     812             :             }
     813             :         }
     814             :         else
     815             :         {
     816           0 :             switch (pEntry->nWID)
     817             :             {
     818             :                 case SC_WID_UNO_TBLBORD:
     819             :                 case SC_WID_UNO_TBLBORD2:
     820             :                     {
     821           0 :                         const SfxPoolItem* pItem = pData->GetItem(nFieldIndex, ATTR_BORDER);
     822           0 :                         if (pItem)
     823             :                         {
     824           0 :                             SvxBoxItem aOuter(*(static_cast<const SvxBoxItem*>(pItem)));
     825           0 :                             SvxBoxInfoItem aInner(ATTR_BORDER_INNER);
     826             : 
     827           0 :                             if (pEntry->nWID == SC_WID_UNO_TBLBORD2)
     828           0 :                                 ScHelperFunctions::AssignTableBorder2ToAny( aVal, aOuter, aInner);
     829             :                             else
     830           0 :                                 ScHelperFunctions::AssignTableBorderToAny( aVal, aOuter, aInner);
     831             :                         }
     832             :                     }
     833           0 :                     break;
     834             :             }
     835             :         }
     836             :     }
     837             : 
     838           0 :     return aVal;
     839             : }
     840             : 
     841           0 : SC_IMPL_DUMMY_PROPERTY_LISTENER( ScAutoFormatFieldObj )
     842             : 
     843             : 
     844             : 
     845             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10