svx/source/engine3d/obj3d.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: obj3d.cxx,v $
  10  * $Revision: 1.48.18.1 $
  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 "svdstr.hrc"
  35 #include "svdglob.hxx"
  36 #include <svx/svdview.hxx>
  37 #include <svx/svdattr.hxx>
  38 #include <svx/svdpage.hxx>
  39 #include <svx/svdmodel.hxx>
  40 #include "svditer.hxx"
  41 #include "globl3d.hxx"
  42 #include <svx/camera3d.hxx>
  43 #include <svx/scene3d.hxx>
  44 #include <svx/polysc3d.hxx>
  45 #include <svx/cube3d.hxx>
  46 #include <svx/lathe3d.hxx>
  47 #include <svx/sphere3d.hxx>
  48 #include <svx/extrud3d.hxx>
  49 #include <svx/obj3d.hxx>
  50 #include <svx/xtable.hxx>
  51 #include <svx/xflclit.hxx>
  52 #include <vcl/svapp.hxx>
  53 #include <vcl/settings.hxx>
  54 #include <svx/xlnclit.hxx>
  55 #include <svtools/metitem.hxx>
  56 #include <svx/xtable.hxx>
  57 #include <svx/xfillit.hxx>
  58 #include <svx/xlnwtit.hxx>
  59 #include <vcl/virdev.hxx>
  60 #include <tools/poly.hxx>
  61 #include <goodies/b3dtrans.hxx>
  62 #include <svx/svxids.hrc>
  63 #include <svx/colritem.hxx>
  64 #include <svx/e3ditem.hxx>
  65 #include <svx/xlntrit.hxx>
  66 #include <svx/xfltrit.hxx>
  67 #include <svx/svdpagv.hxx>
  68 #include <vcl/gradient.hxx>
  69 #include <vcl/metaact.hxx>
  70 #include <svx/svx3ditems.hxx>
  71 #include <svtools/whiter.hxx>
  72 #include <svtools/colorcfg.hxx>
  73 #include <svx/eeitem.hxx>
  74 #include <svx/xgrscit.hxx>
  75 #include "svdoimp.hxx"
  76 #include <svx/sdr/properties/e3dproperties.hxx>
  77 #include <svx/sdr/properties/e3dcompoundproperties.hxx>
  78 #include <basegfx/polygon/b3dpolypolygontools.hxx>
  79 #include <basegfx/point/b3dpoint.hxx>
  80 #include <basegfx/vector/b3dvector.hxx>
  81 #include <svx/xlndsit.hxx>
  82 #include <basegfx/matrix/b3dhommatrix.hxx>
  83 #include <basegfx/polygon/b3dpolygon.hxx>
  84 #include <basegfx/matrix/b2dhommatrix.hxx>
  85 #include <basegfx/polygon/b2dpolypolygontools.hxx>
  86 #include <basegfx/polygon/b3dpolygontools.hxx>
  87 #include <svx/helperhittest3d.hxx>
  88 #include <svx/sdr/contact/viewcontactofe3d.hxx>
  89 #include <drawinglayer/geometry/viewinformation3d.hxx>
  90 #include <com/sun/star/uno/Sequence.h>
  91 #include <svx/sdr/contact/viewcontactofe3dscene.hxx>
  92 #include <basegfx/polygon/b3dpolypolygontools.hxx>
  93 #include <svx/e3dsceneupdater.hxx>
  94
  95 #define ITEMVALUE(ItemSet,Id,Cast)      ((const Cast&)(ItemSet).Get(Id)).GetValue()
  96
  97 //////////////////////////////////////////////////////////////////////////////
  98
  99 using namespace com::sun::star;
 100
 101 /*************************************************************************
 102 |*
 103 |* Liste fuer 3D-Objekte
 104 |*
 105 \************************************************************************/
 106
 107 TYPEINIT1(E3dObjList, SdrObjList);
 108
 109 E3dObjList::E3dObjList(SdrModel* pNewModel, SdrPage* pNewPage, E3dObjList* pNewUpList)
 110 :       SdrObjList(pNewModel, pNewPage, pNewUpList)
 111 {
 112 }
 113
 114 E3dObjList::E3dObjList(const E3dObjList& rSrcList)
 115 :       SdrObjList(rSrcList)
 116 {
 117 }
 118
 119 E3dObjList::~E3dObjList()
 120 {
 121 }
 122
 123 void E3dObjList::NbcInsertObject(SdrObject* pObj, ULONG nPos, const SdrInsertReason* pReason)
 124 {
 125     // Owner holen
 126     DBG_ASSERT(GetOwnerObj()->ISA(E3dObject), "AW: Einfuegen 3DObject in Parent != 3DObject");
 127
 128     // Ist es ueberhaupt ein 3D-Objekt?
 129     if(pObj && pObj->ISA(E3dObject))
 130     {
 131         // Normales 3D Objekt, einfuegen mittels
 132         // call parent
 133         SdrObjList::NbcInsertObject(pObj, nPos, pReason);
 134     }
 135     else
 136     {
 137         // Kein 3D Objekt, fuege in Seite statt in Szene ein...
 138         GetOwnerObj()->GetPage()->InsertObject(pObj, nPos);
 139     }
 140 }
 141
 142 void E3dObjList::InsertObject(SdrObject* pObj, ULONG nPos, const SdrInsertReason* pReason)
 143 {
 144     OSL_ENSURE(GetOwnerObj()->ISA(E3dObject), "Insert 3DObject in non-3D Parent");
 145     //E3DModifySceneSnapRectUpdater aUpdater(GetOwnerObj());
 146
 147     // call parent
 148     SdrObjList::InsertObject(pObj, nPos, pReason);
 149
 150     E3dScene* pScene = ((E3dObject*)GetOwnerObj())->GetScene();
 151     if(pScene)
 152     {
 153         pScene->Cleanup3DDepthMapper();
 154     }
 155 }
 156
 157 SdrObject* E3dObjList::NbcRemoveObject(ULONG nObjNum)
 158 {
 159     DBG_ASSERT(GetOwnerObj()->ISA(E3dObject), "AW: Entfernen 3DObject aus Parent != 3DObject");
 160     //E3DModifySceneSnapRectUpdater aUpdater(GetOwnerObj());
 161
 162     // call parent
 163     SdrObject* pRetval = SdrObjList::NbcRemoveObject(nObjNum);
 164
 165     E3dScene* pScene = ((E3dObject*)GetOwnerObj())->GetScene();
 166     if(pScene)
 167     {
 168         pScene->Cleanup3DDepthMapper();
 169     }
 170
 171     return pRetval;
 172 }
 173
 174 SdrObject* E3dObjList::RemoveObject(ULONG nObjNum)
 175 {
 176     OSL_ENSURE(GetOwnerObj()->ISA(E3dObject), "3DObject is removed from non-3D Parent");
 177     //E3DModifySceneSnapRectUpdater aUpdater(GetOwnerObj());
 178
 179     // call parent
 180     SdrObject* pRetval = SdrObjList::RemoveObject(nObjNum);
 181
 182     E3dScene* pScene = ((E3dObject*)GetOwnerObj())->GetScene();
 183     if(pScene)
 184     {
 185         pScene->Cleanup3DDepthMapper();
 186     }
 187
 188     return pRetval;
 189 }
 190
 191 /*************************************************************************
 192 |*
 193 |* Konstruktor
 194 |*
 195 \************************************************************************/
 196
 197 //////////////////////////////////////////////////////////////////////////////
 198
 199 sdr::properties::BaseProperties* E3dObject::CreateObjectSpecificProperties()
 200 {
 201     return new sdr::properties::E3dProperties(*this);
 202 }
 203
 204 ////////////////////////////////////////////////////////////////////////////////////////////////////
 205
 206 TYPEINIT1(E3dObject, SdrAttrObj);
 207
 208 E3dObject::E3dObject()
 209 :   maSubList(),
 210     maLocalBoundVol(),
 211     maTransformation(),
 212     maFullTransform(),
 213     mbTfHasChanged(true),
 214     mbIsSelected(false)
 215 {
 216     bIs3DObj = true;
 217     maSubList.SetOwnerObj(this);
 218     maSubList.SetListKind(SDROBJLIST_GROUPOBJ);
 219     bClosedObj = true;
 220 }
 221
 222 /*************************************************************************
 223 |*
 224 |* Destruktor
 225 |*
 226 \************************************************************************/
 227
 228 E3dObject::~E3dObject()
 229 {
 230 }
 231
 232 /*************************************************************************
 233 |*
 234 |* Selektions-Flag setzen
 235 |*
 236 \************************************************************************/
 237
 238 void E3dObject::SetSelected(bool bNew)
 239 {
 240     if((bool)mbIsSelected != bNew)
 241     {
 242         mbIsSelected = bNew;
 243     }
 244
 245     for(sal_uInt32 a(0); a < maSubList.GetObjCount(); a++)
 246     {
 247         E3dObject* pCandidate = dynamic_cast< E3dObject* >(maSubList.GetObj(a));
 248
 249         if(pCandidate)
 250         {
 251             pCandidate->SetSelected(bNew);
 252         }
 253     }
 254 }
 255
 256 /*************************************************************************
 257 |*
 258 |* Aufbrechen, default-Implementierungen
 259 |*
 260 \************************************************************************/
 261
 262 BOOL E3dObject::IsBreakObjPossible()
 263 {
 264     return FALSE;
 265 }
 266
 267 SdrAttrObj* E3dObject::GetBreakObj()
 268 {
 269     return 0L;
 270 }
 271
 272 /*************************************************************************
 273 |*
 274 |* SetRectsDirty muss ueber die lokale SdrSubList gehen
 275 |*
 276 \************************************************************************/
 277
 278 void E3dObject::SetRectsDirty(sal_Bool bNotMyself)
 279 {
 280     // call parent
 281     SdrAttrObj::SetRectsDirty(bNotMyself);
 282
 283     for(sal_uInt32 a(0); a < maSubList.GetObjCount(); a++)
 284     {
 285         E3dObject* pCandidate = dynamic_cast< E3dObject* >(maSubList.GetObj(a));
 286
 287         if(pCandidate)
 288         {
 289             pCandidate->SetRectsDirty(bNotMyself);
 290         }
 291     }
 292 }
 293
 294 /*************************************************************************
 295 |*
 296 |* Inventor zurueckgeben
 297 |*
 298 \************************************************************************/
 299
 300 UINT32 E3dObject::GetObjInventor() const
 301 {
 302     return E3dInventor;
 303 }
 304
 305 /*************************************************************************
 306 |*
 307 |* Identifier zurueckgeben
 308 |*
 309 \************************************************************************/
 310
 311 UINT16 E3dObject::GetObjIdentifier() const
 312 {
 313     return E3D_OBJECT_ID;
 314 }
 315
 316 /*************************************************************************
 317 |*
 318 |* Faehigkeiten des Objektes feststellen
 319 |*
 320 \************************************************************************/
 321
 322 void E3dObject::TakeObjInfo(SdrObjTransformInfoRec& rInfo) const
 323 {
 324     rInfo.bResizeFreeAllowed    = TRUE;
 325     rInfo.bResizePropAllowed    = TRUE;
 326     rInfo.bRotateFreeAllowed    = TRUE;
 327     rInfo.bRotate90Allowed      = TRUE;
 328     rInfo.bMirrorFreeAllowed    = FALSE;
 329     rInfo.bMirror45Allowed      = FALSE;
 330     rInfo.bMirror90Allowed      = FALSE;
 331     rInfo.bShearAllowed         = FALSE;
 332     rInfo.bEdgeRadiusAllowed    = FALSE;
 333     rInfo.bCanConvToPath        = FALSE;
 334
 335     // no transparence for 3d objects
 336     rInfo.bTransparenceAllowed = FALSE;
 337
 338     // gradient depends on fillstyle
 339     // BM *** check if SetItem is NULL ***
 340     XFillStyle eFillStyle = ((XFillStyleItem&)(GetMergedItem(XATTR_FILLSTYLE))).GetValue();
 341     rInfo.bGradientAllowed = (eFillStyle == XFILL_GRADIENT);
 342
 343     // Umwandeln von 3D-Koerpern in Gruppe von Polygonen:
 344     //
 345     // Erst mal nicht moeglich, da die Erzeugung einer Gruppe von
 346     // 2D-Polygonen notwendig waere, die tiefensortiert werden muessten,
 347     // also bei Durchdringugnen auch gegeneinander geschnitten werden
 348     // muessten. Auch die Texturkoorinaten waeren ein ungeloestes
 349     // Problem.
 350     rInfo.bCanConvToPoly = FALSE;
 351     rInfo.bCanConvToContour = FALSE;
 352     rInfo.bCanConvToPathLineToArea = FALSE;
 353     rInfo.bCanConvToPolyLineToArea = FALSE;
 354 }
 355
 356 /*************************************************************************
 357 |*
 358 |* Layer setzen
 359 |*
 360 \************************************************************************/
 361
 362 void E3dObject::NbcSetLayer(SdrLayerID nLayer)
 363 {
 364     SdrAttrObj::NbcSetLayer(nLayer);
 365
 366     for(sal_uInt32 a(0); a < maSubList.GetObjCount(); a++)
 367     {
 368         E3dObject* pCandidate = dynamic_cast< E3dObject* >(maSubList.GetObj(a));
 369
 370         if(pCandidate)
 371         {
 372             pCandidate->NbcSetLayer(nLayer);
 373         }
 374     }
 375 }
 376
 377 /*************************************************************************
 378 |*
 379 |* ObjList auch an SubList setzen
 380 |*
 381 \************************************************************************/
 382
 383 void E3dObject::SetObjList(SdrObjList* pNewObjList)
 384 {
 385     SdrObject::SetObjList(pNewObjList);
 386     maSubList.SetUpList(pNewObjList);
 387 }
 388
 389 /*************************************************************************
 390 |*
 391 |* Layer setzen
 392 |*
 393 \************************************************************************/
 394
 395 void E3dObject::SetPage(SdrPage* pNewPage)
 396 {
 397     SdrAttrObj::SetPage(pNewPage);
 398     maSubList.SetPage(pNewPage);
 399 }
 400
 401 /*************************************************************************
 402 |*
 403 |* Layer setzen
 404 |*
 405 \************************************************************************/
 406
 407 void E3dObject::SetModel(SdrModel* pNewModel)
 408 {
 409     SdrAttrObj::SetModel(pNewModel);
 410     maSubList.SetModel(pNewModel);
 411 }
 412
 413 /*************************************************************************
 414 |*
 415 |* resize object, used from old 2d interfaces, e.g. in Move/Scale dialog
 416 |* (F4)
 417 |*
 418 \************************************************************************/
 419 void E3dObject::NbcResize(const Point& rRef, const Fraction& xFact, const Fraction& yFact)
 420 {
 421     // Bewegung in X,Y im Augkoordinatensystem
 422     E3dScene* pScene = GetScene();
 423
 424     if(pScene)
 425     {
 426         // transform pos from 2D world to 3D eye
 427         const sdr::contact::ViewContactOfE3dScene& rVCScene = static_cast< sdr::contact::ViewContactOfE3dScene& >(pScene->GetViewContact());
 428         const drawinglayer::geometry::ViewInformation3D aViewInfo3D(rVCScene.getViewInformation3D());
 429         basegfx::B2DPoint aScaleCenter2D((double)rRef.X(), (double)rRef.Y());
 430         basegfx::B2DHomMatrix aInverseSceneTransform(rVCScene.getObjectTransformation());
 431
 432         aInverseSceneTransform.invert();
 433         aScaleCenter2D = aInverseSceneTransform * aScaleCenter2D;
 434
 435         basegfx::B3DPoint aScaleCenter3D(aScaleCenter2D.getX(), aScaleCenter2D.getY(), 0.5);
 436         basegfx::B3DHomMatrix aInverseViewToEye(aViewInfo3D.getDeviceToView() * aViewInfo3D.getProjection());
 437
 438         aInverseViewToEye.invert();
 439         aScaleCenter3D = aInverseViewToEye * aScaleCenter3D;
 440
 441         // scale-faktoren holen
 442         double fScaleX(xFact);
 443         double fScaleY(yFact);
 444
 445         // build transform
 446         basegfx::B3DHomMatrix aInverseOrientation(aViewInfo3D.getOrientation());
 447         aInverseOrientation.invert();
 448         basegfx::B3DHomMatrix mFullTransform(GetFullTransform());
 449         basegfx::B3DHomMatrix mTrans(mFullTransform);
 450
 451         mTrans *= aViewInfo3D.getOrientation();
 452         mTrans.translate(-aScaleCenter3D.getX(), -aScaleCenter3D.getY(), -aScaleCenter3D.getZ());
 453         mTrans.scale(fScaleX, fScaleY, 1.0);
 454         mTrans.translate(aScaleCenter3D.getX(), aScaleCenter3D.getY(), aScaleCenter3D.getZ());
 455         mTrans *= aInverseOrientation;
 456         mFullTransform.invert();
 457         mTrans *= mFullTransform;
 458
 459         // anwenden
 460         basegfx::B3DHomMatrix mObjTrans(GetTransform());
 461         mObjTrans *= mTrans;
 462
 463         E3DModifySceneSnapRectUpdater aUpdater(this);
 464         SetTransform(mObjTrans);
 465     }
 466 }
 467
 468 /*************************************************************************
 469 |*
 470 |* Objekt verschieben in 2D, wird bei Cursortasten benoetigt
 471 |*
 472 \************************************************************************/
 473 void E3dObject::NbcMove(const Size& rSize)
 474 {
 475     // Bewegung in X,Y im Augkoordinatensystem
 476     E3dScene* pScene = GetScene();
 477
 478     if(pScene)
 479     {
 480         // Abmessungen der Szene in 3D und 2D als Vergleich
 481         Rectangle aRect = pScene->GetSnapRect();
 482
 483         // Transformation Weltkoordinaten bis eine VOR Objektkoordinaten holen
 484         basegfx::B3DHomMatrix mInvDispTransform;
 485         if(GetParentObj())
 486         {
 487             mInvDispTransform = GetParentObj()->GetFullTransform();
 488             mInvDispTransform.invert();
 489         }
 490
 491         // BoundVolume from 3d world to 3d eye
 492         const sdr::contact::ViewContactOfE3dScene& rVCScene = static_cast< sdr::contact::ViewContactOfE3dScene& >(pScene->GetViewContact());
 493         const drawinglayer::geometry::ViewInformation3D aViewInfo3D(rVCScene.getViewInformation3D());
 494         basegfx::B3DRange aEyeVol(pScene->GetBoundVolume());
 495         aEyeVol.transform(aViewInfo3D.getOrientation());
 496
 497         // build relative movement vector in eye coordinates
 498         basegfx::B3DPoint aMove(
 499             (double)rSize.Width() * aEyeVol.getWidth() / (double)aRect.GetWidth(),
 500             (double)-rSize.Height() * aEyeVol.getHeight() / (double)aRect.GetHeight(),
 501             0.0);
 502         basegfx::B3DPoint aPos(0.0, 0.0, 0.0);
 503
 504         // movement vektor to local coordinates of objects' parent
 505         basegfx::B3DHomMatrix aInverseOrientation(aViewInfo3D.getOrientation());
 506         aInverseOrientation.invert();
 507         basegfx::B3DHomMatrix aCompleteTrans(mInvDispTransform * aInverseOrientation);
 508
 509         aMove = aCompleteTrans * aMove;
 510         aPos = aCompleteTrans * aPos;
 511
 512         // build transformation and apply
 513         basegfx::B3DHomMatrix aTranslate;
 514         aTranslate.translate(aMove.getX() - aPos.getX(), aMove.getY() - aPos.getY(), aMove.getZ() - aPos.getZ());
 515
 516         E3DModifySceneSnapRectUpdater aUpdater(pScene);
 517         SetTransform(aTranslate * GetTransform());
 518     }
 519 }
 520
 521 /*************************************************************************
 522 |*
 523 |* liefere die Sublist, aber nur dann, wenn darin Objekte enthalten sind !
 524 |*
 525 \************************************************************************/
 526
 527 SdrObjList* E3dObject::GetSubList() const
 528 {
 529     return &(const_cast< E3dObjList& >(maSubList));
 530 }
 531
 532 /*************************************************************************
 533 |*
 534 |* SnapRect berechnen
 535 |*
 536 \************************************************************************/
 537
 538 void E3dObject::RecalcSnapRect()
 539 {
 540     maSnapRect = Rectangle();
 541
 542     for(sal_uInt32 a(0); a < maSubList.GetObjCount(); a++)
 543     {
 544         E3dObject* pCandidate = dynamic_cast< E3dObject* >(maSubList.GetObj(a));
 545
 546         if(pCandidate)
 547         {
 548             maSnapRect.Union(pCandidate->GetSnapRect());
 549         }
 550     }
 551 }
 552
 553 /*************************************************************************
 554 |*
 555 |* Einfuegen eines 3D-Objekts an den Parent weitermelden, damit dieser
 556 |* ggf. eine Sonderbehandlung fuer spezielle Objekte durchfuehren kann
 557 |* (z.B. Light/Label in E3dScene)
 558 |*
 559 \************************************************************************/
 560
 561 void E3dObject::NewObjectInserted(const E3dObject* p3DObj)
 562 {
 563     if(GetParentObj())
 564         GetParentObj()->NewObjectInserted(p3DObj);
 565 }
 566
 567 /*************************************************************************
 568 |*
 569 |* Parent ueber Aenderung der Struktur (z.B. durch Transformation)
 570 |* informieren; dabei wird das Objekt, in welchem die Aenderung
 571 |* aufgetreten ist, uebergeben
 572 |*
 573 \************************************************************************/
 574
 575 void E3dObject::StructureChanged()
 576 {
 577     if ( GetParentObj() )
 578     {
 579         GetParentObj()->InvalidateBoundVolume();
 580         GetParentObj()->StructureChanged();
 581     }
 582 }
 583
 584 /*************************************************************************
 585 |*
 586 |* 3D-Objekt einfuegen
 587 |*
 588 \************************************************************************/
 589
 590 void E3dObject::Insert3DObj(E3dObject* p3DObj)
 591 {
 592     DBG_ASSERT(p3DObj, "Insert3DObj mit NULL-Zeiger!");
 593     SdrPage* pPg = pPage;
 594     maSubList.InsertObject(p3DObj);
 595     pPage = pPg;
 596     InvalidateBoundVolume();
 597     NewObjectInserted(p3DObj);
 598     StructureChanged();
 599 }
 600
 601 void E3dObject::Remove3DObj(E3dObject* p3DObj)
 602 {
 603     DBG_ASSERT(p3DObj, "Remove3DObj mit NULL-Zeiger!");
 604
 605     if(p3DObj->GetParentObj() == this)
 606     {
 607         SdrPage* pPg = pPage;
 608         maSubList.RemoveObject(p3DObj->GetOrdNum());
 609         pPage = pPg;
 610
 611         InvalidateBoundVolume();
 612         StructureChanged();
 613     }
 614 }
 615
 616 /*************************************************************************
 617 |*
 618 |* Parent holen
 619 |*
 620 \************************************************************************/
 621
 622 E3dObject* E3dObject::GetParentObj() const
 623 {
 624     E3dObject* pRetval = NULL;
 625
 626     if(GetObjList()
 627         && GetObjList()->GetOwnerObj()
 628         && GetObjList()->GetOwnerObj()->ISA(E3dObject))
 629         pRetval = ((E3dObject*)GetObjList()->GetOwnerObj());
 630     return pRetval;
 631 }
 632
 633 /*************************************************************************
 634 |*
 635 |* Uebergeordnetes Szenenobjekt bestimmen
 636 |*
 637 \************************************************************************/
 638
 639 E3dScene* E3dObject::GetScene() const
 640 {
 641     if(GetParentObj())
 642         return GetParentObj()->GetScene();
 643     return NULL;
 644 }
 645
 646 /*************************************************************************
 647 |*
 648 |* umschliessendes Volumen inklusive aller Kindobjekte berechnen
 649 |*
 650 \************************************************************************/
 651
 652 basegfx::B3DRange E3dObject::RecalcBoundVolume() const
 653 {
 654     basegfx::B3DRange aRetval;
 655     const sal_uInt32 nObjCnt(maSubList.GetObjCount());
 656
 657     if(nObjCnt)
 658     {
 659         for(sal_uInt32 a(0); a < nObjCnt; a++)
 660         {
 661             const E3dObject* p3DObject = dynamic_cast< const E3dObject* >(maSubList.GetObj(a));
 662
 663             if(p3DObject)
 664             {
 665                 basegfx::B3DRange aLocalRange(p3DObject->GetBoundVolume());
 666                 aLocalRange.transform(p3DObject->GetTransform());
 667                 aRetval.expand(aLocalRange);
 668             }
 669         }
 670     }
 671     else
 672     {
 673         // single 3D object
 674         const sdr::contact::ViewContactOfE3d* pVCOfE3D = dynamic_cast< const sdr::contact::ViewContactOfE3d* >(&GetViewContact());
 675
 676         if(pVCOfE3D)
 677         {
 678             // BoundVolume is without 3D object transformation, use correct sequence
 679             const drawinglayer::primitive3d::Primitive3DSequence xLocalSequence(pVCOfE3D->getVIP3DSWithoutObjectTransform());
 680
 681             if(xLocalSequence.hasElements())
 682             {
 683                 const uno::Sequence< beans::PropertyValue > aEmptyParameters;
 684                 const drawinglayer::geometry::ViewInformation3D aLocalViewInformation3D(aEmptyParameters);
 685
 686                 aRetval = drawinglayer::primitive3d::getB3DRangeFromPrimitive3DSequence(
 687                     xLocalSequence, aLocalViewInformation3D);
 688             }
 689         }
 690     }
 691
 692     return aRetval;
 693 }
 694
 695 /*************************************************************************
 696 |*
 697 |* umschliessendes Volumen zurueckgeben und ggf. neu berechnen
 698 |*
 699 \************************************************************************/
 700
 701 const basegfx::B3DRange& E3dObject::GetBoundVolume() const
 702 {
 703     if(maLocalBoundVol.isEmpty())
 704     {
 705         const_cast< E3dObject* >(this)->maLocalBoundVol = RecalcBoundVolume();
 706     }
 707
 708     return maLocalBoundVol;
 709 }
 710
 711 void E3dObject::InvalidateBoundVolume()
 712 {
 713     maLocalBoundVol.reset();
 714 }
 715
 716 /*************************************************************************
 717 |*
 718 |* Aederung des BoundVolumes an alle Kindobjekte weitergeben
 719 |*
 720 \************************************************************************/
 721
 722 void E3dObject::SetBoundVolInvalid()
 723 {
 724     InvalidateBoundVolume();
 725
 726     for(sal_uInt32 a(0); a < maSubList.GetObjCount(); a++)
 727     {
 728         E3dObject* pCandidate = dynamic_cast< E3dObject* >(maSubList.GetObj(a));
 729
 730         if(pCandidate)
 731         {
 732             pCandidate->SetBoundVolInvalid();
 733         }
 734     }
 735 }
 736
 737 /*************************************************************************
 738 |*
 739 |* Aederung der Transformation an alle Kindobjekte weitergeben
 740 |*
 741 \************************************************************************/
 742
 743 void E3dObject::SetTransformChanged()
 744 {
 745     InvalidateBoundVolume();
 746     mbTfHasChanged = true;
 747
 748     for(sal_uInt32 a(0); a < maSubList.GetObjCount(); a++)
 749     {
 750         E3dObject* pCandidate = dynamic_cast< E3dObject* >(maSubList.GetObj(a));
 751
 752         if(pCandidate)
 753         {
 754             pCandidate->SetTransformChanged();
 755         }
 756     }
 757 }
 758
 759 /*************************************************************************
 760 |*
 761 |* hierarchische Transformation ueber alle Parents bestimmen, in
 762 |* maFullTransform ablegen und diese zurueckgeben
 763 |*
 764 \************************************************************************/
 765
 766 const basegfx::B3DHomMatrix& E3dObject::GetFullTransform() const
 767 {
 768     if(mbTfHasChanged)
 769     {
 770         basegfx::B3DHomMatrix aNewFullTransformation(maTransformation);
 771
 772         if ( GetParentObj() )
 773         {
 774             aNewFullTransformation = GetParentObj()->GetFullTransform() * aNewFullTransformation;
 775         }
 776
 777         const_cast< E3dObject* >(this)->maFullTransform = aNewFullTransformation;
 778         const_cast< E3dObject* >(this)->mbTfHasChanged = false;
 779     }
 780
 781     return maFullTransform;
 782 }
 783
 784 /*************************************************************************
 785 |*
 786 |* Transformationsmatrix abfragen
 787 |*
 788 \************************************************************************/
 789
 790 const basegfx::B3DHomMatrix& E3dObject::GetTransform() const
 791 {
 792     return maTransformation;
 793 }
 794
 795 /*************************************************************************
 796 |*
 797 |* Transformationsmatrix setzen
 798 |*
 799 \************************************************************************/
 800
 801 void E3dObject::NbcSetTransform(const basegfx::B3DHomMatrix& rMatrix)
 802 {
 803     if(maTransformation != rMatrix)
 804     {
 805         maTransformation = rMatrix;
 806         SetTransformChanged();
 807         StructureChanged();
 808     }
 809 }
 810
 811 /*************************************************************************
 812 |*
 813 |* Transformationsmatrix setzen mit Repaint-Broadcast
 814 |*
 815 \************************************************************************/
 816
 817 void E3dObject::SetTransform(const basegfx::B3DHomMatrix& rMatrix)
 818 {
 819     if(rMatrix != maTransformation)
 820     {
 821         // #110094#-14 SendRepaintBroadcast();
 822         NbcSetTransform(rMatrix);
 823         SetChanged();
 824         BroadcastObjectChange();
 825         if (pUserCall != NULL) pUserCall->Changed(*this, SDRUSERCALL_RESIZE, Rectangle());
 826     }
 827 }
 828
 829 /*************************************************************************
 830 |*
 831 |* Linien fuer die Wireframe-Darstellung des Objekts dem uebergebenen
 832 |* basegfx::B3DPolygon hinzufuegen
 833 |*
 834 \************************************************************************/
 835
 836 basegfx::B3DPolyPolygon E3dObject::CreateWireframe() const
 837 {
 838     const basegfx::B3DRange aBoundVolume(GetBoundVolume());
 839     return basegfx::tools::createCubePolyPolygonFromB3DRange(aBoundVolume);
 840 }
 841
 842 /*************************************************************************
 843 |*
 844 |* Get the name of the object (singular)
 845 |*
 846 \************************************************************************/
 847
 848 void E3dObject::TakeObjNameSingul(XubString& rName) const
 849 {
 850     rName=ImpGetResStr(STR_ObjNameSingulObj3d);
 851
 852     String aName( GetName() );
 853     if(aName.Len())
 854     {
 855         rName += sal_Unicode(' ');
 856         rName += sal_Unicode('\'');
 857         rName += aName;
 858         rName += sal_Unicode('\'');
 859     }
 860 }
 861
 862 /*************************************************************************
 863 |*
 864 |* Get the name of the object (plural)
 865 |*
 866 \************************************************************************/
 867
 868 void E3dObject::TakeObjNamePlural(XubString& rName) const
 869 {
 870     rName=ImpGetResStr(STR_ObjNamePluralObj3d);
 871 }
 872
 873 /*************************************************************************
 874 |*
 875 |* Zuweisungsoperator
 876 |*
 877 \************************************************************************/
 878
 879 void E3dObject::operator=(const SdrObject& rObj)
 880 {
 881     SdrObject::operator=(rObj);
 882
 883     const E3dObject& r3DObj = (const E3dObject&) rObj;
 884     if (r3DObj.GetSubList())
 885     {
 886         maSubList.CopyObjects(*r3DObj.GetSubList());
 887     }
 888
 889     // BoundVol kann uebernommen werden, da die Childs auch kopiert werden
 890     maLocalBoundVol  = r3DObj.maLocalBoundVol;
 891     maTransformation = r3DObj.maTransformation;
 892
 893     // Da sich der Parent geaendert haben kann, Gesamttransformation beim
 894     // naechsten Mal auf jeden Fall neu bestimmen
 895     SetTransformChanged();
 896
 897     // Selektionsstatus kopieren
 898     mbIsSelected = r3DObj.mbIsSelected;
 899 }
 900
 901 /*************************************************************************
 902 |*
 903 |* erstelle neues GeoData-Objekt
 904 |*
 905 \************************************************************************/
 906
 907 SdrObjGeoData *E3dObject::NewGeoData() const
 908 {
 909     // Theoretisch duerfen auch nur Szenen ihre GeoDatas erstellen und verwalten !!
 910     // AW: Dies stimmt nicht mehr, diese Stelle ist mit der neuen Engine OK!
 911     return new E3DObjGeoData;
 912 }
 913
 914 /*************************************************************************
 915 |*
 916 |* uebergebe aktuelle werte an das GeoData-Objekt
 917 |*
 918 \************************************************************************/
 919
 920 void E3dObject::SaveGeoData(SdrObjGeoData& rGeo) const
 921 {
 922     SdrAttrObj::SaveGeoData (rGeo);
 923
 924     ((E3DObjGeoData &) rGeo).maLocalBoundVol  = maLocalBoundVol;
 925     ((E3DObjGeoData &) rGeo).maTransformation = maTransformation;
 926 }
 927
 928 /*************************************************************************
 929 |*
 930 |* uebernehme werte aus dem GeoData-Objekt
 931 |*
 932 \************************************************************************/
 933
 934 void E3dObject::RestGeoData(const SdrObjGeoData& rGeo)
 935 {
 936     maLocalBoundVol = ((E3DObjGeoData &) rGeo).maLocalBoundVol;
 937     E3DModifySceneSnapRectUpdater aUpdater(this);
 938     NbcSetTransform(((E3DObjGeoData &) rGeo).maTransformation);
 939     SdrAttrObj::RestGeoData (rGeo);
 940 }
 941
 942 /*************************************************************************
 943 |*
 944 |* Rotation eines 3d-Koerpers
 945 |*
 946 \************************************************************************/
 947 // 2D-rotation eines 3D-Koerpers, normalerweise macht das die Szene selbst
 948 // Ist aber eine korrekte Implementierung, denn alles was passiert ist eine
 949 // Rotation um die Achse die senkrecht auf dem Bildschirm steht und zwar
 950 // unabhaengig davon, wie die Szene bisher gedreht worden ist.
 951
 952 void E3dObject::NbcRotate(const Point& rRef, long nWink, double sn, double cs)
 953 {
 954     // Also derzeit sind die Klebepunkte relativ zum aOutRect der Szene definiert. Vor dem Drehen
 955     // werden die Klebepunkte relativ zur Seite definiert. Sie nehmen an der Drehung der Szene noch nicht Teil
 956     // dafuer gibt es den
 957     SetGlueReallyAbsolute(TRUE);
 958
 959     // SendRepaintBroadcast();
 960     double fWinkelInRad = nWink/100 * F_PI180;
 961
 962     basegfx::B3DHomMatrix aRotateZ;
 963     aRotateZ.rotate(0.0, 0.0, fWinkelInRad);
 964     NbcSetTransform(aRotateZ * GetTransform());
 965
 966     SetRectsDirty();    // Veranlasst eine Neuberechnung aller BoundRects
 967     NbcRotateGluePoints(rRef,nWink,sn,cs);  // Rotiert die Klebepunkte (die haben noch Koordinaten relativ
 968                                             // zum Urpsung des Blattes
 969     SetGlueReallyAbsolute(FALSE);  // ab jetzt sind sie wieder relativ zum BoundRect (also dem aOutRect definiert)
 970 }
 971
 972 /*************************************************************************/
 973
 974 //////////////////////////////////////////////////////////////////////////////
 975
 976 sdr::properties::BaseProperties* E3dCompoundObject::CreateObjectSpecificProperties()
 977 {
 978     return new sdr::properties::E3dCompoundProperties(*this);
 979 }
 980
 981 ////////////////////////////////////////////////////////////////////////////////////////////////////
 982
 983 TYPEINIT1(E3dCompoundObject, E3dObject);
 984
 985 /*************************************************************************
 986 |*
 987 |* Konstruktor
 988 |*
 989 \************************************************************************/
 990
 991 E3dCompoundObject::E3dCompoundObject()
 992 :   E3dObject(),
 993     aMaterialAmbientColor(),
 994     bCreateNormals(false),
 995     bCreateTexture(false)
 996 {
 997     // Defaults setzen
 998     E3dDefaultAttributes aDefault;
 999     SetDefaultAttributes(aDefault);
1000 }
1001
1002 E3dCompoundObject::E3dCompoundObject(E3dDefaultAttributes& rDefault)
1003 :   E3dObject(),
1004     aMaterialAmbientColor(),
1005     bCreateNormals(false),
1006     bCreateTexture(false)
1007 {
1008     // Defaults setzen
1009     SetDefaultAttributes(rDefault);
1010 }
1011
1012 void E3dCompoundObject::SetDefaultAttributes(E3dDefaultAttributes& rDefault)
1013 {
1014     // Defaults setzen
1015     aMaterialAmbientColor = rDefault.GetDefaultAmbientColor();
1016
1017     bCreateNormals = rDefault.GetDefaultCreateNormals();
1018     bCreateTexture = rDefault.GetDefaultCreateTexture();
1019 }
1020
1021 /*************************************************************************
1022 |*
1023 |* Destruktor
1024 |*
1025 \************************************************************************/
1026
1027 E3dCompoundObject::~E3dCompoundObject ()
1028 {
1029 }
1030
1031 /*************************************************************************
1032 |*
1033 |* Drag-Polygon zurueckgeben
1034 |*
1035 \************************************************************************/
1036
1037 basegfx::B2DPolyPolygon E3dCompoundObject::TakeXorPoly() const
1038 {
1039     basegfx::B2DPolyPolygon aRetval;
1040     const uno::Sequence< beans::PropertyValue > aEmptyParameters;
1041     drawinglayer::geometry::ViewInformation3D aViewInfo3D(aEmptyParameters);
1042     E3dScene* pRootScene = fillViewInformation3DForCompoundObject(aViewInfo3D, *this);
1043
1044     if(pRootScene)
1045     {
1046         const sdr::contact::ViewContactOfE3dScene& rVCScene = static_cast< sdr::contact::ViewContactOfE3dScene& >(pRootScene->GetViewContact());
1047         const basegfx::B3DPolyPolygon aCubePolyPolygon(CreateWireframe());
1048         aRetval = basegfx::tools::createB2DPolyPolygonFromB3DPolyPolygon(aCubePolyPolygon,
1049             aViewInfo3D.getObjectToView() * GetTransform());
1050         aRetval.transform(rVCScene.getObjectTransformation());
1051     }
1052
1053     return aRetval;
1054 }
1055
1056 /*************************************************************************
1057 |*
1058 |* Anzahl der Handles zurueckgeben
1059 |*
1060 \************************************************************************/
1061
1062 sal_uInt32 E3dCompoundObject::GetHdlCount() const
1063 {
1064     // 8 Eckpunkte + 1 E3dVolumeMarker (= Wireframe-Darstellung)
1065     return 9L;
1066 }
1067
1068 /*************************************************************************
1069 |*
1070 |* Handle-Liste fuellen
1071 |*
1072 \************************************************************************/
1073
1074 void E3dCompoundObject::AddToHdlList(SdrHdlList& rHdlList) const
1075 {
1076     const uno::Sequence< beans::PropertyValue > aEmptyParameters;
1077     drawinglayer::geometry::ViewInformation3D aViewInfo3D(aEmptyParameters);
1078     E3dScene* pRootScene = fillViewInformation3DForCompoundObject(aViewInfo3D, *this);
1079
1080     if(pRootScene)
1081     {
1082         const basegfx::B3DRange aBoundVolume(GetBoundVolume());
1083
1084         if(!aBoundVolume.isEmpty())
1085         {
1086             const sdr::contact::ViewContactOfE3dScene& rVCScene = static_cast< sdr::contact::ViewContactOfE3dScene& >(pRootScene->GetViewContact());
1087
1088             for(sal_uInt32 a(0); a < 8; a++)
1089             {
1090                 basegfx::B3DPoint aPos3D;
1091
1092                 switch(a)
1093                 {
1094                     case 0 : aPos3D.setX(aBoundVolume.getMinX()); aPos3D.setY(aBoundVolume.getMinY()); aPos3D.setZ(aBoundVolume.getMinZ()); break;
1095                     case 1 : aPos3D.setX(aBoundVolume.getMinX()); aPos3D.setY(aBoundVolume.getMinY()); aPos3D.setZ(aBoundVolume.getMaxZ()); break;
1096                     case 2 : aPos3D.setX(aBoundVolume.getMinX()); aPos3D.setY(aBoundVolume.getMaxY()); aPos3D.setZ(aBoundVolume.getMinZ()); break;
1097                     case 3 : aPos3D.setX(aBoundVolume.getMinX()); aPos3D.setY(aBoundVolume.getMaxY()); aPos3D.setZ(aBoundVolume.getMaxZ()); break;
1098                     case 4 : aPos3D.setX(aBoundVolume.getMaxX()); aPos3D.setY(aBoundVolume.getMinY()); aPos3D.setZ(aBoundVolume.getMinZ()); break;
1099                     case 5 : aPos3D.setX(aBoundVolume.getMaxX()); aPos3D.setY(aBoundVolume.getMinY()); aPos3D.setZ(aBoundVolume.getMaxZ()); break;
1100                     case 6 : aPos3D.setX(aBoundVolume.getMaxX()); aPos3D.setY(aBoundVolume.getMaxY()); aPos3D.setZ(aBoundVolume.getMinZ()); break;
1101                     case 7 : aPos3D.setX(aBoundVolume.getMaxX()); aPos3D.setY(aBoundVolume.getMaxY()); aPos3D.setZ(aBoundVolume.getMaxZ()); break;
1102                 }
1103
1104                 // to 3d view coor
1105                 aPos3D *= aViewInfo3D.getObjectToView() * GetTransform();
1106
1107                 // create 2d relative scene
1108                 basegfx::B2DPoint aPos2D(aPos3D.getX(), aPos3D.getY());
1109
1110                 // to 2d world coor
1111                 aPos2D *= rVCScene.getObjectTransformation();
1112
1113                 rHdlList.AddHdl(new SdrHdl(Point(basegfx::fround(aPos2D.getX()), basegfx::fround(aPos2D.getY())), HDL_BWGT));
1114             }
1115         }
1116     }
1117
1118     const basegfx::B2DPolyPolygon aPolyPolygon(TakeXorPoly());
1119
1120     if(aPolyPolygon.count())
1121     {
1122         E3dVolumeMarker* pVolMarker = new E3dVolumeMarker(aPolyPolygon);
1123         rHdlList.AddHdl(pVolMarker);
1124     }
1125 }
1126
1127 /*************************************************************************
1128 |*
1129 |* Identifier zurueckgeben
1130 |*
1131 \************************************************************************/
1132
1133 UINT16 E3dCompoundObject::GetObjIdentifier() const
1134 {
1135     return E3D_COMPOUNDOBJ_ID;
1136 }
1137
1138 /*************************************************************************
1139 |*
1140 |* SnapRect berechnen
1141 |*
1142 \************************************************************************/
1143
1144 void E3dCompoundObject::RecalcSnapRect()
1145 {
1146     const uno::Sequence< beans::PropertyValue > aEmptyParameters;
1147     drawinglayer::geometry::ViewInformation3D aViewInfo3D(aEmptyParameters);
1148     E3dScene* pRootScene = fillViewInformation3DForCompoundObject(aViewInfo3D, *this);
1149     maSnapRect = Rectangle();
1150
1151     if(pRootScene)
1152     {
1153         // get VC of 3D candidate
1154         const sdr::contact::ViewContactOfE3d* pVCOfE3D = dynamic_cast< const sdr::contact::ViewContactOfE3d* >(&GetViewContact());
1155
1156         if(pVCOfE3D)
1157         {
1158             // get 3D primitive sequence
1159             const drawinglayer::primitive3d::Primitive3DSequence xLocalSequence(pVCOfE3D->getViewIndependentPrimitive3DSequence());
1160
1161             if(xLocalSequence.hasElements())
1162             {
1163                 // get BoundVolume
1164                 basegfx::B3DRange aBoundVolume(drawinglayer::primitive3d::getB3DRangeFromPrimitive3DSequence(
1165                     xLocalSequence, aViewInfo3D));
1166
1167                 // transform bound volume to relative scene coordinates
1168                 aBoundVolume.transform(aViewInfo3D.getObjectToView());
1169
1170                 // build 2d relative scene range
1171                 basegfx::B2DRange aSnapRange(
1172                     aBoundVolume.getMinX(), aBoundVolume.getMinY(),
1173                     aBoundVolume.getMaxX(), aBoundVolume.getMaxY());
1174
1175                 // transform to 2D world coordiantes
1176                 const sdr::contact::ViewContactOfE3dScene& rVCScene = static_cast< sdr::contact::ViewContactOfE3dScene& >(pRootScene->GetViewContact());
1177                 aSnapRange.transform(rVCScene.getObjectTransformation());
1178
1179                 // snap to integer
1180                 maSnapRect = Rectangle(
1181                     sal_Int32(floor(aSnapRange.getMinX())), sal_Int32(floor(aSnapRange.getMinY())),
1182                     sal_Int32(ceil(aSnapRange.getMaxX())), sal_Int32(ceil(aSnapRange.getMaxY())));
1183             }
1184         }
1185     }
1186 }
1187
1188 /*************************************************************************
1189 |*
1190 |* Copy-Operator
1191 |*
1192 \************************************************************************/
1193
1194 void E3dCompoundObject::operator=(const SdrObject& rObj)
1195 {
1196     // erstmal alle Childs kopieren
1197     E3dObject::operator=(rObj);
1198
1199     // weitere Parameter kopieren
1200     const E3dCompoundObject& r3DObj = (const E3dCompoundObject&) rObj;
1201
1202     bCreateNormals = r3DObj.bCreateNormals;
1203     bCreateTexture = r3DObj.bCreateTexture;
1204     aMaterialAmbientColor = r3DObj.aMaterialAmbientColor;
1205 }
1206
1207 /*************************************************************************
1208 |*
1209 |* Parameter Geometrieerzeugung setzen
1210 |*
1211 \************************************************************************/
1212
1213 void E3dCompoundObject::SetCreateNormals(BOOL bNew)
1214 {
1215     if(bCreateNormals != bNew)
1216     {
1217         bCreateNormals = bNew;
1218         ActionChanged();
1219     }
1220 }
1221
1222 void E3dCompoundObject::SetCreateTexture(BOOL bNew)
1223 {
1224     if(bCreateTexture != bNew)
1225     {
1226         bCreateTexture = bNew;
1227         ActionChanged();
1228     }
1229 }
1230
1231 /*************************************************************************
1232 |*
1233 |* Material des Objektes
1234 |*
1235 \************************************************************************/
1236
1237 void E3dCompoundObject::SetMaterialAmbientColor(const Color& rColor)
1238 {
1239     if(aMaterialAmbientColor != rColor)
1240     {
1241         aMaterialAmbientColor = rColor;
1242     }
1243 }
1244
1245 /*************************************************************************
1246 |*
1247 |* convert given basegfx::B3DPolyPolygon to screen coor
1248 |*
1249 \************************************************************************/
1250
1251 basegfx::B2DPolyPolygon E3dCompoundObject::TransformToScreenCoor(const basegfx::B3DPolyPolygon& rCandidate)
1252 {
1253     const uno::Sequence< beans::PropertyValue > aEmptyParameters;
1254     drawinglayer::geometry::ViewInformation3D aViewInfo3D(aEmptyParameters);
1255     E3dScene* pRootScene = fillViewInformation3DForCompoundObject(aViewInfo3D, *this);
1256     basegfx::B2DPolyPolygon aRetval;
1257
1258     if(pRootScene)
1259     {
1260         aRetval = basegfx::tools::createB2DPolyPolygonFromB3DPolyPolygon(rCandidate,
1261             aViewInfo3D.getObjectToView() * GetTransform());
1262         const sdr::contact::ViewContactOfE3dScene& rVCScene = static_cast< sdr::contact::ViewContactOfE3dScene& >(pRootScene->GetViewContact());
1263         aRetval.transform(rVCScene.getObjectTransformation());
1264     }
1265
1266     return aRetval;
1267 }
1268
1269 sal_Bool E3dCompoundObject::IsAOrdNumRemapCandidate(E3dScene*& prScene) const
1270 {
1271     if(GetObjList()
1272         && GetObjList()->GetOwnerObj()
1273         && GetObjList()->GetOwnerObj()->ISA(E3dScene))
1274     {
1275         prScene = (E3dScene*)GetObjList()->GetOwnerObj();
1276         return sal_True;
1277     }
1278
1279     return sal_False;
1280 }
1281
1282 //////////////////////////////////////////////////////////////////////////////
1283 // eof