sc/source/ui/unoobj/fielduno.cxx

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