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