svx/source/unodraw/unoshtxt.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: unoshtxt.cxx,v $
  10  * $Revision: 1.62 $
  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_svx.hxx"
  33 #include <com/sun/star/uno/XInterface.hpp>
  34 #include <vcl/svapp.hxx>
  35
  36 #include <svx/unoshtxt.hxx>
  37 #include <unoedhlp.hxx>
  38 #include <svtools/lstner.hxx>
  39 #include <rtl/ref.hxx>
  40 #include <osl/mutex.hxx>
  41 #include <svtools/hint.hxx>
  42 #include <svtools/style.hxx>
  43 #include <svx/svdmodel.hxx>
  44 #include <svx/svdoutl.hxx>
  45 #include <svx/svdobj.hxx>
  46 #include <svx/svdview.hxx>
  47 #include <svx/svdetc.hxx>
  48 #include <svx/outliner.hxx>
  49 #include <svx/unoforou.hxx>
  50 #include <svx/unoviwou.hxx>
  51 #include <svx/outlobj.hxx>
  52 #include <svx/svdotext.hxx>
  53 #include <svx/svdpage.hxx>
  54 #include <svx/editeng.hxx>
  55 #include <svx/editobj.hxx>
  56
  57 #include <svx/unotext.hxx>
  58 #include <com/sun/star/linguistic2/XLinguServiceManager.hpp>
  59 #include <comphelper/processfactory.hxx>
  60 #include <vos/mutex.hxx>
  61 #include <sdrpaintwindow.hxx>
  62
  63 using namespace ::osl;
  64 using namespace ::vos;
  65 using namespace ::rtl;
  66
  67 using ::com::sun::star::uno::XInterface;
  68
  69 namespace css = ::com::sun::star;
  70
  71
  72 //------------------------------------------------------------------------
  73 // SvxTextEditSourceImpl
  74 //------------------------------------------------------------------------
  75
  76 /** @descr
  77     <p>This class essentially provides the text and view forwarders. If
  78     no SdrView is given, this class handles the UNO objects, which are
  79     currently not concerned with view issues. In this case,
  80     GetViewForwarder() always returns NULL and the underlying
  81     EditEngine of the SvxTextForwarder is a background one (i.e. not
  82     the official DrawOutliner, but one created exclusively for this
  83     object, with no relation to a view).
  84     </p>
  85
  86     <p>If a SdrView is given at construction time, the caller is
  87     responsible for destroying this object when the view becomes
  88     invalid (the views cannot notify). If GetViewForwarder(sal_True)
  89     is called, the underlying shape is put into edit mode, the view
  90     forwarder returned encapsulates the OutlinerView and the next call
  91     to GetTextForwarder() yields a forwarder encapsulating the actual
  92     DrawOutliner. Thus, changes on that Outliner are immediately
  93     reflected on the screen. If the object leaves edit mode, the old
  94     behaviour is restored.</p>
  95  */
  96 class SvxTextEditSourceImpl : public SfxListener, public SfxBroadcaster, public sdr::ObjectUser
  97 {
  98 private:
  99     oslInterlockedCount maRefCount;
 100
 101     SdrObject*                                          mpObject;
 102     SdrText*                                            mpText;
 103     SdrView*                                            mpView;
 104     const Window*                                       mpWindow;
 105     SdrModel*                                           mpModel;
 106     SdrOutliner*                                        mpOutliner;
 107     SvxOutlinerForwarder*                       mpTextForwarder;
 108     SvxDrawOutlinerViewForwarder*       mpViewForwarder;        // if non-NULL, use GetViewModeTextForwarder text forwarder
 109     css::uno::Reference< css::linguistic2::XLinguServiceManager > m_xLinguServiceManager;
 110     Point                                                       maTextOffset;
 111     BOOL                                                        mbDataValid;
 112     BOOL                                                        mbDestroyed;
 113     BOOL                                                        mbIsLocked;
 114     BOOL                                                        mbNeedsUpdate;
 115     BOOL                                                        mbOldUndoMode;
 116     BOOL                                                        mbForwarderIsEditMode;          // have to reflect that, since ENDEDIT can happen more often
 117     BOOL                                                        mbShapeIsEditMode;                      // #104157# only true, if HINT_BEGEDIT was received
 118     BOOL                                                        mbNotificationsDisabled;        // prevent EditEngine/Outliner notifications (e.g. when setting up forwarder)
 119
 120     XInterface*                                         mpOwner;
 121     SvxUnoTextRangeBaseList                     maTextRanges;
 122
 123     SvxTextForwarder*                           GetBackgroundTextForwarder();
 124     SvxTextForwarder*                           GetEditModeTextForwarder();
 125     SvxDrawOutlinerViewForwarder*       CreateViewForwarder();
 126
 127     void                                                        SetupOutliner();
 128     void                                                        UpdateOutliner();
 129
 130     sal_Bool                                            HasView() const { return mpView ? sal_True : sal_False; }
 131     sal_Bool                                            IsEditMode() const
 132                                     {
 133                                         SdrTextObj* pTextObj = PTR_CAST( SdrTextObj, mpObject );
 134                                         return mbShapeIsEditMode && pTextObj && pTextObj->IsTextEditActive() ? sal_True : sal_False;
 135                                     }
 136
 137     void                                                        dispose();
 138
 139 public:
 140     SvxTextEditSourceImpl( SdrObject* pObject, SdrText* pText, XInterface* pOwner );
 141     SvxTextEditSourceImpl( SdrObject& rObject, SdrText* pText, SdrView& rView, const Window& rWindow );
 142     ~SvxTextEditSourceImpl();
 143
 144     void SAL_CALL acquire();
 145     void SAL_CALL release();
 146
 147     virtual void                        Notify( SfxBroadcaster& rBC, const SfxHint& rHint );
 148
 149     SvxEditSource*                      Clone() const;
 150     SvxTextForwarder*           GetTextForwarder();
 151     SvxEditViewForwarder*       GetEditViewForwarder( sal_Bool );
 152     void                                        UpdateData();
 153
 154     void addRange( SvxUnoTextRangeBase* pNewRange );
 155     void removeRange( SvxUnoTextRangeBase* pOldRange );
 156     const SvxUnoTextRangeBaseList& getRanges() const;
 157
 158     SdrObject*                          GetSdrObject() const { return mpObject; }
 159
 160     void                                        lock();
 161     void                                        unlock();
 162
 163     BOOL                                        IsValid() const;
 164
 165     Rectangle                           GetVisArea();
 166     Point                                       LogicToPixel( const Point&, const MapMode& rMapMode );
 167     Point                                       PixelToLogic( const Point&, const MapMode& rMapMode );
 168
 169     DECL_LINK( NotifyHdl, EENotify* );
 170
 171     virtual void ObjectInDestruction(const SdrObject& rObject);
 172
 173     void ChangeModel( SdrModel* pNewModel );
 174 };
 175
 176 //------------------------------------------------------------------------
 177
 178 SvxTextEditSourceImpl::SvxTextEditSourceImpl( SdrObject* pObject, SdrText* pText, XInterface* pOwner )
 179   :     maRefCount              ( 0 ),
 180     mpObject            ( pObject ),
 181     mpText                      ( pText ),
 182     mpView                      ( NULL ),
 183     mpWindow            ( NULL ),
 184     mpModel                     ( pObject ? pObject->GetModel() : NULL ),
 185     mpOutliner          ( NULL ),
 186     mpTextForwarder     ( NULL ),
 187     mpViewForwarder     ( NULL ),
 188     mbDataValid         ( FALSE ),
 189     mbDestroyed         ( FALSE ),
 190     mbIsLocked          ( FALSE ),
 191     mbNeedsUpdate       ( FALSE ),
 192     mbOldUndoMode       ( FALSE ),
 193     mbForwarderIsEditMode ( FALSE ),
 194     mbShapeIsEditMode     ( FALSE ),
 195     mbNotificationsDisabled ( FALSE ),
 196     mpOwner( pOwner )
 197 {
 198     DBG_ASSERT( mpObject, "invalid pObject!" );
 199
 200     if( !mpText )
 201     {
 202         SdrTextObj* pTextObj = dynamic_cast< SdrTextObj* >( mpObject );
 203         if( pTextObj )
 204             mpText = pTextObj->getText( 0 );
 205     }
 206
 207     if( mpModel )
 208         StartListening( *mpModel );
 209
 210     if( mpObject )
 211         mpObject->AddObjectUser( *this );
 212 }
 213
 214 //------------------------------------------------------------------------
 215
 216 SvxTextEditSourceImpl::SvxTextEditSourceImpl( SdrObject& rObject, SdrText* pText, SdrView& rView, const Window& rWindow )
 217   :     maRefCount              ( 0 ),
 218     mpObject            ( &rObject ),
 219     mpText                      ( pText ),
 220     mpView                      ( &rView ),
 221     mpWindow            ( &rWindow ),
 222     mpModel                     ( rObject.GetModel() ),
 223     mpOutliner          ( NULL ),
 224     mpTextForwarder     ( NULL ),
 225     mpViewForwarder     ( NULL ),
 226     mbDataValid         ( FALSE ),
 227     mbDestroyed         ( FALSE ),
 228     mbIsLocked          ( FALSE ),
 229     mbNeedsUpdate       ( FALSE ),
 230     mbOldUndoMode       ( FALSE ),
 231     mbForwarderIsEditMode ( FALSE ),
 232     mbShapeIsEditMode     ( TRUE ),
 233     mbNotificationsDisabled ( FALSE ),
 234     mpOwner(0)
 235 {
 236     if( !mpText )
 237     {
 238         SdrTextObj* pTextObj = dynamic_cast< SdrTextObj* >( mpObject );
 239         if( pTextObj )
 240             mpText = pTextObj->getText( 0 );
 241     }
 242
 243     if( mpModel )
 244         StartListening( *mpModel );
 245     if( mpView )
 246         StartListening( *mpView );
 247     if( mpObject )
 248         mpObject->AddObjectUser( *this );
 249
 250     // #104157# Init edit mode state from shape info (IsTextEditActive())
 251     mbShapeIsEditMode = IsEditMode();
 252 }
 253
 254 //------------------------------------------------------------------------
 255
 256 SvxTextEditSourceImpl::~SvxTextEditSourceImpl()
 257 {
 258     DBG_ASSERT( mbIsLocked == sal_False, "text edit source was not unlocked before dispose!" );
 259     if( mpObject )
 260         mpObject->RemoveObjectUser( *this );
 261
 262     dispose();
 263 }
 264
 265 //------------------------------------------------------------------------
 266
 267 void SvxTextEditSourceImpl::addRange( SvxUnoTextRangeBase* pNewRange )
 268 {
 269     if( pNewRange )
 270         if( std::find( maTextRanges.begin(), maTextRanges.end(), pNewRange ) == maTextRanges.end() )
 271             maTextRanges.push_back( pNewRange );
 272 }
 273
 274 //------------------------------------------------------------------------
 275
 276 void SvxTextEditSourceImpl::removeRange( SvxUnoTextRangeBase* pOldRange )
 277 {
 278     if( pOldRange )
 279         maTextRanges.remove( pOldRange );
 280 }
 281
 282 //------------------------------------------------------------------------
 283
 284 const SvxUnoTextRangeBaseList& SvxTextEditSourceImpl::getRanges() const
 285 {
 286     return maTextRanges;
 287 }
 288
 289 //------------------------------------------------------------------------
 290
 291 void SAL_CALL SvxTextEditSourceImpl::acquire()
 292 {
 293     osl_incrementInterlockedCount( &maRefCount );
 294 }
 295
 296 //------------------------------------------------------------------------
 297
 298 void SAL_CALL SvxTextEditSourceImpl::release()
 299 {
 300     if( ! osl_decrementInterlockedCount( &maRefCount ) )
 301         delete this;
 302 }
 303
 304 void SvxTextEditSourceImpl::ChangeModel( SdrModel* pNewModel )
 305 {
 306     if( mpModel != pNewModel )
 307     {
 308         if( mpModel )
 309             EndListening( *mpModel );
 310
 311         if( mpOutliner )
 312         {
 313             if( mpModel )
 314                 mpModel->disposeOutliner( mpOutliner );
 315             else
 316                 delete mpOutliner;
 317             mpOutliner = 0;
 318         }
 319
 320         if( mpView )
 321         {
 322             EndListening( *mpView );
 323             mpView = 0;
 324         }
 325
 326         mpWindow = 0;
 327         m_xLinguServiceManager.clear();
 328         mpOwner = 0;
 329
 330         mpModel = pNewModel;
 331
 332         if( mpTextForwarder )
 333         {
 334             delete mpTextForwarder;
 335             mpTextForwarder = 0;
 336         }
 337
 338         if( mpViewForwarder )
 339         {
 340             delete mpViewForwarder;
 341             mpViewForwarder = 0;
 342         }
 343
 344         if( mpModel )
 345             StartListening( *mpModel );
 346     }
 347 }
 348
 349 //------------------------------------------------------------------------
 350
 351 void SvxTextEditSourceImpl::Notify( SfxBroadcaster&, const SfxHint& rHint )
 352 {
 353     const SdrHint* pSdrHint = PTR_CAST( SdrHint, &rHint );
 354     const SvxViewHint* pViewHint = PTR_CAST( SvxViewHint, &rHint );
 355
 356     if( pViewHint )
 357     {
 358         switch( pViewHint->GetHintType() )
 359         {
 360             case SvxViewHint::SVX_HINT_VIEWCHANGED:
 361                 Broadcast( *pViewHint );
 362                 break;
 363         }
 364     }
 365     else if( pSdrHint )
 366     {
 367         switch( pSdrHint->GetKind() )
 368         {
 369             case HINT_OBJCHG:
 370             {
 371                 mbDataValid = FALSE;                                            // Text muss neu geholt werden
 372
 373                 if( HasView() )
 374                 {
 375                     // #104157# Update maTextOffset, object has changed
 376                     // #105196#, #105203#: Cannot call that // here,
 377                     // since TakeTextRect() (called from there) //
 378                     // changes outliner content.
 379                     // UpdateOutliner();
 380
 381                     // #101029# Broadcast object changes, as they might change visible attributes
 382                     SvxViewHint aHint(SvxViewHint::SVX_HINT_VIEWCHANGED);
 383                     Broadcast( aHint );
 384                 }
 385                 break;
 386             }
 387
 388             case HINT_BEGEDIT:
 389                 if( mpObject == pSdrHint->GetObject() )
 390                 {
 391                     // invalidate old forwarder
 392                     if( !mbForwarderIsEditMode )
 393                     {
 394                         delete mpTextForwarder;
 395                         mpTextForwarder = NULL;
 396                     }
 397
 398                     // register as listener - need to broadcast state change messages
 399                     if( mpView && mpView->GetTextEditOutliner() )
 400                         mpView->GetTextEditOutliner()->SetNotifyHdl( LINK(this, SvxTextEditSourceImpl, NotifyHdl) );
 401
 402                     // #104157# Only now we're really in edit mode
 403                     mbShapeIsEditMode = TRUE;
 404
 405                     Broadcast( *pSdrHint );
 406                 }
 407                 break;
 408
 409             case HINT_ENDEDIT:
 410                 if( mpObject == pSdrHint->GetObject() )
 411                 {
 412                     Broadcast( *pSdrHint );
 413
 414                     // #104157# We're no longer in edit mode
 415                     mbShapeIsEditMode = FALSE;
 416
 417                     // remove as listener - outliner might outlive ourselves
 418                     if( mpView && mpView->GetTextEditOutliner() )
 419                         mpView->GetTextEditOutliner()->SetNotifyHdl( Link() );
 420
 421                     // destroy view forwarder, OutlinerView no longer
 422                     // valid (no need for UpdateData(), it's been
 423                     // synched on SdrEndTextEdit)
 424                     delete mpViewForwarder;
 425                     mpViewForwarder = NULL;
 426
 427                     // #100424# Invalidate text forwarder, we might
 428                     // not be called again before entering edit mode a
 429                     // second time! Then, the old outliner might be
 430                     // invalid.
 431                     if( mbForwarderIsEditMode )
 432                     {
 433                         mbForwarderIsEditMode = sal_False;
 434                         delete mpTextForwarder;
 435                         mpTextForwarder = NULL;
 436                     }
 437                 }
 438                 break;
 439
 440             case HINT_MODELCLEARED:
 441                 dispose();
 442                 break;
 443             default:
 444                 break;
 445         }
 446     }
 447 }
 448
 449 /* this is a callback from the attached SdrObject when it is actually deleted */
 450 void SvxTextEditSourceImpl::ObjectInDestruction(const SdrObject&)
 451 {
 452     mpObject = 0;
 453     dispose();
 454     Broadcast( SfxSimpleHint( SFX_HINT_DYING ) );
 455 }
 456
 457 /* unregister at all objects and set all references to 0 */
 458 void SvxTextEditSourceImpl::dispose()
 459 {
 460     if( mpTextForwarder )
 461     {
 462         delete mpTextForwarder;
 463         mpTextForwarder = 0;
 464     }
 465
 466     if( mpViewForwarder )
 467     {
 468         delete mpViewForwarder;
 469         mpViewForwarder = 0;
 470     }
 471
 472     if( mpOutliner )
 473     {
 474         if( mpModel )
 475         {
 476             mpModel->disposeOutliner( mpOutliner );
 477         }
 478         else
 479         {
 480             delete mpOutliner;
 481         }
 482         mpOutliner = 0;
 483     }
 484
 485     if( mpModel )
 486     {
 487         EndListening( *mpModel );
 488         mpModel = 0;
 489     }
 490
 491     if( mpView )
 492     {
 493         EndListening( *mpView );
 494         mpView = 0;
 495     }
 496
 497     if( mpObject )
 498     {
 499         mpObject->RemoveObjectUser( *this );
 500         mpObject = 0;
 501     }
 502     mpWindow = 0;
 503 }
 504
 505 //------------------------------------------------------------------------
 506
 507 void SvxTextEditSourceImpl::SetupOutliner()
 508 {
 509     // #101029#
 510     // only for UAA edit source: setup outliner equivalently as in
 511     // SdrTextObj::Paint(), such that formatting equals screen
 512     // layout
 513     if( mpObject && mpOutliner )
 514     {
 515         SdrTextObj* pTextObj = PTR_CAST( SdrTextObj, mpObject );
 516         Rectangle aPaintRect;
 517         if( pTextObj )
 518         {
 519             Rectangle aBoundRect( pTextObj->GetCurrentBoundRect() );
 520             pTextObj->SetupOutlinerFormatting( *mpOutliner, aPaintRect );
 521
 522             // #101029# calc text offset from shape anchor
 523             maTextOffset = aPaintRect.TopLeft() - aBoundRect.TopLeft();
 524         }
 525     }
 526 }
 527
 528 //------------------------------------------------------------------------
 529
 530 void SvxTextEditSourceImpl::UpdateOutliner()
 531 {
 532     // #104157#
 533     // only for UAA edit source: update outliner equivalently as in
 534     // SdrTextObj::Paint(), such that formatting equals screen
 535     // layout
 536     if( mpObject && mpOutliner )
 537     {
 538         SdrTextObj* pTextObj = PTR_CAST( SdrTextObj, mpObject );
 539         Rectangle aPaintRect;
 540         if( pTextObj )
 541         {
 542             Rectangle aBoundRect( pTextObj->GetCurrentBoundRect() );
 543             pTextObj->UpdateOutlinerFormatting( *mpOutliner, aPaintRect );
 544
 545             // #101029# calc text offset from shape anchor
 546             maTextOffset = aPaintRect.TopLeft() - aBoundRect.TopLeft();
 547         }
 548     }
 549 }
 550
 551 //------------------------------------------------------------------------
 552
 553
 554
 555 SvxTextForwarder* SvxTextEditSourceImpl::GetBackgroundTextForwarder()
 556 {
 557     sal_Bool bCreated = sal_False;
 558
 559     // #99840#: prevent EE/Outliner notifications during setup
 560     mbNotificationsDisabled = sal_True;
 561
 562     if (!mpTextForwarder)
 563     {
 564         if( mpOutliner == NULL )
 565         {
 566             SdrTextObj* pTextObj = PTR_CAST( SdrTextObj, mpObject );
 567             USHORT nOutlMode = OUTLINERMODE_TEXTOBJECT;
 568             if( pTextObj && pTextObj->IsTextFrame() && pTextObj->GetTextKind() == OBJ_OUTLINETEXT )
 569                 nOutlMode = OUTLINERMODE_OUTLINEOBJECT;
 570
 571             mpOutliner = mpModel->createOutliner( nOutlMode );
 572
 573             // #109151# Do the setup after outliner creation, would be useless otherwise
 574             if( HasView() )
 575             {
 576                 // #101029#, #104157# Setup outliner _before_ filling it
 577                 SetupOutliner();
 578             }
 579
 580             mpOutliner->SetTextObjNoInit( pTextObj );
 581 /*
 582             mpOutliner = SdrMakeOutliner( nOutlMode, pModel );
 583             Outliner& aDrawOutliner = pModel->GetDrawOutliner();
 584             mpOutliner->SetCalcFieldValueHdl( aDrawOutliner.GetCalcFieldValueHdl() );
 585 */
 586             if( mbIsLocked )
 587             {
 588                 ((EditEngine*)&(mpOutliner->GetEditEngine()))->SetUpdateMode( sal_False );
 589                 mbOldUndoMode = ((EditEngine*)&(mpOutliner->GetEditEngine()))->IsUndoEnabled();
 590                 ((EditEngine*)&(mpOutliner->GetEditEngine()))->EnableUndo( sal_False );
 591             }
 592
 593 // -
 594             if ( !m_xLinguServiceManager.is() )
 595             {
 596                 css::uno::Reference< css::lang::XMultiServiceFactory > xMgr( ::comphelper::getProcessServiceFactory() );
 597                 m_xLinguServiceManager = css::uno::Reference< css::linguistic2::XLinguServiceManager >(
 598                     xMgr->createInstance( OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.linguistic2.LinguServiceManager" ))), css::uno::UNO_QUERY );
 599             }
 600
 601             if ( m_xLinguServiceManager.is() )
 602             {
 603                 css::uno::Reference< css::linguistic2::XHyphenator > xHyphenator( m_xLinguServiceManager->getHyphenator(), css::uno::UNO_QUERY );
 604                 if( xHyphenator.is() )
 605                     mpOutliner->SetHyphenator( xHyphenator );
 606             }
 607 // -
 608         }
 609
 610         mpTextForwarder = new SvxOutlinerForwarder( *mpOutliner, mpObject );
 611
 612         // delay listener subscription and UAA initialization until Outliner is fully setup
 613         bCreated = sal_True;
 614
 615         mbForwarderIsEditMode = sal_False;
 616     }
 617
 618     if( mpObject && mpText && !mbDataValid && mpObject->IsInserted() && mpObject->GetPage() )
 619     {
 620         mpTextForwarder->flushCache();
 621
 622         OutlinerParaObject* pOutlinerParaObject = NULL;
 623         SdrTextObj* pTextObj = PTR_CAST( SdrTextObj, mpObject );
 624         if( pTextObj && pTextObj->getActiveText() == mpText )
 625             pOutlinerParaObject = pTextObj->GetEditOutlinerParaObject(); // Get the OutlinerParaObject if text edit is active
 626         bool bOwnParaObj(false);
 627
 628         if( pOutlinerParaObject )
 629             bOwnParaObj = true; // text edit active
 630         else
 631             pOutlinerParaObject = mpText->GetOutlinerParaObject();
 632
 633         if( pOutlinerParaObject && ( bOwnParaObj || !mpObject->IsEmptyPresObj() || mpObject->GetPage()->IsMasterPage() ) )
 634         {
 635             mpOutliner->SetText( *pOutlinerParaObject );
 636
 637             // #91254# put text to object and set EmptyPresObj to FALSE
 638             if( mpText && bOwnParaObj && pOutlinerParaObject && mpObject->IsEmptyPresObj() && pTextObj->IsRealyEdited() )
 639             {
 640                 mpObject->SetEmptyPresObj( FALSE );
 641                 static_cast< SdrTextObj* >( mpObject)->NbcSetOutlinerParaObjectForText( pOutlinerParaObject, mpText );
 642
 643                 // #i103982# Here, due to mpObject->NbcSetOutlinerParaObjectForText, we LOSE ownership of the
 644                 // OPO, so do NOT delete it when leaving this method (!)
 645                 bOwnParaObj = false;
 646             }
 647         }
 648         else
 649         {
 650             sal_Bool bVertical = pOutlinerParaObject ? pOutlinerParaObject->IsVertical() : sal_False;
 651
 652             // set objects style sheet on empty outliner
 653             SfxStyleSheetPool* pPool = (SfxStyleSheetPool*)mpObject->GetModel()->GetStyleSheetPool();
 654             if( pPool )
 655                 mpOutliner->SetStyleSheetPool( pPool );
 656
 657             SfxStyleSheet* pStyleSheet = mpObject->GetPage()->GetTextStyleSheetForObject( mpObject );
 658             if( pStyleSheet )
 659                 mpOutliner->SetStyleSheet( 0, pStyleSheet );
 660
 661             if( bVertical )
 662                 mpOutliner->SetVertical( sal_True );
 663         }
 664
 665         // evtually we have to set the border attributes
 666         if (mpOutliner->GetParagraphCount()==1)
 667         {
 668             // if we only have one paragraph we check if it is empty
 669             XubString aStr( mpOutliner->GetText( mpOutliner->GetParagraph( 0 ) ) );
 670
 671             if(!aStr.Len())
 672             {
 673                 // its empty, so we have to force the outliner to initialise itself
 674                 mpOutliner->SetText( String(), mpOutliner->GetParagraph( 0 ) );
 675
 676                 if(mpObject->GetStyleSheet())
 677                     mpOutliner->SetStyleSheet( 0, mpObject->GetStyleSheet());
 678             }
 679         }
 680
 681         mbDataValid = TRUE;
 682
 683         if( bOwnParaObj )
 684             delete pOutlinerParaObject;
 685     }
 686
 687     if( bCreated && mpOutliner && HasView() )
 688     {
 689         // register as listener - need to broadcast state change messages
 690         // registration delayed until outliner is completely set up
 691         mpOutliner->SetNotifyHdl( LINK(this, SvxTextEditSourceImpl, NotifyHdl) );
 692     }
 693
 694     // #99840#: prevent EE/Outliner notifications during setup
 695     mbNotificationsDisabled = sal_False;
 696
 697     return mpTextForwarder;
 698 }
 699
 700 //------------------------------------------------------------------------
 701
 702 SvxTextForwarder* SvxTextEditSourceImpl::GetEditModeTextForwarder()
 703 {
 704     if( !mpTextForwarder && HasView() )
 705     {
 706         SdrOutliner* pEditOutliner = mpView->GetTextEditOutliner();
 707
 708         if( pEditOutliner )
 709         {
 710             mpTextForwarder = new SvxOutlinerForwarder( *pEditOutliner, mpObject );
 711
 712             mbForwarderIsEditMode = sal_True;
 713         }
 714     }
 715
 716     return mpTextForwarder;
 717 }
 718
 719 //------------------------------------------------------------------------
 720
 721 SvxTextForwarder* SvxTextEditSourceImpl::GetTextForwarder()
 722 {
 723     if( mbDestroyed || mpObject == NULL )
 724         return NULL;
 725
 726     if( mpModel == NULL )
 727         mpModel = mpObject->GetModel();
 728
 729     if( mpModel == NULL )
 730         return NULL;
 731
 732     // distinguish the cases
 733     // a) connected to view, maybe edit mode is active, can work directly on the EditOutliner
 734     // b) background Outliner, reflect changes into ParaOutlinerObject (this is exactly the old UNO code)
 735     if( HasView() )
 736     {
 737         if( IsEditMode() != mbForwarderIsEditMode )
 738         {
 739             // forwarder mismatch - create new
 740             delete mpTextForwarder;
 741             mpTextForwarder = NULL;
 742         }
 743
 744         if( IsEditMode() )
 745             return GetEditModeTextForwarder();
 746         else
 747             return GetBackgroundTextForwarder();
 748     }
 749     else
 750         return GetBackgroundTextForwarder();
 751 }
 752
 753 //------------------------------------------------------------------------
 754
 755 SvxDrawOutlinerViewForwarder* SvxTextEditSourceImpl::CreateViewForwarder()
 756 {
 757     if( mpView->GetTextEditOutlinerView() && mpObject )
 758     {
 759         // register as listener - need to broadcast state change messages
 760         mpView->GetTextEditOutliner()->SetNotifyHdl( LINK(this, SvxTextEditSourceImpl, NotifyHdl) );
 761
 762         SdrTextObj* pTextObj = PTR_CAST( SdrTextObj, mpObject );
 763         if( pTextObj )
 764         {
 765             Rectangle aBoundRect( pTextObj->GetCurrentBoundRect() );
 766             OutlinerView& rOutlView = *mpView->GetTextEditOutlinerView();
 767
 768             return new SvxDrawOutlinerViewForwarder( rOutlView, aBoundRect.TopLeft() );
 769         }
 770     }
 771
 772     return NULL;
 773 }
 774
 775 SvxEditViewForwarder* SvxTextEditSourceImpl::GetEditViewForwarder( sal_Bool bCreate )
 776 {
 777     if( mbDestroyed || mpObject == NULL )
 778         return NULL;
 779
 780     if( mpModel == NULL )
 781         mpModel = mpObject->GetModel();
 782
 783     if( mpModel == NULL )
 784         return NULL;
 785
 786     // shall we delete?
 787     if( mpViewForwarder )
 788     {
 789         if( !IsEditMode() )
 790         {
 791             // destroy all forwarders (no need for UpdateData(),
 792             // it's been synched on SdrEndTextEdit)
 793             delete mpViewForwarder;
 794             mpViewForwarder = NULL;
 795         }
 796     }
 797     // which to create? Directly in edit mode, create new, or none?
 798     else if( mpView )
 799     {
 800         if( IsEditMode() )
 801         {
 802             // create new view forwarder
 803             mpViewForwarder = CreateViewForwarder();
 804         }
 805         else if( bCreate )
 806         {
 807             // dispose old text forwarder
 808             UpdateData();
 809
 810             delete mpTextForwarder;
 811             mpTextForwarder = NULL;
 812
 813             // enter edit mode
 814             mpView->SdrEndTextEdit();
 815
 816             if(mpView->SdrBeginTextEdit(mpObject, 0L, 0L, sal_False, (SdrOutliner*)0L, 0L, sal_False, sal_False))
 817             {
 818                 SdrTextObj* pTextObj = PTR_CAST( SdrTextObj, mpObject );
 819                 if( pTextObj->IsTextEditActive() )
 820                 {
 821                     // create new view forwarder
 822                     mpViewForwarder = CreateViewForwarder();
 823                 }
 824                 else
 825                 {
 826                     // failure. Somehow, SdrBeginTextEdit did not set
 827                     // our SdrTextObj into edit mode
 828                     mpView->SdrEndTextEdit();
 829                 }
 830             }
 831         }
 832     }
 833
 834     return mpViewForwarder;
 835 }
 836
 837 //------------------------------------------------------------------------
 838
 839 void SvxTextEditSourceImpl::UpdateData()
 840 {
 841     // if we have a view and in edit mode, we're working with the
 842     // DrawOutliner. Thus, all changes made on the text forwarder are
 843     // reflected on the view and committed to the model on
 844     // SdrEndTextEdit(). Thus, no need for explicit updates here.
 845     if( !HasView() || !IsEditMode() )
 846     {
 847         if( mbIsLocked  )
 848         {
 849             mbNeedsUpdate = sal_True;
 850         }
 851         else
 852         {
 853             if( mpOutliner && mpObject && mpText && !mbDestroyed )
 854             {
 855                 SdrTextObj* pTextObj = dynamic_cast< SdrTextObj* >( mpObject );
 856                 if( pTextObj )
 857                 {
 858                     if( mpOutliner->GetParagraphCount() != 1 || mpOutliner->GetEditEngine().GetTextLen( 0 ) )
 859                     {
 860                         if( mpOutliner->GetParagraphCount() > 1 )
 861                         {
 862                             if( pTextObj && pTextObj->IsTextFrame() && pTextObj->GetTextKind() == OBJ_TITLETEXT )
 863                             {
 864                                 while( mpOutliner->GetParagraphCount() > 1 )
 865                                 {
 866                                     ESelection aSel( 0,mpOutliner->GetEditEngine().GetTextLen( 0 ), 1,0 );
 867                                     mpOutliner->QuickInsertLineBreak( aSel );
 868                                 }
 869                             }
 870                         }
 871
 872                         pTextObj->NbcSetOutlinerParaObjectForText( mpOutliner->CreateParaObject(), mpText );
 873                     }
 874                     else
 875                     {
 876                         pTextObj->NbcSetOutlinerParaObjectForText( NULL,mpText );
 877                     }
 878                 }
 879
 880                 if( mpObject->IsEmptyPresObj() )
 881                     mpObject->SetEmptyPresObj(sal_False);
 882             }
 883         }
 884     }
 885 }
 886
 887 void SvxTextEditSourceImpl::lock()
 888 {
 889     mbIsLocked = sal_True;
 890     if( mpOutliner )
 891     {
 892         ((EditEngine*)&(mpOutliner->GetEditEngine()))->SetUpdateMode( sal_False );
 893         mbOldUndoMode = ((EditEngine*)&(mpOutliner->GetEditEngine()))->IsUndoEnabled();
 894         ((EditEngine*)&(mpOutliner->GetEditEngine()))->EnableUndo( sal_False );
 895     }
 896 }
 897
 898 void SvxTextEditSourceImpl::unlock()
 899 {
 900     mbIsLocked = sal_False;
 901
 902     if( mbNeedsUpdate )
 903     {
 904         UpdateData();
 905         mbNeedsUpdate = sal_False;
 906     }
 907
 908     if( mpOutliner )
 909     {
 910         ((EditEngine*)&(mpOutliner->GetEditEngine()))->SetUpdateMode( sal_True );
 911         ((EditEngine*)&(mpOutliner->GetEditEngine()))->EnableUndo( mbOldUndoMode );
 912     }
 913 }
 914
 915 BOOL SvxTextEditSourceImpl::IsValid() const
 916 {
 917     return mpView && mpWindow ? TRUE : FALSE;
 918 }
 919
 920 Rectangle SvxTextEditSourceImpl::GetVisArea()
 921 {
 922     if( IsValid() )
 923     {
 924         SdrPaintWindow* pPaintWindow = mpView->FindPaintWindow(*mpWindow);
 925         Rectangle aVisArea;
 926
 927         if(pPaintWindow)
 928         {
 929             aVisArea = pPaintWindow->GetVisibleArea();
 930         }
 931
 932         // offset vis area by edit engine left-top position
 933         SdrTextObj* pTextObj = PTR_CAST( SdrTextObj, mpObject );
 934         if( pTextObj )
 935         {
 936             Rectangle aAnchorRect;
 937             pTextObj->TakeTextAnchorRect( aAnchorRect );
 938             aVisArea.Move( -aAnchorRect.Left(), -aAnchorRect.Top() );
 939
 940             MapMode aMapMode(mpWindow->GetMapMode());
 941             aMapMode.SetOrigin(Point());
 942             return mpWindow->LogicToPixel( aVisArea, aMapMode );
 943         }
 944     }
 945
 946     return Rectangle();
 947 }
 948
 949 Point SvxTextEditSourceImpl::LogicToPixel( const Point& rPoint, const MapMode& rMapMode )
 950 {
 951     // #101029#: The responsibilities of ViewForwarder happen to be
 952     // somewhat mixed in this case. On the one hand, we need the
 953     // different interface queries on the SvxEditSource interface,
 954     // since we need both VisAreas. On the other hand, if an
 955     // EditViewForwarder exists, maTextOffset does not remain static,
 956     // but may change with every key press.
 957     if( IsEditMode() )
 958     {
 959         SvxEditViewForwarder* pForwarder = GetEditViewForwarder(sal_False);
 960
 961         if( pForwarder )
 962             return pForwarder->LogicToPixel( rPoint, rMapMode );
 963     }
 964     else if( IsValid() && mpModel )
 965     {
 966         // #101029#
 967         Point aPoint1( rPoint );
 968         aPoint1.X() += maTextOffset.X();
 969         aPoint1.Y() += maTextOffset.Y();
 970
 971         Point aPoint2( OutputDevice::LogicToLogic( aPoint1, rMapMode,
 972                                                    MapMode(mpModel->GetScaleUnit()) ) );
 973         MapMode aMapMode(mpWindow->GetMapMode());
 974         aMapMode.SetOrigin(Point());
 975         return mpWindow->LogicToPixel( aPoint2, aMapMode );
 976     }
 977
 978     return Point();
 979 }
 980
 981 Point SvxTextEditSourceImpl::PixelToLogic( const Point& rPoint, const MapMode& rMapMode )
 982 {
 983     // #101029#: The responsibilities of ViewForwarder happen to be
 984     // somewhat mixed in this case. On the one hand, we need the
 985     // different interface queries on the SvxEditSource interface,
 986     // since we need both VisAreas. On the other hand, if an
 987     // EditViewForwarder exists, maTextOffset does not remain static,
 988     // but may change with every key press.
 989     if( IsEditMode() )
 990     {
 991         SvxEditViewForwarder* pForwarder = GetEditViewForwarder(sal_False);
 992
 993         if( pForwarder )
 994             return pForwarder->PixelToLogic( rPoint, rMapMode );
 995     }
 996     else if( IsValid() && mpModel )
 997     {
 998         MapMode aMapMode(mpWindow->GetMapMode());
 999         aMapMode.SetOrigin(Point());
1000         Point aPoint1( mpWindow->PixelToLogic( rPoint, aMapMode ) );
1001         Point aPoint2( OutputDevice::LogicToLogic( aPoint1,
1002                                                    MapMode(mpModel->GetScaleUnit()),
1003                                                    rMapMode ) );
1004         // #101029#
1005         aPoint2.X() -= maTextOffset.X();
1006         aPoint2.Y() -= maTextOffset.Y();
1007
1008         return aPoint2;
1009     }
1010
1011     return Point();
1012 }
1013
1014 IMPL_LINK(SvxTextEditSourceImpl, NotifyHdl, EENotify*, aNotify)
1015 {
1016     if( aNotify && !mbNotificationsDisabled )
1017     {
1018         ::std::auto_ptr< SfxHint > aHint( SvxEditSourceHelper::EENotification2Hint( aNotify) );
1019
1020         if( aHint.get() )
1021             Broadcast( *aHint.get() );
1022     }
1023
1024     return 0;
1025 }
1026
1027 //------------------------------------------------------------------------
1028
1029 // --------------------------------------------------------------------
1030 // SvxTextEditSource
1031 // --------------------------------------------------------------------
1032
1033 SvxTextEditSource::SvxTextEditSource( SdrObject* pObject, SdrText* pText, XInterface* pOwner )
1034 {
1035     mpImpl = new SvxTextEditSourceImpl( pObject, pText, pOwner );
1036     mpImpl->acquire();
1037 }
1038
1039 // --------------------------------------------------------------------
1040 SvxTextEditSource::SvxTextEditSource( SdrObject& rObj, SdrText* pText, SdrView& rView, const Window& rWindow )
1041 {
1042     mpImpl = new SvxTextEditSourceImpl( rObj, pText, rView, rWindow );
1043     mpImpl->acquire();
1044 }
1045
1046 // --------------------------------------------------------------------
1047
1048 SvxTextEditSource::SvxTextEditSource( SvxTextEditSourceImpl* pImpl )
1049 {
1050     mpImpl = pImpl;
1051     mpImpl->acquire();
1052 }
1053
1054 //------------------------------------------------------------------------
1055 SvxTextEditSource::~SvxTextEditSource()
1056 {
1057     OGuard aGuard( Application::GetSolarMutex() );
1058
1059     mpImpl->release();
1060 }
1061
1062 //------------------------------------------------------------------------
1063 SvxEditSource* SvxTextEditSource::Clone() const
1064 {
1065     return new SvxTextEditSource( mpImpl );
1066 }
1067
1068 //------------------------------------------------------------------------
1069 SvxTextForwarder* SvxTextEditSource::GetTextForwarder()
1070 {
1071     return mpImpl->GetTextForwarder();
1072 }
1073
1074 //------------------------------------------------------------------------
1075 SvxEditViewForwarder* SvxTextEditSource::GetEditViewForwarder( sal_Bool bCreate )
1076 {
1077     return mpImpl->GetEditViewForwarder( bCreate );
1078 }
1079
1080 //------------------------------------------------------------------------
1081 SvxViewForwarder* SvxTextEditSource::GetViewForwarder()
1082 {
1083     return this;
1084 }
1085
1086 //------------------------------------------------------------------------
1087 void SvxTextEditSource::UpdateData()
1088 {
1089     mpImpl->UpdateData();
1090 }
1091
1092 SfxBroadcaster& SvxTextEditSource::GetBroadcaster() const
1093 {
1094     return *mpImpl;
1095 }
1096
1097 SdrObject* SvxTextEditSource::GetSdrObject() const
1098 {
1099     return mpImpl->GetSdrObject();
1100 }
1101
1102 void SvxTextEditSource::lock()
1103 {
1104     mpImpl->lock();
1105 }
1106
1107 void SvxTextEditSource::unlock()
1108 {
1109     mpImpl->unlock();
1110 }
1111
1112 BOOL SvxTextEditSource::IsValid() const
1113 {
1114     return mpImpl->IsValid();
1115 }
1116
1117 Rectangle SvxTextEditSource::GetVisArea() const
1118 {
1119     return mpImpl->GetVisArea();
1120 }
1121
1122 Point SvxTextEditSource::LogicToPixel( const Point& rPoint, const MapMode& rMapMode ) const
1123 {
1124     return mpImpl->LogicToPixel( rPoint, rMapMode );
1125 }
1126
1127 Point SvxTextEditSource::PixelToLogic( const Point& rPoint, const MapMode& rMapMode ) const
1128 {
1129     return mpImpl->PixelToLogic( rPoint, rMapMode );
1130 }
1131
1132 void SvxTextEditSource::addRange( SvxUnoTextRangeBase* pNewRange )
1133 {
1134     mpImpl->addRange( pNewRange );
1135 }
1136
1137 void SvxTextEditSource::removeRange( SvxUnoTextRangeBase* pOldRange )
1138 {
1139     mpImpl->removeRange( pOldRange );
1140 }
1141
1142 const SvxUnoTextRangeBaseList& SvxTextEditSource::getRanges() const
1143 {
1144     return mpImpl->getRanges();
1145 }
1146
1147 void SvxTextEditSource::ChangeModel( SdrModel* pNewModel )
1148 {
1149     mpImpl->ChangeModel( pNewModel );
1150 }