LCOV - code coverage report
Current view: top level - sc/source/ui/unoobj - fielduno.cxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 451 728 62.0 %
Date: 2015-06-13 12:38:46 Functions: 64 94 68.1 %
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 "fielduno.hxx"
      21             : #include "textuno.hxx"
      22             : #include "miscuno.hxx"
      23             : #include "docsh.hxx"
      24             : #include "hints.hxx"
      25             : #include "editsrc.hxx"
      26             : #include "cellsuno.hxx"
      27             : #include "servuno.hxx"
      28             : #include "unonames.hxx"
      29             : #include "editutil.hxx"
      30             : 
      31             : #include <svl/smplhint.hxx>
      32             : #include <vcl/svapp.hxx>
      33             : 
      34             : #include <editeng/eeitem.hxx>
      35             : 
      36             : #include <editeng/editeng.hxx>
      37             : #include <editeng/editobj.hxx>
      38             : #include <editeng/flditem.hxx>
      39             : #include <comphelper/servicehelper.hxx>
      40             : #include <cppuhelper/supportsservice.hxx>
      41             : 
      42             : #include <com/sun/star/beans/PropertyAttribute.hpp>
      43             : #include <com/sun/star/text/TextContentAnchorType.hpp>
      44             : #include <com/sun/star/text/WrapTextMode.hpp>
      45             : #include <com/sun/star/text/FilenameDisplayFormat.hpp>
      46             : #include <com/sun/star/text/textfield/Type.hpp>
      47             : 
      48             : using namespace com::sun::star;
      49             : 
      50             : namespace {
      51             : 
      52             : //  alles ohne Which-ID, Map nur fuer PropertySetInfo
      53             : 
      54         353 : const SfxItemPropertySet* getDateTimePropertySet()
      55             : {
      56             :     static const SfxItemPropertyMapEntry aMapContent[] =
      57             :     {
      58          35 :         { OUString(SC_UNONAME_DATETIME), 0, cppu::UnoType<util::DateTime>::get(), 0, 0 },
      59          35 :         { OUString(SC_UNONAME_ISFIXED),  0, cppu::UnoType<bool>::get(),                  0, 0 },
      60          35 :         { OUString(SC_UNONAME_ISDATE),   0, cppu::UnoType<bool>::get(),                  0, 0 },
      61          35 :         { OUString(SC_UNONAME_NUMFMT),   0, cppu::UnoType<sal_Int32>::get(),      0, 0 },
      62             :         { OUString(), 0, css::uno::Type(), 0, 0 }
      63         528 :     };
      64         353 :     static SfxItemPropertySet aMap(aMapContent);
      65         353 :     return &aMap;
      66             : }
      67             : 
      68         171 : const SfxItemPropertySet* getEmptyPropertySet()
      69             : {
      70             :     static const SfxItemPropertyMapEntry aMapContent[] =
      71             :     {
      72             :         { OUString(), 0, css::uno::Type(), 0, 0 }
      73         204 :     };
      74         171 :     static SfxItemPropertySet aMap(aMapContent);
      75         171 :     return &aMap;
      76             : }
      77             : 
      78          16 : const SfxItemPropertySet* lcl_GetURLPropertySet()
      79             : {
      80             :     static const SfxItemPropertyMapEntry aURLPropertyMap_Impl[] =
      81             :     {
      82           3 :         {OUString(SC_UNONAME_ANCTYPE),  0,  cppu::UnoType<text::TextContentAnchorType>::get(), beans::PropertyAttribute::READONLY, 0 },
      83           3 :         {OUString(SC_UNONAME_ANCTYPES), 0,  cppu::UnoType<uno::Sequence<text::TextContentAnchorType>>::get(), beans::PropertyAttribute::READONLY, 0 },
      84           3 :         {OUString(SC_UNONAME_REPR),     0,  cppu::UnoType<OUString>::get(),    0, 0},
      85           3 :         {OUString(SC_UNONAME_TARGET),   0,  cppu::UnoType<OUString>::get(),    0, 0},
      86           3 :         {OUString(SC_UNONAME_TEXTWRAP), 0,  cppu::UnoType<text::WrapTextMode>::get(), beans::PropertyAttribute::READONLY, 0 },
      87           3 :         {OUString(SC_UNONAME_URL),      0,  cppu::UnoType<OUString>::get(),    0, 0},
      88             :         { OUString(), 0, css::uno::Type(), 0, 0 }
      89          37 :     };
      90          16 :     static SfxItemPropertySet aURLPropertySet_Impl( aURLPropertyMap_Impl );
      91          16 :     return &aURLPropertySet_Impl;
      92             : }
      93             : 
      94         958 : const SfxItemPropertySet* lcl_GetHeaderFieldPropertySet()
      95             : {
      96             :     static const SfxItemPropertyMapEntry aHeaderFieldPropertyMap_Impl[] =
      97             :     {
      98          32 :         {OUString(SC_UNONAME_ANCTYPE),  0,  cppu::UnoType<text::TextContentAnchorType>::get(), beans::PropertyAttribute::READONLY, 0 },
      99          32 :         {OUString(SC_UNONAME_ANCTYPES), 0,  cppu::UnoType<uno::Sequence<text::TextContentAnchorType>>::get(), beans::PropertyAttribute::READONLY, 0 },
     100          32 :         {OUString(SC_UNONAME_TEXTWRAP), 0,  cppu::UnoType<text::WrapTextMode>::get(), beans::PropertyAttribute::READONLY, 0 },
     101             :         { OUString(), 0, css::uno::Type(), 0, 0 }
     102        1086 :     };
     103         958 :     static SfxItemPropertySet aHeaderFieldPropertySet_Impl( aHeaderFieldPropertyMap_Impl );
     104         958 :     return &aHeaderFieldPropertySet_Impl;
     105             : }
     106             : 
     107           2 : const SfxItemPropertySet* lcl_GetFileFieldPropertySet()
     108             : {
     109             :     static const SfxItemPropertyMapEntry aFileFieldPropertyMap_Impl[] =
     110             :     {
     111           1 :         {OUString(SC_UNONAME_ANCTYPE),  0,  cppu::UnoType<text::TextContentAnchorType>::get(), beans::PropertyAttribute::READONLY, 0 },
     112           1 :         {OUString(SC_UNONAME_ANCTYPES), 0,  cppu::UnoType<uno::Sequence<text::TextContentAnchorType>>::get(), beans::PropertyAttribute::READONLY, 0 },
     113           1 :         {OUString(SC_UNONAME_FILEFORM), 0,  cppu::UnoType<sal_Int16>::get(),        0, 0 },
     114           1 :         {OUString(SC_UNONAME_TEXTWRAP), 0,  cppu::UnoType<text::WrapTextMode>::get(), beans::PropertyAttribute::READONLY, 0 },
     115             :         { OUString(), 0, css::uno::Type(), 0, 0 }
     116           7 :     };
     117           2 :     static SfxItemPropertySet aFileFieldPropertySet_Impl( aFileFieldPropertyMap_Impl );
     118           2 :     return &aFileFieldPropertySet_Impl;
     119             : }
     120             : 
     121           0 : SvxFileFormat lcl_UnoToSvxFileFormat( sal_Int16 nUnoValue )
     122             : {
     123           0 :     switch( nUnoValue )
     124             :     {
     125           0 :         case text::FilenameDisplayFormat::FULL: return SVXFILEFORMAT_FULLPATH;
     126           0 :         case text::FilenameDisplayFormat::PATH: return SVXFILEFORMAT_PATH;
     127           0 :         case text::FilenameDisplayFormat::NAME: return SVXFILEFORMAT_NAME;
     128             :         default:
     129           0 :             return SVXFILEFORMAT_NAME_EXT;
     130             :     }
     131             : }
     132             : 
     133           0 : sal_Int16 lcl_SvxToUnoFileFormat( SvxFileFormat nSvxValue )
     134             : {
     135           0 :     switch( nSvxValue )
     136             :     {
     137           0 :         case SVXFILEFORMAT_NAME_EXT:    return text::FilenameDisplayFormat::NAME_AND_EXT;
     138           0 :         case SVXFILEFORMAT_FULLPATH:    return text::FilenameDisplayFormat::FULL;
     139           0 :         case SVXFILEFORMAT_PATH:        return text::FilenameDisplayFormat::PATH;
     140             :         default:
     141           0 :             return text::FilenameDisplayFormat::NAME;
     142             :     }
     143             : }
     144             : 
     145             : }
     146             : 
     147           0 : SC_SIMPLE_SERVICE_INFO( ScCellFieldsObj, "ScCellFieldsObj", "com.sun.star.text.TextFields" )
     148           0 : SC_SIMPLE_SERVICE_INFO( ScHeaderFieldsObj, "ScHeaderFieldsObj", "com.sun.star.text.TextFields" )
     149             : 
     150             : //  ScUnoEditEngine nur um aus einer EditEngine die Felder herauszubekommen...
     151             : 
     152             : enum ScUnoCollectMode
     153             : {
     154             :     SC_UNO_COLLECT_NONE,
     155             :     SC_UNO_COLLECT_COUNT,
     156             :     SC_UNO_COLLECT_FINDINDEX,
     157             :     SC_UNO_COLLECT_FINDPOS
     158             : };
     159             : 
     160             : /**
     161             :  * This class exists solely to allow searching through field items.  TODO:
     162             :  * Look into providing the same functionality directly in EditEngine, to
     163             :  * avoid having this class altogether.
     164             :  */
     165             : class ScUnoEditEngine : public ScEditEngineDefaulter
     166             : {
     167             :     ScUnoCollectMode    eMode;
     168             :     sal_uInt16              nFieldCount;
     169             :     sal_Int32           mnFieldType;
     170             :     SvxFieldData*       pFound;         // lokale Kopie
     171             :     sal_Int32           nFieldPar;
     172             :     sal_Int32           nFieldPos;
     173             :     sal_uInt16              nFieldIndex;
     174             : 
     175             : public:
     176             :                 ScUnoEditEngine(ScEditEngineDefaulter* pSource);
     177             :                 virtual ~ScUnoEditEngine();
     178             : 
     179             :     virtual OUString  CalcFieldValue( const SvxFieldItem& rField, sal_Int32 nPara, sal_Int32 nPos,
     180             :                                     Color*& rTxtColor, Color*& rFldColor ) SAL_OVERRIDE;
     181             : 
     182             :     sal_uInt16 CountFields();
     183             :     SvxFieldData* FindByIndex(sal_uInt16 nIndex);
     184             :     SvxFieldData* FindByPos(sal_Int32 nPar, sal_Int32 nPos, sal_Int32 nType);
     185             : 
     186           2 :     sal_Int32       GetFieldPar() const     { return nFieldPar; }
     187           2 :     sal_Int32       GetFieldPos() const     { return nFieldPos; }
     188             : };
     189             : 
     190          86 : ScUnoEditEngine::ScUnoEditEngine(ScEditEngineDefaulter* pSource)
     191             :     : ScEditEngineDefaulter(*pSource)
     192             :     , eMode(SC_UNO_COLLECT_NONE)
     193             :     , nFieldCount(0)
     194             :     , mnFieldType(text::textfield::Type::UNSPECIFIED)
     195             :     , pFound(NULL)
     196             :     , nFieldPar(0)
     197             :     , nFieldPos(0)
     198          86 :     , nFieldIndex(0)
     199             : {
     200          86 :     EditTextObject* pData = pSource->CreateTextObject();
     201          86 :     SetText( *pData );
     202          86 :     delete pData;
     203          86 : }
     204             : 
     205         172 : ScUnoEditEngine::~ScUnoEditEngine()
     206             : {
     207          86 :     delete pFound;
     208          86 : }
     209             : 
     210         172 : OUString ScUnoEditEngine::CalcFieldValue( const SvxFieldItem& rField,
     211             :             sal_Int32 nPara, sal_Int32 nPos, Color*& rTxtColor, Color*& rFldColor )
     212             : {
     213         172 :     OUString aRet(EditEngine::CalcFieldValue( rField, nPara, nPos, rTxtColor, rFldColor ));
     214         172 :     if (eMode != SC_UNO_COLLECT_NONE)
     215             :     {
     216          86 :         const SvxFieldData* pFieldData = rField.GetField();
     217          86 :         if ( pFieldData )
     218             :         {
     219          86 :             if (mnFieldType == text::textfield::Type::UNSPECIFIED || pFieldData->GetClassId() == mnFieldType)
     220             :             {
     221          86 :                 if ( eMode == SC_UNO_COLLECT_FINDINDEX && !pFound && nFieldCount == nFieldIndex )
     222             :                 {
     223           2 :                     pFound = pFieldData->Clone();
     224           2 :                     nFieldPar = nPara;
     225           2 :                     nFieldPos = nPos;
     226             :                 }
     227         163 :                 if ( eMode == SC_UNO_COLLECT_FINDPOS && !pFound &&
     228         154 :                         nPara == nFieldPar && nPos == nFieldPos )
     229             :                 {
     230          77 :                     pFound = pFieldData->Clone();
     231          77 :                     nFieldIndex = nFieldCount;
     232             :                 }
     233          86 :                 ++nFieldCount;
     234             :             }
     235             :         }
     236             :     }
     237         172 :     return aRet;
     238             : }
     239             : 
     240           6 : sal_uInt16 ScUnoEditEngine::CountFields()
     241             : {
     242           6 :     eMode = SC_UNO_COLLECT_COUNT;
     243           6 :     mnFieldType = text::textfield::Type::UNSPECIFIED;
     244           6 :     nFieldCount = 0;
     245           6 :     UpdateFields();
     246           6 :     eMode = SC_UNO_COLLECT_NONE;
     247             : 
     248           6 :     return nFieldCount;
     249             : }
     250             : 
     251           3 : SvxFieldData* ScUnoEditEngine::FindByIndex(sal_uInt16 nIndex)
     252             : {
     253           3 :     eMode = SC_UNO_COLLECT_FINDINDEX;
     254           3 :     nFieldIndex = nIndex;
     255           3 :     mnFieldType = text::textfield::Type::UNSPECIFIED;
     256           3 :     nFieldCount = 0;
     257           3 :     UpdateFields();
     258           3 :     eMode = SC_UNO_COLLECT_NONE;
     259             : 
     260           3 :     return pFound;
     261             : }
     262             : 
     263          77 : SvxFieldData* ScUnoEditEngine::FindByPos(sal_Int32 nPar, sal_Int32 nPos, sal_Int32 nType)
     264             : {
     265          77 :     eMode = SC_UNO_COLLECT_FINDPOS;
     266          77 :     nFieldPar = nPar;
     267          77 :     nFieldPos = nPos;
     268          77 :     mnFieldType = nType;
     269          77 :     nFieldCount = 0;
     270          77 :     UpdateFields();
     271          77 :     mnFieldType = text::textfield::Type::UNSPECIFIED;
     272          77 :     eMode = SC_UNO_COLLECT_NONE;
     273             : 
     274          77 :     return pFound;
     275             : }
     276             : 
     277           4 : ScCellFieldsObj::ScCellFieldsObj(
     278             :     const uno::Reference<text::XTextRange>& xContent,
     279             :     ScDocShell* pDocSh, const ScAddress& rPos) :
     280             :     mxContent(xContent),
     281             :     pDocShell( pDocSh ),
     282             :     aCellPos( rPos ),
     283           4 :     mpRefreshListeners( NULL )
     284             : {
     285           4 :     pDocShell->GetDocument().AddUnoObject(*this);
     286             : 
     287           4 :     mpEditSource = new ScCellEditSource( pDocShell, aCellPos );
     288           4 : }
     289             : 
     290          12 : ScCellFieldsObj::~ScCellFieldsObj()
     291             : {
     292           4 :     SolarMutexGuard g;
     293             : 
     294           4 :     if (pDocShell)
     295           0 :         pDocShell->GetDocument().RemoveUnoObject(*this);
     296             : 
     297           4 :     delete mpEditSource;
     298             : 
     299             :     // increment refcount to prevent double call off dtor
     300           4 :     osl_atomic_increment( &m_refCount );
     301             : 
     302           4 :     if (mpRefreshListeners)
     303             :     {
     304           1 :         lang::EventObject aEvent;
     305           1 :         aEvent.Source.set(static_cast<cppu::OWeakObject*>(this));
     306           1 :         if (mpRefreshListeners)
     307             :         {
     308           1 :             mpRefreshListeners->disposeAndClear(aEvent);
     309           1 :             DELETEZ( mpRefreshListeners );
     310           1 :         }
     311           4 :     }
     312           8 : }
     313             : 
     314           4 : void ScCellFieldsObj::Notify( SfxBroadcaster&, const SfxHint& rHint )
     315             : {
     316           4 :     if ( dynamic_cast<const ScUpdateRefHint*>(&rHint) )
     317             :     {
     318             :         //! Ref-Update
     319             :     }
     320           8 :     else if ( dynamic_cast<const SfxSimpleHint*>(&rHint) &&
     321           4 :             static_cast<const SfxSimpleHint&>(rHint).GetId() == SFX_HINT_DYING )
     322             :     {
     323           4 :         pDocShell = NULL;       // ungueltig geworden
     324             :     }
     325             : 
     326             :     //  EditSource hat sich selber als Listener angemeldet
     327           4 : }
     328             : 
     329             : // XIndexAccess (via XTextFields)
     330             : 
     331           3 : uno::Reference<text::XTextField> ScCellFieldsObj::GetObjectByIndex_Impl(sal_Int32 Index) const
     332             : {
     333             :     //! Feld-Funktionen muessen an den Forwarder !!!
     334           3 :     ScEditEngineDefaulter* pEditEngine = mpEditSource->GetEditEngine();
     335           3 :     ScUnoEditEngine aTempEngine(pEditEngine);
     336           3 :     SvxFieldData* pData = aTempEngine.FindByIndex(static_cast<sal_uInt16>(Index));
     337           3 :     if (!pData)
     338           1 :         return uno::Reference<text::XTextField>();
     339             : 
     340           2 :     sal_Int32 nPar = aTempEngine.GetFieldPar();
     341           2 :     sal_Int32 nPos = aTempEngine.GetFieldPos();
     342           2 :     ESelection aSelection( nPar, nPos, nPar, nPos+1 );      // Feld ist 1 Zeichen
     343             : 
     344           2 :     sal_Int32 eType = pData->GetClassId();
     345             :     uno::Reference<text::XTextField> xRet(
     346           4 :         new ScEditFieldObj(mxContent, new ScCellEditSource(pDocShell, aCellPos), eType, aSelection));
     347           5 :     return xRet;
     348             : }
     349             : 
     350           5 : sal_Int32 SAL_CALL ScCellFieldsObj::getCount() throw(uno::RuntimeException, std::exception)
     351             : {
     352           5 :     SolarMutexGuard aGuard;
     353             : 
     354             :     //! Feld-Funktionen muessen an den Forwarder !!!
     355           5 :     ScEditEngineDefaulter* pEditEngine = mpEditSource->GetEditEngine();
     356          10 :     ScUnoEditEngine aTempEngine(pEditEngine);
     357             : 
     358          10 :     return aTempEngine.CountFields();       // Felder zaehlen, in Zelle ist der Typ egal
     359             : }
     360             : 
     361           3 : uno::Any SAL_CALL ScCellFieldsObj::getByIndex( sal_Int32 nIndex )
     362             :                             throw(lang::IndexOutOfBoundsException,
     363             :                                     lang::WrappedTargetException, uno::RuntimeException, std::exception)
     364             : {
     365           3 :     SolarMutexGuard aGuard;
     366           6 :     uno::Reference<text::XTextField> xField(GetObjectByIndex_Impl(nIndex));
     367           3 :     if (xField.is())
     368           4 :         return uno::makeAny(xField);
     369             :     else
     370           4 :         throw lang::IndexOutOfBoundsException();
     371             : }
     372             : 
     373           1 : uno::Type SAL_CALL ScCellFieldsObj::getElementType() throw(uno::RuntimeException, std::exception)
     374             : {
     375           1 :     SolarMutexGuard aGuard;
     376           1 :     return cppu::UnoType<text::XTextField>::get();
     377             : }
     378             : 
     379           1 : sal_Bool SAL_CALL ScCellFieldsObj::hasElements() throw(uno::RuntimeException, std::exception)
     380             : {
     381           1 :     SolarMutexGuard aGuard;
     382           1 :     return ( getCount() != 0 );
     383             : }
     384             : 
     385           3 : uno::Reference<container::XEnumeration> SAL_CALL ScCellFieldsObj::createEnumeration()
     386             :                                                     throw(uno::RuntimeException, std::exception)
     387             : {
     388           3 :     SolarMutexGuard aGuard;
     389           3 :     return new ScIndexEnumeration(this, OUString("com.sun.star.text.TextFieldEnumeration"));
     390             : }
     391             : 
     392           0 : void SAL_CALL ScCellFieldsObj::addContainerListener(
     393             :                                 const uno::Reference<container::XContainerListener>& /* xListener */ )
     394             :                                     throw(uno::RuntimeException, std::exception)
     395             : {
     396             :     OSL_FAIL("not implemented");
     397           0 : }
     398             : 
     399           0 : void SAL_CALL ScCellFieldsObj::removeContainerListener(
     400             :                                 const uno::Reference<container::XContainerListener>& /* xListener */ )
     401             :                                     throw(uno::RuntimeException, std::exception)
     402             : {
     403             :     OSL_FAIL("not implemented");
     404           0 : }
     405             : 
     406             : // XRefreshable
     407           2 : void SAL_CALL ScCellFieldsObj::refresh(  )
     408             :                                     throw (uno::RuntimeException, std::exception)
     409             : {
     410           2 :     if (mpRefreshListeners)
     411             :     {
     412             :         //  Call all listeners.
     413           2 :         uno::Sequence< uno::Reference< uno::XInterface > > aListeners(mpRefreshListeners->getElements());
     414           2 :         sal_uInt32 nLength(aListeners.getLength());
     415           2 :         if (nLength)
     416             :         {
     417           1 :             const uno::Reference< uno::XInterface >* pInterfaces = aListeners.getConstArray();
     418           1 :             if (pInterfaces)
     419             :             {
     420           1 :                 lang::EventObject aEvent;
     421           1 :                 aEvent.Source.set(uno::Reference< util::XRefreshable >(this));
     422           1 :                 sal_uInt32 i(0);
     423           3 :                 while (i < nLength)
     424             :                 {
     425             :                     try
     426             :                     {
     427           3 :                         while(i < nLength)
     428             :                         {
     429           1 :                             static_cast< util::XRefreshListener* >(pInterfaces->get())->refreshed(aEvent);
     430           1 :                             ++pInterfaces;
     431           1 :                             ++i;
     432             :                         }
     433             :                     }
     434           0 :                     catch(uno::RuntimeException&)
     435             :                     {
     436           0 :                         ++pInterfaces;
     437           0 :                         ++i;
     438             :                     }
     439           1 :                 }
     440             :             }
     441           2 :         }
     442             :     }
     443           2 : }
     444             : 
     445           1 : void SAL_CALL ScCellFieldsObj::addRefreshListener( const uno::Reference< util::XRefreshListener >& xListener )
     446             :                                     throw (uno::RuntimeException, std::exception)
     447             : {
     448           1 :     if (xListener.is())
     449             :     {
     450           1 :         SolarMutexGuard aGuard;
     451           1 :         if (!mpRefreshListeners)
     452           1 :             mpRefreshListeners = new cppu::OInterfaceContainerHelper(aMutex);
     453           1 :         mpRefreshListeners->addInterface(xListener);
     454             :     }
     455           1 : }
     456             : 
     457           1 : void SAL_CALL ScCellFieldsObj::removeRefreshListener( const uno::Reference<util::XRefreshListener >& xListener )
     458             :                                     throw (uno::RuntimeException, std::exception)
     459             : {
     460           1 :     if (xListener.is())
     461             :     {
     462           1 :         SolarMutexGuard aGuard;
     463           1 :         if (mpRefreshListeners)
     464           1 :             mpRefreshListeners->removeInterface(xListener);
     465             :     }
     466           1 : }
     467             : 
     468           1 : ScHeaderFieldsObj::ScHeaderFieldsObj(ScHeaderFooterTextData& rData) :
     469             :     mrData(rData),
     470           1 :     mpRefreshListeners( NULL )
     471             : {
     472           1 :     mpEditSource = new ScHeaderFooterEditSource(rData);
     473           1 : }
     474             : 
     475           3 : ScHeaderFieldsObj::~ScHeaderFieldsObj()
     476             : {
     477           1 :     delete mpEditSource;
     478             : 
     479             :     // increment refcount to prevent double call off dtor
     480           1 :     osl_atomic_increment( &m_refCount );
     481             : 
     482           1 :     if (mpRefreshListeners)
     483             :     {
     484           1 :         lang::EventObject aEvent;
     485           1 :         aEvent.Source = static_cast<cppu::OWeakObject*>(this);
     486           1 :         if (mpRefreshListeners)
     487             :         {
     488           1 :             mpRefreshListeners->disposeAndClear(aEvent);
     489           1 :             DELETEZ( mpRefreshListeners );
     490           1 :         }
     491             :     }
     492           2 : }
     493             : 
     494             : // XIndexAccess (via XTextFields)
     495             : 
     496           0 : uno::Reference<text::XTextField> ScHeaderFieldsObj::GetObjectByIndex_Impl(sal_Int32 Index) const
     497             : {
     498             :     //! Feld-Funktionen muessen an den Forwarder !!!
     499           0 :     ScEditEngineDefaulter* pEditEngine = mpEditSource->GetEditEngine();
     500           0 :     ScUnoEditEngine aTempEngine(pEditEngine);
     501             : 
     502           0 :     SvxFieldData* pData = aTempEngine.FindByIndex(static_cast<sal_uInt16>(Index));
     503           0 :     if (!pData)
     504           0 :         return NULL;
     505             : 
     506             :     // Get the parent text range instance.
     507           0 :     uno::Reference<text::XTextRange> xTextRange;
     508           0 :     rtl::Reference<ScHeaderFooterContentObj> rContentObj = mrData.GetContentObj();
     509           0 :     uno::Reference<text::XText> xText;
     510           0 :     sal_uInt16 nPart = mrData.GetPart();
     511           0 :     if (nPart == SC_HDFT_LEFT)
     512           0 :         xText = rContentObj->getLeftText();
     513           0 :     else if (nPart == SC_HDFT_CENTER)
     514           0 :         xText = rContentObj->getCenterText();
     515             :     else
     516           0 :         xText = rContentObj->getRightText();
     517             : 
     518           0 :     uno::Reference<text::XTextRange> xTemp(xText, uno::UNO_QUERY);
     519           0 :     xTextRange = xTemp;
     520             : 
     521           0 :     sal_Int32 nPar = aTempEngine.GetFieldPar();
     522           0 :     sal_Int32 nPos = aTempEngine.GetFieldPos();
     523           0 :     ESelection aSelection( nPar, nPos, nPar, nPos+1 );      // Field is 1 character
     524             : 
     525           0 :     sal_Int32 eRealType = pData->GetClassId();
     526             :     uno::Reference<text::XTextField> xRet(
     527           0 :         new ScEditFieldObj(xTextRange, new ScHeaderFooterEditSource(mrData), eRealType, aSelection));
     528           0 :     return xRet;
     529             : }
     530             : 
     531           1 : sal_Int32 SAL_CALL ScHeaderFieldsObj::getCount() throw(uno::RuntimeException, std::exception)
     532             : {
     533           1 :     SolarMutexGuard aGuard;
     534             : 
     535             :     //! Feld-Funktionen muessen an den Forwarder !!!
     536           1 :     ScEditEngineDefaulter* pEditEngine = mpEditSource->GetEditEngine();
     537           2 :     ScUnoEditEngine aTempEngine(pEditEngine);
     538           2 :     return aTempEngine.CountFields();
     539             : }
     540             : 
     541           0 : uno::Any SAL_CALL ScHeaderFieldsObj::getByIndex( sal_Int32 nIndex )
     542             :                             throw(lang::IndexOutOfBoundsException,
     543             :                                     lang::WrappedTargetException, uno::RuntimeException, std::exception)
     544             : {
     545           0 :     SolarMutexGuard aGuard;
     546           0 :     uno::Reference<text::XTextField> xField(GetObjectByIndex_Impl(nIndex));
     547           0 :     if (xField.is())
     548           0 :         return uno::makeAny(xField);
     549             :     else
     550           0 :         throw lang::IndexOutOfBoundsException();
     551             : }
     552             : 
     553           1 : uno::Type SAL_CALL ScHeaderFieldsObj::getElementType() throw(uno::RuntimeException, std::exception)
     554             : {
     555           1 :     SolarMutexGuard aGuard;
     556           1 :     return cppu::UnoType<text::XTextField>::get();
     557             : }
     558             : 
     559           1 : sal_Bool SAL_CALL ScHeaderFieldsObj::hasElements() throw(uno::RuntimeException, std::exception)
     560             : {
     561           1 :     SolarMutexGuard aGuard;
     562           1 :     return ( getCount() != 0 );
     563             : }
     564             : 
     565           1 : uno::Reference<container::XEnumeration> SAL_CALL ScHeaderFieldsObj::createEnumeration()
     566             :                                                     throw(uno::RuntimeException, std::exception)
     567             : {
     568           1 :     SolarMutexGuard aGuard;
     569           1 :     return new ScIndexEnumeration(this, OUString("com.sun.star.text.TextFieldEnumeration"));
     570             : }
     571             : 
     572           0 : void SAL_CALL ScHeaderFieldsObj::addContainerListener(
     573             :                                 const uno::Reference<container::XContainerListener>& /* xListener */ )
     574             :                                     throw(uno::RuntimeException, std::exception)
     575             : {
     576             :     OSL_FAIL("not implemented");
     577           0 : }
     578             : 
     579           0 : void SAL_CALL ScHeaderFieldsObj::removeContainerListener(
     580             :                                 const uno::Reference<container::XContainerListener>& /* xListener */ )
     581             :                                     throw(uno::RuntimeException, std::exception)
     582             : {
     583             :     OSL_FAIL("not implemented");
     584           0 : }
     585             : 
     586             : // XRefreshable
     587           2 : void SAL_CALL ScHeaderFieldsObj::refresh(  )
     588             :                                     throw (uno::RuntimeException, std::exception)
     589             : {
     590           2 :     if (mpRefreshListeners)
     591             :     {
     592             :         //  Call all listeners.
     593           2 :         uno::Sequence< uno::Reference< uno::XInterface > > aListeners(mpRefreshListeners->getElements());
     594           2 :         sal_uInt32 nLength(aListeners.getLength());
     595           2 :         if (nLength)
     596             :         {
     597           1 :             const uno::Reference< uno::XInterface >* pInterfaces = aListeners.getConstArray();
     598           1 :             if (pInterfaces)
     599             :             {
     600           1 :                 lang::EventObject aEvent;
     601           1 :                 aEvent.Source.set(uno::Reference< util::XRefreshable >(this));
     602           1 :                 sal_uInt32 i(0);
     603           3 :                 while (i < nLength)
     604             :                 {
     605             :                     try
     606             :                     {
     607           3 :                         while(i < nLength)
     608             :                         {
     609           1 :                             static_cast< util::XRefreshListener* >(pInterfaces->get())->refreshed(aEvent);
     610           1 :                             ++pInterfaces;
     611           1 :                             ++i;
     612             :                         }
     613             :                     }
     614           0 :                     catch(uno::RuntimeException&)
     615             :                     {
     616           0 :                         ++pInterfaces;
     617           0 :                         ++i;
     618             :                     }
     619           1 :                 }
     620             :             }
     621           2 :         }
     622             :     }
     623           2 : }
     624             : 
     625           1 : void SAL_CALL ScHeaderFieldsObj::addRefreshListener( const uno::Reference< util::XRefreshListener >& xListener )
     626             :                                     throw (uno::RuntimeException, std::exception)
     627             : {
     628           1 :     if (xListener.is())
     629             :     {
     630           1 :         SolarMutexGuard aGuard;
     631           1 :         if (!mpRefreshListeners)
     632           1 :             mpRefreshListeners = new cppu::OInterfaceContainerHelper(aMutex);
     633           1 :         mpRefreshListeners->addInterface(xListener);
     634             :     }
     635           1 : }
     636             : 
     637           1 : void SAL_CALL ScHeaderFieldsObj::removeRefreshListener( const uno::Reference<util::XRefreshListener >& xListener )
     638             :                                     throw (uno::RuntimeException, std::exception)
     639             : {
     640           1 :     if (xListener.is())
     641             :     {
     642           1 :         SolarMutexGuard aGuard;
     643           1 :         if (mpRefreshListeners)
     644           1 :             mpRefreshListeners->removeInterface(xListener);
     645             :     }
     646           1 : }
     647             : 
     648        1473 : SvxFieldData* ScEditFieldObj::getData()
     649             : {
     650        1473 :     if (!mpData)
     651             :     {
     652        1469 :         switch (meType)
     653             :         {
     654             :             case text::textfield::Type::DATE:
     655           0 :                 mpData.reset(new SvxDateField);
     656           0 :             break;
     657             :             case text::textfield::Type::EXTENDED_FILE:
     658             :                 mpData.reset(
     659           0 :                     new SvxExtFileField(OUString(), SVXFILETYPE_VAR, SVXFILEFORMAT_NAME_EXT));
     660           0 :             break;
     661             :             case text::textfield::Type::PAGE:
     662         389 :                 mpData.reset(new SvxPageField);
     663         389 :             break;
     664             :             case text::textfield::Type::PAGES:
     665         168 :                 mpData.reset(new SvxPagesField);
     666         168 :             break;
     667             :             case text::textfield::Type::TABLE:
     668         395 :                 mpData.reset(new SvxTableField);
     669         395 :             break;
     670             :             case text::textfield::Type::TIME:
     671           3 :                 mpData.reset(new SvxTimeField);
     672           3 :             break;
     673             :             case text::textfield::Type::EXTENDED_TIME:
     674             :             {
     675         340 :                 if (mbIsDate)
     676         172 :                     mpData.reset(new SvxDateField);
     677             :                 else
     678         168 :                     mpData.reset(new SvxExtTimeField);
     679             :             }
     680         340 :             break;
     681             :             case text::textfield::Type::DOCINFO_TITLE:
     682         168 :                 mpData.reset(new SvxFileField);
     683         168 :             break;
     684             :             case text::textfield::Type::URL:
     685             :                 mpData.reset(
     686           6 :                     new SvxURLField(OUString(), OUString(), SVXURLFORMAT_APPDEFAULT));
     687           6 :             break;
     688             :             default:
     689           0 :                 mpData.reset(new SvxFieldData);
     690             :         }
     691             :     }
     692        1473 :     return mpData.get();
     693             : }
     694             : 
     695          16 : void ScEditFieldObj::setPropertyValueURL(const OUString& rName, const com::sun::star::uno::Any& rVal)
     696             : {
     697          16 :     OUString aStrVal;
     698          16 :     if (mpEditSource)
     699             :     {
     700             :         // Edit engine instance already exists for this field item.  Use it.
     701          12 :         ScEditEngineDefaulter* pEditEngine = mpEditSource->GetEditEngine();
     702          12 :         ScUnoEditEngine aTempEngine(pEditEngine);
     703             : 
     704             :         //  Typ egal (in Zellen gibts nur URLs)
     705             :         SvxFieldData* pField = aTempEngine.FindByPos(
     706          12 :             aSelection.nStartPara, aSelection.nStartPos, text::textfield::Type::UNSPECIFIED);
     707             :         OSL_ENSURE(pField,"setPropertyValue: Feld nicht gefunden");
     708          12 :         if (!pField)
     709           0 :             return;
     710             : 
     711          12 :         if (pField->GetClassId() != text::textfield::Type::URL)
     712             :             // Make sure this is indeed a URL field.
     713           0 :             return;
     714             : 
     715          12 :         SvxURLField* pURL = static_cast<SvxURLField*>(pField);
     716             : 
     717          12 :         if (rName == SC_UNONAME_URL)
     718             :         {
     719           4 :             if (rVal >>= aStrVal)
     720           4 :                 pURL->SetURL(aStrVal);
     721             :         }
     722           8 :         else if (rName == SC_UNONAME_REPR)
     723             :         {
     724           4 :             if (rVal >>= aStrVal)
     725           4 :                 pURL->SetRepresentation(aStrVal);
     726             :         }
     727           4 :         else if (rName == SC_UNONAME_TARGET)
     728             :         {
     729           4 :             if (rVal >>= aStrVal)
     730           4 :                 pURL->SetTargetFrame(aStrVal);
     731             :         }
     732             :         else
     733           0 :             throw beans::UnknownPropertyException();
     734             : 
     735          12 :         pEditEngine->QuickInsertField( SvxFieldItem(*pField, EE_FEATURE_FIELD), aSelection );
     736          12 :         mpEditSource->UpdateData();
     737          12 :         return;
     738             :     }
     739             : 
     740             :     // Edit engine instance not yet present.  Store the item data for later use.
     741           4 :     SvxFieldData* pData = getData();
     742           4 :     if (!pData)
     743           0 :         throw uno::RuntimeException();
     744             : 
     745           4 :     SvxURLField* p = static_cast<SvxURLField*>(pData);
     746           4 :     if (rName == SC_UNONAME_URL)
     747             :     {
     748           2 :         if (rVal >>= aStrVal)
     749           2 :             p->SetURL(aStrVal);
     750             :     }
     751           2 :     else if (rName == SC_UNONAME_REPR)
     752             :     {
     753           2 :         if (rVal >>= aStrVal)
     754           2 :             p->SetRepresentation(aStrVal);
     755             :     }
     756           0 :     else if (rName == SC_UNONAME_TARGET)
     757             :     {
     758           0 :         if (rVal >>= aStrVal)
     759           0 :             p->SetTargetFrame(aStrVal);
     760             :     }
     761             :     else
     762           0 :         throw beans::UnknownPropertyException();
     763             : }
     764             : 
     765          27 : uno::Any ScEditFieldObj::getPropertyValueURL(const OUString& rName)
     766             : {
     767          27 :     uno::Any aRet;
     768             : 
     769             :     // anchor type is always "as character", text wrap always "none"
     770             : 
     771          27 :     if (mpEditSource)
     772             :     {
     773             :         //! Feld-Funktionen muessen an den Forwarder !!!
     774          27 :         ScEditEngineDefaulter* pEditEngine = mpEditSource->GetEditEngine();
     775          27 :         ScUnoEditEngine aTempEngine(pEditEngine);
     776             : 
     777             :         //  Typ egal (in Zellen gibts nur URLs)
     778             :         const SvxFieldData* pField = aTempEngine.FindByPos(
     779          27 :             aSelection.nStartPara, aSelection.nStartPos, text::textfield::Type::UNSPECIFIED);
     780             :         OSL_ENSURE(pField,"getPropertyValue: Feld nicht gefunden");
     781          27 :         if (!pField)
     782           0 :             throw uno::RuntimeException();
     783             : 
     784          27 :         if (pField->GetClassId() != text::textfield::Type::URL)
     785           0 :             throw uno::RuntimeException();
     786             : 
     787          27 :         const SvxURLField* pURL = static_cast<const SvxURLField*>(pField);
     788             : 
     789          27 :         if (rName == SC_UNONAME_URL)
     790           9 :             aRet <<= pURL->GetURL();
     791          18 :         else if (rName == SC_UNONAME_REPR)
     792           9 :             aRet <<= pURL->GetRepresentation();
     793           9 :         else if (rName == SC_UNONAME_TARGET)
     794           9 :             aRet <<= pURL->GetTargetFrame();
     795             :         else
     796           0 :             throw beans::UnknownPropertyException();
     797             :     }
     798             :     else        // noch nicht eingefuegt
     799             :     {
     800           0 :         const SvxFieldData* pField = getData();
     801           0 :         if (!pField)
     802           0 :             return aRet;
     803             : 
     804           0 :         const SvxURLField* pURL = static_cast<const SvxURLField*>(pField);
     805           0 :         if (rName == SC_UNONAME_URL)
     806           0 :             aRet <<= pURL->GetURL();
     807           0 :         else if (rName == SC_UNONAME_REPR)
     808           0 :             aRet <<= pURL->GetRepresentation();
     809           0 :         else if (rName == SC_UNONAME_TARGET)
     810           0 :             aRet <<= pURL->GetTargetFrame();
     811             :         else
     812           0 :             throw beans::UnknownPropertyException();
     813             :     }
     814          27 :     return aRet;
     815             : }
     816             : 
     817           0 : void ScEditFieldObj::setPropertyValueFile(const OUString& rName, const uno::Any& rVal)
     818             : {
     819           0 :     if (rName == SC_UNONAME_FILEFORM)
     820             :     {
     821           0 :         sal_Int16 nIntVal = 0;
     822           0 :         if (rVal >>= nIntVal)
     823             :         {
     824           0 :             SvxFileFormat eFormat = lcl_UnoToSvxFileFormat(nIntVal);
     825           0 :             if (mpEditSource)
     826             :             {
     827           0 :                 ScEditEngineDefaulter* pEditEngine = mpEditSource->GetEditEngine();
     828           0 :                 ScUnoEditEngine aTempEngine(pEditEngine);
     829             :                 SvxFieldData* pField = aTempEngine.FindByPos(
     830           0 :                         aSelection.nStartPara, aSelection.nStartPos, text::textfield::Type::EXTENDED_FILE);
     831             :                 OSL_ENSURE(pField, "setPropertyValueFile: Field not found");
     832           0 :                 if (pField)
     833             :                 {
     834           0 :                     SvxExtFileField* pExtFile = static_cast<SvxExtFileField*>(pField);   // local to the ScUnoEditEngine
     835           0 :                     pExtFile->SetFormat(eFormat);
     836           0 :                     pEditEngine->QuickInsertField(SvxFieldItem(*pField, EE_FEATURE_FIELD), aSelection);
     837           0 :                     mpEditSource->UpdateData();
     838           0 :                 }
     839             :             }
     840             :             else
     841             :             {
     842           0 :                 SvxFieldData* pField = getData();
     843           0 :                 SvxExtFileField* pExtFile = static_cast<SvxExtFileField*>(pField);
     844           0 :                 pExtFile->SetFormat(eFormat);
     845             :             }
     846             :         }
     847             :     }
     848             :     else
     849           0 :         throw beans::UnknownPropertyException();
     850           0 : }
     851             : 
     852           0 : uno::Any ScEditFieldObj::getPropertyValueFile(const OUString& rName)
     853             : {
     854           0 :     uno::Any aRet;
     855           0 :     if (rName == SC_UNONAME_FILEFORM)
     856             :     {
     857           0 :         SvxFileFormat eFormat = SVXFILEFORMAT_NAME_EXT;
     858           0 :         const SvxFieldData* pField = NULL;
     859           0 :         if (mpEditSource)
     860             :         {
     861           0 :             ScEditEngineDefaulter* pEditEngine = mpEditSource->GetEditEngine();
     862           0 :             ScUnoEditEngine aTempEngine(pEditEngine);
     863             :             pField = aTempEngine.FindByPos(
     864           0 :                 aSelection.nStartPara, aSelection.nStartPos, text::textfield::Type::EXTENDED_FILE);
     865             :         }
     866             :         else
     867           0 :             pField = getData();
     868             : 
     869             :         OSL_ENSURE(pField, "setPropertyValueFile: Field not found");
     870           0 :         if (!pField)
     871           0 :             throw uno::RuntimeException();
     872             : 
     873           0 :         const SvxExtFileField* pExtFile = static_cast<const SvxExtFileField*>(pField);
     874           0 :         eFormat = pExtFile->GetFormat();
     875           0 :         sal_Int16 nIntVal = lcl_SvxToUnoFileFormat(eFormat);
     876           0 :         aRet <<= nIntVal;
     877             :     }
     878             :     else
     879           0 :         throw beans::UnknownPropertyException();
     880             : 
     881           0 :     return aRet;
     882             : }
     883             : 
     884         692 : void ScEditFieldObj::setPropertyValueDateTime(const OUString& rName, const uno::Any& rVal)
     885             : {
     886         692 :     if (mpEditSource)
     887             :     {
     888             :         // Field already inserted.
     889          12 :         ScEditEngineDefaulter* pEditEngine = mpEditSource->GetEditEngine();
     890          12 :         ScUnoEditEngine aTempEngine(pEditEngine);
     891          12 :         SvxFieldData* pField = aTempEngine.FindByPos(aSelection.nStartPara, aSelection.nStartPos, meType);
     892          12 :         if (!pField)
     893         692 :             return;
     894             : 
     895          12 :         switch (meType)
     896             :         {
     897             :             case text::textfield::Type::DATE:
     898             :             {
     899           0 :                 SvxDateField* p = static_cast<SvxDateField*>(pField);
     900           0 :                 if (rName == SC_UNONAME_ISDATE)
     901             :                 {
     902             :                     // Do nothing for now.
     903             :                 }
     904           0 :                 else if (rName == SC_UNONAME_ISFIXED)
     905             :                 {
     906           0 :                     SvxDateType eType = rVal.get<sal_Bool>() ? SVXDATETYPE_FIX : SVXDATETYPE_VAR;
     907           0 :                     p->SetType(eType);
     908             :                 }
     909           0 :                 else if (rName == SC_UNONAME_DATETIME)
     910             :                 {
     911           0 :                     maDateTime = rVal.get<util::DateTime>();
     912           0 :                     Date aDate(maDateTime.Day, maDateTime.Month, maDateTime.Year);
     913           0 :                     p->SetFixDate(aDate);
     914             :                 }
     915           0 :                 else if (rName == SC_UNONAME_NUMFMT)
     916             :                 {
     917           0 :                     mnNumFormat = rVal.get<sal_Int32>();
     918           0 :                     p->SetFormat(static_cast<SvxDateFormat>(mnNumFormat));
     919             :                 }
     920             :                 else
     921           0 :                     throw beans::UnknownPropertyException();
     922             :             }
     923           0 :             break;
     924             :             case text::textfield::Type::TIME:
     925             :             {
     926             :                 // SvxTimeField doesn't have any attributes.
     927          39 :                 if (rName != SC_UNONAME_ISDATE && rName != SC_UNONAME_ISFIXED &&
     928          21 :                     rName != SC_UNONAME_DATETIME && rName != SC_UNONAME_NUMFMT)
     929           0 :                     throw beans::UnknownPropertyException();
     930             :             }
     931          12 :             break;
     932             :             case text::textfield::Type::EXTENDED_TIME:
     933             :             {
     934           0 :                 SvxExtTimeField* p = static_cast<SvxExtTimeField*>(pField);
     935           0 :                 if (rName == SC_UNONAME_ISDATE)
     936             :                 {
     937             :                     // Do nothing for now.
     938             :                 }
     939           0 :                 else if (rName == SC_UNONAME_ISFIXED)
     940             :                 {
     941           0 :                     SvxTimeType eType = rVal.get<sal_Bool>() ? SVXTIMETYPE_FIX : SVXTIMETYPE_VAR;
     942           0 :                     p->SetType(eType);
     943             :                 }
     944           0 :                 else if (rName == SC_UNONAME_DATETIME)
     945             :                 {
     946           0 :                     maDateTime = rVal.get<util::DateTime>();
     947           0 :                     tools::Time aTime(maDateTime);
     948           0 :                     p->SetFixTime(aTime);
     949             :                 }
     950           0 :                 else if (rName == SC_UNONAME_NUMFMT)
     951             :                 {
     952           0 :                     mnNumFormat = rVal.get<sal_Int32>();
     953           0 :                     p->SetFormat(static_cast<SvxTimeFormat>(mnNumFormat));
     954             :                 }
     955             :                 else
     956           0 :                     throw beans::UnknownPropertyException();
     957             :             }
     958           0 :             break;
     959             :             default:
     960           0 :                 throw beans::UnknownPropertyException();
     961          12 :         }
     962             :     }
     963             :     else
     964             :     {
     965         680 :         if (rName == SC_UNONAME_ISDATE)
     966         340 :             mbIsDate = rVal.get<sal_Bool>();
     967         340 :         else if (rName == SC_UNONAME_ISFIXED)
     968         340 :             mbIsFixed = rVal.get<sal_Bool>();
     969           0 :         else if (rName == SC_UNONAME_DATETIME)
     970           0 :             maDateTime = rVal.get<util::DateTime>();
     971           0 :         else if (rName == SC_UNONAME_NUMFMT)
     972           0 :             mnNumFormat = rVal.get<sal_Int32>();
     973             :         else
     974           0 :             throw beans::UnknownPropertyException();
     975             :     }
     976             : }
     977             : 
     978          27 : uno::Any ScEditFieldObj::getPropertyValueDateTime(const OUString& rName)
     979             : {
     980          27 :     if (mpEditSource)
     981             :     {
     982             :         // Field already inserted.
     983          24 :         ScEditEngineDefaulter* pEditEngine = mpEditSource->GetEditEngine();
     984          24 :         ScUnoEditEngine aTempEngine(pEditEngine);
     985          24 :         SvxFieldData* pField = aTempEngine.FindByPos(aSelection.nStartPara, aSelection.nStartPos, meType);
     986          24 :         if (!pField)
     987           0 :             throw uno::RuntimeException();
     988             : 
     989          24 :         switch (meType)
     990             :         {
     991             :             case text::textfield::Type::DATE:
     992             :             {
     993           0 :                 SvxDateField* p = static_cast<SvxDateField*>(pField);
     994           0 :                 if (rName == SC_UNONAME_ISDATE)
     995           0 :                     return uno::makeAny(sal_True);
     996             : 
     997           0 :                 if (rName == SC_UNONAME_ISFIXED)
     998           0 :                     return uno::makeAny<sal_Bool>(p->GetType() == SVXDATETYPE_FIX);
     999             : 
    1000           0 :                 if (rName == SC_UNONAME_DATETIME)
    1001             :                 {
    1002           0 :                     Date aD(p->GetFixDate());
    1003           0 :                     maDateTime.Year = aD.GetYear();
    1004           0 :                     maDateTime.Month = aD.GetMonth();
    1005           0 :                     maDateTime.Day = aD.GetDay();
    1006           0 :                     maDateTime.Hours = 0;
    1007           0 :                     maDateTime.Minutes = 0;
    1008           0 :                     maDateTime.Seconds = 0;
    1009           0 :                     maDateTime.NanoSeconds = 0;
    1010           0 :                     return uno::makeAny(maDateTime);
    1011             :                 }
    1012             : 
    1013           0 :                 if (rName == SC_UNONAME_NUMFMT)
    1014           0 :                     return uno::makeAny<sal_Int32>(p->GetFormat());
    1015             :             }
    1016           0 :             break;
    1017             :             case text::textfield::Type::TIME:
    1018             :             {
    1019             :                 // SvxTimeField doesn't have any attributes.
    1020          24 :                 if (rName == SC_UNONAME_ISDATE)
    1021           6 :                     return uno::makeAny(sal_False);
    1022             : 
    1023          18 :                 if (rName == SC_UNONAME_ISFIXED)
    1024           6 :                     return uno::makeAny(sal_False);
    1025             : 
    1026          12 :                 if (rName == SC_UNONAME_DATETIME)
    1027             :                     // This is the best we can do.
    1028           6 :                     return uno::makeAny(maDateTime);
    1029             : 
    1030           6 :                 if (rName == SC_UNONAME_NUMFMT)
    1031             :                     // Same as above.
    1032           6 :                     return uno::makeAny<sal_Int32>(0);
    1033             :             }
    1034           0 :             break;
    1035             :             case text::textfield::Type::EXTENDED_TIME:
    1036             :             {
    1037           0 :                 SvxExtTimeField* p = static_cast<SvxExtTimeField*>(pField);
    1038           0 :                 if (rName == SC_UNONAME_ISDATE)
    1039           0 :                     return uno::makeAny(sal_False);
    1040             : 
    1041           0 :                 if (rName == SC_UNONAME_ISFIXED)
    1042           0 :                     return uno::makeAny<sal_Bool>(p->GetType() == SVXTIMETYPE_FIX);
    1043             : 
    1044           0 :                 if (rName == SC_UNONAME_DATETIME)
    1045             :                 {
    1046           0 :                     tools::Time aT(p->GetFixTime());
    1047           0 :                     maDateTime.Year = 0;
    1048           0 :                     maDateTime.Month = 0;
    1049           0 :                     maDateTime.Day = 0;
    1050           0 :                     maDateTime.Hours = aT.GetHour();
    1051           0 :                     maDateTime.Minutes = aT.GetMin();
    1052           0 :                     maDateTime.Seconds = aT.GetSec();
    1053           0 :                     maDateTime.NanoSeconds = aT.GetNanoSec();
    1054           0 :                     return uno::makeAny(maDateTime);
    1055             :                 }
    1056             : 
    1057           0 :                 if (rName == SC_UNONAME_NUMFMT)
    1058           0 :                     return uno::makeAny<sal_Int32>(p->GetFormat());
    1059             :             }
    1060           0 :             break;
    1061             :             default:
    1062             :                 ;
    1063           0 :         }
    1064             :     }
    1065             :     else
    1066             :     {
    1067           3 :         if (rName == SC_UNONAME_ISDATE)
    1068           0 :             return uno::makeAny<sal_Bool>(mbIsDate);
    1069             : 
    1070           3 :         if (rName == SC_UNONAME_ISFIXED)
    1071           0 :             return uno::makeAny<sal_Bool>(mbIsFixed);
    1072             : 
    1073           3 :         if (rName == SC_UNONAME_DATETIME)
    1074           0 :             return uno::makeAny(maDateTime);
    1075             : 
    1076           3 :         if (rName == SC_UNONAME_NUMFMT)
    1077           0 :             return uno::makeAny(mnNumFormat);
    1078             :     }
    1079             : 
    1080           3 :     throw beans::UnknownPropertyException();
    1081             : }
    1082             : 
    1083           0 : void ScEditFieldObj::setPropertyValueSheet(const OUString& rName, const uno::Any& rVal)
    1084             : {
    1085           0 :     if (mpEditSource)
    1086             :     {
    1087             :         // Edit engine instance already exists for this field item.  Use it.
    1088           0 :         ScEditEngineDefaulter* pEditEngine = mpEditSource->GetEditEngine();
    1089           0 :         ScUnoEditEngine aTempEngine(pEditEngine);
    1090             : 
    1091             :         //  Typ egal (in Zellen gibts nur URLs)
    1092             :         SvxFieldData* pField = aTempEngine.FindByPos(
    1093           0 :             aSelection.nStartPara, aSelection.nStartPos, text::textfield::Type::UNSPECIFIED);
    1094             :         OSL_ENSURE(pField,"setPropertyValue: Feld nicht gefunden");
    1095           0 :         if (!pField)
    1096           0 :             return;
    1097             : 
    1098           0 :         if (pField->GetClassId() != text::textfield::Type::TABLE)
    1099             :             // Make sure this is indeed a URL field.
    1100           0 :             return;
    1101             : 
    1102           0 :         SvxTableField* p = static_cast<SvxTableField*>(pField);
    1103             : 
    1104           0 :         if (rName == SC_UNONAME_TABLEPOS)
    1105             :         {
    1106           0 :             sal_Int32 nTab = rVal.get<sal_Int32>();
    1107           0 :             p->SetTab(nTab);
    1108             :         }
    1109             :         else
    1110           0 :             throw beans::UnknownPropertyException();
    1111             : 
    1112           0 :         pEditEngine->QuickInsertField(SvxFieldItem(*pField, EE_FEATURE_FIELD), aSelection);
    1113           0 :         mpEditSource->UpdateData();
    1114           0 :         return;
    1115             :     }
    1116             : 
    1117             :     // Edit engine instance not yet present.  Store the item data for later use.
    1118           0 :     SvxFieldData* pData = getData();
    1119           0 :     if (!pData)
    1120           0 :         throw uno::RuntimeException();
    1121             : 
    1122           0 :     SvxTableField* p = static_cast<SvxTableField*>(pData);
    1123           0 :     if (rName == SC_UNONAME_TABLEPOS)
    1124             :     {
    1125           0 :         sal_Int32 nTab = rVal.get<sal_Int32>();
    1126           0 :         p->SetTab(nTab);
    1127             :     }
    1128             :     else
    1129           0 :         throw beans::UnknownPropertyException();
    1130             : 
    1131             : }
    1132             : 
    1133        1500 : ScEditFieldObj::ScEditFieldObj(
    1134             :     const uno::Reference<text::XTextRange>& rContent,
    1135             :     ScEditSource* pEditSrc, sal_Int32 eType, const ESelection& rSel) :
    1136        1500 :     OComponentHelper(getMutex()),
    1137             :     pPropSet(NULL),
    1138             :     mpEditSource(pEditSrc),
    1139             :     aSelection(rSel),
    1140        3000 :     meType(eType), mpData(NULL), mpContent(rContent), mnNumFormat(0), mbIsDate(false), mbIsFixed(false)
    1141             : {
    1142        1500 :     switch (meType)
    1143             :     {
    1144             :         case text::textfield::Type::DOCINFO_TITLE:
    1145         171 :             pPropSet = getEmptyPropertySet();
    1146         171 :         break;
    1147             :         case text::textfield::Type::EXTENDED_FILE:
    1148           2 :             pPropSet = lcl_GetFileFieldPropertySet();
    1149           2 :         break;
    1150             :         case text::textfield::Type::URL:
    1151          16 :             pPropSet = lcl_GetURLPropertySet();
    1152          16 :         break;
    1153             :         case text::textfield::Type::DATE:
    1154             :         case text::textfield::Type::TIME:
    1155             :         case text::textfield::Type::EXTENDED_TIME:
    1156         353 :             pPropSet = getDateTimePropertySet();
    1157         353 :         break;
    1158             :         default:
    1159         958 :             pPropSet = lcl_GetHeaderFieldPropertySet();
    1160             :     }
    1161             : 
    1162        1500 :     if (meType == text::textfield::Type::DATE)
    1163           3 :         mbIsDate = true;
    1164        1500 : }
    1165             : 
    1166        1469 : void ScEditFieldObj::InitDoc(
    1167             :     const uno::Reference<text::XTextRange>& rContent, ScEditSource* pEditSrc, const ESelection& rSel)
    1168             : {
    1169        1469 :     if (!mpEditSource)
    1170             :     {
    1171        1469 :         mpContent = rContent;
    1172        1469 :         mpData.reset();
    1173             : 
    1174        1469 :         aSelection = rSel;
    1175        1469 :         mpEditSource = pEditSrc;
    1176             :     }
    1177        1469 : }
    1178             : 
    1179        4500 : ScEditFieldObj::~ScEditFieldObj()
    1180             : {
    1181        1500 :     delete mpEditSource;
    1182        3000 : }
    1183             : 
    1184        1469 : SvxFieldItem ScEditFieldObj::CreateFieldItem()
    1185             : {
    1186             :     OSL_ENSURE( !mpEditSource, "CreateFieldItem mit eingefuegtem Feld" );
    1187        1469 :     return SvxFieldItem(*getData(), EE_FEATURE_FIELD);
    1188             : }
    1189             : 
    1190           2 : void ScEditFieldObj::DeleteField()
    1191             : {
    1192           2 :     if (mpEditSource)
    1193             :     {
    1194           2 :         SvxTextForwarder* pForwarder = mpEditSource->GetTextForwarder();
    1195           2 :         pForwarder->QuickInsertText( OUString(), aSelection );
    1196           2 :         mpEditSource->UpdateData();
    1197             : 
    1198           2 :         aSelection.nEndPara = aSelection.nStartPara;
    1199           2 :         aSelection.nEndPos  = aSelection.nStartPos;
    1200             : 
    1201             :         //! Broadcast, um Selektion in anderen Objekten anzupassen
    1202             :         //! (auch bei anderen Aktionen)
    1203             :     }
    1204           2 : }
    1205             : 
    1206        1471 : bool ScEditFieldObj::IsInserted() const
    1207             : {
    1208        1471 :     return mpEditSource != NULL;
    1209             : }
    1210             : 
    1211             : // XTextField
    1212             : 
    1213           2 : OUString SAL_CALL ScEditFieldObj::getPresentation( sal_Bool bShowCommand )
    1214             :                                                     throw(uno::RuntimeException, std::exception)
    1215             : {
    1216           2 :     SolarMutexGuard aGuard;
    1217             : 
    1218           2 :     if (!mpEditSource)
    1219           0 :         return OUString();
    1220             : 
    1221             :     //! Feld-Funktionen muessen an den Forwarder !!!
    1222           2 :     ScEditEngineDefaulter* pEditEngine = mpEditSource->GetEditEngine();
    1223           4 :     ScUnoEditEngine aTempEngine(pEditEngine);
    1224             : 
    1225             :     //  Typ egal (in Zellen gibts nur URLs)
    1226             :     const SvxFieldData* pField = aTempEngine.FindByPos(
    1227           2 :         aSelection.nStartPara, aSelection.nStartPos, text::textfield::Type::UNSPECIFIED);
    1228             :     OSL_ENSURE(pField,"getPresentation: Feld nicht gefunden");
    1229           2 :     if (!pField)
    1230           0 :         return OUString();
    1231             : 
    1232           2 :     switch (meType)
    1233             :     {
    1234             :         case text::textfield::Type::URL:
    1235             :         {
    1236           2 :             if (pField->GetClassId() != text::textfield::Type::URL)
    1237             :                 // Not an URL field, but URL is expected.
    1238           0 :                 throw uno::RuntimeException();
    1239             : 
    1240           2 :             const SvxURLField* pURL = static_cast<const SvxURLField*>(pField);
    1241           2 :             return bShowCommand ? pURL->GetURL() : pURL->GetRepresentation();
    1242             :         }
    1243             :         break;
    1244             :         default:
    1245             :             ;
    1246             :     }
    1247           2 :     return OUString();
    1248             : }
    1249             : 
    1250             : // XTextContent
    1251             : 
    1252           2 : void SAL_CALL ScEditFieldObj::attach( const uno::Reference<text::XTextRange>& xTextRange )
    1253             :                                 throw(lang::IllegalArgumentException, uno::RuntimeException, std::exception)
    1254             : {
    1255           2 :     SolarMutexGuard aGuard;
    1256           2 :     if (xTextRange.is())
    1257             :     {
    1258           2 :         uno::Reference<text::XText> xText(xTextRange->getText());
    1259           2 :         if (xText.is())
    1260             :         {
    1261           3 :             xText->insertTextContent( xTextRange, this, sal_True );
    1262           2 :         }
    1263           2 :     }
    1264           1 : }
    1265             : 
    1266           4 : uno::Reference<text::XTextRange> SAL_CALL ScEditFieldObj::getAnchor() throw(uno::RuntimeException, std::exception)
    1267             : {
    1268           4 :     SolarMutexGuard aGuard;
    1269           4 :     return mpContent;
    1270             : }
    1271             : 
    1272             : // XComponent
    1273             : 
    1274           0 : void SAL_CALL ScEditFieldObj::dispose() throw(uno::RuntimeException, std::exception)
    1275             : {
    1276           0 :     OComponentHelper::dispose();
    1277           0 : }
    1278             : 
    1279           0 : void SAL_CALL ScEditFieldObj::addEventListener(
    1280             :                         const uno::Reference<lang::XEventListener>& xListener )
    1281             :                                                     throw(uno::RuntimeException, std::exception)
    1282             : {
    1283           0 :     OComponentHelper::addEventListener( xListener );
    1284           0 : }
    1285             : 
    1286           0 : void SAL_CALL ScEditFieldObj::removeEventListener(
    1287             :                         const uno::Reference<lang::XEventListener>& xListener )
    1288             :                                                     throw(uno::RuntimeException, std::exception)
    1289             : {
    1290           0 :     OComponentHelper::removeEventListener( xListener );
    1291           0 : }
    1292             : 
    1293             : // XPropertySet
    1294             : 
    1295        1030 : uno::Reference<beans::XPropertySetInfo> SAL_CALL ScEditFieldObj::getPropertySetInfo()
    1296             :                                                         throw(uno::RuntimeException, std::exception)
    1297             : {
    1298        1030 :     SolarMutexGuard aGuard;
    1299        1030 :     uno::Reference<beans::XPropertySetInfo> aRef = pPropSet->getPropertySetInfo();
    1300        1030 :     return aRef;
    1301             : }
    1302             : 
    1303         708 : void SAL_CALL ScEditFieldObj::setPropertyValue(
    1304             :                         const OUString& aPropertyName, const uno::Any& aValue )
    1305             :                 throw (beans::UnknownPropertyException, beans::PropertyVetoException,
    1306             :                        lang::IllegalArgumentException, lang::WrappedTargetException,
    1307             :                        uno::RuntimeException, std::exception)
    1308             : {
    1309         708 :     SolarMutexGuard aGuard;
    1310         708 :     if (aPropertyName == SC_UNONAME_ANCHOR)
    1311             :     {
    1312           0 :         aValue >>= mpContent;
    1313         708 :         return;
    1314             :     }
    1315             : 
    1316         708 :     switch (meType)
    1317             :     {
    1318             :         case text::textfield::Type::URL:
    1319          16 :             setPropertyValueURL(aPropertyName, aValue);
    1320          16 :         break;
    1321             :         case text::textfield::Type::EXTENDED_FILE:
    1322           0 :             setPropertyValueFile(aPropertyName, aValue);
    1323           0 :         break;
    1324             :         case text::textfield::Type::DATE:
    1325             :         case text::textfield::Type::TIME:
    1326             :         case text::textfield::Type::EXTENDED_TIME:
    1327         692 :             setPropertyValueDateTime(aPropertyName, aValue);
    1328         692 :         break;
    1329             :         case text::textfield::Type::TABLE:
    1330           0 :             setPropertyValueSheet(aPropertyName, aValue);
    1331           0 :         break;
    1332             :         case text::textfield::Type::DOCINFO_TITLE:
    1333             :         default:
    1334           0 :             throw beans::UnknownPropertyException();
    1335         708 :     }
    1336             : }
    1337             : 
    1338          57 : uno::Any SAL_CALL ScEditFieldObj::getPropertyValue( const OUString& aPropertyName )
    1339             :                 throw(beans::UnknownPropertyException, lang::WrappedTargetException,
    1340             :                         uno::RuntimeException, std::exception)
    1341             : {
    1342          57 :     SolarMutexGuard aGuard;
    1343          57 :     if (aPropertyName == SC_UNONAME_TEXTFIELD_TYPE)
    1344           0 :         return uno::makeAny(meType);
    1345             : 
    1346          57 :     if (aPropertyName == SC_UNONAME_ANCHOR)
    1347           0 :         return uno::makeAny(mpContent);
    1348             : 
    1349          57 :     if (aPropertyName == SC_UNONAME_ANCTYPE)
    1350             :     {
    1351           1 :         uno::Any aRet;
    1352           1 :         aRet <<= text::TextContentAnchorType_AS_CHARACTER;
    1353           1 :         return aRet;
    1354             :     }
    1355          56 :     if (aPropertyName == SC_UNONAME_ANCTYPES)
    1356             :     {
    1357           1 :         uno::Any aRet;
    1358           2 :         uno::Sequence<text::TextContentAnchorType> aSeq(1);
    1359           1 :         aSeq[0] = text::TextContentAnchorType_AS_CHARACTER;
    1360           1 :         aRet <<= aSeq;
    1361           2 :         return aRet;
    1362             :     }
    1363          55 :     if (aPropertyName == SC_UNONAME_TEXTWRAP)
    1364             :     {
    1365           1 :         uno::Any aRet;
    1366           1 :         aRet <<= text::WrapTextMode_NONE;
    1367           1 :         return aRet;
    1368             :     }
    1369             : 
    1370          54 :     switch (meType)
    1371             :     {
    1372             :         case text::textfield::Type::URL:
    1373          27 :             return getPropertyValueURL(aPropertyName);
    1374             :         case text::textfield::Type::EXTENDED_FILE:
    1375           0 :             return getPropertyValueFile(aPropertyName);
    1376             :         case text::textfield::Type::DATE:
    1377             :         case text::textfield::Type::TIME:
    1378             :         case text::textfield::Type::EXTENDED_TIME:
    1379          27 :             return getPropertyValueDateTime(aPropertyName);
    1380             :         case text::textfield::Type::DOCINFO_TITLE:
    1381             :         default:
    1382           0 :             throw beans::UnknownPropertyException();
    1383          57 :     }
    1384             : }
    1385             : 
    1386           0 : SC_IMPL_DUMMY_PROPERTY_LISTENER( ScEditFieldObj )
    1387             : 
    1388             : // XUnoTunnel
    1389             : 
    1390        1472 : sal_Int64 SAL_CALL ScEditFieldObj::getSomething(
    1391             :                 const uno::Sequence<sal_Int8 >& rId ) throw(uno::RuntimeException, std::exception)
    1392             : {
    1393        2944 :     if ( rId.getLength() == 16 &&
    1394        1472 :           0 == memcmp( getUnoTunnelId().getConstArray(),
    1395        2944 :                                     rId.getConstArray(), 16 ) )
    1396             :     {
    1397        1472 :         return sal::static_int_cast<sal_Int64>(reinterpret_cast<sal_IntPtr>(this));
    1398             :     }
    1399           0 :     return 0;
    1400             : }
    1401             : 
    1402             : namespace
    1403             : {
    1404             :     class theScEditFieldObjUnoTunnelId : public rtl::Static< UnoTunnelIdInit, theScEditFieldObjUnoTunnelId> {};
    1405             : }
    1406             : 
    1407        2944 : const uno::Sequence<sal_Int8>& ScEditFieldObj::getUnoTunnelId()
    1408             : {
    1409        2944 :     return theScEditFieldObjUnoTunnelId::get().getSeq();
    1410             : }
    1411             : 
    1412        1472 : ScEditFieldObj* ScEditFieldObj::getImplementation(const uno::Reference<text::XTextContent>& xObj)
    1413             : {
    1414        1472 :     ScEditFieldObj* pRet = NULL;
    1415        1472 :     uno::Reference<lang::XUnoTunnel> xUT( xObj, uno::UNO_QUERY );
    1416        1472 :     if (xUT.is())
    1417        1472 :         pRet = reinterpret_cast<ScEditFieldObj*>(sal::static_int_cast<sal_IntPtr>(xUT->getSomething(getUnoTunnelId())));
    1418        1472 :     return pRet;
    1419             : }
    1420             : 
    1421             : // XServiceInfo
    1422             : 
    1423           0 : OUString SAL_CALL ScEditFieldObj::getImplementationName() throw(uno::RuntimeException, std::exception)
    1424             : {
    1425           0 :     return OUString("ScEditFieldObj");
    1426             : }
    1427             : 
    1428           0 : sal_Bool SAL_CALL ScEditFieldObj::supportsService( const OUString& rServiceName )
    1429             :                                                     throw(uno::RuntimeException, std::exception)
    1430             : {
    1431           0 :     return cppu::supportsService(this, rServiceName);
    1432             : }
    1433             : 
    1434           0 : uno::Sequence<OUString> SAL_CALL ScEditFieldObj::getSupportedServiceNames()
    1435             :                                                     throw(uno::RuntimeException, std::exception)
    1436             : {
    1437           0 :     uno::Sequence<OUString> aRet(2);
    1438           0 :     OUString* pArray = aRet.getArray();
    1439           0 :     pArray[0] = "com.sun.star.text.TextField";
    1440           0 :     pArray[1] = "com.sun.star.text.TextContent";
    1441           0 :     return aRet;
    1442             : }
    1443             : 
    1444           0 : uno::Sequence<uno::Type> SAL_CALL ScEditFieldObj::getTypes() throw(uno::RuntimeException, std::exception)
    1445             : {
    1446           0 :     static uno::Sequence<uno::Type> aTypes;
    1447           0 :     if ( aTypes.getLength() == 0 )
    1448             :     {
    1449           0 :         uno::Sequence<uno::Type> aParentTypes(OComponentHelper::getTypes());
    1450           0 :         long nParentLen = aParentTypes.getLength();
    1451           0 :         const uno::Type* pParentPtr = aParentTypes.getConstArray();
    1452             : 
    1453           0 :         aTypes.realloc( nParentLen + 4 );
    1454           0 :         uno::Type* pPtr = aTypes.getArray();
    1455           0 :         pPtr[nParentLen + 0] = cppu::UnoType<text::XTextField>::get();
    1456           0 :         pPtr[nParentLen + 1] = cppu::UnoType<beans::XPropertySet>::get();
    1457           0 :         pPtr[nParentLen + 2] = cppu::UnoType<lang::XUnoTunnel>::get();
    1458           0 :         pPtr[nParentLen + 3] = cppu::UnoType<lang::XServiceInfo>::get();
    1459             : 
    1460           0 :         for (long i=0; i<nParentLen; i++)
    1461           0 :             pPtr[i] = pParentPtr[i];                // parent types first
    1462             :     }
    1463           0 :     return aTypes;
    1464             : }
    1465             : 
    1466           0 : uno::Sequence<sal_Int8> SAL_CALL ScEditFieldObj::getImplementationId()
    1467             :                                                     throw(uno::RuntimeException, std::exception)
    1468             : {
    1469           0 :     return css::uno::Sequence<sal_Int8>();
    1470         156 : }
    1471             : 
    1472             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.11