sc/source/ui/unoobj/textuno.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 "scitems.hxx"
  21 #include <editeng/eeitem.hxx>
  22 #include <svx/svdpool.hxx>
  23 #include <svx/svdobj.hxx>
  24 #include <editeng/editeng.hxx>
  25 #include <editeng/editobj.hxx>
  26 #include <editeng/flditem.hxx>
  27 #include <svx/unomid.hxx>
  28 #include <editeng/unoprnms.hxx>
  29 #include <editeng/unofored.hxx>
  30 #include <vcl/virdev.hxx>
  31 #include <vcl/svapp.hxx>
  32 #include <com/sun/star/awt/FontSlant.hpp>
  33
  34 #include <com/sun/star/beans/PropertyAttribute.hpp>
  35 #include <editeng/unoipset.hxx>
  36 #include "textuno.hxx"
  37 #include "fielduno.hxx"
  38 #include "servuno.hxx"
  39 #include "editsrc.hxx"
  40 #include "docsh.hxx"
  41 #include "editutil.hxx"
  42 #include "miscuno.hxx"
  43 #include "cellsuno.hxx"
  44 #include "hints.hxx"
  45 #include "patattr.hxx"
  46 #include "formulacell.hxx"
  47 #include "docfunc.hxx"
  48 #include "scmod.hxx"
  49
  50 using namespace com::sun::star;
  51
  52 static const SvxItemPropertySet * lcl_GetHdFtPropertySet()
  53 {
  54     static SfxItemPropertyMapEntry aHdFtPropertyMap_Impl[] =
  55     {
  56         SVX_UNOEDIT_CHAR_PROPERTIES,
  57         SVX_UNOEDIT_FONT_PROPERTIES,
  58         SVX_UNOEDIT_PARA_PROPERTIES,
  59         SVX_UNOEDIT_NUMBERING_PROPERTIE,    // for completeness of service ParagraphProperties
  60         { OUString(), 0, css::uno::Type(), 0, 0 }
  61     };
  62     static bool bTwipsSet = false;
  63
  64     if (!bTwipsSet)
  65     {
  66         //  modify PropertyMap to include CONVERT_TWIPS flag for font height
  67         //  (headers/footers are in twips)
  68
  69         SfxItemPropertyMapEntry* pEntry = aHdFtPropertyMap_Impl;
  70         while (!pEntry->aName.isEmpty())
  71         {
  72             if ( ( pEntry->nWID == EE_CHAR_FONTHEIGHT ||
  73                    pEntry->nWID == EE_CHAR_FONTHEIGHT_CJK ||
  74                    pEntry->nWID == EE_CHAR_FONTHEIGHT_CTL ) &&
  75                  pEntry->nMemberId == MID_FONTHEIGHT )
  76             {
  77                 pEntry->nMemberId |= CONVERT_TWIPS;
  78             }
  79
  80             ++pEntry;
  81         }
  82         bTwipsSet = true;
  83     }
  84     static SvxItemPropertySet aHdFtPropertySet_Impl( aHdFtPropertyMap_Impl, SdrObject::GetGlobalDrawObjectItemPool() );
  85     return &aHdFtPropertySet_Impl;
  86 }
  87
  88 SC_SIMPLE_SERVICE_INFO( ScHeaderFooterContentObj, "ScHeaderFooterContentObj", "com.sun.star.sheet.HeaderFooterContent" )
  89 SC_SIMPLE_SERVICE_INFO( ScHeaderFooterTextObj, "ScHeaderFooterTextObj", "stardiv.one.Text.Text" )
  90
  91 ScHeaderFooterContentObj::ScHeaderFooterContentObj( const EditTextObject* pLeft,
  92                                                     const EditTextObject* pCenter,
  93                                                     const EditTextObject* pRight ) :
  94     mxLeftText(new ScHeaderFooterTextObj(*this, SC_HDFT_LEFT, pLeft)),
  95     mxCenterText(new ScHeaderFooterTextObj(*this, SC_HDFT_CENTER, pCenter)),
  96     mxRightText(new ScHeaderFooterTextObj(*this, SC_HDFT_RIGHT, pRight))
  97 {
  98 }
  99
 100 ScHeaderFooterContentObj::~ScHeaderFooterContentObj() {}
 101
 102 const EditTextObject* ScHeaderFooterContentObj::GetLeftEditObject() const
 103 {
 104     return mxLeftText->GetTextObject();
 105 }
 106
 107 const EditTextObject* ScHeaderFooterContentObj::GetCenterEditObject() const
 108 {
 109     return mxCenterText->GetTextObject();
 110 }
 111
 112 const EditTextObject* ScHeaderFooterContentObj::GetRightEditObject() const
 113 {
 114     return mxRightText->GetTextObject();
 115 }
 116
 117 // XHeaderFooterContent
 118
 119 uno::Reference<text::XText> SAL_CALL ScHeaderFooterContentObj::getLeftText()
 120                                                 throw(uno::RuntimeException, std::exception)
 121 {
 122     SolarMutexGuard aGuard;
 123     uno::Reference<text::XText> xInt(*mxLeftText, uno::UNO_QUERY);
 124     return xInt;
 125 }
 126
 127 uno::Reference<text::XText> SAL_CALL ScHeaderFooterContentObj::getCenterText()
 128                                                 throw(uno::RuntimeException, std::exception)
 129 {
 130     SolarMutexGuard aGuard;
 131     uno::Reference<text::XText> xInt(*mxCenterText, uno::UNO_QUERY);
 132     return xInt;
 133 }
 134
 135 uno::Reference<text::XText> SAL_CALL ScHeaderFooterContentObj::getRightText()
 136                                                 throw(uno::RuntimeException, std::exception)
 137 {
 138     SolarMutexGuard aGuard;
 139     uno::Reference<text::XText> xInt(*mxRightText, uno::UNO_QUERY);
 140     return xInt;
 141 }
 142
 143 // XUnoTunnel
 144
 145 sal_Int64 SAL_CALL ScHeaderFooterContentObj::getSomething(
 146                 const uno::Sequence<sal_Int8 >& rId ) throw(uno::RuntimeException, std::exception)
 147 {
 148     if ( rId.getLength() == 16 &&
 149           0 == memcmp( getUnoTunnelId().getConstArray(),
 150                                     rId.getConstArray(), 16 ) )
 151     {
 152         return sal::static_int_cast<sal_Int64>(reinterpret_cast<sal_IntPtr>(this));
 153     }
 154     return 0;
 155 }
 156
 157 namespace
 158 {
 159     class theScHeaderFooterContentObjUnoTunnelId : public rtl::Static< UnoTunnelIdInit, theScHeaderFooterContentObjUnoTunnelId> {};
 160 }
 161
 162 const uno::Sequence<sal_Int8>& ScHeaderFooterContentObj::getUnoTunnelId()
 163 {
 164     return theScHeaderFooterContentObjUnoTunnelId::get().getSeq();
 165 }
 166
 167 ScHeaderFooterContentObj* ScHeaderFooterContentObj::getImplementation(
 168                                 const uno::Reference<sheet::XHeaderFooterContent> xObj )
 169 {
 170     ScHeaderFooterContentObj* pRet = NULL;
 171     uno::Reference<lang::XUnoTunnel> xUT( xObj, uno::UNO_QUERY );
 172     if (xUT.is())
 173         pRet = reinterpret_cast<ScHeaderFooterContentObj*>(sal::static_int_cast<sal_IntPtr>(xUT->getSomething(getUnoTunnelId())));
 174     return pRet;
 175 }
 176
 177
 178 ScHeaderFooterTextData::ScHeaderFooterTextData(
 179     ScHeaderFooterContentObj& rContent, sal_uInt16 nP, const EditTextObject* pTextObj) :
 180     mpTextObj(pTextObj ? pTextObj->Clone() : NULL),
 181     rContentObj( rContent ),
 182     nPart( nP ),
 183     pEditEngine( NULL ),
 184     pForwarder( NULL ),
 185     bDataValid(false)
 186 {
 187 }
 188
 189 ScHeaderFooterTextData::~ScHeaderFooterTextData()
 190 {
 191     SolarMutexGuard aGuard;     //  needed for EditEngine dtor
 192
 193     delete pForwarder;
 194     delete pEditEngine;
 195     delete mpTextObj;
 196 }
 197
 198 SvxTextForwarder* ScHeaderFooterTextData::GetTextForwarder()
 199 {
 200     if (!pEditEngine)
 201     {
 202         SfxItemPool* pEnginePool = EditEngine::CreatePool();
 203         pEnginePool->FreezeIdRanges();
 204         ScHeaderEditEngine* pHdrEngine = new ScHeaderEditEngine( pEnginePool, true );
 205
 206         pHdrEngine->EnableUndo( false );
 207         pHdrEngine->SetRefMapMode( MAP_TWIP );
 208
 209         //  default font must be set, independently of document
 210         //  -> use global pool from module
 211
 212         SfxItemSet aDefaults( pHdrEngine->GetEmptyItemSet() );
 213         const ScPatternAttr& rPattern = (const ScPatternAttr&)SC_MOD()->GetPool().GetDefaultItem(ATTR_PATTERN);
 214         rPattern.FillEditItemSet( &aDefaults );
 215         //  FillEditItemSet adjusts font height to 1/100th mm,
 216         //  but for header/footer twips is needed, as in the PatternAttr:
 217         aDefaults.Put( rPattern.GetItem(ATTR_FONT_HEIGHT), EE_CHAR_FONTHEIGHT );
 218         aDefaults.Put( rPattern.GetItem(ATTR_CJK_FONT_HEIGHT), EE_CHAR_FONTHEIGHT_CJK );
 219         aDefaults.Put( rPattern.GetItem(ATTR_CTL_FONT_HEIGHT), EE_CHAR_FONTHEIGHT_CTL );
 220         pHdrEngine->SetDefaults( aDefaults );
 221
 222         ScHeaderFieldData aData;
 223         ScHeaderFooterTextObj::FillDummyFieldData( aData );
 224         pHdrEngine->SetData( aData );
 225
 226         pEditEngine = pHdrEngine;
 227         pForwarder = new SvxEditEngineForwarder(*pEditEngine);
 228     }
 229
 230     if (bDataValid)
 231         return pForwarder;
 232
 233     if (mpTextObj)
 234         pEditEngine->SetText(*mpTextObj);
 235
 236     bDataValid = true;
 237     return pForwarder;
 238 }
 239
 240 void ScHeaderFooterTextData::UpdateData()
 241 {
 242     if (pEditEngine)
 243     {
 244         delete mpTextObj;
 245         mpTextObj = pEditEngine->CreateTextObject();
 246     }
 247 }
 248
 249 void ScHeaderFooterTextData::UpdateData(EditEngine& rEditEngine)
 250 {
 251     delete mpTextObj;
 252     mpTextObj = rEditEngine.CreateTextObject();
 253     bDataValid = false;
 254 }
 255
 256 const EditTextObject* ScHeaderFooterTextData::GetTextObject() const
 257 {
 258     return mpTextObj;
 259 }
 260
 261 ScHeaderFooterTextObj::ScHeaderFooterTextObj(
 262     ScHeaderFooterContentObj& rContent, sal_uInt16 nP, const EditTextObject* pTextObj) :
 263     aTextData(rContent, nP, pTextObj)
 264 {
 265     //  ScHeaderFooterTextData acquires rContent
 266     //  pUnoText is created on demand (getString/setString work without it)
 267 }
 268
 269 void ScHeaderFooterTextObj::CreateUnoText_Impl()
 270 {
 271     if (!mxUnoText.is())
 272     {
 273         //  can't be aggregated because getString/setString is handled here
 274         ScHeaderFooterEditSource aEditSrc(aTextData);
 275         mxUnoText.set(new SvxUnoText(&aEditSrc, lcl_GetHdFtPropertySet(), uno::Reference<text::XText>()));
 276     }
 277 }
 278
 279 ScHeaderFooterTextObj::~ScHeaderFooterTextObj() {}
 280
 281 const EditTextObject* ScHeaderFooterTextObj::GetTextObject() const
 282 {
 283     return aTextData.GetTextObject();
 284 }
 285
 286 const SvxUnoText& ScHeaderFooterTextObj::GetUnoText()
 287 {
 288     if (!mxUnoText.is())
 289         CreateUnoText_Impl();
 290     return *mxUnoText;
 291 }
 292
 293 // XText
 294
 295 uno::Reference<text::XTextCursor> SAL_CALL ScHeaderFooterTextObj::createTextCursor()
 296                                                     throw(uno::RuntimeException, std::exception)
 297 {
 298     SolarMutexGuard aGuard;
 299     return new ScHeaderFooterTextCursor( *this );
 300 }
 301
 302 uno::Reference<text::XTextCursor> SAL_CALL ScHeaderFooterTextObj::createTextCursorByRange(
 303                                     const uno::Reference<text::XTextRange>& aTextPosition )
 304                                                     throw(uno::RuntimeException, std::exception)
 305 {
 306     SolarMutexGuard aGuard;
 307     if (!mxUnoText.is())
 308         CreateUnoText_Impl();
 309     return mxUnoText->createTextCursorByRange(aTextPosition);
 310     //! wie ScCellObj::createTextCursorByRange, wenn SvxUnoTextRange_getReflection verfuegbar
 311 }
 312
 313 void ScHeaderFooterTextObj::FillDummyFieldData( ScHeaderFieldData& rData )
 314 {
 315     OUString aDummy("???");
 316     rData.aTitle        = aDummy;
 317     rData.aLongDocName  = aDummy;
 318     rData.aShortDocName = aDummy;
 319     rData.aTabName      = aDummy;
 320     rData.nPageNo       = 1;
 321     rData.nTotalPages   = 99;
 322 }
 323
 324 OUString SAL_CALL ScHeaderFooterTextObj::getString() throw(uno::RuntimeException, std::exception)
 325 {
 326     SolarMutexGuard aGuard;
 327     OUString aRet;
 328     const EditTextObject* pData;
 329
 330     sal_uInt16 nPart = aTextData.GetPart();
 331     ScHeaderFooterContentObj& rContentObj = aTextData.GetContentObj();
 332
 333     if (nPart == SC_HDFT_LEFT)
 334         pData = rContentObj.GetLeftEditObject();
 335     else if (nPart == SC_HDFT_CENTER)
 336         pData = rContentObj.GetCenterEditObject();
 337     else
 338         pData = rContentObj.GetRightEditObject();
 339     if (pData)
 340     {
 341         // for pure text, no font info is needed in pool defaults
 342         ScHeaderEditEngine aEditEngine( EditEngine::CreatePool(), true );
 343
 344         ScHeaderFieldData aData;
 345         FillDummyFieldData( aData );
 346         aEditEngine.SetData( aData );
 347
 348         aEditEngine.SetText(*pData);
 349         aRet = ScEditUtil::GetSpaceDelimitedString( aEditEngine );
 350     }
 351     return aRet;
 352 }
 353
 354 void SAL_CALL ScHeaderFooterTextObj::setString( const OUString& aText ) throw(uno::RuntimeException, std::exception)
 355 {
 356     SolarMutexGuard aGuard;
 357     OUString aString(aText);
 358
 359     // for pure text, no font info is needed in pool defaults
 360     ScHeaderEditEngine aEditEngine(EditEngine::CreatePool(), true);
 361     aEditEngine.SetText( aString );
 362     aTextData.UpdateData(aEditEngine);
 363 }
 364
 365 void SAL_CALL ScHeaderFooterTextObj::insertString( const uno::Reference<text::XTextRange>& xRange,
 366                                             const OUString& aString, sal_Bool bAbsorb )
 367                                 throw(uno::RuntimeException, std::exception)
 368 {
 369     SolarMutexGuard aGuard;
 370     if (!mxUnoText.is())
 371         CreateUnoText_Impl();
 372     mxUnoText->insertString( xRange, aString, bAbsorb );
 373 }
 374
 375 void SAL_CALL ScHeaderFooterTextObj::insertControlCharacter(
 376                                             const uno::Reference<text::XTextRange>& xRange,
 377                                             sal_Int16 nControlCharacter, sal_Bool bAbsorb )
 378                                 throw(lang::IllegalArgumentException, uno::RuntimeException, std::exception)
 379 {
 380     SolarMutexGuard aGuard;
 381     if (!mxUnoText.is())
 382         CreateUnoText_Impl();
 383     mxUnoText->insertControlCharacter( xRange, nControlCharacter, bAbsorb );
 384 }
 385
 386 void SAL_CALL ScHeaderFooterTextObj::insertTextContent(
 387                                             const uno::Reference<text::XTextRange >& xRange,
 388                                             const uno::Reference<text::XTextContent >& xContent,
 389                                             sal_Bool bAbsorb )
 390                                 throw(lang::IllegalArgumentException, uno::RuntimeException, std::exception)
 391 {
 392     SolarMutexGuard aGuard;
 393     if ( xContent.is() && xRange.is() )
 394     {
 395         ScEditFieldObj* pHeaderField = ScEditFieldObj::getImplementation( xContent );
 396
 397         SvxUnoTextRangeBase* pTextRange =
 398             ScHeaderFooterTextCursor::getImplementation( xRange );
 399
 400         if ( pHeaderField && !pHeaderField->IsInserted() && pTextRange )
 401         {
 402             SvxEditSource* pEditSource = pTextRange->GetEditSource();
 403             ESelection aSelection(pTextRange->GetSelection());
 404
 405             if (!bAbsorb)
 406             {
 407                 //  don't replace -> append at end
 408                 aSelection.Adjust();
 409                 aSelection.nStartPara = aSelection.nEndPara;
 410                 aSelection.nStartPos  = aSelection.nEndPos;
 411             }
 412
 413             SvxFieldItem aItem(pHeaderField->CreateFieldItem());
 414
 415             SvxTextForwarder* pForwarder = pEditSource->GetTextForwarder();
 416             pForwarder->QuickInsertField( aItem, aSelection );
 417             pEditSource->UpdateData();
 418
 419             //  neue Selektion: ein Zeichen
 420             aSelection.Adjust();
 421             aSelection.nEndPara = aSelection.nStartPara;
 422             aSelection.nEndPos = aSelection.nStartPos + 1;
 423
 424             uno::Reference<text::XTextRange> xTextRange;
 425             switch (aTextData.GetPart())
 426             {
 427                 case SC_HDFT_LEFT:
 428                 {
 429                     uno::Reference<text::XTextRange> xTemp(
 430                         aTextData.GetContentObj().getLeftText(), uno::UNO_QUERY);
 431                     xTextRange = xTemp;
 432                 }
 433                 break;
 434                 case SC_HDFT_CENTER:
 435                 {
 436                     uno::Reference<text::XTextRange> xTemp(
 437                         aTextData.GetContentObj().getCenterText(), uno::UNO_QUERY);
 438                     xTextRange = xTemp;
 439                 }
 440                 break;
 441                 case SC_HDFT_RIGHT:
 442                 {
 443                     uno::Reference<text::XTextRange> xTemp(
 444                         aTextData.GetContentObj().getRightText(), uno::UNO_QUERY);
 445                     xTextRange = xTemp;
 446                 }
 447                 break;
 448             }
 449
 450             pHeaderField->InitDoc(xTextRange, new ScHeaderFooterEditSource(aTextData), aSelection);
 451
 452             //  for bAbsorb=FALSE, the new selection must be behind the inserted content
 453             //  (the xml filter relies on this)
 454             if (!bAbsorb)
 455                 aSelection.nStartPos = aSelection.nEndPos;
 456
 457             pTextRange->SetSelection( aSelection );
 458
 459             return;
 460         }
 461     }
 462
 463     if (!mxUnoText.is())
 464         CreateUnoText_Impl();
 465     mxUnoText->insertTextContent( xRange, xContent, bAbsorb );
 466 }
 467
 468 void SAL_CALL ScHeaderFooterTextObj::removeTextContent(
 469                                             const uno::Reference<text::XTextContent>& xContent )
 470                                 throw(container::NoSuchElementException, uno::RuntimeException, std::exception)
 471 {
 472     SolarMutexGuard aGuard;
 473     if ( xContent.is() )
 474     {
 475         ScEditFieldObj* pHeaderField = ScEditFieldObj::getImplementation(xContent);
 476         if ( pHeaderField && pHeaderField->IsInserted() )
 477         {
 478             //! Testen, ob das Feld in dieser Zelle ist
 479             pHeaderField->DeleteField();
 480             return;
 481         }
 482     }
 483     if (!mxUnoText.is())
 484         CreateUnoText_Impl();
 485     mxUnoText->removeTextContent( xContent );
 486 }
 487
 488 uno::Reference<text::XText> SAL_CALL ScHeaderFooterTextObj::getText() throw(uno::RuntimeException, std::exception)
 489 {
 490     SolarMutexGuard aGuard;
 491     if (!mxUnoText.is())
 492         CreateUnoText_Impl();
 493     return mxUnoText->getText();
 494 }
 495
 496 uno::Reference<text::XTextRange> SAL_CALL ScHeaderFooterTextObj::getStart() throw(uno::RuntimeException, std::exception)
 497 {
 498     SolarMutexGuard aGuard;
 499     if (!mxUnoText.is())
 500         CreateUnoText_Impl();
 501     return mxUnoText->getStart();
 502 }
 503
 504 uno::Reference<text::XTextRange> SAL_CALL ScHeaderFooterTextObj::getEnd() throw(uno::RuntimeException, std::exception)
 505 {
 506     SolarMutexGuard aGuard;
 507     if (!mxUnoText.is())
 508         CreateUnoText_Impl();
 509     return mxUnoText->getEnd();
 510 }
 511
 512 // XTextFieldsSupplier
 513
 514 uno::Reference<container::XEnumerationAccess> SAL_CALL ScHeaderFooterTextObj::getTextFields()
 515                                                 throw(uno::RuntimeException, std::exception)
 516 {
 517     SolarMutexGuard aGuard;
 518     // all fields
 519     return new ScHeaderFieldsObj(aTextData);
 520 }
 521
 522 uno::Reference<container::XNameAccess> SAL_CALL ScHeaderFooterTextObj::getTextFieldMasters()
 523                                                 throw(uno::RuntimeException, std::exception)
 524 {
 525     //  sowas gibts nicht im Calc (?)
 526     return NULL;
 527 }
 528
 529 // XTextRangeMover
 530
 531 void SAL_CALL ScHeaderFooterTextObj::moveTextRange(
 532                                         const uno::Reference<text::XTextRange>& xRange,
 533                                         sal_Int16 nParagraphs )
 534                                         throw(uno::RuntimeException, std::exception)
 535 {
 536     SolarMutexGuard aGuard;
 537     if (!mxUnoText.is())
 538         CreateUnoText_Impl();
 539     mxUnoText->moveTextRange( xRange, nParagraphs );
 540 }
 541
 542 // XEnumerationAccess
 543
 544 uno::Reference<container::XEnumeration> SAL_CALL ScHeaderFooterTextObj::createEnumeration()
 545                                                 throw(uno::RuntimeException, std::exception)
 546 {
 547     SolarMutexGuard aGuard;
 548     if (!mxUnoText.is())
 549         CreateUnoText_Impl();
 550     return mxUnoText->createEnumeration();
 551 }
 552
 553 // XElementAccess
 554
 555 uno::Type SAL_CALL ScHeaderFooterTextObj::getElementType() throw(uno::RuntimeException, std::exception)
 556 {
 557     SolarMutexGuard aGuard;
 558     if (!mxUnoText.is())
 559         CreateUnoText_Impl();
 560     return mxUnoText->getElementType();
 561 }
 562
 563 sal_Bool SAL_CALL ScHeaderFooterTextObj::hasElements() throw(uno::RuntimeException, std::exception)
 564 {
 565     SolarMutexGuard aGuard;
 566     if (!mxUnoText.is())
 567         CreateUnoText_Impl();
 568     return mxUnoText->hasElements();
 569 }
 570
 571 ScCellTextCursor::ScCellTextCursor(const ScCellTextCursor& rOther) :
 572     SvxUnoTextCursor( rOther ),
 573     rTextObj( rOther.rTextObj )
 574 {
 575     rTextObj.acquire();
 576 }
 577
 578 ScCellTextCursor::ScCellTextCursor(ScCellObj& rText) :
 579     SvxUnoTextCursor( rText.GetUnoText() ),
 580     rTextObj( rText )
 581 {
 582     rTextObj.acquire();
 583 }
 584
 585 ScCellTextCursor::~ScCellTextCursor() throw()
 586 {
 587     rTextObj.release();
 588 }
 589
 590 // SvxUnoTextCursor methods reimplemented here to return the right objects:
 591
 592 uno::Reference<text::XText> SAL_CALL ScCellTextCursor::getText() throw(uno::RuntimeException, std::exception)
 593 {
 594     SolarMutexGuard aGuard;
 595     return &rTextObj;
 596 }
 597
 598 uno::Reference<text::XTextRange> SAL_CALL ScCellTextCursor::getStart() throw(uno::RuntimeException, std::exception)
 599 {
 600     SolarMutexGuard aGuard;
 601
 602     //! use other object for range than cursor?
 603
 604     ScCellTextCursor* pNew = new ScCellTextCursor( *this );
 605     uno::Reference<text::XTextRange> xRange( static_cast<SvxUnoTextRangeBase*>(pNew) );
 606
 607     ESelection aNewSel(GetSelection());
 608     aNewSel.nEndPara = aNewSel.nStartPara;
 609     aNewSel.nEndPos  = aNewSel.nStartPos;
 610     pNew->SetSelection( aNewSel );
 611
 612     return xRange;
 613 }
 614
 615 uno::Reference<text::XTextRange> SAL_CALL ScCellTextCursor::getEnd() throw(uno::RuntimeException, std::exception)
 616 {
 617     SolarMutexGuard aGuard;
 618
 619     //! use other object for range than cursor?
 620
 621     ScCellTextCursor* pNew = new ScCellTextCursor( *this );
 622     uno::Reference<text::XTextRange> xRange( static_cast<SvxUnoTextRangeBase*>(pNew) );
 623
 624     ESelection aNewSel(GetSelection());
 625     aNewSel.nStartPara = aNewSel.nEndPara;
 626     aNewSel.nStartPos  = aNewSel.nEndPos;
 627     pNew->SetSelection( aNewSel );
 628
 629     return xRange;
 630 }
 631
 632 // XUnoTunnel
 633
 634 sal_Int64 SAL_CALL ScCellTextCursor::getSomething(
 635                 const uno::Sequence<sal_Int8 >& rId ) throw(uno::RuntimeException, std::exception)
 636 {
 637     if ( rId.getLength() == 16 &&
 638           0 == memcmp( getUnoTunnelId().getConstArray(),
 639                                     rId.getConstArray(), 16 ) )
 640     {
 641         return sal::static_int_cast<sal_Int64>(reinterpret_cast<sal_IntPtr>(this));
 642     }
 643     return SvxUnoTextCursor::getSomething( rId );
 644 }
 645
 646 namespace
 647 {
 648     class theScCellTextCursorUnoTunnelId : public rtl::Static< UnoTunnelIdInit, theScCellTextCursorUnoTunnelId> {};
 649 }
 650
 651 const uno::Sequence<sal_Int8>& ScCellTextCursor::getUnoTunnelId()
 652 {
 653     return theScCellTextCursorUnoTunnelId::get().getSeq();
 654 }
 655
 656 ScCellTextCursor* ScCellTextCursor::getImplementation( const uno::Reference<uno::XInterface> xObj )
 657 {
 658     ScCellTextCursor* pRet = NULL;
 659     uno::Reference<lang::XUnoTunnel> xUT( xObj, uno::UNO_QUERY );
 660     if (xUT.is())
 661         pRet = reinterpret_cast<ScCellTextCursor*>(sal::static_int_cast<sal_IntPtr>(xUT->getSomething(getUnoTunnelId())));
 662     return pRet;
 663 }
 664
 665 ScHeaderFooterTextCursor::ScHeaderFooterTextCursor(const ScHeaderFooterTextCursor& rOther) :
 666     SvxUnoTextCursor( rOther ),
 667     rTextObj( rOther.rTextObj )
 668 {
 669     rTextObj.acquire();
 670 }
 671
 672 ScHeaderFooterTextCursor::ScHeaderFooterTextCursor(ScHeaderFooterTextObj& rText) :
 673     SvxUnoTextCursor( rText.GetUnoText() ),
 674     rTextObj( rText )
 675 {
 676     rTextObj.acquire();
 677 }
 678
 679 ScHeaderFooterTextCursor::~ScHeaderFooterTextCursor() throw()
 680 {
 681     rTextObj.release();
 682 }
 683
 684 // SvxUnoTextCursor methods reimplemented here to return the right objects:
 685
 686 uno::Reference<text::XText> SAL_CALL ScHeaderFooterTextCursor::getText() throw(uno::RuntimeException, std::exception)
 687 {
 688     SolarMutexGuard aGuard;
 689     return &rTextObj;
 690 }
 691
 692 uno::Reference<text::XTextRange> SAL_CALL ScHeaderFooterTextCursor::getStart() throw(uno::RuntimeException, std::exception)
 693 {
 694     SolarMutexGuard aGuard;
 695
 696     //! use other object for range than cursor?
 697
 698     ScHeaderFooterTextCursor* pNew = new ScHeaderFooterTextCursor( *this );
 699     uno::Reference<text::XTextRange> xRange( static_cast<SvxUnoTextRangeBase*>(pNew) );
 700
 701     ESelection aNewSel(GetSelection());
 702     aNewSel.nEndPara = aNewSel.nStartPara;
 703     aNewSel.nEndPos  = aNewSel.nStartPos;
 704     pNew->SetSelection( aNewSel );
 705
 706     return xRange;
 707 }
 708
 709 uno::Reference<text::XTextRange> SAL_CALL ScHeaderFooterTextCursor::getEnd() throw(uno::RuntimeException, std::exception)
 710 {
 711     SolarMutexGuard aGuard;
 712
 713     //! use other object for range than cursor?
 714
 715     ScHeaderFooterTextCursor* pNew = new ScHeaderFooterTextCursor( *this );
 716     uno::Reference<text::XTextRange> xRange( static_cast<SvxUnoTextRangeBase*>(pNew) );
 717
 718     ESelection aNewSel(GetSelection());
 719     aNewSel.nStartPara = aNewSel.nEndPara;
 720     aNewSel.nStartPos  = aNewSel.nEndPos;
 721     pNew->SetSelection( aNewSel );
 722
 723     return xRange;
 724 }
 725
 726 // XUnoTunnel
 727
 728 sal_Int64 SAL_CALL ScHeaderFooterTextCursor::getSomething(
 729                 const uno::Sequence<sal_Int8 >& rId ) throw(uno::RuntimeException, std::exception)
 730 {
 731     if ( rId.getLength() == 16 &&
 732           0 == memcmp( getUnoTunnelId().getConstArray(),
 733                                     rId.getConstArray(), 16 ) )
 734     {
 735         return sal::static_int_cast<sal_Int64>(reinterpret_cast<sal_IntPtr>(this));
 736     }
 737     return SvxUnoTextCursor::getSomething( rId );
 738 }
 739
 740 namespace
 741 {
 742     class theScHeaderFooterTextCursorUnoTunnelId : public rtl::Static< UnoTunnelIdInit, theScHeaderFooterTextCursorUnoTunnelId> {};
 743 }
 744
 745 const uno::Sequence<sal_Int8>& ScHeaderFooterTextCursor::getUnoTunnelId()
 746 {
 747     return theScHeaderFooterTextCursorUnoTunnelId::get().getSeq();
 748 }
 749
 750 ScHeaderFooterTextCursor* ScHeaderFooterTextCursor::getImplementation(
 751                                 const uno::Reference<uno::XInterface> xObj )
 752 {
 753     ScHeaderFooterTextCursor* pRet = NULL;
 754     uno::Reference<lang::XUnoTunnel> xUT( xObj, uno::UNO_QUERY );
 755     if (xUT.is())
 756         pRet = reinterpret_cast<ScHeaderFooterTextCursor*>(sal::static_int_cast<sal_IntPtr>(xUT->getSomething(getUnoTunnelId())));
 757     return pRet;
 758 }
 759
 760 ScDrawTextCursor::ScDrawTextCursor(const ScDrawTextCursor& rOther) :
 761     SvxUnoTextCursor( rOther ),
 762     xParentText( rOther.xParentText )
 763 {
 764 }
 765
 766 ScDrawTextCursor::ScDrawTextCursor( const uno::Reference<text::XText>& xParent,
 767                                     const SvxUnoTextBase& rText ) :
 768     SvxUnoTextCursor( rText ),
 769     xParentText( xParent )
 770
 771 {
 772 }
 773
 774 ScDrawTextCursor::~ScDrawTextCursor() throw()
 775 {
 776 }
 777
 778 // SvxUnoTextCursor methods reimplemented here to return the right objects:
 779
 780 uno::Reference<text::XText> SAL_CALL ScDrawTextCursor::getText() throw(uno::RuntimeException, std::exception)
 781 {
 782     SolarMutexGuard aGuard;
 783     return xParentText;
 784 }
 785
 786 uno::Reference<text::XTextRange> SAL_CALL ScDrawTextCursor::getStart() throw(uno::RuntimeException, std::exception)
 787 {
 788     SolarMutexGuard aGuard;
 789
 790     //! use other object for range than cursor?
 791
 792     ScDrawTextCursor* pNew = new ScDrawTextCursor( *this );
 793     uno::Reference<text::XTextRange> xRange( static_cast<SvxUnoTextRangeBase*>(pNew) );
 794
 795     ESelection aNewSel(GetSelection());
 796     aNewSel.nEndPara = aNewSel.nStartPara;
 797     aNewSel.nEndPos  = aNewSel.nStartPos;
 798     pNew->SetSelection( aNewSel );
 799
 800     return xRange;
 801 }
 802
 803 uno::Reference<text::XTextRange> SAL_CALL ScDrawTextCursor::getEnd() throw(uno::RuntimeException, std::exception)
 804 {
 805     SolarMutexGuard aGuard;
 806
 807     //! use other object for range than cursor?
 808
 809     ScDrawTextCursor* pNew = new ScDrawTextCursor( *this );
 810     uno::Reference<text::XTextRange> xRange( static_cast<SvxUnoTextRangeBase*>(pNew) );
 811
 812     ESelection aNewSel(GetSelection());
 813     aNewSel.nStartPara = aNewSel.nEndPara;
 814     aNewSel.nStartPos  = aNewSel.nEndPos;
 815     pNew->SetSelection( aNewSel );
 816
 817     return xRange;
 818 }
 819
 820 // XUnoTunnel
 821
 822 sal_Int64 SAL_CALL ScDrawTextCursor::getSomething(
 823                 const uno::Sequence<sal_Int8 >& rId ) throw(uno::RuntimeException, std::exception)
 824 {
 825     if ( rId.getLength() == 16 &&
 826           0 == memcmp( getUnoTunnelId().getConstArray(),
 827                                     rId.getConstArray(), 16 ) )
 828     {
 829         return sal::static_int_cast<sal_Int64>(reinterpret_cast<sal_IntPtr>(this));
 830     }
 831     return SvxUnoTextCursor::getSomething( rId );
 832 }
 833
 834 namespace
 835 {
 836     class theScDrawTextCursorUnoTunnelId : public rtl::Static< UnoTunnelIdInit, theScDrawTextCursorUnoTunnelId> {};
 837 }
 838
 839 const uno::Sequence<sal_Int8>& ScDrawTextCursor::getUnoTunnelId()
 840 {
 841     return theScDrawTextCursorUnoTunnelId::get().getSeq();
 842 }
 843
 844 ScDrawTextCursor* ScDrawTextCursor::getImplementation( const uno::Reference<uno::XInterface> xObj )
 845 {
 846     ScDrawTextCursor* pRet = NULL;
 847     uno::Reference<lang::XUnoTunnel> xUT( xObj, uno::UNO_QUERY );
 848     if (xUT.is())
 849         pRet = reinterpret_cast<ScDrawTextCursor*>(sal::static_int_cast<sal_IntPtr>(xUT->getSomething(getUnoTunnelId())));
 850     return pRet;
 851 }
 852
 853 ScSimpleEditSourceHelper::ScSimpleEditSourceHelper()
 854 {
 855     SfxItemPool* pEnginePool = EditEngine::CreatePool();
 856     pEnginePool->SetDefaultMetric( SFX_MAPUNIT_100TH_MM );
 857     pEnginePool->FreezeIdRanges();
 858
 859     pEditEngine = new ScFieldEditEngine(NULL, pEnginePool, NULL, true);     // TRUE: become owner of pool
 860     pForwarder = new SvxEditEngineForwarder( *pEditEngine );
 861     pOriginalSource = new ScSimpleEditSource( pForwarder );
 862 }
 863
 864 ScSimpleEditSourceHelper::~ScSimpleEditSourceHelper()
 865 {
 866     SolarMutexGuard aGuard;     //  needed for EditEngine dtor
 867
 868     delete pOriginalSource;
 869     delete pForwarder;
 870     delete pEditEngine;
 871 }
 872
 873 ScEditEngineTextObj::ScEditEngineTextObj() :
 874     SvxUnoText( GetOriginalSource(), ScCellObj::GetEditPropertySet(), uno::Reference<text::XText>() )
 875 {
 876 }
 877
 878 ScEditEngineTextObj::~ScEditEngineTextObj() throw()
 879 {
 880 }
 881
 882 void ScEditEngineTextObj::SetText( const EditTextObject& rTextObject )
 883 {
 884     GetEditEngine()->SetText( rTextObject );
 885
 886     ESelection aSel;
 887     ::GetSelection( aSel, GetEditSource()->GetTextForwarder() );
 888     SetSelection( aSel );
 889 }
 890
 891 EditTextObject* ScEditEngineTextObj::CreateTextObject()
 892 {
 893     return GetEditEngine()->CreateTextObject();
 894 }
 895
 896 ScCellTextData::ScCellTextData(ScDocShell* pDocSh, const ScAddress& rP) :
 897     pDocShell( pDocSh ),
 898     aCellPos( rP ),
 899     pEditEngine( NULL ),
 900     pForwarder( NULL ),
 901     pOriginalSource( NULL ),
 902     bDataValid( false ),
 903     bInUpdate( false ),
 904     bDirty( false ),
 905     bDoUpdate( true )
 906 {
 907     if (pDocShell)
 908         pDocShell->GetDocument()->AddUnoObject(*this);
 909 }
 910
 911 ScCellTextData::~ScCellTextData()
 912 {
 913     SolarMutexGuard aGuard;     //  needed for EditEngine dtor
 914
 915     if (pDocShell)
 916     {
 917         pDocShell->GetDocument()->RemoveUnoObject(*this);
 918         pDocShell->GetDocument()->DisposeFieldEditEngine(pEditEngine);
 919     }
 920     else
 921         delete pEditEngine;
 922
 923     delete pForwarder;
 924
 925     delete pOriginalSource;
 926 }
 927
 928 ScCellEditSource* ScCellTextData::GetOriginalSource()
 929 {
 930     if (!pOriginalSource)
 931         pOriginalSource = new ScCellEditSource(pDocShell, aCellPos);
 932     return pOriginalSource;
 933 }
 934
 935 void ScCellTextData::GetCellText(const ScAddress& rCellPos, OUString& rText)
 936 {
 937     if (pDocShell)
 938     {
 939         ScDocument* pDoc = pDocShell->GetDocument();
 940         pDoc->GetInputString( rCellPos.Col(), rCellPos.Row(), rCellPos.Tab(), rText );
 941     }
 942 }
 943
 944 SvxTextForwarder* ScCellTextData::GetTextForwarder()
 945 {
 946     if (!pEditEngine)
 947     {
 948         if ( pDocShell )
 949         {
 950             ScDocument* pDoc = pDocShell->GetDocument();
 951             pEditEngine = pDoc->CreateFieldEditEngine();
 952         }
 953         else
 954         {
 955             SfxItemPool* pEnginePool = EditEngine::CreatePool();
 956             pEnginePool->FreezeIdRanges();
 957             pEditEngine = new ScFieldEditEngine(NULL, pEnginePool, NULL, true);
 958         }
 959         //  currently, GetPortions doesn't work if UpdateMode is sal_False,
 960         //  this will be fixed (in EditEngine) by src600
 961 //      pEditEngine->SetUpdateMode( sal_False );
 962         pEditEngine->EnableUndo( false );
 963         if (pDocShell)
 964             pEditEngine->SetRefDevice(pDocShell->GetRefDevice());
 965         else
 966             pEditEngine->SetRefMapMode( MAP_100TH_MM );
 967         pForwarder = new SvxEditEngineForwarder(*pEditEngine);
 968     }
 969
 970     if (bDataValid)
 971         return pForwarder;
 972
 973     OUString aText;
 974
 975     if (pDocShell)
 976     {
 977         ScDocument* pDoc = pDocShell->GetDocument();
 978
 979         SfxItemSet aDefaults( pEditEngine->GetEmptyItemSet() );
 980         if( const ScPatternAttr* pPattern =
 981                 pDoc->GetPattern( aCellPos.Col(), aCellPos.Row(), aCellPos.Tab() ) )
 982         {
 983             pPattern->FillEditItemSet( &aDefaults );
 984             pPattern->FillEditParaItems( &aDefaults );  // including alignment etc. (for reading)
 985         }
 986
 987         if (pDoc->GetCellType(aCellPos) == CELLTYPE_EDIT)
 988         {
 989             const EditTextObject* pObj = pDoc->GetEditText(aCellPos);
 990             if (pObj)
 991                 pEditEngine->SetTextNewDefaults(*pObj, aDefaults);
 992         }
 993         else
 994         {
 995             GetCellText(aCellPos, aText);
 996             if (!aText.isEmpty())
 997                 pEditEngine->SetTextNewDefaults(aText, aDefaults);
 998             else
 999                 pEditEngine->SetDefaults(aDefaults);
1000         }
1001     }
1002
1003     bDataValid = true;
1004     return pForwarder;
1005 }
1006
1007 void ScCellTextData::UpdateData()
1008 {
1009     if ( bDoUpdate )
1010     {
1011         OSL_ENSURE(pEditEngine != NULL, "no EditEngine for UpdateData()");
1012         if ( pDocShell && pEditEngine )
1013         {
1014             //  during the own UpdateData call, bDataValid must not be reset,
1015             //  or things like attributes after the text would be lost
1016             //  (are not stored in the cell)
1017             bInUpdate = true;   // prevents bDataValid from being reset
1018             pDocShell->GetDocFunc().PutData(aCellPos, *pEditEngine, true); // always as text
1019
1020             bInUpdate = false;
1021             bDirty = false;
1022         }
1023     }
1024     else
1025         bDirty = true;
1026 }
1027
1028 void ScCellTextData::Notify( SfxBroadcaster&, const SfxHint& rHint )
1029 {
1030     if ( rHint.ISA( ScUpdateRefHint ) )
1031     {
1032 //        const ScUpdateRefHint& rRef = (const ScUpdateRefHint&)rHint;
1033
1034         //! Ref-Update
1035     }
1036     else if ( rHint.ISA( SfxSimpleHint ) )
1037     {
1038         sal_uLong nId = ((const SfxSimpleHint&)rHint).GetId();
1039         if ( nId == SFX_HINT_DYING )
1040         {
1041             pDocShell = NULL;                       // invalid now
1042
1043             DELETEZ( pForwarder );
1044             DELETEZ( pEditEngine );     // EditEngine uses document's pool
1045         }
1046         else if ( nId == SFX_HINT_DATACHANGED )
1047         {
1048             if (!bInUpdate)                         // not for own UpdateData calls
1049                 bDataValid = false;                 // text has to be read from the cell again
1050         }
1051     }
1052 }
1053
1054 ScCellTextObj::ScCellTextObj(ScDocShell* pDocSh, const ScAddress& rP) :
1055     ScCellTextData( pDocSh, rP ),
1056     SvxUnoText( GetOriginalSource(), ScCellObj::GetEditPropertySet(), uno::Reference<text::XText>() )
1057 {
1058 }
1059
1060 ScCellTextObj::~ScCellTextObj() throw()
1061 {
1062 }
1063
1064 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */