svx/source/engine3d/scene3d.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 <cstdlib>
  23
  24 #include <svx/strings.hrc>
  25 #include <svx/dialmgr.hxx>
  26 #include <svx/svditer.hxx>
  27
  28 #include <svx/svdobjkind.hxx>
  29 #include <svx/svdpage.hxx>
  30 #include <svx/scene3d.hxx>
  31 #include <svx/svdtrans.hxx>
  32 #include <sdr/properties/e3dsceneproperties.hxx>
  33 #include <svx/sdr/contact/viewcontactofe3dscene.hxx>
  34 #include <svx/svddrag.hxx>
  35 #include "helperminimaldepth3d.hxx"
  36 #include <algorithm>
  37 #include <drawinglayer/geometry/viewinformation3d.hxx>
  38 #include <basegfx/polygon/b2dpolypolygontools.hxx>
  39 #include <svx/e3dsceneupdater.hxx>
  40 #include <svx/svdmodel.hxx>
  41
  42 namespace {
  43
  44 class ImpRemap3DDepth
  45 {
  46     sal_uInt32                  mnOrdNum;
  47     double                      mfMinimalDepth;
  48
  49     // bit field
  50     bool                        mbIsScene : 1;
  51
  52 public:
  53     ImpRemap3DDepth(sal_uInt32 nOrdNum, double fMinimalDepth);
  54     explicit ImpRemap3DDepth(sal_uInt32 nOrdNum);
  55
  56     // for ::std::sort
  57     bool operator<(const ImpRemap3DDepth& rComp) const;
  58
  59     sal_uInt32 GetOrdNum() const { return mnOrdNum; }
  60     bool IsScene() const { return mbIsScene; }
  61 };
  62
  63 }
  64
  65 ImpRemap3DDepth::ImpRemap3DDepth(sal_uInt32 nOrdNum, double fMinimalDepth)
  66 :   mnOrdNum(nOrdNum),
  67     mfMinimalDepth(fMinimalDepth),
  68     mbIsScene(false)
  69 {
  70 }
  71
  72 ImpRemap3DDepth::ImpRemap3DDepth(sal_uInt32 nOrdNum)
  73 :   mnOrdNum(nOrdNum),
  74     mfMinimalDepth(0.0),
  75     mbIsScene(true)
  76 {
  77 }
  78
  79 bool ImpRemap3DDepth::operator<(const ImpRemap3DDepth& rComp) const
  80 {
  81     if(IsScene())
  82     {
  83         return false;
  84     }
  85     else
  86     {
  87         if(rComp.IsScene())
  88         {
  89             return true;
  90         }
  91         else
  92         {
  93             return mfMinimalDepth < rComp.mfMinimalDepth;
  94         }
  95     }
  96 }
  97
  98 class Imp3DDepthRemapper
  99 {
 100     std::vector< ImpRemap3DDepth > maVector;
 101
 102 public:
 103     explicit Imp3DDepthRemapper(E3dScene const & rScene);
 104
 105     sal_uInt32 RemapOrdNum(sal_uInt32 nOrdNum) const;
 106 };
 107
 108 Imp3DDepthRemapper::Imp3DDepthRemapper(E3dScene const & rScene)
 109 {
 110     // only called when rScene.GetSubList() and nObjCount > 1
 111     SdrObjList* pList = rScene.GetSubList();
 112     const size_t nObjCount(pList->GetObjCount());
 113
 114     for(size_t a = 0; a < nObjCount; ++a)
 115     {
 116         SdrObject* pCandidate = pList->GetObj(a);
 117
 118         if(pCandidate)
 119         {
 120             if(auto pCompoundObj = dynamic_cast< const E3dCompoundObject*>(pCandidate))
 121             {
 122                 // single 3d object, calc depth
 123                 const double fMinimalDepth(getMinimalDepthInViewCoordinates(*pCompoundObj));
 124                 ImpRemap3DDepth aEntry(a, fMinimalDepth);
 125                 maVector.push_back(aEntry);
 126             }
 127             else
 128             {
 129                 // scene, use standard entry for scene
 130                 ImpRemap3DDepth aEntry(a);
 131                 maVector.push_back(aEntry);
 132             }
 133         }
 134     }
 135
 136     // now, we need to sort the maVector by its members minimal depth. The
 137     // smaller, the nearer to the viewer.
 138     ::std::sort(maVector.begin(), maVector.end());
 139 }
 140
 141 sal_uInt32 Imp3DDepthRemapper::RemapOrdNum(sal_uInt32 nOrdNum) const
 142 {
 143     if(nOrdNum < maVector.size())
 144     {
 145         nOrdNum = maVector[(maVector.size() - 1) - nOrdNum].GetOrdNum();
 146     }
 147
 148     return nOrdNum;
 149 }
 150
 151
 152 // BaseProperties section
 153
 154 std::unique_ptr<sdr::properties::BaseProperties> E3dScene::CreateObjectSpecificProperties()
 155 {
 156     return std::make_unique<sdr::properties::E3dSceneProperties>(*this);
 157 }
 158
 159
 160 // DrawContact section
 161
 162 std::unique_ptr<sdr::contact::ViewContact> E3dScene::CreateObjectSpecificViewContact()
 163 {
 164     return std::make_unique<sdr::contact::ViewContactOfE3dScene>(*this);
 165 }
 166
 167
 168 E3dScene::E3dScene(SdrModel& rSdrModel)
 169 :   E3dObject(rSdrModel),
 170     aCamera(basegfx::B3DPoint(0.0, 0.0, 4.0), basegfx::B3DPoint()),
 171     bDrawOnlySelected(false),
 172     mbSkipSettingDirty(false)
 173 {
 174     // Set defaults
 175     SetDefaultAttributes();
 176 }
 177
 178 E3dScene::E3dScene(SdrModel& rSdrModel, E3dScene const & rSource)
 179 :   E3dObject(rSdrModel, rSource),
 180     aCamera(basegfx::B3DPoint(0.0, 0.0, 4.0), basegfx::B3DPoint()),
 181     bDrawOnlySelected(false),
 182     mbSkipSettingDirty(false)
 183 {
 184     // Set defaults
 185     SetDefaultAttributes();
 186
 187     // copy child SdrObjects
 188     if (rSource.GetSubList())
 189     {
 190         CopyObjects(*rSource.GetSubList());
 191
 192         // tdf#116979: needed here, we need bSnapRectDirty to be true
 193         // which it is after using SdrObject::operator= (see above),
 194         // but set to false again using CopyObjects
 195         SetBoundAndSnapRectsDirty();
 196     }
 197
 198     // copy local data
 199     aCamera = rSource.aCamera;
 200     aCameraSet = rSource.aCameraSet;
 201     static_cast<sdr::properties::E3dSceneProperties&>(GetProperties()).SetSceneItemsFromCamera();
 202     InvalidateBoundVolume();
 203     RebuildLists();
 204     ImpCleanup3DDepthMapper();
 205     GetViewContact().ActionChanged();
 206 }
 207
 208 void E3dScene::SetDefaultAttributes()
 209 {
 210     // For WIN95/NT turn off the FP-Exceptions
 211 #if defined(_WIN32)
 212     _control87( _MCW_EM, _MCW_EM );
 213 #endif
 214
 215     // Set defaults
 216     aCamera.SetViewWindow(-2, -2, 4, 4);
 217     aCameraSet.SetDeviceRectangle(-2, 2, -2, 2);
 218     aCamera.SetDeviceWindow(tools::Rectangle(0, 0, 10, 10));
 219     tools::Rectangle aRect(0, 0, 10, 10);
 220     aCameraSet.SetViewportRectangle(aRect);
 221
 222     // set defaults for Camera from ItemPool
 223     aCamera.SetProjection(GetPerspective());
 224     basegfx::B3DPoint aActualPosition(aCamera.GetPosition());
 225     double fNew = GetDistance();
 226
 227     if(fabs(fNew - aActualPosition.getZ()) > 1.0)
 228     {
 229         aCamera.SetPosition( basegfx::B3DPoint( aActualPosition.getX(), aActualPosition.getY(), fNew) );
 230     }
 231
 232     fNew = GetFocalLength() / 100.0;
 233     aCamera.SetFocalLength(fNew);
 234 }
 235
 236 E3dScene::~E3dScene()
 237 {
 238     ImpCleanup3DDepthMapper();
 239 }
 240
 241 SdrPage* E3dScene::getSdrPageFromSdrObjList() const
 242 {
 243     return getSdrPageFromSdrObject();
 244 }
 245
 246 SdrObject* E3dScene::getSdrObjectFromSdrObjList() const
 247 {
 248     return const_cast< E3dScene* >(this);
 249 }
 250
 251 SdrObjList* E3dScene::getChildrenOfSdrObject() const
 252 {
 253     return const_cast< E3dScene* >(this);
 254 }
 255
 256 basegfx::B2DPolyPolygon E3dScene::TakeXorPoly() const
 257 {
 258     const sdr::contact::ViewContactOfE3dScene& rVCScene = static_cast< sdr::contact::ViewContactOfE3dScene& >(GetViewContact());
 259     const drawinglayer::geometry::ViewInformation3D& aViewInfo3D(rVCScene.getViewInformation3D());
 260     const basegfx::B3DPolyPolygon aCubePolyPolygon(CreateWireframe());
 261
 262     basegfx::B2DPolyPolygon aRetval(basegfx::utils::createB2DPolyPolygonFromB3DPolyPolygon(aCubePolyPolygon,
 263         aViewInfo3D.getObjectToView()));
 264     aRetval.transform(rVCScene.getObjectTransformation());
 265
 266     return aRetval;
 267 }
 268
 269 void E3dScene::ImpCleanup3DDepthMapper()
 270 {
 271     mp3DDepthRemapper.reset();
 272 }
 273
 274 sal_uInt32 E3dScene::RemapOrdNum(sal_uInt32 nNewOrdNum) const
 275 {
 276     if(!mp3DDepthRemapper)
 277     {
 278         const size_t nObjCount(GetSubList() ? GetSubList()->GetObjCount() : 0);
 279
 280         if(nObjCount > 1)
 281         {
 282             mp3DDepthRemapper.reset(new Imp3DDepthRemapper(*this));
 283         }
 284     }
 285
 286     if(mp3DDepthRemapper)
 287     {
 288         return mp3DDepthRemapper->RemapOrdNum(nNewOrdNum);
 289     }
 290
 291     return nNewOrdNum;
 292 }
 293
 294 SdrObjKind E3dScene::GetObjIdentifier() const
 295 {
 296     return SdrObjKind::E3D_Scene;
 297 }
 298
 299 void E3dScene::SetBoundRectDirty()
 300 {
 301     E3dScene* pScene(getRootE3dSceneFromE3dObject());
 302
 303     if(pScene == this)
 304     {
 305         // avoid resetting aOutRect which in case of a 3D scene used as 2d object
 306         // is model data,not re-creatable view data
 307     }
 308     else
 309     {
 310         // if not the outmost scene it is used as group in 3d, call parent
 311         E3dObject::SetBoundRectDirty();
 312     }
 313 }
 314
 315 void E3dScene::NbcSetSnapRect(const tools::Rectangle& rRect)
 316 {
 317     SetBoundAndSnapRectsDirty();
 318     E3dObject::NbcSetSnapRect(rRect);
 319     aCamera.SetDeviceWindow(rRect);
 320     aCameraSet.SetViewportRectangle(rRect);
 321
 322     ImpCleanup3DDepthMapper();
 323 }
 324
 325 void E3dScene::NbcMove(const Size& rSize)
 326 {
 327     tools::Rectangle aNewSnapRect = GetSnapRect();
 328     aNewSnapRect.Move(rSize);
 329     NbcSetSnapRect(aNewSnapRect);
 330 }
 331
 332 void E3dScene::NbcResize(const Point& rRef, const Fraction& rXFact,
 333                                             const Fraction& rYFact)
 334 {
 335     tools::Rectangle aNewSnapRect = GetSnapRect();
 336     ResizeRect(aNewSnapRect, rRef, rXFact, rYFact);
 337     NbcSetSnapRect(aNewSnapRect);
 338 }
 339
 340 // Set new camera, and thus mark the scene and if possible the bound volume
 341 // as changed
 342
 343 void E3dScene::SetCamera(const Camera3D& rNewCamera)
 344 {
 345     aCamera = rNewCamera;
 346     static_cast<sdr::properties::E3dSceneProperties&>(GetProperties()).SetSceneItemsFromCamera();
 347
 348     SetBoundAndSnapRectsDirty();
 349
 350     // Turn off ratio
 351     GetCameraSet().SetRatio(0.0);
 352
 353     // Set Imaging geometry
 354     basegfx::B3DPoint aVRP(aCamera.GetViewPoint());
 355     basegfx::B3DVector aVPN(aVRP - aCamera.GetVRP());
 356     basegfx::B3DVector aVUV(aCamera.GetVUV());
 357
 358     // use SetViewportValues() to set VRP, VPN and VUV as vectors, too.
 359     // Else these values would not be exported/imported correctly.
 360     GetCameraSet().SetViewportValues(aVRP, aVPN, aVUV);
 361
 362     // Set perspective
 363     GetCameraSet().SetPerspective(aCamera.GetProjection() == ProjectionType::Perspective);
 364     GetCameraSet().SetViewportRectangle(aCamera.GetDeviceWindow());
 365
 366     ImpCleanup3DDepthMapper();
 367 }
 368
 369 // Inform parent of changes of a child
 370
 371 void E3dScene::StructureChanged()
 372 {
 373     E3dObject::StructureChanged();
 374
 375     E3dScene* pScene(getRootE3dSceneFromE3dObject());
 376
 377     if(nullptr != pScene && !pScene->mbSkipSettingDirty)
 378     {
 379         SetBoundAndSnapRectsDirty();
 380     }
 381
 382     ImpCleanup3DDepthMapper();
 383 }
 384
 385 // Determine the overall scene object
 386
 387 E3dScene* E3dScene::getRootE3dSceneFromE3dObject() const
 388 {
 389     E3dScene* pParent(getParentE3dSceneFromE3dObject());
 390
 391     if(nullptr != pParent)
 392     {
 393         return pParent->getRootE3dSceneFromE3dObject();
 394     }
 395
 396     return const_cast< E3dScene* >(this);
 397 }
 398
 399 void E3dScene::removeAllNonSelectedObjects()
 400 {
 401     E3DModifySceneSnapRectUpdater aUpdater(this);
 402
 403     for(size_t a = 0; a < GetObjCount(); ++a)
 404     {
 405         SdrObject* pObj = GetObj(a);
 406
 407         if(pObj)
 408         {
 409             bool bRemoveObject(false);
 410
 411             if(E3dScene* pScene = DynCastE3dScene(pObj))
 412             {
 413                 // iterate over this sub-scene
 414                 pScene->removeAllNonSelectedObjects();
 415
 416                 // check object count. Empty scenes can be deleted
 417                 const size_t nObjCount(pScene->GetSubList() ? pScene->GetSubList()->GetObjCount() : 0);
 418
 419                 if(!nObjCount)
 420                 {
 421                     // all objects removed, scene can be removed, too
 422                     bRemoveObject = true;
 423                 }
 424             }
 425             else if(auto pCompound = dynamic_cast<E3dCompoundObject*>(pObj))
 426             {
 427                 if(!pCompound->GetSelected())
 428                 {
 429                     bRemoveObject = true;
 430                 }
 431             }
 432
 433             if(bRemoveObject)
 434             {
 435                 NbcRemoveObject(pObj->GetOrdNum());
 436                 a--;
 437             }
 438         }
 439     }
 440 }
 441
 442 rtl::Reference<SdrObject> E3dScene::CloneSdrObject(SdrModel& rTargetModel) const
 443 {
 444     return new E3dScene(rTargetModel, *this);
 445 }
 446
 447 void E3dScene::SuspendReportingDirtyRects()
 448 {
 449     E3dScene* pScene(getRootE3dSceneFromE3dObject());
 450
 451     if(nullptr != pScene)
 452     {
 453         pScene->mbSkipSettingDirty = true;
 454     }
 455 }
 456
 457 void E3dScene::ResumeReportingDirtyRects()
 458 {
 459     E3dScene* pScene(getRootE3dSceneFromE3dObject());
 460
 461     if(nullptr != pScene)
 462     {
 463         pScene->mbSkipSettingDirty = false;
 464     }
 465 }
 466
 467 void E3dScene::SetAllSceneRectsDirty()
 468 {
 469     E3dScene* pScene(getRootE3dSceneFromE3dObject());
 470
 471     if(nullptr != pScene)
 472     {
 473         pScene->SetBoundAndSnapRectsDirty();
 474     }
 475 }
 476
 477 // Rebuild Light- and label- object lists rebuild (after loading, allocation)
 478
 479 void E3dScene::RebuildLists()
 480 {
 481     // first delete
 482     const SdrLayerID nCurrLayerID(GetLayer());
 483     SdrObjListIter a3DIterator(GetSubList(), SdrIterMode::Flat);
 484
 485     // then examine all the objects in the scene
 486     while(a3DIterator.IsMore())
 487     {
 488         E3dObject* p3DObj(static_cast< E3dObject* >(a3DIterator.Next()));
 489         p3DObj->NbcSetLayer(nCurrLayerID);
 490     }
 491
 492     ImpCleanup3DDepthMapper();
 493 }
 494
 495 std::unique_ptr<SdrObjGeoData> E3dScene::NewGeoData() const
 496 {
 497     return std::make_unique<E3DSceneGeoData>();
 498 }
 499
 500 void E3dScene::SaveGeoData(SdrObjGeoData& rGeo) const
 501 {
 502     E3dObject::SaveGeoData (rGeo);
 503
 504     static_cast<E3DSceneGeoData &>(rGeo).aCamera = aCamera;
 505 }
 506
 507 void E3dScene::RestoreGeoData(const SdrObjGeoData& rGeo)
 508 {
 509     // #i94832# removed E3DModifySceneSnapRectUpdater here.
 510     // It should not be needed, is already part of E3dObject::RestoreGeoData
 511     E3dObject::RestoreGeoData (rGeo);
 512     SetCamera (static_cast<const E3DSceneGeoData &>(rGeo).aCamera);
 513 }
 514
 515 // Something was changed in the style sheet, so change scene
 516
 517 void E3dScene::Notify(SfxBroadcaster &rBC, const SfxHint  &rHint)
 518 {
 519     SetBoundAndSnapRectsDirty();
 520     E3dObject::Notify(rBC, rHint);
 521 }
 522
 523 void E3dScene::RotateScene (const Point& rRef, double sn, double cs)
 524 {
 525     Point NewCenter;
 526
 527     auto const& rRectangle = getOutRectangle();
 528     Point Center = rRectangle.Center();
 529
 530         // Only the center is moved. The corners are moved by NbcMove. For the
 531         // rotation a cartesian coordinate system is used in which the pivot
 532         // point is the origin, and the y-axis increases upward, the X-axis to
 533         // the right. This must be especially noted for the Y-values.
 534         // (When considering a flat piece of paper the Y-axis pointing downwards
 535     Center.setX(Center.X() - rRef.X());
 536     Center.setY(rRef.Y() - Center.Y());
 537                   // A few special cases has to be dealt with first (n * 90 degrees n integer)
 538     if (sn==1.0 && cs==0.0) { // 90deg
 539         NewCenter.setX( -Center.Y() );
 540         NewCenter.setY( -Center.X() );
 541     } else if (sn==0.0 && cs==-1.0) { // 180deg
 542         NewCenter.setX( -Center.X() );
 543         NewCenter.setY( -Center.Y() );
 544     } else if (sn==-1.0 && cs==0.0) { // 270deg
 545         NewCenter.setX(  Center.Y() );
 546         NewCenter.setY( -Center.X() );
 547     }
 548     else          // Here it is rotated to any angle in the mathematically
 549                   // positive direction!
 550     {             // xnew = x * cos(alpha) - y * sin(alpha)
 551                   // ynew = x * sin(alpha) + y * cos(alpha)
 552                   // Bottom Right is not rotated: the pages of aOutRect must
 553                   // remain parallel to the coordinate axes.
 554         NewCenter.setX( static_cast<tools::Long>(Center.X() * cs - Center.Y() * sn) );
 555         NewCenter.setY( static_cast<tools::Long>(Center.X() * sn + Center.Y() * cs) );
 556     }
 557
 558     Size Differenz;
 559     Point DiffPoint = NewCenter - Center;
 560     Differenz.setWidth( DiffPoint.X() );
 561     Differenz.setHeight( -DiffPoint.Y() );  // Note that the Y-axis is counted ad positive downward.
 562     NbcMove (Differenz);  // Actually executes the coordinate transformation.
 563 }
 564
 565 OUString E3dScene::TakeObjNameSingul() const
 566 {
 567     OUString sName(SvxResId(STR_ObjNameSingulScene3d));
 568
 569     OUString aName(GetName());
 570     if (!aName.isEmpty())
 571         sName += " '" + aName + "'";
 572     return sName;
 573 }
 574
 575 OUString E3dScene::TakeObjNamePlural() const
 576 {
 577     return SvxResId(STR_ObjNamePluralScene3d);
 578 }
 579
 580 // The NbcRotate routine overrides the one of the SdrObject. The idea is
 581 // to be able to rotate the scene relative to the position of the scene
 582 // and then the objects in the scene
 583
 584 void E3dScene::NbcSetTransform(const basegfx::B3DHomMatrix& rMatrix)
 585 {
 586     if(maTransformation != rMatrix)
 587     {
 588         // call parent
 589         E3dObject::NbcSetTransform(rMatrix);
 590     }
 591 }
 592
 593 void E3dScene::SetTransform(const basegfx::B3DHomMatrix& rMatrix)
 594 {
 595     if(rMatrix != maTransformation)
 596     {
 597         // call parent
 598         E3dObject::SetTransform(rMatrix);
 599     }
 600 }
 601
 602 void E3dScene::NbcRotate(const Point& rRef, Degree100 nAngle, double sn, double cs)
 603 {
 604     // So currently the gluepoints are defined relative to the scene aOutRect.
 605     // Before turning the gluepoints are defined relative to the page. They
 606     // take no part in the rotation of the scene. To ensure this, there is the
 607     // SetGlueReallyAbsolute(sal_True);
 608
 609     // So that was the scene, now the objects used in the scene
 610     // 3D objects, if there is only one it can still have multiple surfaces but
 611     // the surfaces do not have to be connected. This allows you to access child
 612     // objects. So going through the entire list and rotate around the Z axis
 613     // through the enter of aOutRect's (Steiner's theorem), so RotateZ
 614
 615     RotateScene (rRef, sn, cs);  // Rotates the scene
 616     double fAngleInRad = toRadians(nAngle);
 617
 618     basegfx::B3DHomMatrix aRotation;
 619     aRotation.rotate(0.0, 0.0, fAngleInRad);
 620     NbcSetTransform(aRotation * GetTransform());
 621
 622     SetBoundAndSnapRectsDirty();    // This forces a recalculation of all BoundRects
 623     NbcRotateGluePoints(rRef,nAngle,sn,cs);  // Rotate the gluepoints (who still
 624                                             // have coordinates relative to the
 625                                             // original page)
 626     SetGlueReallyAbsolute(false);  // from now they are again relative to BoundRect (that is defined as aOutRect)
 627     SetBoundAndSnapRectsDirty();
 628 }
 629
 630 void E3dScene::RecalcSnapRect()
 631 {
 632     E3dScene* pScene(getRootE3dSceneFromE3dObject());
 633
 634     if(pScene == this)
 635     {
 636         // The Scene is used as a 2D-Object, take the SnapRect from the
 637         // 2D Display settings
 638         maSnapRect = pScene->aCamera.GetDeviceWindow();
 639     }
 640     else
 641     {
 642         // The Scene itself is a member of another scene, get the SnapRect
 643         // as a composite object
 644         // call parent
 645         E3dObject::RecalcSnapRect();
 646
 647         for(size_t a = 0; a < GetObjCount(); ++a)
 648         {
 649             E3dObject* pCandidate(DynCastE3dObject(GetObj(a)));
 650
 651             if(pCandidate)
 652             {
 653                 maSnapRect.Union(pCandidate->GetSnapRect());
 654             }
 655         }
 656     }
 657 }
 658
 659 bool E3dScene::IsBreakObjPossible()
 660 {
 661     // Break scene, if all members are able to break
 662     SdrObjListIter a3DIterator(GetSubList(), SdrIterMode::DeepWithGroups);
 663
 664     while ( a3DIterator.IsMore() )
 665     {
 666         E3dObject* pObj = static_cast<E3dObject*>(a3DIterator.Next());
 667         if(!pObj->IsBreakObjPossible())
 668             return false;
 669     }
 670
 671     return true;
 672 }
 673
 674 basegfx::B2DPolyPolygon E3dScene::TakeCreatePoly(const SdrDragStat& /*rDrag*/) const
 675 {
 676     return TakeXorPoly();
 677 }
 678
 679 bool E3dScene::BegCreate(SdrDragStat& rStat)
 680 {
 681     rStat.SetOrtho4Possible();
 682     tools::Rectangle aRect1(rStat.GetStart(), rStat.GetNow());
 683     aRect1.Normalize();
 684     rStat.SetActionRect(aRect1);
 685     NbcSetSnapRect(aRect1);
 686     return true;
 687 }
 688
 689 bool E3dScene::MovCreate(SdrDragStat& rStat)
 690 {
 691     tools::Rectangle aRect1;
 692     rStat.TakeCreateRect(aRect1);
 693     aRect1.Normalize();
 694     rStat.SetActionRect(aRect1);
 695     NbcSetSnapRect(aRect1);
 696     SetBoundRectDirty();
 697     m_bSnapRectDirty=true;
 698     return true;
 699 }
 700
 701 bool E3dScene::EndCreate(SdrDragStat& rStat, SdrCreateCmd eCmd)
 702 {
 703     tools::Rectangle aRect1;
 704     rStat.TakeCreateRect(aRect1);
 705     aRect1.Normalize();
 706     NbcSetSnapRect(aRect1);
 707     SetBoundAndSnapRectsDirty();
 708     return (eCmd==SdrCreateCmd::ForceEnd || rStat.GetPointCount()>=2);
 709 }
 710
 711 bool E3dScene::BckCreate(SdrDragStat& /*rStat*/)
 712 {
 713     return false;
 714 }
 715
 716 void E3dScene::BrkCreate(SdrDragStat& /*rStat*/)
 717 {
 718 }
 719
 720 void E3dScene::SetSelected(bool bNew)
 721 {
 722     // call parent
 723     E3dObject::SetSelected(bNew);
 724
 725     for(size_t a(0); a < GetObjCount(); a++)
 726     {
 727         E3dObject* pCandidate(DynCastE3dObject(GetObj(a)));
 728
 729         if(pCandidate)
 730         {
 731             pCandidate->SetSelected(bNew);
 732         }
 733     }
 734 }
 735
 736 void E3dScene::NbcInsertObject(SdrObject* pObj, size_t nPos)
 737 {
 738     // Is it even a 3D object?
 739     if(DynCastE3dObject(pObj))
 740     {
 741         // Normal 3D object, insert means call parent
 742         SdrObjList::NbcInsertObject(pObj, nPos);
 743
 744         // local needed stuff
 745         InvalidateBoundVolume();
 746         StructureChanged();
 747     }
 748     else
 749     {
 750         // No 3D object, inserted a page in place in a scene ...
 751         getSdrObjectFromSdrObjList()->getSdrPageFromSdrObject()->InsertObject(pObj, nPos);
 752     }
 753 }
 754
 755 void E3dScene::InsertObject(SdrObject* pObj, size_t nPos)
 756 {
 757     // Is it even a 3D object?
 758     if(DynCastE3dObject(pObj))
 759     {
 760         // call parent
 761         SdrObjList::InsertObject(pObj, nPos);
 762
 763         // local needed stuff
 764         InvalidateBoundVolume();
 765         StructureChanged();
 766     }
 767     else
 768     {
 769         // No 3D object, inserted a page in place in a scene ...
 770         getSdrObjectFromSdrObjList()->getSdrPageFromSdrObject()->InsertObject(pObj, nPos);
 771     }
 772 }
 773
 774 rtl::Reference<SdrObject> E3dScene::NbcRemoveObject(size_t nObjNum)
 775 {
 776     // call parent
 777     rtl::Reference<SdrObject> pRetval = SdrObjList::NbcRemoveObject(nObjNum);
 778
 779     InvalidateBoundVolume();
 780     StructureChanged();
 781
 782     return pRetval;
 783 }
 784
 785 rtl::Reference<SdrObject> E3dScene::RemoveObject(size_t nObjNum)
 786 {
 787     // call parent
 788     rtl::Reference<SdrObject> pRetval(SdrObjList::RemoveObject(nObjNum));
 789
 790     InvalidateBoundVolume();
 791     StructureChanged();
 792
 793     return pRetval;
 794 }
 795
 796 void E3dScene::SetBoundAndSnapRectsDirty(bool bNotMyself, bool bRecursive)
 797 {
 798     // call parent
 799     E3dObject::SetBoundAndSnapRectsDirty(bNotMyself, bRecursive);
 800
 801     for(size_t a = 0; a < GetObjCount(); ++a)
 802     {
 803         E3dObject* pCandidate = DynCastE3dObject(GetObj(a));
 804
 805         if(pCandidate)
 806         {
 807             pCandidate->SetBoundAndSnapRectsDirty(bNotMyself, false);
 808         }
 809     }
 810 }
 811
 812 void E3dScene::NbcSetLayer(SdrLayerID nLayer)
 813 {
 814     // call parent
 815     E3dObject::NbcSetLayer(nLayer);
 816
 817     for(size_t a = 0; a < GetObjCount(); ++a)
 818     {
 819         E3dObject* pCandidate = DynCastE3dObject(GetObj(a));
 820
 821         if(pCandidate)
 822         {
 823             pCandidate->NbcSetLayer(nLayer);
 824         }
 825     }
 826 }
 827
 828 void E3dScene::handlePageChange(SdrPage* pOldPage, SdrPage* pNewPage)
 829 {
 830     if(pOldPage == pNewPage)
 831         return;
 832
 833     // call parent
 834     E3dObject::handlePageChange(pOldPage, pNewPage);
 835
 836     for(size_t a(0); a < GetObjCount(); a++)
 837     {
 838         E3dObject* pCandidate = DynCastE3dObject(GetObj(a));
 839
 840         if(pCandidate)
 841         {
 842             pCandidate->handlePageChange(pOldPage, pNewPage);
 843         }
 844         else
 845         {
 846             OSL_ENSURE(false, "E3dScene::handlePageChange invalid object list (!)");
 847         }
 848     }
 849 }
 850
 851 SdrObjList* E3dScene::GetSubList() const
 852 {
 853     return const_cast< E3dScene* >(this);
 854 }
 855
 856 basegfx::B3DRange E3dScene::RecalcBoundVolume() const
 857 {
 858     basegfx::B3DRange aRetval;
 859     const size_t nObjCnt(GetObjCount());
 860
 861     for(size_t a = 0; a < nObjCnt; ++a)
 862     {
 863         const E3dObject* p3DObject = DynCastE3dObject(GetObj(a));
 864
 865         if(p3DObject)
 866         {
 867             basegfx::B3DRange aLocalRange(p3DObject->GetBoundVolume());
 868             aLocalRange.transform(p3DObject->GetTransform());
 869             aRetval.expand(aLocalRange);
 870         }
 871     }
 872
 873     return aRetval;
 874 }
 875
 876 void E3dScene::SetTransformChanged()
 877 {
 878     // call parent
 879     E3dObject::SetTransformChanged();
 880
 881     for(size_t a = 0; a < GetObjCount(); ++a)
 882     {
 883         E3dObject* pCandidate = DynCastE3dObject(GetObj(a));
 884
 885         if(pCandidate)
 886         {
 887             pCandidate->SetTransformChanged();
 888         }
 889     }
 890 }
 891
 892 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */