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