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