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