1162 lines
38 KiB
C++
1162 lines
38 KiB
C++
/*************************************************************************
|
|
*
|
|
* $RCSfile: lathe3d.cxx,v $
|
|
*
|
|
* $Revision: 1.18 $
|
|
*
|
|
* last change: $Author: pjunck $ $Date: 2004-11-03 10:39:17 $
|
|
*
|
|
* The Contents of this file are made available subject to the terms of
|
|
* either of the following licenses
|
|
*
|
|
* - GNU Lesser General Public License Version 2.1
|
|
* - Sun Industry Standards Source License Version 1.1
|
|
*
|
|
* Sun Microsystems Inc., October, 2000
|
|
*
|
|
* GNU Lesser General Public License Version 2.1
|
|
* =============================================
|
|
* Copyright 2000 by Sun Microsystems, Inc.
|
|
* 901 San Antonio Road, Palo Alto, CA 94303, USA
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License version 2.1, as published by the Free Software Foundation.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
|
|
* MA 02111-1307 USA
|
|
*
|
|
*
|
|
* Sun Industry Standards Source License Version 1.1
|
|
* =================================================
|
|
* The contents of this file are subject to the Sun Industry Standards
|
|
* Source License Version 1.1 (the "License"); You may not use this file
|
|
* except in compliance with the License. You may obtain a copy of the
|
|
* License at http://www.openoffice.org/license.html.
|
|
*
|
|
* Software provided under this License is provided on an "AS IS" basis,
|
|
* WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
|
|
* WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
|
|
* MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
|
|
* See the License for the specific provisions governing your rights and
|
|
* obligations concerning the Software.
|
|
*
|
|
* The Initial Developer of the Original Code is: Sun Microsystems, Inc.
|
|
*
|
|
* Copyright: 2000 by Sun Microsystems, Inc.
|
|
*
|
|
* All Rights Reserved.
|
|
*
|
|
* Contributor(s): _______________________________________
|
|
*
|
|
*
|
|
************************************************************************/
|
|
|
|
#include "svdstr.hrc"
|
|
#include "svdglob.hxx"
|
|
|
|
#ifndef _TL_POLY_HXX
|
|
#include <tools/poly.hxx>
|
|
#endif
|
|
|
|
#ifndef _SVDPAGE_HXX
|
|
#include "svdpage.hxx"
|
|
#endif
|
|
|
|
#ifndef _XOUTX_HXX
|
|
#include "xoutx.hxx"
|
|
#endif
|
|
|
|
#ifndef _E3D_GLOBL3D_HXX
|
|
#include "globl3d.hxx"
|
|
#endif
|
|
|
|
#ifndef _SVDIO_HXX
|
|
#include "svdio.hxx"
|
|
#endif
|
|
|
|
#ifndef _E3D_POLYOB3D_HXX
|
|
#include "polyob3d.hxx"
|
|
#endif
|
|
|
|
#ifndef _E3D_LATHE3D_HXX
|
|
#include "lathe3d.hxx"
|
|
#endif
|
|
|
|
#ifndef _POLY3D_HXX
|
|
#include "poly3d.hxx"
|
|
#endif
|
|
|
|
#ifndef _XPOLY_HXX
|
|
#include "xpoly.hxx"
|
|
#endif
|
|
|
|
#ifndef _SVX_SVXIDS_HRC
|
|
#include "svxids.hrc"
|
|
#endif
|
|
|
|
#ifndef _SVDOPATH_HXX
|
|
#include "svdopath.hxx"
|
|
#endif
|
|
|
|
#ifndef _SVDMODEL_HXX
|
|
#include "svdmodel.hxx"
|
|
#endif
|
|
|
|
#ifndef _SVX3DITEMS_HXX
|
|
#include "svx3ditems.hxx"
|
|
#endif
|
|
|
|
#ifndef _SDR_PROPERTIES_E3DLATHEPROPERTIES_HXX
|
|
#include <svx/sdr/properties/e3dlatheproperties.hxx>
|
|
#endif
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
sdr::properties::BaseProperties* E3dLatheObj::CreateObjectSpecificProperties()
|
|
{
|
|
return new sdr::properties::E3dLatheProperties(*this);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
TYPEINIT1(E3dLatheObj, E3dCompoundObject);
|
|
|
|
/*************************************************************************
|
|
|*
|
|
|* Konstruktor aus SV-Polygon, Scale gibt den Umrechnungsfaktor fuer
|
|
|* die Koordinaten an
|
|
|*
|
|
\************************************************************************/
|
|
|
|
E3dLatheObj::E3dLatheObj(E3dDefaultAttributes& rDefault, const PolyPolygon& rPoly)
|
|
: E3dCompoundObject(rDefault),
|
|
aPolyPoly3D (PolyPolygon3D(rPoly, rDefault.GetDefaultLatheScale()))
|
|
{
|
|
// Defaults setzen
|
|
SetDefaultAttributes(rDefault);
|
|
|
|
// Ueberfluessige Punkte entfernen, insbesondere doppelte
|
|
// Start- und Endpunkte verhindern
|
|
aPolyPoly3D.RemoveDoublePoints();
|
|
|
|
const Polygon3D rPoly3D = aPolyPoly3D[0];
|
|
sal_uInt32 nSegCnt((sal_uInt32)rPoly3D.GetPointCount());
|
|
if(nSegCnt && !rPoly3D.IsClosed())
|
|
nSegCnt -= 1;
|
|
|
|
GetProperties().SetObjectItemDirect(Svx3DVerticalSegmentsItem(nSegCnt));
|
|
|
|
// Geometrie erzeugen
|
|
CreateGeometry();
|
|
}
|
|
|
|
/*************************************************************************
|
|
|*
|
|
|* wie voriger Konstruktor, nur mit XPolygon; das XPolygon wird
|
|
|* jedoch nicht Bezier-konvertiert, sondern es werden nur seine
|
|
|* Punktkoordinaten uebernommen
|
|
|*
|
|
\************************************************************************/
|
|
|
|
E3dLatheObj::E3dLatheObj(E3dDefaultAttributes& rDefault, const XPolyPolygon& rXPoly)
|
|
: E3dCompoundObject(rDefault),
|
|
aPolyPoly3D (PolyPolygon3D(rXPoly, rDefault.GetDefaultLatheScale()))
|
|
{
|
|
// Defaults setzen
|
|
SetDefaultAttributes(rDefault);
|
|
|
|
// Ueberfluessige Punkte entfernen, insbesondere doppelte
|
|
// Start- und Endpunkte verhindern
|
|
aPolyPoly3D.RemoveDoublePoints();
|
|
const Polygon3D rPoly = aPolyPoly3D[0];
|
|
sal_uInt32 nSegCnt((sal_uInt32)rPoly.GetPointCount());
|
|
if(nSegCnt && !rPoly.IsClosed())
|
|
nSegCnt -= 1;
|
|
|
|
GetProperties().SetObjectItemDirect(Svx3DVerticalSegmentsItem(nSegCnt));
|
|
|
|
// Geometrie erzeugen
|
|
CreateGeometry();
|
|
}
|
|
|
|
/*************************************************************************
|
|
|*
|
|
\************************************************************************/
|
|
|
|
E3dLatheObj::E3dLatheObj(E3dDefaultAttributes& rDefault, const XPolygon& rXPoly)
|
|
: E3dCompoundObject(rDefault),
|
|
aPolyPoly3D (PolyPolygon3D(rXPoly, rDefault.GetDefaultLatheScale()))
|
|
{
|
|
// Defaults setzen
|
|
SetDefaultAttributes(rDefault);
|
|
|
|
// Ueberfluessige Punkte entfernen, insbesondere doppelte
|
|
// Start- und Endpunkte verhindern
|
|
aPolyPoly3D.RemoveDoublePoints();
|
|
const Polygon3D rPoly = aPolyPoly3D[0];
|
|
sal_uInt32 nSegCnt((sal_uInt32)rPoly.GetPointCount());
|
|
if(nSegCnt && !rPoly.IsClosed())
|
|
nSegCnt -= 1;
|
|
|
|
GetProperties().SetObjectItemDirect(Svx3DVerticalSegmentsItem(nSegCnt));
|
|
|
|
// Geometrie erzeugen
|
|
CreateGeometry();
|
|
}
|
|
|
|
/*************************************************************************
|
|
|*
|
|
|* Konstruktor aus 3D-Polygon, Scale gibt den Umrechnungsfaktor fuer
|
|
|* die Koordinaten an
|
|
|*
|
|
\************************************************************************/
|
|
|
|
E3dLatheObj::E3dLatheObj (E3dDefaultAttributes& rDefault, const PolyPolygon3D rPoly3D)
|
|
: E3dCompoundObject(rDefault),
|
|
aPolyPoly3D(rPoly3D)
|
|
{
|
|
// Defaults setzen
|
|
SetDefaultAttributes(rDefault);
|
|
|
|
// Ueberfluessige Punkte entfernen, insbesondere doppelte
|
|
// Start- und Endpunkte verhindern
|
|
aPolyPoly3D.RemoveDoublePoints();
|
|
const Polygon3D rPoly = aPolyPoly3D[0];
|
|
sal_uInt32 nSegCnt((sal_uInt32)rPoly.GetPointCount());
|
|
if(nSegCnt && !rPoly.IsClosed())
|
|
nSegCnt -= 1;
|
|
|
|
GetProperties().SetObjectItemDirect(Svx3DVerticalSegmentsItem(nSegCnt));
|
|
|
|
// Geometrie erzeugen
|
|
CreateGeometry();
|
|
}
|
|
|
|
/*************************************************************************
|
|
|*
|
|
|* Leer-Konstruktor
|
|
|*
|
|
\************************************************************************/
|
|
|
|
E3dLatheObj::E3dLatheObj()
|
|
: aPolyPoly3D(Polygon3D())
|
|
{
|
|
// Defaults setzen
|
|
E3dDefaultAttributes aDefault;
|
|
SetDefaultAttributes(aDefault);
|
|
}
|
|
|
|
void E3dLatheObj::SetDefaultAttributes(E3dDefaultAttributes& rDefault)
|
|
{
|
|
fLatheScale = rDefault.GetDefaultLatheScale();
|
|
|
|
GetProperties().SetObjectItemDirect(Svx3DSmoothNormalsItem(rDefault.GetDefaultLatheSmoothed()));
|
|
GetProperties().SetObjectItemDirect(Svx3DSmoothLidsItem(rDefault.GetDefaultLatheSmoothFrontBack()));
|
|
GetProperties().SetObjectItemDirect(Svx3DCharacterModeItem(rDefault.GetDefaultLatheCharacterMode()));
|
|
GetProperties().SetObjectItemDirect(Svx3DCloseFrontItem(rDefault.GetDefaultLatheCloseFront()));
|
|
GetProperties().SetObjectItemDirect(Svx3DCloseBackItem(rDefault.GetDefaultLatheCloseBack()));
|
|
}
|
|
|
|
/*************************************************************************
|
|
|*
|
|
|* Give out simple line geometry
|
|
|*
|
|
\************************************************************************/
|
|
|
|
::basegfx::B3DPolyPolygon E3dLatheObj::Get3DLineGeometry() const
|
|
{
|
|
::basegfx::B3DPolyPolygon aRetval;
|
|
|
|
aRetval.append(maLinePolyPolygon.getB3DPolyPolygon());
|
|
|
|
return aRetval;
|
|
}
|
|
|
|
/*************************************************************************
|
|
|*
|
|
|* Die eigentliche Konstruktionmethode, erzeugt einen Koerper durch
|
|
|* Rotation des uebergebenen Polygons um die senkrechte Y-Achse. Wenn
|
|
|* nEndAngle < 3600 ist, werden ausserdem zwei Deckelflaechen-Polygone
|
|
|* erzeugt, die den Koerper abschliessen. Das Polygon sollte in der
|
|
|* XY-Ebene liegen, mit X-Koordinaten >= 0; wenn die Anfangs- und End-
|
|
|* X-Koordinaten nicht 0 sind, sollte das Polygon geschlossen sein.
|
|
|* Wenn bDblSided TRUE ist, werden die Rotationsflaechen doppelseitig
|
|
|* angelegt und keine Deckelflaechen erzeugt.
|
|
|*
|
|
\************************************************************************/
|
|
|
|
// Geometrieerzeugung
|
|
void E3dLatheObj::CreateGeometry()
|
|
{
|
|
// Start der Geometrieerzeugung ankuendigen
|
|
StartCreateGeometry();
|
|
|
|
// #78972#
|
|
maLinePolyPolygon.Clear();
|
|
|
|
// Polygon erzeugen
|
|
PolyPolygon3D aLathePoly3D(aPolyPoly3D);
|
|
|
|
// Eventuelle Anpassung der Segmentanzahlen
|
|
aLathePoly3D = CreateLathePolyPoly(aPolyPoly3D, GetVerticalSegments());
|
|
|
|
// Normale holen
|
|
Vector3D aNormal = aLathePoly3D.GetNormal();
|
|
if(aNormal.Z() > 0.0)
|
|
{
|
|
aLathePoly3D.FlipDirections();
|
|
aNormal = aLathePoly3D.GetNormal();
|
|
}
|
|
|
|
// Orientierung evtl. vorhandener Loecher in einen definierten
|
|
// Ausgangszustand bringen
|
|
aLathePoly3D.SetDirections();
|
|
|
|
// #i28528#
|
|
PolyPolygon3D aFrontLines;
|
|
PolyPolygon3D aBackLines;
|
|
PolyPolygon3D aInBetweenLines;
|
|
|
|
// Spezialfall Einzelnes Polygon erzeugen
|
|
BOOL bSinglePoly = (GetEndAngle() == 0 || GetHorizontalSegments() == 0);
|
|
if(bSinglePoly)
|
|
{
|
|
// nur ein Polygon erzeugen
|
|
GetProperties().SetObjectItemDirect(Svx3DDoubleSidedItem(TRUE));
|
|
|
|
// Fuer evtl. selbst erzeugte Normalen
|
|
PolyPolygon3D aNormalsFront;
|
|
|
|
// Normalen und Vorderseite selbst erzeugen
|
|
AddFrontNormals(aLathePoly3D, aNormalsFront, aNormal);
|
|
CreateFront(aLathePoly3D, aNormalsFront, GetCreateNormals(), GetCreateTexture());
|
|
|
|
// #i28528#
|
|
aInBetweenLines.Insert(aLathePoly3D);
|
|
}
|
|
else
|
|
{
|
|
// Eventuell doppelseitig erzeugen?
|
|
if(!aLathePoly3D.IsClosed())
|
|
{
|
|
GetProperties().SetObjectItemDirect(Svx3DDoubleSidedItem(TRUE));
|
|
}
|
|
|
|
// Seiten genenrieren?
|
|
BOOL bCreateSides = ((GetEndAngle() < 3600 && !GetDoubleSided())
|
|
|| (GetBackScale() != 100));
|
|
|
|
// Polygone vorbereiten
|
|
PolyPolygon3D aPrev, aFront, aBack, aNext;
|
|
|
|
// Rotation vorbereiten
|
|
double fAng = DEG2RAD(double(GetEndAngle()) / 10);
|
|
Matrix4D aRotMat;
|
|
|
|
// Skalierung vorbereiten
|
|
double fScalePerStep;
|
|
if(GetBackScale() != 100)
|
|
fScalePerStep = (((double)GetBackScale() - 100.0) / 100.0) / (double)GetHorizontalSegments();
|
|
|
|
// Texturen erzeugen?
|
|
double fTextureDepth=1.0;
|
|
double fTextureStart=0.0;
|
|
if(!GetCreateTexture())
|
|
fTextureStart = fTextureDepth = 0.0;
|
|
|
|
// aPrev bis aBack ausfuellen als Startvorbereitung
|
|
aRotMat.RotateY(-(fAng / (double)GetHorizontalSegments()));
|
|
aPrev = aLathePoly3D;
|
|
RotatePoly(aPrev, aRotMat);
|
|
if(GetBackScale() != 100)
|
|
{
|
|
ScalePoly(aPrev, 1.0 - fScalePerStep);
|
|
}
|
|
aRotMat.Identity();
|
|
aRotMat.RotateY(fAng / (double)GetHorizontalSegments());
|
|
aFront = aLathePoly3D;
|
|
aBack = aLathePoly3D;
|
|
RotatePoly(aBack, aRotMat);
|
|
if(GetBackScale() != 100)
|
|
{
|
|
ScalePoly(aBack, 1.0 + fScalePerStep);
|
|
}
|
|
|
|
// Werte fuer Textur-Zwischensegmenterzeugung berechnen
|
|
double fTmpStart = 0.0;
|
|
double fTmpLength = fTextureDepth / (double)GetHorizontalSegments();
|
|
sal_uInt16 nUpperBound = (sal_uInt16)GetHorizontalSegments();
|
|
|
|
for(UINT16 a=0;a<nUpperBound;a++)
|
|
{
|
|
// Naechstes Polygon vorbereiten
|
|
aNext = aLathePoly3D;
|
|
|
|
// Rotieren
|
|
if(!(a+2 == nUpperBound && GetEndAngle() == 3600))
|
|
{
|
|
aRotMat.Identity();
|
|
aRotMat.RotateY((fAng * (double)(a+2))/ (double)nUpperBound);
|
|
RotatePoly(aNext, aRotMat);
|
|
}
|
|
|
|
// Skalieren
|
|
if(GetBackScale() != 100)
|
|
{
|
|
ScalePoly(aNext, 1.0 + (fScalePerStep * (double)(a+2)));
|
|
}
|
|
|
|
// Jetzt Segment erzeugen
|
|
ImpCreateSegment(
|
|
aFront,
|
|
aBack,
|
|
&aPrev,
|
|
&aNext,
|
|
(a == 0) && bCreateSides && GetCloseFront(), // #107245# bLatheCloseFront,
|
|
(a == nUpperBound-1) && bCreateSides && GetCloseBack(), // #107245# bLatheCloseBack,
|
|
((double)GetPercentDiagonal() / 200.0)
|
|
* (double(nUpperBound) / 6.0),
|
|
GetSmoothNormals(), // #107245# GetLatheSmoothed(),
|
|
GetSmoothNormals(), // #107245# GetLatheSmoothed(),
|
|
GetSmoothLids(), // #107245# GetLatheSmoothFrontBack(),
|
|
1.0,
|
|
fTmpStart,
|
|
fTmpLength,
|
|
GetCreateTexture(),
|
|
GetCreateNormals(),
|
|
GetCharacterMode(), // #107245# GetLatheCharacterMode(),
|
|
TRUE,
|
|
// #78972#
|
|
&aFrontLines,
|
|
&aBackLines,
|
|
&aInBetweenLines);
|
|
|
|
// naechsten Schritt vorbereiten
|
|
fTmpStart += fTmpLength;
|
|
aPrev = aFront;
|
|
aFront = aBack;
|
|
aBack = aNext;
|
|
}
|
|
}
|
|
|
|
// #78972#
|
|
// Simply add them for preparing line geometry
|
|
maLinePolyPolygon.Insert(aFrontLines);
|
|
maLinePolyPolygon.Insert(aInBetweenLines);
|
|
maLinePolyPolygon.Insert(aBackLines);
|
|
|
|
// #i28528#
|
|
sal_Bool bClosedLines((3600 == GetEndAngle()) && (100 == GetBackScale()));
|
|
PolyPolygon3D aNewPolyPoly = ImpCompleteLinePolygon(maLinePolyPolygon, aLathePoly3D.Count(), bClosedLines);
|
|
|
|
if(GetReducedLineGeometry())
|
|
{
|
|
// replace vertical with horizontal lines
|
|
maLinePolyPolygon = aNewPolyPoly;
|
|
|
|
// append front lines
|
|
maLinePolyPolygon.Insert(aFrontLines);
|
|
|
|
// append back lines
|
|
maLinePolyPolygon.Insert(aBackLines);
|
|
}
|
|
else
|
|
{
|
|
// append horizontal lines
|
|
maLinePolyPolygon.Insert(aNewPolyPoly);
|
|
}
|
|
|
|
ImpCorrectLinePolygon(maLinePolyPolygon, aLathePoly3D.Count());
|
|
|
|
// call parent
|
|
E3dCompoundObject::CreateGeometry();
|
|
}
|
|
|
|
PolyPolygon3D E3dLatheObj::CreateLathePolyPoly(PolyPolygon3D& rPolyPoly3D, long nVSegs)
|
|
{
|
|
PolyPolygon3D aLathePolyPolygon3D = rPolyPoly3D;
|
|
sal_uInt16 nCnt = aLathePolyPolygon3D.Count();
|
|
sal_uInt16 nOrigSegmentCnt = aPolyPoly3D[0].GetPointCount();
|
|
|
|
if(nOrigSegmentCnt && !aPolyPoly3D[0].IsClosed())
|
|
nOrigSegmentCnt -= 1;
|
|
|
|
if(nVSegs && nVSegs != nOrigSegmentCnt)
|
|
{
|
|
// make sure minimum is not too small, 3 edges for closed
|
|
// and 2 edges for open obects
|
|
sal_Int32 nMinVSegs = aPolyPoly3D[0].IsClosed() ? 3 : 2;
|
|
if(nVSegs <= nMinVSegs)
|
|
nVSegs = nMinVSegs;
|
|
|
|
if(nVSegs != nOrigSegmentCnt)
|
|
{
|
|
// Erstes Polygon anpassen
|
|
aLathePolyPolygon3D[0] = CreateLathePoly(aLathePolyPolygon3D[0], nVSegs);
|
|
|
|
GetProperties().SetObjectItemDirect(Svx3DVerticalSegmentsItem(nVSegs));
|
|
|
|
// andere Polygone im richtigen Verhaeltnis anpassen,
|
|
// aber nur, wenn Wert fuer erstes angepasst werden musste
|
|
for(UINT16 i = 1; i < nCnt; i++ )
|
|
{
|
|
Polygon3D &rPoly3D = aLathePolyPolygon3D[i];
|
|
sal_uInt16 nSegCnt(rPoly3D.GetPointCount());
|
|
if(nSegCnt && !rPoly3D.IsClosed())
|
|
nSegCnt -= 1;
|
|
long nNewVSegs = (nSegCnt * nVSegs) / nOrigSegmentCnt;
|
|
|
|
// make sure min is not too small for subpolys, too
|
|
if(nNewVSegs <= nMinVSegs)
|
|
nNewVSegs = nMinVSegs;
|
|
|
|
if(nNewVSegs && nNewVSegs != nSegCnt)
|
|
{
|
|
aLathePolyPolygon3D[i] = CreateLathePoly(aLathePolyPolygon3D[i], nNewVSegs);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return aLathePolyPolygon3D;
|
|
}
|
|
|
|
Polygon3D E3dLatheObj::CreateLathePoly(Polygon3D& rPoly3D, long nVSegs)
|
|
{
|
|
// attention: Here number of SEGMENTS is given, while GetExpandedPolygon()
|
|
// takes number of points. Calc PntNum first
|
|
long nNumPts = rPoly3D.IsClosed() ? nVSegs : nVSegs + 1;
|
|
if(nNumPts != rPoly3D.GetPointCount())
|
|
return rPoly3D.GetExpandedPolygon(nNumPts);
|
|
return rPoly3D;
|
|
}
|
|
|
|
/*************************************************************************
|
|
|*
|
|
|* Identifier zurueckgeben
|
|
|*
|
|
\************************************************************************/
|
|
|
|
UINT16 E3dLatheObj::GetObjIdentifier() const
|
|
{
|
|
return E3D_LATHEOBJ_ID;
|
|
}
|
|
|
|
/*************************************************************************
|
|
|*
|
|
|* Wireframe erzeugen
|
|
|*
|
|
\************************************************************************/
|
|
|
|
//BFS01void E3dLatheObj::CreateWireframe(Polygon3D& rWirePoly, const Matrix4D* pTf, E3dDragDetail eDetail)
|
|
//BFS01{
|
|
//BFS01 // Nur selbst erzeugen, wenn alle Linien angezeigt werden sollen
|
|
//BFS01 if ( eDetail == E3DDETAIL_ALLLINES ||
|
|
//BFS01 (eDetail == E3DDETAIL_DEFAULT && GetDragDetail() == E3DDETAIL_ALLLINES) )
|
|
//BFS01 {
|
|
//BFS01 // Detailliert erzeugen
|
|
//BFS01 }
|
|
//BFS01 else
|
|
//BFS01 {
|
|
//BFS01 // call parent
|
|
//BFS01 E3dObject::CreateWireframe(rWirePoly, pTf, eDetail);
|
|
//BFS01 }
|
|
//BFS01}
|
|
|
|
/*************************************************************************
|
|
|*
|
|
|* Zuweisungsoperator
|
|
|*
|
|
\************************************************************************/
|
|
|
|
void E3dLatheObj::operator=(const SdrObject& rObj)
|
|
{
|
|
// erstmal alle Childs kopieren
|
|
E3dCompoundObject::operator=(rObj);
|
|
|
|
// weitere Parameter kopieren
|
|
const E3dLatheObj& r3DObj = (const E3dLatheObj&)rObj;
|
|
|
|
aPolyPoly3D = r3DObj.aPolyPoly3D;
|
|
fLatheScale = r3DObj.fLatheScale;
|
|
|
|
// #95519# copy LinePolygon info, too
|
|
maLinePolyPolygon = r3DObj.maLinePolyPolygon;
|
|
|
|
// #107245# These properties are now items and are copied with the ItemSet
|
|
// // Ab Version 374 (15.12.97)
|
|
// bLatheSmoothed = r3DObj.bLatheSmoothed;
|
|
// bLatheSmoothFrontBack = r3DObj.bLatheSmoothFrontBack;
|
|
// bLatheCharacterMode = r3DObj.bLatheCharacterMode;
|
|
// bLatheCloseFront = r3DObj.bLatheCloseFront;
|
|
// bLatheCloseBack = r3DObj.bLatheCloseBack;
|
|
}
|
|
|
|
/*************************************************************************
|
|
|*
|
|
|* Objektdaten in Stream speichern
|
|
|*
|
|
\************************************************************************/
|
|
|
|
//BFS01void E3dLatheObj::WriteData(SvStream& rOut) const
|
|
//BFS01{
|
|
//BFS01#ifndef SVX_LIGHT
|
|
//BFS01 long nVersion = rOut.GetVersion(); // Build_Nr * 10 z.B. 3810
|
|
//BFS01 if(nVersion < 3800)
|
|
//BFS01 {
|
|
//BFS01 // Alte Geometrie erzeugen, um die E3dPolyObj's zu haben
|
|
//BFS01 ((E3dCompoundObject*)this)->ReCreateGeometry(TRUE);
|
|
//BFS01 }
|
|
//BFS01
|
|
//BFS01 // leider kann das E3dLatheObj nicht auf E3dObject abgestuetzt werden,
|
|
//BFS01 // da neue Member hinzugekommen sind und die Kompatibilitaet erhalten
|
|
//BFS01 // bleiben muss.
|
|
//BFS01 SdrAttrObj::WriteData(rOut);
|
|
//BFS01
|
|
//BFS01 // Fuer Abwaertskompatibilitaet (Lesen neuer Daten mit altem Code)
|
|
//BFS01 SdrDownCompat aCompat(rOut, STREAM_WRITE);
|
|
//BFS01#ifdef DBG_UTIL
|
|
//BFS01 aCompat.SetID("E3dLatheObj");
|
|
//BFS01#endif
|
|
//BFS01
|
|
//BFS01 pSub->Save(rOut);
|
|
//BFS01
|
|
//BFS01 // Parameter aus E3dObject speichern
|
|
//BFS01 rOut << aLocalBoundVol;
|
|
//BFS01 Old_Matrix3D aMat3D;
|
|
//BFS01 aMat3D = aTfMatrix;
|
|
//BFS01 rOut << aMat3D;
|
|
//BFS01 rOut << nLogicalGroup;
|
|
//BFS01 rOut << nObjTreeLevel;
|
|
//BFS01 rOut << nPartOfParent;
|
|
//BFS01 rOut << UINT16(eDragDetail);
|
|
//BFS01
|
|
//BFS01 // neue Member
|
|
//BFS01 // Alte version schreibt Polygon3D raus, neue Version
|
|
//BFS01 // benutzt dafuer das erste Teilpolygon von PolyPolygon3D
|
|
//BFS01 // rOut << aPolyPoly3D;
|
|
//BFS01 rOut << aPolyPoly3D[0];
|
|
//BFS01
|
|
//BFS01 rOut << GetHorizontalSegments();
|
|
//BFS01
|
|
//BFS01 rOut << GetEndAngle();
|
|
//BFS01
|
|
//BFS01 rOut << ((E3dLatheObj*)this)->GetDoubleSided();
|
|
//BFS01 rOut << fLatheScale;
|
|
//BFS01
|
|
//BFS01 // Ab Version 364f (19.06.97)
|
|
//BFS01
|
|
//BFS01 // #83965# internally the real number of segments (edges) is
|
|
//BFS01 // used, no longer the number of points
|
|
//BFS01 sal_Int32 nVSegs = GetVerticalSegments();
|
|
//BFS01 if(!aPolyPoly3D[0].IsClosed())
|
|
//BFS01 nVSegs += 1;
|
|
//BFS01
|
|
//BFS01 rOut << nVSegs;
|
|
//BFS01
|
|
//BFS01 // Ab Version 374 (15.12.97)
|
|
//BFS01 rOut << aPolyPoly3D;
|
|
//BFS01
|
|
//BFS01 rOut << ((double)GetBackScale() / 100.0);
|
|
//BFS01
|
|
//BFS01 rOut << ((double)GetPercentDiagonal() / 200.0);
|
|
//BFS01
|
|
//BFS01 rOut << GetSmoothNormals(); // #107245# (BOOL)bLatheSmoothed;
|
|
//BFS01 rOut << GetSmoothLids(); // #107245# (BOOL)bLatheSmoothFrontBack;
|
|
//BFS01 rOut << GetCharacterMode(); // #107245# (BOOL)bLatheCharacterMode;
|
|
//BFS01
|
|
//BFS01 // Ab Version 395 (8.6.98): Parameter aus dem Objekt
|
|
//BFS01 // E3dCompoundObject. Da irgendwann mal jemand die Ableitungs-
|
|
//BFS01 // hierarchie beim FileFormat unterbrochen hat, wurden diese Attribute
|
|
//BFS01 // bisher NOCH NIE gespeichert (Grrr). Diese Stelle muss nun natuerlich
|
|
//BFS01 // auch IMMER MITGEPFLEGT werden, wenn sich Parameter in
|
|
//BFS01 // E3dCompoundObject oder E3dObject aendern.
|
|
//BFS01 rOut << GetDoubleSided();
|
|
//BFS01
|
|
//BFS01 rOut << BOOL(bCreateNormals);
|
|
//BFS01 rOut << BOOL(bCreateTexture);
|
|
//BFS01
|
|
//BFS01 sal_uInt16 nVal = GetNormalsKind();
|
|
//BFS01 rOut << BOOL(nVal > 0);
|
|
//BFS01 rOut << BOOL(nVal > 1);
|
|
//BFS01
|
|
//BFS01 nVal = GetTextureProjectionX();
|
|
//BFS01 rOut << BOOL(nVal > 0);
|
|
//BFS01 rOut << BOOL(nVal > 1);
|
|
//BFS01
|
|
//BFS01 nVal = GetTextureProjectionY();
|
|
//BFS01 rOut << BOOL(nVal > 0);
|
|
//BFS01 rOut << BOOL(nVal > 1);
|
|
//BFS01
|
|
//BFS01 rOut << BOOL(GetShadow3D());
|
|
//BFS01
|
|
//BFS01 rOut << GetMaterialAmbientColor();
|
|
//BFS01 rOut << GetMaterialColor();
|
|
//BFS01 rOut << GetMaterialSpecular();
|
|
//BFS01 rOut << GetMaterialEmission();
|
|
//BFS01 rOut << GetMaterialSpecularIntensity();
|
|
//BFS01
|
|
//BFS01 aBackMaterial.WriteData(rOut);
|
|
//BFS01
|
|
//BFS01 rOut << (UINT16)GetTextureKind();
|
|
//BFS01
|
|
//BFS01 rOut << (UINT16)GetTextureMode();
|
|
//BFS01
|
|
//BFS01 rOut << BOOL(GetNormalsInvert());
|
|
//BFS01
|
|
//BFS01 // Ab Version 513a (5.2.99): Parameter fuer das
|
|
//BFS01 // Erzeugen der Vorder/Rueckwand
|
|
//BFS01 rOut << GetCloseFront(); // #107245# BOOL(bLatheCloseFront);
|
|
//BFS01 rOut << GetCloseBack(); // #107245# BOOL(bLatheCloseBack);
|
|
//BFS01
|
|
//BFS01 // neu ab 534: (hat noch gefehlt)
|
|
//BFS01 rOut << BOOL(GetTextureFilter());
|
|
//BFS01
|
|
//BFS01 if(nVersion < 3800)
|
|
//BFS01 {
|
|
//BFS01 // Geometrie neu erzeugen, um E3dPolyObj's wieder loszuwerden
|
|
//BFS01 ((E3dCompoundObject*)this)->ReCreateGeometry();
|
|
//BFS01 }
|
|
//BFS01#endif
|
|
//BFS01}
|
|
|
|
/*************************************************************************
|
|
|*
|
|
|* Objektdaten aus Stream laden
|
|
|*
|
|
\************************************************************************/
|
|
|
|
//BFS01void E3dLatheObj::ReadData(const SdrObjIOHeader& rHead, SvStream& rIn)
|
|
//BFS01{
|
|
//BFS01 if (ImpCheckSubRecords (rHead, rIn))
|
|
//BFS01 {
|
|
//BFS01 // leider kann das E3dLatheObj nicht auf E3dObject abgestuetzt werden,
|
|
//BFS01 // da neue Member hinzugekommen sind und die Kompatibilitaet erhalten
|
|
//BFS01 // bleiben muss.
|
|
//BFS01 SdrAttrObj::ReadData(rHead, rIn);
|
|
//BFS01
|
|
//BFS01 // Fuer Abwaertskompatibilitaet (Lesen neuer Daten mit altem Code)
|
|
//BFS01 SdrDownCompat aCompat(rIn, STREAM_READ);
|
|
//BFS01#ifdef DBG_UTIL
|
|
//BFS01 aCompat.SetID("E3dLatheObj");
|
|
//BFS01#endif
|
|
//BFS01 // dann die Member
|
|
//BFS01 UINT16 nTmp16;
|
|
//BFS01
|
|
//BFS01 // #106240# Flag if poly was loaded (all versions above 3.0 and 3.1)
|
|
//BFS01 sal_Bool bPolyWasRead(sal_False);
|
|
//BFS01
|
|
//BFS01 pSub->Load(rIn, *pPage);
|
|
//BFS01
|
|
//BFS01 // Parameter aus E3dObject laden
|
|
//BFS01 rIn >> aLocalBoundVol;
|
|
//BFS01 Old_Matrix3D aMat3D;
|
|
//BFS01 rIn >> aMat3D;
|
|
//BFS01 aTfMatrix = Matrix4D(aMat3D);
|
|
//BFS01 rIn >> nLogicalGroup;
|
|
//BFS01 rIn >> nObjTreeLevel;
|
|
//BFS01 rIn >> nPartOfParent;
|
|
//BFS01 rIn >> nTmp16; eDragDetail = E3dDragDetail(nTmp16);
|
|
//BFS01
|
|
//BFS01 // BoundVolume muss neu berechnet werden
|
|
//BFS01 bBoundVolValid = FALSE;
|
|
//BFS01
|
|
//BFS01 if (aCompat.GetBytesLeft ())
|
|
//BFS01 {
|
|
//BFS01 // neue Member
|
|
//BFS01 BOOL bTmp;
|
|
//BFS01 sal_Int32 nTmp;
|
|
//BFS01
|
|
//BFS01 // alte Version holt sich nur ein Polygon3D, wird hier durch
|
|
//BFS01 // Eintragen als erstes Teilpolygon geladen
|
|
//BFS01 // rIn >> aPolyPoly3D;
|
|
//BFS01 rIn >> aPolyPoly3D[0];
|
|
//BFS01
|
|
//BFS01 // #106240# OK, this file does have a saved polygon
|
|
//BFS01 bPolyWasRead = sal_True;
|
|
//BFS01
|
|
//BFS01 rIn >> nTmp;
|
|
//BFS01 GetProperties().SetObjectItemDirect(Svx3DHorizontalSegmentsItem(nTmp));
|
|
//BFS01
|
|
//BFS01 rIn >> nTmp;
|
|
//BFS01 GetProperties().SetObjectItemDirect(Svx3DEndAngleItem(nTmp));
|
|
//BFS01
|
|
//BFS01 rIn >> bTmp;
|
|
//BFS01 GetProperties().SetObjectItemDirect(Svx3DDoubleSidedItem(bTmp));
|
|
//BFS01
|
|
//BFS01 rIn >> fLatheScale;
|
|
//BFS01 }
|
|
//BFS01
|
|
//BFS01 // #106240# No PolyPolygon as base for the lathe object was saved.
|
|
//BFS01 // Reconstruct it from the objects in the SubList.
|
|
//BFS01 if(!bPolyWasRead)
|
|
//BFS01 {
|
|
//BFS01 // This is really a old 3.0 or 3.1 file, reconstruct
|
|
//BFS01 // the not saved polygon using the SubList.
|
|
//BFS01 SdrObjList* pSubList = GetSubList();
|
|
//BFS01
|
|
//BFS01 if(pSubList && pSubList->GetObjCount())
|
|
//BFS01 {
|
|
//BFS01 sal_uInt16 nHorSegCount = (sal_uInt16)GetHorizontalSegments() / 2;
|
|
//BFS01 sal_uInt16 nVerSegCount = (sal_uInt16)(pSubList->GetObjCount() / nHorSegCount);
|
|
//BFS01 Polygon3D aNewBasePoly;
|
|
//BFS01
|
|
//BFS01 for(sal_uInt16 a(0); a < nVerSegCount; a++)
|
|
//BFS01 {
|
|
//BFS01 E3dPolyObj* pCandidate = (E3dPolyObj*)pSubList->GetObj(a * nHorSegCount);
|
|
//BFS01 if(pCandidate->ISA(E3dPolyObj))
|
|
//BFS01 {
|
|
//BFS01 const PolyPolygon3D& rCandPoly = ((E3dPolyObj*)pCandidate)->GetPolyPolygon3D();
|
|
//BFS01
|
|
//BFS01 if(rCandPoly[0].GetPointCount() > 1)
|
|
//BFS01 {
|
|
//BFS01 aNewBasePoly[a] = rCandPoly[0][1];
|
|
//BFS01 }
|
|
//BFS01 }
|
|
//BFS01 }
|
|
//BFS01
|
|
//BFS01 aPolyPoly3D.Clear();
|
|
//BFS01 aNewBasePoly.SetClosed(sal_True);
|
|
//BFS01 aPolyPoly3D.Insert(aNewBasePoly);
|
|
//BFS01 }
|
|
//BFS01 }
|
|
//BFS01
|
|
//BFS01 if (aCompat.GetBytesLeft())
|
|
//BFS01 {
|
|
//BFS01 // Ab Version 364f (19.06.97)
|
|
//BFS01 sal_Int32 nTmp;
|
|
//BFS01 rIn >> nTmp;
|
|
//BFS01
|
|
//BFS01 // #83965# internally the real number of segments (edges) is
|
|
//BFS01 // used, no longer the number of points
|
|
//BFS01 if(!aPolyPoly3D[0].IsClosed())
|
|
//BFS01 nTmp -= 1;
|
|
//BFS01
|
|
//BFS01 GetProperties().SetObjectItemDirect(Svx3DVerticalSegmentsItem(nTmp));
|
|
//BFS01 }
|
|
//BFS01
|
|
//BFS01 if (aCompat.GetBytesLeft())
|
|
//BFS01 {
|
|
//BFS01 // Ab Version 374 (15.12.97)
|
|
//BFS01 // Gesamtes PolyPolygon laden
|
|
//BFS01 BOOL bTmp;
|
|
//BFS01 double fTmp;
|
|
//BFS01
|
|
//BFS01 aPolyPoly3D.Clear();
|
|
//BFS01 rIn >> aPolyPoly3D;
|
|
//BFS01
|
|
//BFS01 rIn >> fTmp;
|
|
//BFS01 GetProperties().SetObjectItemDirect(Svx3DBackscaleItem((sal_uInt16)(fTmp * 100.0)));
|
|
//BFS01
|
|
//BFS01 rIn >> fTmp;
|
|
//BFS01 GetProperties().SetObjectItemDirect(Svx3DPercentDiagonalItem(sal_uInt16(fTmp * 200.0)));
|
|
//BFS01
|
|
//BFS01 rIn >> bTmp; // #107245# bLatheSmoothed = bTmp;
|
|
//BFS01 GetProperties().SetObjectItemDirect(Svx3DSmoothNormalsItem(bTmp));
|
|
//BFS01
|
|
//BFS01 rIn >> bTmp; // #107245# bLatheSmoothFrontBack = bTmp;
|
|
//BFS01 GetProperties().SetObjectItemDirect(Svx3DSmoothLidsItem(bTmp));
|
|
//BFS01
|
|
//BFS01 rIn >> bTmp; // #107245# bLatheCharacterMode = bTmp;
|
|
//BFS01 GetProperties().SetObjectItemDirect(Svx3DCharacterModeItem(bTmp));
|
|
//BFS01 }
|
|
//BFS01 else
|
|
//BFS01 {
|
|
//BFS01 // Geometrie aus erzeugten PolyObj's rekonstruieren
|
|
//BFS01 GetProperties().SetObjectItemDirect(Svx3DBackscaleItem(100));
|
|
//BFS01 GetProperties().SetObjectItemDirect(Svx3DPercentDiagonalItem(10));
|
|
//BFS01
|
|
//BFS01 // #107245# bLatheSmoothed = TRUE;
|
|
//BFS01 GetProperties().SetObjectItemDirect(Svx3DSmoothNormalsItem(sal_True));
|
|
//BFS01
|
|
//BFS01 // #107245# bLatheSmoothFrontBack = FALSE;
|
|
//BFS01 GetProperties().SetObjectItemDirect(Svx3DSmoothLidsItem(sal_False));
|
|
//BFS01
|
|
//BFS01 // #107245# bLatheCharacterMode = FALSE;
|
|
//BFS01 GetProperties().SetObjectItemDirect(Svx3DCharacterModeItem(sal_False));
|
|
//BFS01 }
|
|
//BFS01
|
|
//BFS01 if (aCompat.GetBytesLeft())
|
|
//BFS01 {
|
|
//BFS01 // Ab Version 395 (8.6.98): Parameter aus dem Objekt
|
|
//BFS01 // E3dCompoundObject. Da irgendwann mal jemand die Ableitungs-
|
|
//BFS01 // hierarchie beim FileFormat unterbrochen hat, wurden diese Attribute
|
|
//BFS01 // bisher NOCH NIE gespeichert (Grrr). Diese Stelle muss nun natuerlich
|
|
//BFS01 // auch IMMER MITGEPFLEGT werden, wenn sich Parameter in
|
|
//BFS01 // E3dCompoundObject oder E3dObject aendern.
|
|
//BFS01 BOOL bTmp, bTmp2;
|
|
//BFS01 sal_uInt16 nTmp;
|
|
//BFS01
|
|
//BFS01 rIn >> bTmp;
|
|
//BFS01 GetProperties().SetObjectItemDirect(Svx3DDoubleSidedItem(bTmp));
|
|
//BFS01
|
|
//BFS01 rIn >> bTmp; bCreateNormals = bTmp;
|
|
//BFS01 rIn >> bTmp; bCreateTexture = bTmp;
|
|
//BFS01
|
|
//BFS01 rIn >> bTmp;
|
|
//BFS01 rIn >> bTmp2;
|
|
//BFS01 if(bTmp == FALSE && bTmp2 == FALSE)
|
|
//BFS01 nTmp = 0;
|
|
//BFS01 else if(bTmp == TRUE && bTmp2 == FALSE)
|
|
//BFS01 nTmp = 1;
|
|
//BFS01 else
|
|
//BFS01 nTmp = 2;
|
|
//BFS01 GetProperties().SetObjectItemDirect(Svx3DNormalsKindItem(nTmp));
|
|
//BFS01
|
|
//BFS01 rIn >> bTmp;
|
|
//BFS01 rIn >> bTmp2;
|
|
//BFS01 if(bTmp == FALSE && bTmp2 == FALSE)
|
|
//BFS01 nTmp = 0;
|
|
//BFS01 else if(bTmp == TRUE && bTmp2 == FALSE)
|
|
//BFS01 nTmp = 1;
|
|
//BFS01 else
|
|
//BFS01 nTmp = 2;
|
|
//BFS01 GetProperties().SetObjectItemDirect(Svx3DTextureProjectionXItem(nTmp));
|
|
//BFS01
|
|
//BFS01 rIn >> bTmp;
|
|
//BFS01 rIn >> bTmp2;
|
|
//BFS01 if(bTmp == FALSE && bTmp2 == FALSE)
|
|
//BFS01 nTmp = 0;
|
|
//BFS01 else if(bTmp == TRUE && bTmp2 == FALSE)
|
|
//BFS01 nTmp = 1;
|
|
//BFS01 else
|
|
//BFS01 nTmp = 2;
|
|
//BFS01 GetProperties().SetObjectItemDirect(Svx3DTextureProjectionYItem(nTmp));
|
|
//BFS01
|
|
//BFS01 rIn >> bTmp;
|
|
//BFS01 GetProperties().SetObjectItemDirect(Svx3DShadow3DItem(bTmp));
|
|
//BFS01
|
|
//BFS01 Color aCol;
|
|
//BFS01
|
|
//BFS01 rIn >> aCol;
|
|
//BFS01 SetMaterialAmbientColor(aCol);
|
|
//BFS01
|
|
//BFS01 rIn >> aCol;
|
|
//BFS01 // do NOT use, this is the old 3D-Color(!)
|
|
//BFS01 // SetItem(XFillColorItem(String(), aCol));
|
|
//BFS01
|
|
//BFS01 rIn >> aCol;
|
|
//BFS01 GetProperties().SetObjectItemDirect(Svx3DMaterialSpecularItem(aCol));
|
|
//BFS01
|
|
//BFS01 rIn >> aCol;
|
|
//BFS01 GetProperties().SetObjectItemDirect(Svx3DMaterialEmissionItem(aCol));
|
|
//BFS01
|
|
//BFS01 rIn >> nTmp;
|
|
//BFS01 GetProperties().SetObjectItemDirect(Svx3DMaterialSpecularIntensityItem(nTmp));
|
|
//BFS01
|
|
//BFS01 aBackMaterial.ReadData(rIn);
|
|
//BFS01
|
|
//BFS01 rIn >> nTmp;
|
|
//BFS01 GetProperties().SetObjectItemDirect(Svx3DTextureKindItem(nTmp));
|
|
//BFS01
|
|
//BFS01 rIn >> nTmp;
|
|
//BFS01 GetProperties().SetObjectItemDirect(Svx3DTextureModeItem(nTmp));
|
|
//BFS01
|
|
//BFS01 rIn >> bTmp;
|
|
//BFS01 GetProperties().SetObjectItemDirect(Svx3DNormalsInvertItem(bTmp));
|
|
//BFS01 }
|
|
//BFS01
|
|
//BFS01 if (aCompat.GetBytesLeft())
|
|
//BFS01 {
|
|
//BFS01 // Ab Version 513a (5.2.99): Parameter fuer das
|
|
//BFS01 // Erzeugen der Vorder/Rueckwand
|
|
//BFS01 BOOL bTmp;
|
|
//BFS01
|
|
//BFS01 rIn >> bTmp; // #107245# bLatheCloseFront = bTmp;
|
|
//BFS01 GetProperties().SetObjectItemDirect(Svx3DCloseFrontItem(bTmp));
|
|
//BFS01
|
|
//BFS01 rIn >> bTmp; // #107245# bLatheCloseBack = bTmp;
|
|
//BFS01 GetProperties().SetObjectItemDirect(Svx3DCloseBackItem(bTmp));
|
|
//BFS01 }
|
|
//BFS01 else
|
|
//BFS01 {
|
|
//BFS01 // #107245# bLatheCloseFront = TRUE;
|
|
//BFS01 GetProperties().SetObjectItemDirect(Svx3DCloseFrontItem(sal_True));
|
|
//BFS01
|
|
//BFS01 // #107245# bLatheCloseBack = TRUE;
|
|
//BFS01 GetProperties().SetObjectItemDirect(Svx3DCloseBackItem(sal_True));
|
|
//BFS01 }
|
|
//BFS01
|
|
//BFS01 // neu ab 534: (hat noch gefehlt)
|
|
//BFS01 if (aCompat.GetBytesLeft () >= sizeof (BOOL))
|
|
//BFS01 {
|
|
//BFS01 BOOL bTmp;
|
|
//BFS01 rIn >> bTmp;
|
|
//BFS01 GetProperties().SetObjectItemDirect(Svx3DTextureFilterItem(bTmp));
|
|
//BFS01 }
|
|
//BFS01 }
|
|
//BFS01
|
|
//BFS01 // correct position of extrude polygon, in case it's not positioned
|
|
//BFS01 // at the Z==0 layer
|
|
//BFS01 if(aPolyPoly3D.Count() && aPolyPoly3D[0].GetPointCount())
|
|
//BFS01 {
|
|
//BFS01 const Vector3D& rFirstPoint = aPolyPoly3D[0][0];
|
|
//BFS01 if(rFirstPoint.Z() != 0.0)
|
|
//BFS01 {
|
|
//BFS01 // change transformation so that source poly lies in Z == 0,
|
|
//BFS01 // so it can be exported as 2D polygon
|
|
//BFS01 //
|
|
//BFS01 // ATTENTION: the translation has to be multiplied from LEFT
|
|
//BFS01 // SIDE since it was executed as the first translate for this
|
|
//BFS01 // 3D object during it's creation.
|
|
//BFS01 double fTransDepth(rFirstPoint.Z());
|
|
//BFS01 Matrix4D aTransMat;
|
|
//BFS01 aTransMat.TranslateZ(fTransDepth);
|
|
//BFS01 NbcSetTransform(GetTransform() * aTransMat); // #112587#
|
|
//BFS01
|
|
//BFS01 // correct polygon itself
|
|
//BFS01 aTransMat.Identity();
|
|
//BFS01 aTransMat.TranslateZ(-fTransDepth);
|
|
//BFS01 aPolyPoly3D.Transform(aTransMat);
|
|
//BFS01 }
|
|
//BFS01 }
|
|
//BFS01
|
|
//BFS01 // Geometrie neu erzeugen
|
|
//BFS01 ReCreateGeometry();
|
|
//BFS01}
|
|
|
|
/*************************************************************************
|
|
|*
|
|
|* Wandle das Objekt in ein Gruppenobjekt bestehend aus n Polygonen
|
|
|*
|
|
\************************************************************************/
|
|
|
|
SdrObject *E3dLatheObj::DoConvertToPolyObj(BOOL bBezier) const
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
/*************************************************************************
|
|
|*
|
|
|* Neue Segmentierung (Beschreibung siehe Header-File)
|
|
|*
|
|
\************************************************************************/
|
|
|
|
void E3dLatheObj::ReSegment(long nHSegs, long nVSegs)
|
|
{
|
|
if ((nHSegs != GetHorizontalSegments() || nVSegs != GetVerticalSegments()) &&
|
|
(nHSegs != 0 || nVSegs != 0))
|
|
{
|
|
GetProperties().SetObjectItemDirect(Svx3DHorizontalSegmentsItem(nHSegs));
|
|
GetProperties().SetObjectItemDirect(Svx3DVerticalSegmentsItem(nVSegs));
|
|
|
|
bGeometryValid = FALSE;
|
|
}
|
|
}
|
|
|
|
/*************************************************************************
|
|
|*
|
|
|* Lokale Parameter setzen mit Geometrieneuerzeugung
|
|
|*
|
|
\************************************************************************/
|
|
|
|
void E3dLatheObj::SetPolyPoly3D(const PolyPolygon3D& rNew)
|
|
{
|
|
if(aPolyPoly3D != rNew)
|
|
{
|
|
aPolyPoly3D = rNew;
|
|
|
|
// #83965# take care of vertical segments, too.
|
|
sal_Int32 nNumVSegs = aPolyPoly3D[0].GetPointCount();
|
|
if(!aPolyPoly3D[0].IsClosed())
|
|
nNumVSegs -= 1;
|
|
|
|
GetProperties().SetObjectItemDirect(Svx3DVerticalSegmentsItem(nNumVSegs));
|
|
|
|
bGeometryValid = FALSE;
|
|
}
|
|
}
|
|
|
|
void E3dLatheObj::SetLatheScale(double fNew)
|
|
{
|
|
if(fLatheScale != fNew)
|
|
{
|
|
fLatheScale = fNew;
|
|
bGeometryValid = FALSE;
|
|
}
|
|
}
|
|
|
|
/*************************************************************************
|
|
|*
|
|
|* Get the name of the object (singular)
|
|
|*
|
|
\************************************************************************/
|
|
|
|
void E3dLatheObj::TakeObjNameSingul(XubString& rName) const
|
|
{
|
|
rName=ImpGetResStr(STR_ObjNameSingulLathe3d);
|
|
|
|
String aName( GetName() );
|
|
if(aName.Len())
|
|
{
|
|
rName += sal_Unicode(' ');
|
|
rName += sal_Unicode('\'');
|
|
rName += aName;
|
|
rName += sal_Unicode('\'');
|
|
}
|
|
}
|
|
|
|
/*************************************************************************
|
|
|*
|
|
|* Get the name of the object (plural)
|
|
|*
|
|
\************************************************************************/
|
|
|
|
void E3dLatheObj::TakeObjNamePlural(XubString& rName) const
|
|
{
|
|
rName=ImpGetResStr(STR_ObjNamePluralLathe3d);
|
|
}
|
|
|
|
/*************************************************************************
|
|
|*
|
|
|* Aufbrechen
|
|
|*
|
|
\************************************************************************/
|
|
|
|
BOOL E3dLatheObj::IsBreakObjPossible()
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
SdrAttrObj* E3dLatheObj::GetBreakObj()
|
|
{
|
|
// create PathObj
|
|
PolyPolygon3D aTransPoly = TransformToScreenCoor(GetPolyPolygon());
|
|
XPolyPolygon aPoly(aTransPoly.GetXPolyPolygon());
|
|
SdrPathObj* pPathObj = new SdrPathObj(OBJ_PLIN, aPoly);
|
|
|
|
if(pPathObj)
|
|
{
|
|
// set position ans size
|
|
Rectangle aNewPosSize(aPoly.GetBoundRect());
|
|
pPathObj->SetSnapRect(aNewPosSize);
|
|
|
|
// Objekt ggf. schliessen
|
|
BOOL bDistSmallerTen = FALSE;
|
|
for(UINT16 nCnt=0;nCnt<pPathObj->GetPathPoly().Count();nCnt++)
|
|
if(((XPolygon)(pPathObj->GetPathPoly()[0])).CalcDistance(0, pPathObj->GetPathPoly()[0].GetPointCount()-1) < 10)
|
|
bDistSmallerTen = TRUE;
|
|
if (!pPathObj->IsClosed() && bDistSmallerTen)
|
|
pPathObj->ToggleClosed(0);
|
|
|
|
// Attribute setzen
|
|
SfxItemSet aSet(GetObjectItemSet());
|
|
|
|
// Linien aktivieren, um Objekt garantiert sichtbar zu machen
|
|
aSet.Put(XLineStyleItem (XLINE_SOLID));
|
|
|
|
pPathObj->SetMergedItemSet(aSet);
|
|
}
|
|
|
|
return pPathObj;
|
|
}
|
|
|
|
// eof
|