sc/source/ui/unoobj/editsrc.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: editsrc.cxx,v $
  10  * $Revision: 1.26.128.4 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_sc.hxx"
  33
  34 #include "editsrc.hxx"
  35
  36 #include "scitems.hxx"
  37 #include <svx/eeitem.hxx>
  38 #include <svx/unofored.hxx>
  39 #include <svx/svdpage.hxx>
  40 #include <svx/svditer.hxx>
  41 #include <svx/svdocapt.hxx>
  42 #include <svx/outlobj.hxx>
  43 #include <svx/editobj.hxx>
  44
  45 #include "textuno.hxx"
  46 #include "editutil.hxx"
  47 #include "docsh.hxx"
  48 #include "docfunc.hxx"
  49 #include "hints.hxx"
  50 #include "patattr.hxx"
  51 #include "unoguard.hxx"
  52 #include "drwlayer.hxx"
  53 #include "userdat.hxx"
  54 #include "postit.hxx"
  55 #include "AccessibleText.hxx"
  56
  57 //------------------------------------------------------------------------
  58
  59 TYPEINIT1( ScHeaderFooterChangedHint, SfxHint );
  60
  61 ScHeaderFooterChangedHint::ScHeaderFooterChangedHint(USHORT nP) :
  62     nPart( nP )
  63 {
  64 }
  65
  66 ScHeaderFooterChangedHint::~ScHeaderFooterChangedHint()
  67 {
  68 }
  69
  70 //------------------------------------------------------------------------
  71
  72 ScSharedHeaderFooterEditSource::ScSharedHeaderFooterEditSource( ScHeaderFooterTextData* pData ) :
  73     pTextData( pData )
  74 {
  75     //  pTextData is held by the ScHeaderFooterTextObj.
  76     //  Text range and cursor keep a reference to their parent text, so the text object is
  77     //  always alive and the TextData is valid as long as there are children.
  78 }
  79
  80 ScSharedHeaderFooterEditSource::~ScSharedHeaderFooterEditSource()
  81 {
  82 }
  83
  84 SvxEditSource* ScSharedHeaderFooterEditSource::Clone() const
  85 {
  86     return new ScSharedHeaderFooterEditSource( pTextData );
  87 }
  88
  89 SvxTextForwarder* ScSharedHeaderFooterEditSource::GetTextForwarder()
  90 {
  91     return pTextData->GetTextForwarder();
  92 }
  93
  94 void ScSharedHeaderFooterEditSource::UpdateData()
  95 {
  96     pTextData->UpdateData();
  97 }
  98
  99 ScEditEngineDefaulter* ScSharedHeaderFooterEditSource::GetEditEngine()
 100 {
 101     return pTextData->GetEditEngine();
 102 }
 103
 104 //------------------------------------------------------------------------
 105
 106 //      each ScHeaderFooterEditSource object has its own ScHeaderFooterTextData
 107
 108 ScHeaderFooterEditSource::ScHeaderFooterEditSource( ScHeaderFooterContentObj* pContent,
 109                                                     USHORT nP ) :
 110     ScSharedHeaderFooterEditSource( new ScHeaderFooterTextData( *pContent, nP ) )
 111 {
 112 }
 113
 114 ScHeaderFooterEditSource::ScHeaderFooterEditSource( ScHeaderFooterContentObj& rContent,
 115                                                     USHORT nP ) :
 116     ScSharedHeaderFooterEditSource( new ScHeaderFooterTextData( rContent, nP ) )
 117 {
 118 }
 119
 120 ScHeaderFooterEditSource::~ScHeaderFooterEditSource()
 121 {
 122     delete GetTextData();       // not accessed in ScSharedHeaderFooterEditSource dtor
 123 }
 124
 125 SvxEditSource* ScHeaderFooterEditSource::Clone() const
 126 {
 127     const ScHeaderFooterTextData* pData = GetTextData();
 128     return new ScHeaderFooterEditSource( pData->GetContentObj(), pData->GetPart() );
 129 }
 130
 131 //------------------------------------------------------------------------
 132
 133 ScSharedCellEditSource::ScSharedCellEditSource( ScCellTextData* pData ) :
 134     pCellTextData( pData )
 135 {
 136     //  pCellTextData is part of the ScCellTextObj.
 137     //  Text range and cursor keep a reference to their parent text, so the text object is
 138     //  always alive and the CellTextData is valid as long as there are children.
 139 }
 140
 141 ScSharedCellEditSource::~ScSharedCellEditSource()
 142 {
 143 }
 144
 145 SvxEditSource* ScSharedCellEditSource::Clone() const
 146 {
 147     return new ScSharedCellEditSource( pCellTextData );
 148 }
 149
 150 SvxTextForwarder* ScSharedCellEditSource::GetTextForwarder()
 151 {
 152     return pCellTextData->GetTextForwarder();
 153 }
 154
 155 void ScSharedCellEditSource::UpdateData()
 156 {
 157     pCellTextData->UpdateData();
 158 }
 159
 160 void ScSharedCellEditSource::SetDoUpdateData(sal_Bool bValue)
 161 {
 162     pCellTextData->SetDoUpdate(bValue);
 163 }
 164
 165 sal_Bool ScSharedCellEditSource::IsDirty() const
 166 {
 167     return pCellTextData->IsDirty();
 168 }
 169
 170 ScEditEngineDefaulter* ScSharedCellEditSource::GetEditEngine()
 171 {
 172     return pCellTextData->GetEditEngine();
 173 }
 174
 175 //------------------------------------------------------------------------
 176
 177 //      each ScCellEditSource object has its own ScCellTextData
 178
 179 ScCellEditSource::ScCellEditSource( ScDocShell* pDocSh, const ScAddress& rP ) :
 180     ScSharedCellEditSource( new ScCellTextData( pDocSh, rP ) )
 181 {
 182 }
 183
 184 ScCellEditSource::~ScCellEditSource()
 185 {
 186     delete GetCellTextData();   // not accessed in ScSharedCellEditSource dtor
 187 }
 188
 189 SvxEditSource* ScCellEditSource::Clone() const
 190 {
 191     const ScCellTextData* pData = GetCellTextData();
 192     return new ScCellEditSource( pData->GetDocShell(), pData->GetCellPos() );
 193 }
 194
 195 //------------------------------------------------------------------------
 196
 197 ScAnnotationEditSource::ScAnnotationEditSource(ScDocShell* pDocSh, const ScAddress& rP) :
 198     pDocShell( pDocSh ),
 199     aCellPos( rP ),
 200     pEditEngine( NULL ),
 201     pForwarder( NULL ),
 202     bDataValid( FALSE )
 203 {
 204     if (pDocShell)
 205         pDocShell->GetDocument()->AddUnoObject(*this);
 206 }
 207
 208 ScAnnotationEditSource::~ScAnnotationEditSource()
 209 {
 210     ScUnoGuard aGuard;          //      needed for EditEngine dtor
 211
 212     if (pDocShell)
 213         pDocShell->GetDocument()->RemoveUnoObject(*this);
 214
 215     delete pForwarder;
 216     delete pEditEngine;
 217 }
 218
 219 SvxEditSource* ScAnnotationEditSource::Clone() const
 220 {
 221     return new ScAnnotationEditSource( pDocShell, aCellPos );
 222 }
 223
 224 SdrObject* ScAnnotationEditSource::GetCaptionObj()
 225 {
 226     ScPostIt* pNote = pDocShell->GetDocument()->GetNote( aCellPos );
 227     return pNote ? pNote->GetOrCreateCaption( aCellPos ) : 0;
 228 }
 229
 230 SvxTextForwarder* ScAnnotationEditSource::GetTextForwarder()
 231 {
 232     if (!pEditEngine)
 233     {
 234         // Notizen haben keine Felder
 235         if ( pDocShell )
 236         {
 237             pEditEngine = new ScNoteEditEngine( pDocShell->GetDocument()->GetNoteEngine() );
 238         }
 239         else
 240         {
 241             SfxItemPool* pEnginePool = EditEngine::CreatePool();
 242             pEnginePool->FreezeIdRanges();
 243             pEditEngine = new ScEditEngineDefaulter( pEnginePool, TRUE );
 244         }
 245         pForwarder = new SvxEditEngineForwarder(*pEditEngine);
 246     }
 247
 248     if (bDataValid)
 249         return pForwarder;
 250
 251     if ( pDocShell )
 252         if ( ScPostIt* pNote = pDocShell->GetDocument()->GetNote( aCellPos ) )
 253             if ( const EditTextObject* pEditObj = pNote->GetEditTextObject() )
 254                 pEditEngine->SetText( *pEditObj );              // incl. Umbrueche
 255
 256     bDataValid = TRUE;
 257     return pForwarder;
 258 }
 259
 260 void ScAnnotationEditSource::UpdateData()
 261 {
 262     if ( pDocShell && pEditEngine )
 263     {
 264         ScDocShellModificator aModificator( *pDocShell );
 265
 266         if( SdrObject* pObj = GetCaptionObj() )
 267         {
 268             EditTextObject* pEditObj = pEditEngine->CreateTextObject();
 269             OutlinerParaObject* pOPO = new OutlinerParaObject( *pEditObj );
 270             delete pEditObj;
 271             pOPO->SetOutlinerMode( OUTLINERMODE_TEXTOBJECT );
 272             pObj->NbcSetOutlinerParaObject( pOPO );
 273             pObj->ActionChanged();
 274         }
 275
 276         //!     Undo !!!
 277
 278         aModificator.SetDocumentModified();
 279
 280         // bDataValid wird bei SetDocumentModified zurueckgesetzt
 281     }
 282 }
 283
 284 void ScAnnotationEditSource::Notify( SfxBroadcaster&, const SfxHint& rHint )
 285 {
 286     if ( rHint.ISA( ScUpdateRefHint ) )
 287     {
 288 //        const ScUpdateRefHint& rRef = (const ScUpdateRefHint&)rHint;
 289
 290         //!     Ref-Update
 291     }
 292     else if ( rHint.ISA( SfxSimpleHint ) )
 293     {
 294         ULONG nId = ((const SfxSimpleHint&)rHint).GetId();
 295         if ( nId == SFX_HINT_DYING )
 296         {
 297             pDocShell = NULL;                                           // ungueltig geworden
 298
 299             DELETEZ( pForwarder );
 300             DELETEZ( pEditEngine );             // EditEngine uses document's pool
 301         }
 302         else if ( nId == SFX_HINT_DATACHANGED )
 303             bDataValid = FALSE;                                         // Text muss neu geholt werden
 304     }
 305 }
 306
 307 //------------------------------------------------------------------------
 308
 309 ScSimpleEditSource::ScSimpleEditSource( SvxTextForwarder* pForw ) :
 310     pForwarder( pForw )
 311 {
 312     //  The same forwarder (and EditEngine) is shared by all children of the same Text object.
 313     //  Text range and cursor keep a reference to their parent text, so the text object is
 314     //  always alive and the forwarder is valid as long as there are children.
 315 }
 316
 317 ScSimpleEditSource::~ScSimpleEditSource()
 318 {
 319 }
 320
 321 SvxEditSource* ScSimpleEditSource::Clone() const
 322 {
 323     return new ScSimpleEditSource( pForwarder );
 324 }
 325
 326 SvxTextForwarder* ScSimpleEditSource::GetTextForwarder()
 327 {
 328     return pForwarder;
 329 }
 330
 331 void ScSimpleEditSource::UpdateData()
 332 {
 333     //  nothing
 334 }
 335
 336 //------------------------------------------------------------------------
 337
 338 ScAccessibilityEditSource::ScAccessibilityEditSource( ::std::auto_ptr < ScAccessibleTextData > pAccessibleCellTextData )
 339     : mpAccessibleTextData(pAccessibleCellTextData)
 340 {
 341 }
 342
 343 ScAccessibilityEditSource::~ScAccessibilityEditSource()
 344 {
 345 }
 346
 347 SvxEditSource* ScAccessibilityEditSource::Clone() const
 348 {
 349     return new ScAccessibilityEditSource(::std::auto_ptr < ScAccessibleTextData > (mpAccessibleTextData->Clone()));
 350 }
 351
 352 SvxTextForwarder* ScAccessibilityEditSource::GetTextForwarder()
 353 {
 354     return mpAccessibleTextData->GetTextForwarder();
 355 }
 356
 357 SvxViewForwarder* ScAccessibilityEditSource::GetViewForwarder()
 358 {
 359     return mpAccessibleTextData->GetViewForwarder();
 360 }
 361
 362 SvxEditViewForwarder* ScAccessibilityEditSource::GetEditViewForwarder( sal_Bool bCreate )
 363 {
 364     return mpAccessibleTextData->GetEditViewForwarder(bCreate);
 365 }
 366
 367 void ScAccessibilityEditSource::UpdateData()
 368 {
 369     mpAccessibleTextData->UpdateData();
 370 }
 371
 372 SfxBroadcaster& ScAccessibilityEditSource::GetBroadcaster() const
 373 {
 374     return mpAccessibleTextData->GetBroadcaster();
 375 }
 376