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