sw/source/core/draw/dview.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: dview.cxx,v $
  10  * $Revision: 1.30 $
  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_sw.hxx"
  33
  34 #include "hintids.hxx"
  35 #include <svx/protitem.hxx>
  36 #include <svx/svdpagv.hxx>
  37 #ifndef _FM_FMMODEL_HXX
  38 #include <svx/fmmodel.hxx>
  39 #endif
  40
  41 #include "swtypes.hxx"
  42 #include "pagefrm.hxx"
  43 #include "rootfrm.hxx"
  44 #include "cntfrm.hxx"
  45 #include "flyfrm.hxx"
  46 #include "frmfmt.hxx"
  47 #include "dflyobj.hxx"
  48 #include "dcontact.hxx"
  49 #include "frmatr.hxx"
  50 #include "viewsh.hxx"
  51 #include "viewimp.hxx"
  52 #include "dview.hxx"
  53 #include "dpage.hxx"
  54 #include "doc.hxx"
  55 #include "mdiexp.hxx"
  56 #include <ndole.hxx>
  57 #include <fmtanchr.hxx>
  58 #include "shellres.hxx"
  59
  60 // #i7672#
  61 #include <svx/outliner.hxx>
  62
  63 #include <com/sun/star/embed/EmbedMisc.hpp>
  64
  65 using namespace com::sun::star;
  66
  67 // OD 18.06.2003 #108784#
  68 //#ifndef _SVDVMARK_HXX //autogen
  69 //#include <svx/svdvmark.hxx>
  70 //#endif
  71 #include <vector>
  72 // --> OD 2004-06-24 #i28701#
  73 #include <sortedobjs.hxx>
  74 #include <flyfrms.hxx>
  75 // <--
  76
  77 class SwSdrHdl : public SdrHdl
  78 {
  79 public:
  80     SwSdrHdl(const Point& rPnt, bool bTopRight ) :
  81         SdrHdl( rPnt, bTopRight ? HDL_ANCHOR_TR : HDL_ANCHOR ) {}
  82     virtual BOOL IsFocusHdl() const;
  83 };
  84
  85 BOOL SwSdrHdl::IsFocusHdl() const
  86 {
  87     if( HDL_ANCHOR == eKind || HDL_ANCHOR_TR == eKind )
  88         return TRUE;
  89     return SdrHdl::IsFocusHdl();
  90 }
  91
  92 const SwFrm *lcl_FindAnchor( const SdrObject *pObj, BOOL bAll )
  93 {
  94     const SwVirtFlyDrawObj *pVirt = pObj->ISA(SwVirtFlyDrawObj) ?
  95                                             (SwVirtFlyDrawObj*)pObj : 0;
  96     if ( pVirt )
  97     {
  98         if ( bAll || !pVirt->GetFlyFrm()->IsFlyInCntFrm() )
  99             return pVirt->GetFlyFrm()->GetAnchorFrm();
 100     }
 101     else
 102     {
 103         const SwDrawContact *pCont = (const SwDrawContact*)GetUserCall(pObj);
 104         if ( pCont )
 105             return pCont->GetAnchorFrm( pObj );
 106     }
 107     return 0;
 108 }
 109
 110 /*************************************************************************
 111 |*
 112 |*      SwDrawView::Ctor
 113 |*
 114 |*      Ersterstellung          OK 18.11.94
 115 |*      Letzte Aenderung        MA 22. Jul. 96
 116 |*
 117 *************************************************************************/
 118
 119
 120
 121 SwDrawView::SwDrawView( SwViewImp &rI, SdrModel *pMd, OutputDevice *pOutDev) :
 122     FmFormView( (FmFormModel*)pMd, pOutDev ),
 123     rImp( rI )
 124 {
 125     SetPageVisible( FALSE );
 126     SetBordVisible( FALSE );
 127     SetGridVisible( FALSE );
 128     SetHlplVisible( FALSE );
 129     SetGlueVisible( FALSE );
 130     SetFrameDragSingles( TRUE );
 131     SetVirtualObjectBundling( TRUE );
 132     SetSwapAsynchron( TRUE );
 133
 134     EnableExtendedKeyInputDispatcher( FALSE );
 135     EnableExtendedMouseEventDispatcher( FALSE );
 136     EnableExtendedCommandEventDispatcher( FALSE );
 137
 138     SetHitTolerancePixel( GetMarkHdlSizePixel()/2 );
 139
 140     SetPrintPreview( rI.GetShell()->IsPreView() );
 141
 142     // #i73602# Use default from the configuration
 143     SetBufferedOverlayAllowed(getOptionsDrawinglayer().IsOverlayBuffer_Writer());
 144
 145     // #i74769#, #i75172# Use default from the configuration
 146     SetBufferedOutputAllowed(getOptionsDrawinglayer().IsPaintBuffer_Writer());
 147 }
 148
 149 // --> OD 2009-03-05 #i99665#
 150 sal_Bool SwDrawView::IsAntiAliasing() const
 151 {
 152     return getOptionsDrawinglayer().IsAntiAliasing();
 153 }
 154 // <--
 155
 156 //////////////////////////////////////////////////////////////////////////////
 157
 158 SdrObject* impLocalHitCorrection(SdrObject* pRetval, const Point& rPnt, USHORT nTol, const SdrMarkList &rMrkList)
 159 {
 160     if(!nTol)
 161     {
 162         // the old method forced back to outer bounds test when nTol == 0, so
 163         // do not try to correct when nTol is not set (used from HelpContent)
 164     }
 165     else
 166     {
 167         // rebuild logic from former SwVirtFlyDrawObj::CheckSdrObjectHit. This is needed since
 168         // the SdrObject-specific CheckHit implementations are now replaced with primitives and
 169         // 'tricks' like in the old implementation (e.g. using a view from a model-data class to
 170         // detect if object is selected) are no longer valid.
 171         // The standard primitive hit-test for SwVirtFlyDrawObj now is the outer bound. The old
 172         // implementation reduced this excluding the inner bound when the object was not selected.
 173         SwVirtFlyDrawObj* pSwVirtFlyDrawObj = dynamic_cast< SwVirtFlyDrawObj* >(pRetval);
 174
 175         if(pSwVirtFlyDrawObj)
 176         {
 177             if(pSwVirtFlyDrawObj->GetFlyFrm()->Lower() && pSwVirtFlyDrawObj->GetFlyFrm()->Lower()->IsNoTxtFrm())
 178             {
 179                 // the old method used IsNoTxtFrm (should be for SW's own OLE and
 180                 // graphic's) to accept hit only based on outer bounds; nothing to do
 181             }
 182             else
 183             {
 184                 // check if the object is selected in this view
 185                 const sal_uInt32 nMarkCount(rMrkList.GetMarkCount());
 186                 bool bSelected(false);
 187
 188                 for(sal_uInt32 a(0); !bSelected && a < nMarkCount; a++)
 189                 {
 190                     if(pSwVirtFlyDrawObj == rMrkList.GetMark(a)->GetMarkedSdrObj())
 191                     {
 192                         bSelected = true;
 193                     }
 194                 }
 195
 196                 if(!bSelected)
 197                 {
 198                     // when not selected, the object is not hit when hit position is inside
 199                     // inner range. Get and shrink inner range
 200                     basegfx::B2DRange aInnerBound(pSwVirtFlyDrawObj->getInnerBound());
 201
 202                     aInnerBound.grow(-1.0 * nTol);
 203
 204                     if(aInnerBound.isInside(basegfx::B2DPoint(rPnt.X(), rPnt.Y())))
 205                     {
 206                         // exclude this hit
 207                         pRetval = 0;
 208                     }
 209                 }
 210             }
 211         }
 212     }
 213
 214     return pRetval;
 215 }
 216
 217 SdrObject* SwDrawView::CheckSingleSdrObjectHit(const Point& rPnt, USHORT nTol, SdrObject* pObj, SdrPageView* pPV, ULONG nOptions, const SetOfByte* pMVisLay) const
 218 {
 219     // call parent
 220     SdrObject* pRetval = FmFormView::CheckSingleSdrObjectHit(rPnt, nTol, pObj, pPV, nOptions, pMVisLay);
 221
 222     if(pRetval)
 223     {
 224         // overloaded to allow extra handling when picking SwVirtFlyDrawObj's
 225         pRetval = impLocalHitCorrection(pRetval, rPnt, nTol, GetMarkedObjectList());
 226     }
 227
 228     return pRetval;
 229 }
 230
 231 /*************************************************************************
 232 |*
 233 |*      SwDrawView::AddCustomHdl()
 234 |*
 235 |*  Gets called every time the handles need to be build
 236 |*
 237 |*      Ersterstellung          AW 06. Sep. 99
 238 |*      Letzte Aenderung        AW 06. Sep. 99
 239 |*
 240 *************************************************************************/
 241
 242 void SwDrawView::AddCustomHdl()
 243 {
 244     const SdrMarkList &rMrkList = GetMarkedObjectList();
 245
 246     if(rMrkList.GetMarkCount() != 1 || !GetUserCall(rMrkList.GetMark( 0 )->GetMarkedSdrObj()))
 247         return;
 248
 249     SdrObject *pObj = rMrkList.GetMark(0)->GetMarkedSdrObj();
 250     // --> OD 2006-11-06 #130889# - make code robust
 251 //    const SwFmtAnchor &rAnchor = ::FindFrmFmt(pObj)->GetAnchor();
 252     SwFrmFmt* pFrmFmt( ::FindFrmFmt( pObj ) );
 253     if ( !pFrmFmt )
 254     {
 255         ASSERT( false, "<SwDrawView::AddCustomHdl()> - missing frame format!" );
 256         return;
 257     }
 258     const SwFmtAnchor &rAnchor = pFrmFmt->GetAnchor();
 259     // <--
 260
 261     if(FLY_IN_CNTNT == rAnchor.GetAnchorId())
 262         return;
 263
 264     const SwFrm* pAnch;
 265     if(0 == (pAnch = CalcAnchor()))
 266         return;
 267
 268     Point aPos(aAnchorPoint);
 269
 270     if ( FLY_AUTO_CNTNT == rAnchor.GetAnchorId() )
 271     {
 272         // --> OD 2004-06-24 #i28701# - use last character rectangle saved at object
 273         // in order to avoid a format of the anchor frame
 274         SwAnchoredObject* pAnchoredObj = ::GetUserCall( pObj )->GetAnchoredObj( pObj );
 275         SwRect aAutoPos = pAnchoredObj->GetLastCharRect();
 276         if ( aAutoPos.Height() )
 277         {
 278             aPos = aAutoPos.Pos();
 279         }
 280     }
 281
 282     // add anchor handle:
 283     aHdl.AddHdl( new SwSdrHdl( aPos, pAnch->IsVertical() ||
 284                                      pAnch->IsRightToLeft() ) );
 285 }
 286
 287 /*************************************************************************
 288 |*
 289 |*      SwDrawView::GetMaxToTopObj(), _GetMaxToTopObj()
 290 |*
 291 |*      Ersterstellung          MA 13. Jan. 95
 292 |*      Letzte Aenderung        MA 18. Mar. 97
 293 |*
 294 *************************************************************************/
 295
 296
 297 SdrObject* SwDrawView::GetMaxToTopObj( SdrObject* pObj ) const
 298 {
 299     if ( GetUserCall(pObj) )
 300     {
 301         const SwFrm *pAnch = ::lcl_FindAnchor( pObj, FALSE );
 302         if ( pAnch )
 303         {
 304             //Das oberste Obj innerhalb des Ankers darf nicht ueberholt
 305             //werden.
 306             const SwFlyFrm *pFly = pAnch->FindFlyFrm();
 307             if ( pFly )
 308             {
 309                 const SwPageFrm *pPage = pFly->FindPageFrm();
 310                 if ( pPage->GetSortedObjs() )
 311                 {
 312                     UINT32 nOrdNum = 0;
 313                     for ( USHORT i = 0; i < pPage->GetSortedObjs()->Count(); ++i )
 314                     {
 315                         const SdrObject *pO =
 316                                     (*pPage->GetSortedObjs())[i]->GetDrawObj();
 317
 318                         if ( pO->GetOrdNumDirect() > nOrdNum )
 319                         {
 320                             const SwFrm *pTmpAnch = ::lcl_FindAnchor( pO, FALSE );
 321                             if ( pFly->IsAnLower( pTmpAnch ) )
 322                             {
 323                                 nOrdNum = pO->GetOrdNumDirect();
 324                             }
 325                         }
 326                     }
 327                     if ( nOrdNum )
 328                     {
 329                         SdrPage *pTmpPage = GetModel()->GetPage( 0 );
 330                         ++nOrdNum;
 331                         if ( nOrdNum < pTmpPage->GetObjCount() )
 332                         {
 333                             return pTmpPage->GetObj( nOrdNum );
 334                         }
 335                     }
 336                 }
 337             }
 338         }
 339     }
 340     return 0;
 341 }
 342
 343 /*************************************************************************
 344 |*
 345 |*      SwDrawView::GetMaxToBtmObj()
 346 |*
 347 |*      Ersterstellung          MA 13. Jan. 95
 348 |*      Letzte Aenderung        MA 05. Sep. 96
 349 |*
 350 *************************************************************************/
 351
 352
 353 SdrObject* SwDrawView::GetMaxToBtmObj(SdrObject* pObj) const
 354 {
 355     if ( GetUserCall(pObj) )
 356     {
 357         const SwFrm *pAnch = ::lcl_FindAnchor( pObj, FALSE );
 358         if ( pAnch )
 359         {
 360             //Der Fly des Ankers darf nicht "unterflogen" werden.
 361             const SwFlyFrm *pFly = pAnch->FindFlyFrm();
 362             if ( pFly )
 363             {
 364                 SdrObject *pRet = (SdrObject*)pFly->GetVirtDrawObj();
 365                 return pRet != pObj ? pRet : 0;
 366             }
 367         }
 368     }
 369     return 0;
 370 }
 371
 372 /*************************************************************************
 373 |*
 374 |*      SwDrawView::ObjOrderChanged()
 375 |*
 376 |*      Ersterstellung          MA 31. Jul. 95
 377 |*      Letzte Aenderung        MA 18. Mar. 97
 378 |*
 379 *************************************************************************/
 380
 381 inline BOOL lcl_IsChild( SdrObject *pParent, SdrObject *pChild )
 382 {
 383     if ( pParent->ISA(SwVirtFlyDrawObj) )
 384     {
 385         const SwFrm *pAnch = lcl_FindAnchor( pChild, FALSE );
 386         if ( pAnch && ((SwVirtFlyDrawObj*)pParent)->GetFlyFrm()->IsAnLower( pAnch ))
 387         {
 388             return TRUE;
 389         }
 390     }
 391     return FALSE;
 392 }
 393
 394 inline SdrObject *lcl_FindParent( SdrObject *pObj )
 395 {
 396     const SwFrm *pAnch = lcl_FindAnchor( pObj, FALSE );
 397     if ( pAnch && pAnch->IsInFly() )
 398         return (SdrObject*)pAnch->FindFlyFrm()->GetVirtDrawObj();
 399     return 0;
 400 }
 401
 402 /** determine maximal order number for a 'child' object of given 'parent' object
 403
 404     OD 2004-08-20 #110810#
 405
 406     @author OD
 407 */
 408 sal_uInt32 SwDrawView::_GetMaxChildOrdNum( const SwFlyFrm& _rParentObj,
 409                                            const SdrObject* _pExclChildObj ) const
 410 {
 411     sal_uInt32 nMaxChildOrdNum = _rParentObj.GetDrawObj()->GetOrdNum();
 412
 413     const SdrPage* pDrawPage = _rParentObj.GetDrawObj()->GetPage();
 414     ASSERT( pDrawPage,
 415             "<SwDrawView::_GetMaxChildOrdNum(..) - missing drawing page at parent object - crash!" );
 416
 417     sal_uInt32 nObjCount = pDrawPage->GetObjCount();
 418     for ( sal_uInt32 i = nObjCount-1; i > _rParentObj.GetDrawObj()->GetOrdNum() ; --i )
 419     {
 420         const SdrObject* pObj = pDrawPage->GetObj( i );
 421
 422         // Don't consider 'child' object <_pExclChildObj>
 423         if ( pObj == _pExclChildObj )
 424         {
 425             continue;
 426         }
 427
 428         if ( pObj->GetOrdNum() > nMaxChildOrdNum &&
 429              _rParentObj.IsAnLower( lcl_FindAnchor( pObj, TRUE ) ) )
 430         {
 431             nMaxChildOrdNum = pObj->GetOrdNum();
 432             break;
 433         }
 434     }
 435
 436     return nMaxChildOrdNum;
 437 }
 438
 439 /** method to move 'repeated' objects of the given moved object to the
 440     according level
 441
 442     OD 2004-08-23 #110810#
 443
 444     @author OD
 445 */
 446 void SwDrawView::_MoveRepeatedObjs( const SwAnchoredObject& _rMovedAnchoredObj,
 447                                     const std::vector<SdrObject*>& _rMovedChildObjs ) const
 448 {
 449     // determine 'repeated' objects of already moved object <_rMovedAnchoredObj>
 450     std::vector<SwAnchoredObject*> aAnchoredObjs;
 451     {
 452         const SwContact* pContact = ::GetUserCall( _rMovedAnchoredObj.GetDrawObj() );
 453         ASSERT( pContact,
 454                 "SwDrawView::_MoveRepeatedObjs(..) - missing contact object -> crash." );
 455         pContact->GetAnchoredObjs( aAnchoredObjs );
 456     }
 457
 458     // check, if 'repeated' objects exists.
 459     if ( aAnchoredObjs.size() > 1 )
 460     {
 461         SdrPage* pDrawPage = GetModel()->GetPage( 0 );
 462
 463         // move 'repeated' ones to the same order number as the already moved one.
 464         sal_uInt32 nNewPos = _rMovedAnchoredObj.GetDrawObj()->GetOrdNum();
 465         while ( !aAnchoredObjs.empty() )
 466         {
 467             SwAnchoredObject* pAnchoredObj = aAnchoredObjs.back();
 468             if ( pAnchoredObj != &_rMovedAnchoredObj )
 469             {
 470                 pDrawPage->SetObjectOrdNum( pAnchoredObj->GetDrawObj()->GetOrdNum(),
 471                                             nNewPos );
 472                 pDrawPage->RecalcObjOrdNums();
 473                 // adjustments for accessibility API
 474                 if ( pAnchoredObj->ISA(SwFlyFrm) )
 475                 {
 476                     const SwFlyFrm *pTmpFlyFrm = static_cast<SwFlyFrm*>(pAnchoredObj);
 477                     rImp.DisposeAccessibleFrm( pTmpFlyFrm );
 478                     rImp.AddAccessibleFrm( pTmpFlyFrm );
 479                 }
 480                 else
 481                 {
 482                     rImp.DisposeAccessibleObj( pAnchoredObj->GetDrawObj() );
 483                     rImp.AddAccessibleObj( pAnchoredObj->GetDrawObj() );
 484                 }
 485             }
 486             aAnchoredObjs.pop_back();
 487         }
 488
 489         // move 'repeated' ones of 'child' objects
 490         for ( std::vector<SdrObject*>::const_iterator aObjIter = _rMovedChildObjs.begin();
 491               aObjIter != _rMovedChildObjs.end(); ++aObjIter )
 492         {
 493             SdrObject* pChildObj = (*aObjIter);
 494             {
 495                 const SwContact* pContact = ::GetUserCall( pChildObj );
 496                 ASSERT( pContact,
 497                         "SwDrawView::_MoveRepeatedObjs(..) - missing contact object -> crash." );
 498                 pContact->GetAnchoredObjs( aAnchoredObjs );
 499             }
 500             // move 'repeated' ones to the same order number as the already moved one.
 501             const sal_uInt32 nTmpNewPos = pChildObj->GetOrdNum();
 502             while ( !aAnchoredObjs.empty() )
 503             {
 504                 SwAnchoredObject* pAnchoredObj = aAnchoredObjs.back();
 505                 if ( pAnchoredObj->GetDrawObj() != pChildObj )
 506                 {
 507                     pDrawPage->SetObjectOrdNum( pAnchoredObj->GetDrawObj()->GetOrdNum(),
 508                                                 nTmpNewPos );
 509                     pDrawPage->RecalcObjOrdNums();
 510                     // adjustments for accessibility API
 511                     if ( pAnchoredObj->ISA(SwFlyFrm) )
 512                     {
 513                         const SwFlyFrm *pTmpFlyFrm = static_cast<SwFlyFrm*>(pAnchoredObj);
 514                         rImp.DisposeAccessibleFrm( pTmpFlyFrm );
 515                         rImp.AddAccessibleFrm( pTmpFlyFrm );
 516                     }
 517                     else
 518                     {
 519                         rImp.DisposeAccessibleObj( pAnchoredObj->GetDrawObj() );
 520                         rImp.AddAccessibleObj( pAnchoredObj->GetDrawObj() );
 521                     }
 522                 }
 523                 aAnchoredObjs.pop_back();
 524             }
 525         }
 526     }
 527 }
 528
 529 // --> OD 2004-08-20 #110810# - adjustment and re-factoring of method
 530 void SwDrawView::ObjOrderChanged( SdrObject* pObj, ULONG nOldPos,
 531                                           ULONG nNewPos )
 532 {
 533     // --> OD 2004-08-17 #110810# - nothing to do for group members
 534     if ( pObj->GetUpGroup() )
 535     {
 536         return;
 537     }
 538     // <--
 539
 540     // determine drawing page and assure that the order numbers are correct.
 541     SdrPage* pDrawPage = GetModel()->GetPage( 0 );
 542     if ( pDrawPage->IsObjOrdNumsDirty() )
 543         pDrawPage->RecalcObjOrdNums();
 544     const sal_uInt32 nObjCount = pDrawPage->GetObjCount();
 545
 546     SwAnchoredObject* pMovedAnchoredObj =
 547                                 ::GetUserCall( pObj )->GetAnchoredObj( pObj );
 548     const SwFlyFrm* pParentAnchoredObj =
 549                                 pMovedAnchoredObj->GetAnchorFrm()->FindFlyFrm();
 550
 551     const bool bMovedForward = nOldPos < nNewPos;
 552
 553     // assure for a 'child' object, that it doesn't exceed the limits of its 'parent'
 554     if ( pParentAnchoredObj )
 555     {
 556         if ( bMovedForward )
 557         {
 558             sal_uInt32 nMaxChildOrdNumWithoutMoved =
 559                     _GetMaxChildOrdNum( *pParentAnchoredObj, pMovedAnchoredObj->GetDrawObj() );
 560             if ( nNewPos > nMaxChildOrdNumWithoutMoved+1 )
 561             {
 562                 // set position to the top of the 'child' object group
 563                 pDrawPage->SetObjectOrdNum( nNewPos, nMaxChildOrdNumWithoutMoved+1 );
 564                 nNewPos = nMaxChildOrdNumWithoutMoved+1;
 565             }
 566         }
 567         else
 568         {
 569             const sal_uInt32 nParentOrdNum = pParentAnchoredObj->GetDrawObj()->GetOrdNum();
 570             if ( nNewPos < nParentOrdNum )
 571             {
 572                 // set position to the bottom of the 'child' object group
 573                 pDrawPage->SetObjectOrdNum( nNewPos, nParentOrdNum );
 574                 nNewPos = nParentOrdNum;
 575             }
 576         }
 577         if ( pDrawPage->IsObjOrdNumsDirty() )
 578             pDrawPage->RecalcObjOrdNums();
 579     }
 580
 581     // Assure, that object isn't positioned between 'repeated' ones
 582     if ( ( bMovedForward && nNewPos < nObjCount - 1 ) ||
 583          ( !bMovedForward && nNewPos > 0 ) )
 584     {
 585         const SdrObject* pTmpObj =
 586                 pDrawPage->GetObj( bMovedForward ? nNewPos - 1 : nNewPos + 1 );
 587         if ( pTmpObj )
 588         {
 589             sal_uInt32 nTmpNewPos( nNewPos );
 590             if ( bMovedForward )
 591             {
 592                 // move before the top 'repeated' object
 593                 const sal_uInt32 nTmpMaxOrdNum =
 594                                     ::GetUserCall( pTmpObj )->GetMaxOrdNum();
 595                 if ( nTmpMaxOrdNum > nNewPos )
 596                     nTmpNewPos = nTmpMaxOrdNum;
 597             }
 598             else
 599             {
 600                 // move behind the bottom 'repeated' object
 601                 const sal_uInt32 nTmpMinOrdNum =
 602                                     ::GetUserCall( pTmpObj )->GetMinOrdNum();
 603                 if ( nTmpMinOrdNum < nNewPos )
 604                     nTmpNewPos = nTmpMinOrdNum;
 605             }
 606             if ( nTmpNewPos != nNewPos )
 607             {
 608                 pDrawPage->SetObjectOrdNum( nNewPos, nTmpNewPos );
 609                 nNewPos = nTmpNewPos;
 610                 pDrawPage->RecalcObjOrdNums();
 611             }
 612         }
 613     }
 614
 615     // On move forward, assure that object is moved before its own childs.
 616     // Only Writer fly frames can have childs.
 617     if ( pMovedAnchoredObj->ISA(SwFlyFrm) &&
 618          bMovedForward && nNewPos < nObjCount - 1 )
 619     {
 620         sal_uInt32 nMaxChildOrdNum =
 621                     _GetMaxChildOrdNum( *(static_cast<const SwFlyFrm*>(pMovedAnchoredObj)) );
 622         if ( nNewPos < nMaxChildOrdNum )
 623         {
 624             // determine position before the object before its top 'child' object
 625             const SdrObject* pTmpObj = pDrawPage->GetObj( nMaxChildOrdNum );
 626             sal_uInt32 nTmpNewPos = ::GetUserCall( pTmpObj )->GetMaxOrdNum() + 1;
 627             if ( nTmpNewPos >= nObjCount )
 628             {
 629                 --nTmpNewPos;
 630             }
 631             // assure, that determined position isn't between 'repeated' objects
 632             pTmpObj = pDrawPage->GetObj( nTmpNewPos );
 633             nTmpNewPos = ::GetUserCall( pTmpObj )->GetMaxOrdNum();
 634             // apply new position
 635             pDrawPage->SetObjectOrdNum( nNewPos, nTmpNewPos );
 636             nNewPos = nTmpNewPos;
 637             pDrawPage->RecalcObjOrdNums();
 638         }
 639     }
 640
 641     // Assure, that object isn't positioned between nested objects
 642     if ( ( bMovedForward && nNewPos < nObjCount - 1 ) ||
 643          ( !bMovedForward && nNewPos > 0 ) )
 644     {
 645         sal_uInt32 nTmpNewPos( nNewPos );
 646         const SwFrmFmt* pParentFrmFmt =
 647                 pParentAnchoredObj ? &(pParentAnchoredObj->GetFrmFmt()) : 0L;
 648         const SdrObject* pTmpObj = pDrawPage->GetObj( nNewPos + 1 );
 649         while ( pTmpObj )
 650         {
 651             // --> OD 2004-12-07 #i38563# - assure, that anchor frame exists.
 652             // If object is anchored inside a invisible part of the document
 653             // (e.g. page header, whose page style isn't applied, or hidden
 654             // section), no anchor frame exists.
 655             const SwFrm* pTmpAnchorFrm = lcl_FindAnchor( pTmpObj, TRUE );
 656             const SwFlyFrm* pTmpParentObj = pTmpAnchorFrm
 657                                             ? pTmpAnchorFrm->FindFlyFrm() : 0L;
 658             // <--
 659             if ( pTmpParentObj &&
 660                  &(pTmpParentObj->GetFrmFmt()) != pParentFrmFmt )
 661             {
 662                 if ( bMovedForward )
 663                 {
 664                     nTmpNewPos = ::GetUserCall( pTmpObj )->GetMaxOrdNum();
 665                     pTmpObj = pDrawPage->GetObj( nTmpNewPos + 1 );
 666                 }
 667                 else
 668                 {
 669                     nTmpNewPos = ::GetUserCall( pTmpParentObj->GetDrawObj() )
 670                                                             ->GetMinOrdNum();
 671                     pTmpObj = pTmpParentObj->GetDrawObj();
 672                 }
 673             }
 674             else
 675                 break;
 676         }
 677         if ( nTmpNewPos != nNewPos )
 678         {
 679             pDrawPage->SetObjectOrdNum( nNewPos, nTmpNewPos );
 680             nNewPos = nTmpNewPos;
 681             pDrawPage->RecalcObjOrdNums();
 682         }
 683     }
 684
 685     // setup collection of moved 'child' objects to move its 'repeated' objects.
 686     std::vector< SdrObject* > aMovedChildObjs;
 687
 688     // move 'childs' accordingly
 689     if ( pMovedAnchoredObj->ISA(SwFlyFrm) )
 690     {
 691         const SwFlyFrm* pFlyFrm = static_cast<SwFlyFrm*>(pMovedAnchoredObj);
 692
 693         // adjustments for accessibility API
 694         rImp.DisposeAccessibleFrm( pFlyFrm );
 695         rImp.AddAccessibleFrm( pFlyFrm );
 696
 697         const sal_uInt32 nChildNewPos = bMovedForward ? nNewPos : nNewPos+1;
 698         sal_uInt32 i = bMovedForward ? nOldPos : nObjCount-1;
 699         do
 700         {
 701             SdrObject* pTmpObj = pDrawPage->GetObj( i );
 702             if ( pTmpObj == pObj )
 703                 break;
 704
 705             // --> OD 2004-12-07 #i38563# - assure, that anchor frame exists.
 706             // If object is anchored inside a invisible part of the document
 707             // (e.g. page header, whose page style isn't applied, or hidden
 708             // section), no anchor frame exists.
 709             const SwFrm* pTmpAnchorFrm = lcl_FindAnchor( pTmpObj, TRUE );
 710             const SwFlyFrm* pTmpParentObj = pTmpAnchorFrm
 711                                             ? pTmpAnchorFrm->FindFlyFrm() : 0L;
 712             // <--
 713             if ( pTmpParentObj &&
 714                  ( ( pTmpParentObj == pFlyFrm ) ||
 715                    ( pFlyFrm->IsUpperOf( *pTmpParentObj ) ) ) )
 716             {
 717                 // move child object.,
 718                 pDrawPage->SetObjectOrdNum( i, nChildNewPos );
 719                 pDrawPage->RecalcObjOrdNums();
 720                 // collect 'child' object
 721                 aMovedChildObjs.push_back( pTmpObj );
 722                 // adjustments for accessibility API
 723                 if ( pTmpObj->ISA(SwVirtFlyDrawObj) )
 724                 {
 725                     const SwFlyFrm *pTmpFlyFrm =
 726                         static_cast<SwVirtFlyDrawObj*>(pTmpObj)->GetFlyFrm();
 727                     rImp.DisposeAccessibleFrm( pTmpFlyFrm );
 728                     rImp.AddAccessibleFrm( pTmpFlyFrm );
 729                 }
 730                 else
 731                 {
 732                     rImp.DisposeAccessibleObj( pTmpObj );
 733                     rImp.AddAccessibleObj( pTmpObj );
 734                 }
 735             }
 736             else
 737             {
 738                 // adjust loop counter
 739                 if ( bMovedForward )
 740                     ++i;
 741                 else if ( !bMovedForward && i > 0 )
 742                     --i;
 743             }
 744
 745         } while ( ( bMovedForward && i < ( nObjCount - aMovedChildObjs.size() ) ) ||
 746                   ( !bMovedForward && i > ( nNewPos + aMovedChildObjs.size() ) ) );
 747     }
 748     else
 749     {
 750         // adjustments for accessibility API
 751         rImp.DisposeAccessibleObj( pObj );
 752         rImp.AddAccessibleObj( pObj );
 753     }
 754
 755     _MoveRepeatedObjs( *pMovedAnchoredObj, aMovedChildObjs );
 756 }
 757 // <--
 758
 759 /*************************************************************************
 760 |*
 761 |*      SwDrawView::TakeDragLimit()
 762 |*
 763 |*      Ersterstellung          AMA 26. Apr. 96
 764 |*      Letzte Aenderung        MA 03. May. 96
 765 |*
 766 *************************************************************************/
 767
 768
 769 BOOL SwDrawView::TakeDragLimit( SdrDragMode eMode,
 770                                             Rectangle& rRect ) const
 771 {
 772     const SdrMarkList &rMrkList = GetMarkedObjectList();
 773     BOOL bRet = FALSE;
 774     if( 1 == rMrkList.GetMarkCount() )
 775     {
 776         const SdrObject *pObj = rMrkList.GetMark( 0 )->GetMarkedSdrObj();
 777         SwRect aRect;
 778         if( ::CalcClipRect( pObj, aRect, eMode == SDRDRAG_MOVE ) )
 779         {
 780             rRect = aRect.SVRect();
 781              bRet = TRUE;
 782         }
 783     }
 784     return bRet;
 785 }
 786
 787 /*************************************************************************
 788 |*
 789 |*      SwDrawView::CalcAnchor()
 790 |*
 791 |*      Ersterstellung          MA 13. Jan. 95
 792 |*      Letzte Aenderung        MA 08. Nov. 96
 793 |*
 794 *************************************************************************/
 795
 796
 797 const SwFrm* SwDrawView::CalcAnchor()
 798 {
 799     const SdrMarkList &rMrkList = GetMarkedObjectList();
 800     if ( rMrkList.GetMarkCount() != 1 )
 801         return NULL;
 802
 803     SdrObject* pObj = rMrkList.GetMark( 0 )->GetMarkedSdrObj();
 804
 805     //Fuer Absatzgebundene Objekte suchen, andernfalls einfach nur
 806     //der aktuelle Anker. Nur suchen wenn wir gerade draggen.
 807     const SwFrm* pAnch;
 808     Rectangle aMyRect;
 809     const BOOL bFly = pObj->ISA(SwVirtFlyDrawObj);
 810     if ( bFly )
 811     {
 812         pAnch = ((SwVirtFlyDrawObj*)pObj)->GetFlyFrm()->GetAnchorFrm();
 813         aMyRect = ((SwVirtFlyDrawObj*)pObj)->GetFlyFrm()->Frm().SVRect();
 814     }
 815     else
 816     {
 817         SwDrawContact *pC = (SwDrawContact*)GetUserCall(pObj);
 818         // OD 17.06.2003 #108784# - determine correct anchor position for
 819         // 'virtual' drawing objects.
 820         // OD 2004-03-25 #i26791#
 821         pAnch = pC->GetAnchorFrm( pObj );
 822         if( !pAnch )
 823         {
 824             pC->ConnectToLayout();
 825             // OD 17.06.2003 #108784# - determine correct anchor position for
 826             // 'virtual' drawing objects.
 827             // OD 2004-03-25 #i26791#
 828             pAnch = pC->GetAnchorFrm( pObj );
 829         }
 830         aMyRect = pObj->GetSnapRect();
 831     }
 832
 833     const sal_Bool bTopRight = pAnch && ( pAnch->IsVertical() ||
 834                                           pAnch->IsRightToLeft() );
 835
 836     const Point aMyPt = bTopRight ? aMyRect.TopRight() : aMyRect.TopLeft();
 837
 838     Point aPt;
 839     if ( IsAction() )
 840     {
 841         if ( !TakeDragObjAnchorPos( aPt, bTopRight ) )
 842             return NULL;
 843     }
 844     else
 845     {
 846         Rectangle aRect = pObj->GetSnapRect();
 847         aPt = bTopRight ? aRect.TopRight() : aRect.TopLeft();
 848     }
 849
 850     if ( aPt != aMyPt )
 851     {
 852         if ( pAnch->IsCntntFrm() )
 853         {
 854             // OD 26.06.2003 #108784# - allow drawing objects in header/footer,
 855             // but exclude control objects.
 856             bool bBodyOnly = CheckControlLayer( pObj );
 857             pAnch = ::FindAnchor( (SwCntntFrm*)pAnch, aPt, bBodyOnly );
 858         }
 859         else if ( !bFly )
 860         {
 861             const SwRect aRect( aPt.X(), aPt.Y(), 1, 1 );
 862
 863             SwDrawContact* pContact = (SwDrawContact*)GetUserCall(pObj);
 864             if ( pContact->GetAnchorFrm( pObj ) &&
 865                  pContact->GetAnchorFrm( pObj )->IsPageFrm() )
 866                 pAnch = pContact->GetPageFrm();
 867             else
 868                 pAnch = pContact->FindPage( aRect );
 869         }
 870     }
 871     if( pAnch && !pAnch->IsProtected() )
 872         aAnchorPoint = pAnch->GetFrmAnchorPos( ::HasWrap( pObj ) );
 873     else
 874         pAnch = 0;
 875     return pAnch;
 876 }
 877
 878 /*************************************************************************
 879 |*
 880 |*      SwDrawView::ShowDragXor(), HideDragXor()
 881 |*
 882 |*      Ersterstellung          MA 17. Jan. 95
 883 |*      Letzte Aenderung        MA 27. Jan. 95
 884 |*
 885 *************************************************************************/
 886
 887
 888 void SwDrawView::ShowDragAnchor()
 889 {
 890     SdrHdl* pHdl = aHdl.GetHdl(HDL_ANCHOR);
 891     if ( ! pHdl )
 892         pHdl = aHdl.GetHdl(HDL_ANCHOR_TR);
 893
 894     if(pHdl)
 895     {
 896         CalcAnchor();
 897         pHdl->SetPos(aAnchorPoint);
 898         //OLMRefreshAllIAOManagers();
 899     }
 900 }
 901
 902 /*************************************************************************
 903 |*
 904 |*      SwDrawView::MarkListHasChanged()
 905 |*
 906 |*      Ersterstellung          OM 02. Feb. 95
 907 |*      Letzte Aenderung        OM 07. Jul. 95
 908 |*
 909 *************************************************************************/
 910
 911
 912 void SwDrawView::MarkListHasChanged()
 913 {
 914     Imp().GetShell()->DrawSelChanged();
 915     FmFormView::MarkListHasChanged();
 916 }
 917
 918 // #i7672#
 919 void SwDrawView::ModelHasChanged()
 920 {
 921     // The ModelHasChanged() call in DrawingLayer also updates
 922     // a eventually active text edit view (OutlinerView). This also leads
 923     // to newly setting the background color for that edit view. Thus,
 924     // this method rescues the current background color if a OutlinerView
 925     // exists and re-establishes it then. To be more safe, the OutlinerView
 926     // will be fetched again (maybe textedit has ended).
 927     OutlinerView* pView = GetTextEditOutlinerView();
 928     Color aBackColor;
 929     sal_Bool bColorWasSaved(sal_False);
 930
 931     if(pView)
 932     {
 933         aBackColor = pView->GetBackgroundColor();
 934         bColorWasSaved = sal_True;
 935     }
 936
 937     // call parent
 938     FmFormView::ModelHasChanged();
 939
 940     if(bColorWasSaved)
 941     {
 942         pView = GetTextEditOutlinerView();
 943
 944         if(pView)
 945         {
 946             pView->SetBackgroundColor(aBackColor);
 947         }
 948     }
 949 }
 950
 951 void SwDrawView::MakeVisible( const Rectangle &rRect, Window & )
 952 {
 953     ASSERT( rImp.GetShell()->GetWin(), "MakeVisible, unknown Window");
 954     rImp.GetShell()->MakeVisible( SwRect( rRect ) );
 955 }
 956
 957 void SwDrawView::CheckPossibilities()
 958 {
 959     FmFormView::CheckPossibilities();
 960
 961     //Zusaetzlich zu den bestehenden Flags der Objekte selbst, die von der
 962     //DrawingEngine ausgewertet werden, koennen weitere Umstaende zu einem
 963     //Schutz fuehren.
 964     //Objekte, die in Rahmen verankert sind, muessen genau dann geschuetzt
 965     //sein, wenn der Inhalt des Rahmens geschuetzt ist.
 966     //OLE-Objekte konnen selbst einen Resize-Schutz wuenschen (StarMath)
 967
 968     const SdrMarkList &rMrkList = GetMarkedObjectList();
 969     BOOL bProtect = FALSE,
 970              bSzProtect = FALSE;
 971     for ( USHORT i = 0; !bProtect && i < rMrkList.GetMarkCount(); ++i )
 972     {
 973         const SdrObject *pObj = rMrkList.GetMark( i )->GetMarkedSdrObj();
 974         const SwFrm *pFrm = NULL;
 975         if ( pObj->ISA(SwVirtFlyDrawObj) )
 976         {
 977             const SwFlyFrm *pFly = ((SwVirtFlyDrawObj*)pObj)->GetFlyFrm();
 978             if ( pFly  )
 979             {
 980                 pFrm = pFly->GetAnchorFrm();
 981                 if ( pFly->Lower() && pFly->Lower()->IsNoTxtFrm() )
 982                 {
 983                     SwOLENode *pNd = ((SwCntntFrm*)pFly->Lower())->GetNode()->GetOLENode();
 984                     if ( pNd )
 985                     {
 986                         uno::Reference < embed::XEmbeddedObject > xObj = pNd->GetOLEObj().GetOleRef();
 987                         if ( xObj.is() )
 988                         {
 989                             // --> OD 2004-08-16 #110810# - improvement for
 990                             // the future, when more than one Writer fly frame
 991                             // can be selected.
 992
 993                             // TODO/LATER: retrieve Aspect - from where?!
 994                             bSzProtect |= ( embed::EmbedMisc::EMBED_NEVERRESIZE & xObj->getStatus( embed::Aspects::MSOLE_CONTENT ) ) ? TRUE : FALSE;
 995
 996                             // <--
 997                         }
 998                     }
 999                 }
1000             }
1001         }
1002         else
1003         {
1004             SwDrawContact *pC = (SwDrawContact*)GetUserCall(pObj);
1005             if ( pC )
1006                 pFrm = pC->GetAnchorFrm( pObj );
1007         }
1008         if ( pFrm )
1009             bProtect = pFrm->IsProtected(); //Rahmen, Bereiche usw.
1010         // --> OD 2006-11-06 #130889# - make code robust
1011 //        if ( FLY_IN_CNTNT == ::FindFrmFmt( (SdrObject*)pObj )->GetAnchor().GetAnchorId() &&
1012 //             rMrkList.GetMarkCount() > 1 )
1013 //            bProtect = TRUE;
1014         {
1015             SwFrmFmt* pFrmFmt( ::FindFrmFmt( const_cast<SdrObject*>(pObj) ) );
1016             if ( !pFrmFmt )
1017             {
1018                 ASSERT( false,
1019                         "<SwDrawView::CheckPossibilities()> - missing frame format" );
1020                 bProtect = TRUE;
1021             }
1022             else if ( FLY_IN_CNTNT == pFrmFmt->GetAnchor().GetAnchorId() &&
1023                       rMrkList.GetMarkCount() > 1 )
1024             {
1025                 bProtect = TRUE;
1026             }
1027         }
1028         // <--
1029     }
1030     bMoveProtect        |= bProtect;
1031     bResizeProtect      |= bProtect | bSzProtect;
1032 }
1033
1034 /** replace marked <SwDrawVirtObj>-objects by its reference object for delete
1035     marked objects.
1036
1037     OD 18.06.2003 #108784#
1038
1039     @author OD
1040 */
1041 void SwDrawView::ReplaceMarkedDrawVirtObjs( SdrMarkView& _rMarkView )
1042 {
1043     SdrPageView* pDrawPageView = _rMarkView.GetSdrPageView();
1044     const SdrMarkList& rMarkList = _rMarkView.GetMarkedObjectList();
1045
1046     if( rMarkList.GetMarkCount() )
1047     {
1048         // collect marked objects in a local data structure
1049         std::vector<SdrObject*> aMarkedObjs;
1050         for( sal_uInt32 i = 0; i < rMarkList.GetMarkCount(); ++i )
1051         {
1052             SdrObject* pMarkedObj = rMarkList.GetMark( i )->GetMarkedSdrObj();
1053             aMarkedObjs.push_back( pMarkedObj );
1054         }
1055         // unmark all objects
1056         _rMarkView.UnmarkAllObj();
1057         // re-mark objects, but for marked <SwDrawVirtObj>-objects marked its
1058         // reference object.
1059         while ( !aMarkedObjs.empty() )
1060         {
1061             SdrObject* pMarkObj = aMarkedObjs.back();
1062             if ( pMarkObj->ISA(SwDrawVirtObj) )
1063             {
1064                 SdrObject* pRefObj = &(static_cast<SwDrawVirtObj*>(pMarkObj)->ReferencedObj());
1065                 if ( !_rMarkView.IsObjMarked( pRefObj )  )
1066                 {
1067                     _rMarkView.MarkObj( pRefObj, pDrawPageView );
1068                 }
1069             }
1070             else
1071             {
1072                 _rMarkView.MarkObj( pMarkObj, pDrawPageView );
1073             }
1074
1075             aMarkedObjs.pop_back();
1076         }
1077         // sort marked list in order to assure consistent state in drawing layer
1078         _rMarkView.SortMarkedObjects();
1079     }
1080 }
1081
1082 void SwDrawView::DeleteMarked()
1083 {
1084     SwDoc* pDoc = Imp().GetShell()->GetDoc();
1085     if ( pDoc->GetRootFrm() )
1086         pDoc->GetRootFrm()->StartAllAction();
1087     pDoc->StartUndo(UNDO_EMPTY, NULL);
1088     // OD 18.06.2003 #108784# - replace marked <SwDrawVirtObj>-objects by its
1089     // reference objects.
1090     {
1091         SdrPageView* pDrawPageView = rImp.GetPageView();
1092         if ( pDrawPageView )
1093         {
1094             SdrMarkView* pMarkView = PTR_CAST( SdrMarkView, &(pDrawPageView->GetView()) );
1095             if ( pMarkView )
1096             {
1097                 ReplaceMarkedDrawVirtObjs( *pMarkView );
1098             }
1099         }
1100     }
1101     if ( pDoc->DeleteSelection( *this ) )
1102     {
1103         FmFormView::DeleteMarked();
1104         ::FrameNotify( Imp().GetShell(), FLY_DRAG_END );
1105     }
1106     pDoc->EndUndo(UNDO_EMPTY, NULL);
1107     if( pDoc->GetRootFrm() )
1108         pDoc->GetRootFrm()->EndAllAction();
1109 }
1110
1111 /********
1112 JP 02.10.98: sollte als Fix fuer 57153 gelten, hatte aber Nebenwirkungen,
1113             wie Bug 57475
1114 const SdrMarkList& SwDrawView::GetMarkedObjectList() const
1115 {
1116     FlushComeBackTimer();
1117     return FmFormView::GetMarkedObjectList();
1118 }
1119 *************/
1120
1121
1122
1123