1
/***************************************************************************
2
* Copyright (c) Jļæ½rgen Riegel (juergen.riegel@web.de) 2002 *
4
* This file is part of the FreeCAD CAx development system. *
6
* This library is free software; you can redistribute it and/or *
7
* modify it under the terms of the GNU Library General Public *
8
* License as published by the Free Software Foundation; either *
9
* version 2 of the License, or (at your option) any later version. *
11
* This library is distributed in the hope that it will be useful, *
12
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
13
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
14
* GNU Library General Public License for more details. *
16
* You should have received a copy of the GNU Library General Public *
17
* License along with this library; see the file COPYING.LIB. If not, *
18
* write to the Free Software Foundation, Inc., 59 Temple Place, *
19
* Suite 330, Boston, MA 02111-1307, USA *
21
***************************************************************************/
24
#include "PreCompiled.h"
30
/// Here the FreeCAD includes sorted by Base,App,Gui......
32
#include <Base/Exception.h>
33
#include <Base/Writer.h>
34
#include <Base/Reader.h>
35
#include <Base/Stream.h>
36
#include <Base/Rotation.h>
37
#include <Base/VectorPy.h>
38
#include <Base/MatrixPy.h>
39
#include <Base/PlacementPy.h>
41
#include "Placement.h"
43
#include "PropertyGeo.h"
52
//**************************************************************************
53
//**************************************************************************
55
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
57
TYPESYSTEM_SOURCE(App::PropertyVector , App::Property);
59
//**************************************************************************
60
// Construction/Destruction
63
PropertyVector::PropertyVector()
69
PropertyVector::~PropertyVector()
74
//**************************************************************************
75
// Base class implementer
78
void PropertyVector::setValue(const Base::Vector3f &vec)
85
void PropertyVector::setValue(float x, float y, float z)
88
_cVec=Vector3f(x,y,z);
92
const Base::Vector3f & PropertyVector::getValue(void)const
97
PyObject *PropertyVector::getPyObject(void)
99
return new Base::VectorPy(_cVec);
102
void PropertyVector::setPyObject(PyObject *value)
104
if (PyObject_TypeCheck(value, &(Base::VectorPy::Type))) {
105
Base::VectorPy *pcObject = static_cast<Base::VectorPy*>(value);
106
Base::Vector3d* val = pcObject->getVectorPtr();
107
Base::Vector3f vec((float)val->x,(float)val->y,(float)val->z);
110
else if (PyTuple_Check(value)&&PyTuple_Size(value)==3) {
114
item = PyTuple_GetItem(value,0);
115
if (PyFloat_Check(item))
116
cVec.x = (float)PyFloat_AsDouble(item);
117
else if (PyInt_Check(item))
118
cVec.x = (float)PyInt_AsLong(item);
120
throw Base::Exception("Not allowed type used in tuple (float expected)...");
122
item = PyTuple_GetItem(value,1);
123
if (PyFloat_Check(item))
124
cVec.y = (float)PyFloat_AsDouble(item);
125
else if (PyInt_Check(item))
126
cVec.y = (float)PyInt_AsLong(item);
128
throw Base::Exception("Not allowed type used in tuple (float expected)...");
130
item = PyTuple_GetItem(value,2);
131
if (PyFloat_Check(item))
132
cVec.z = (float)PyFloat_AsDouble(item);
133
else if (PyInt_Check(item))
134
cVec.z = (float)PyInt_AsLong(item);
136
throw Base::Exception("Not allowed type used in tuple (float expected)...");
140
std::string error = std::string("type must be 'Vector' or tuple of three floats, not ");
141
error += value->ob_type->tp_name;
142
throw Py::TypeError(error);
146
void PropertyVector::Save (Writer &writer) const
148
writer.Stream() << writer.ind() << "<PropertyVector valueX=\"" << _cVec.x << "\" valueY=\"" << _cVec.y << "\" valueZ=\"" << _cVec.z <<"\"/>" << endl;
151
void PropertyVector::Restore(Base::XMLReader &reader)
154
reader.readElement("PropertyVector");
155
// get the value of my Attribute
157
_cVec.x = (float)reader.getAttributeAsFloat("valueX");
158
_cVec.y = (float)reader.getAttributeAsFloat("valueY");
159
_cVec.z = (float)reader.getAttributeAsFloat("valueZ");
164
Property *PropertyVector::Copy(void) const
166
PropertyVector *p= new PropertyVector();
171
void PropertyVector::Paste(const Property &from)
174
_cVec = dynamic_cast<const PropertyVector&>(from)._cVec;
179
//**************************************************************************
180
// PropertyVectorList
181
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
183
TYPESYSTEM_SOURCE(App::PropertyVectorList , App::PropertyLists);
185
//**************************************************************************
186
// Construction/Destruction
188
PropertyVectorList::PropertyVectorList()
193
PropertyVectorList::~PropertyVectorList()
198
//**************************************************************************
199
// Base class implementer
201
void PropertyVectorList::setValue(const Base::Vector3f& lValue)
204
_lValueList.resize(1);
205
_lValueList[0]=lValue;
209
void PropertyVectorList::setValue(float x, float y, float z)
212
_lValueList.resize(1);
213
_lValueList[0].Set(x,y,z);
217
void PropertyVectorList::setValues(const std::vector<Base::Vector3f>& values)
220
_lValueList = values;
224
PyObject *PropertyVectorList::getPyObject(void)
226
PyObject* list = PyList_New( getSize() );
228
for (int i = 0;i<getSize(); i++)
229
PyList_SetItem( list, i, new VectorPy( _lValueList[i]));
234
void PropertyVectorList::setPyObject(PyObject *value)
236
if (PyList_Check(value)) {
237
Py_ssize_t nSize = PyList_Size(value);
238
std::vector<Base::Vector3f> values;
239
values.resize(nSize);
241
for (Py_ssize_t i=0; i<nSize;++i) {
242
PyObject* item = PyList_GetItem(value, i);
244
val.setPyObject( item );
245
values[i] = val.getValue();
250
else if (PyObject_TypeCheck(value, &(VectorPy::Type))) {
251
Base::VectorPy *pcObject = static_cast<Base::VectorPy*>(value);
252
Base::Vector3d* val = pcObject->getVectorPtr();
253
Base::Vector3f vec((float)val->x,(float)val->y,(float)val->z);
256
else if (PyTuple_Check(value) && PyTuple_Size(value) == 3) {
258
val.setPyObject( value );
259
setValue( val.getValue() );
262
std::string error = std::string("type must be 'Vector' or list of 'Vector', not ");
263
error += value->ob_type->tp_name;
264
throw Py::TypeError(error);
268
void PropertyVectorList::Save (Writer &writer) const
270
if (!writer.isForceXML()) {
271
writer.Stream() << writer.ind() << "<VectorList file=\"" << writer.addFile(getName(), this) << "\"/>" << std::endl;
275
void PropertyVectorList::Restore(Base::XMLReader &reader)
277
reader.readElement("VectorList");
278
std::string file (reader.getAttribute("file") );
281
// initate a file read
282
reader.addFile(file.c_str(),this);
286
void PropertyVectorList::SaveDocFile (Base::Writer &writer) const
288
Base::OutputStream str(writer.Stream());
289
uint32_t uCt = (uint32_t)getSize();
291
for (std::vector<Base::Vector3f>::const_iterator it = _lValueList.begin(); it != _lValueList.end(); ++it) {
292
str << it->x << it->y << it->z;
296
void PropertyVectorList::RestoreDocFile(Base::Reader &reader)
298
Base::InputStream str(reader);
301
std::vector<Base::Vector3f> values(uCt);
302
for (std::vector<Base::Vector3f>::iterator it = values.begin(); it != values.end(); ++it) {
303
str >> it->x >> it->y >> it->z;
308
Property *PropertyVectorList::Copy(void) const
310
PropertyVectorList *p= new PropertyVectorList();
311
p->_lValueList = _lValueList;
315
void PropertyVectorList::Paste(const Property &from)
318
_lValueList = dynamic_cast<const PropertyVectorList&>(from)._lValueList;
322
//**************************************************************************
323
//**************************************************************************
325
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
327
TYPESYSTEM_SOURCE(App::PropertyMatrix , App::Property);
329
//**************************************************************************
330
// Construction/Destruction
333
PropertyMatrix::PropertyMatrix()
339
PropertyMatrix::~PropertyMatrix()
344
//**************************************************************************
345
// Base class implementer
348
void PropertyMatrix::setValue(const Base::Matrix4D &mat)
356
const Base::Matrix4D & PropertyMatrix::getValue(void)const
361
PyObject *PropertyMatrix::getPyObject(void)
363
return new Base::MatrixPy(_cMat);
366
void PropertyMatrix::setPyObject(PyObject *value)
368
if (PyObject_TypeCheck(value, &(Base::MatrixPy::Type))) {
369
Base::MatrixPy *pcObject = (Base::MatrixPy*)value;
370
setValue( pcObject->value() );
372
else if (PyTuple_Check(value)&&PyTuple_Size(value)==16) {
374
Base::Matrix4D cMatrix;
376
for (int x=0; x<4;x++) {
377
for (int y=0; y<4;y++) {
378
item = PyTuple_GetItem(value,x+y*4);
379
if (PyFloat_Check(item))
380
cMatrix[x][y] = PyFloat_AsDouble(item);
381
else if (PyInt_Check(item))
382
cMatrix[x][y] = (double)PyInt_AsLong(item);
384
throw Base::Exception("Not allowed type used in matrix tuple (a number expected)...");
391
std::string error = std::string("type must be 'Matrix' or tuple of 16 float or int, not ");
392
error += value->ob_type->tp_name;
393
throw Py::TypeError(error);
397
void PropertyMatrix::Save (Base::Writer &writer) const
399
writer.Stream() << writer.ind() << "<PropertyMatrix";
400
writer.Stream() << " a11=\"" << _cMat[0][0] << "\" a12=\"" << _cMat[0][1] << "\" a13=\"" << _cMat[0][2] << "\" a14=\"" << _cMat[0][3] << "\"";
401
writer.Stream() << " a21=\"" << _cMat[1][0] << "\" a22=\"" << _cMat[1][1] << "\" a23=\"" << _cMat[1][2] << "\" a24=\"" << _cMat[1][3] << "\"";
402
writer.Stream() << " a31=\"" << _cMat[2][0] << "\" a32=\"" << _cMat[2][1] << "\" a33=\"" << _cMat[2][2] << "\" a34=\"" << _cMat[2][3] << "\"";
403
writer.Stream() << " a41=\"" << _cMat[3][0] << "\" a42=\"" << _cMat[3][1] << "\" a43=\"" << _cMat[3][2] << "\" a44=\"" << _cMat[3][3] << "\"";
404
writer.Stream() <<"/>" << endl;
407
void PropertyMatrix::Restore(Base::XMLReader &reader)
410
reader.readElement("PropertyMatrix");
411
// get the value of my Attribute
413
_cMat[0][0] = (float)reader.getAttributeAsFloat("a11");
414
_cMat[0][1] = (float)reader.getAttributeAsFloat("a12");
415
_cMat[0][2] = (float)reader.getAttributeAsFloat("a13");
416
_cMat[0][3] = (float)reader.getAttributeAsFloat("a14");
418
_cMat[1][0] = (float)reader.getAttributeAsFloat("a21");
419
_cMat[1][1] = (float)reader.getAttributeAsFloat("a22");
420
_cMat[1][2] = (float)reader.getAttributeAsFloat("a23");
421
_cMat[1][3] = (float)reader.getAttributeAsFloat("a24");
423
_cMat[2][0] = (float)reader.getAttributeAsFloat("a31");
424
_cMat[2][1] = (float)reader.getAttributeAsFloat("a32");
425
_cMat[2][2] = (float)reader.getAttributeAsFloat("a33");
426
_cMat[2][3] = (float)reader.getAttributeAsFloat("a34");
428
_cMat[3][0] = (float)reader.getAttributeAsFloat("a41");
429
_cMat[3][1] = (float)reader.getAttributeAsFloat("a42");
430
_cMat[3][2] = (float)reader.getAttributeAsFloat("a43");
431
_cMat[3][3] = (float)reader.getAttributeAsFloat("a44");
436
Property *PropertyMatrix::Copy(void) const
438
PropertyMatrix *p= new PropertyMatrix();
443
void PropertyMatrix::Paste(const Property &from)
446
_cMat = dynamic_cast<const PropertyMatrix&>(from)._cMat;
450
//**************************************************************************
451
//**************************************************************************
453
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
455
TYPESYSTEM_SOURCE(App::PropertyPlacement , App::Property);
457
//**************************************************************************
458
// Construction/Destruction
461
PropertyPlacement::PropertyPlacement()
467
PropertyPlacement::~PropertyPlacement()
472
//**************************************************************************
473
// Base class implementer
476
void PropertyPlacement::setValue(const Base::Placement &pos)
483
const Base::Placement & PropertyPlacement::getValue(void)const
488
PyObject *PropertyPlacement::getPyObject(void)
490
Base::Matrix4D mat = _cPos.toMatrix();
491
return new Base::MatrixPy(mat);
494
void PropertyPlacement::setPyObject(PyObject *value)
496
if (PyObject_TypeCheck(value, &(Base::MatrixPy::Type))) {
497
Base::MatrixPy *pcObject = (Base::MatrixPy*)value;
498
Base::Matrix4D mat = pcObject->value();
503
else if (PyObject_TypeCheck(value, &(Base::PlacementPy::Type))) {
504
setValue(*static_cast<Base::PlacementPy*>(value)->getPlacementPtr());
507
std::string error = std::string("type must be 'Matrix' or 'Placement', not ");
508
error += value->ob_type->tp_name;
509
throw Py::TypeError(error);
513
void PropertyPlacement::Save (Base::Writer &writer) const
515
writer.Stream() << writer.ind() << "<PropertyPlacement";
516
writer.Stream() << " Px=\"" << _cPos._pos.x << "\" Py=\"" << _cPos._pos.y << "\" Pz=\"" << _cPos._pos.z << "\"";
517
writer.Stream() << " Q0=\"" << _cPos._rot.getValue()[0] << "\" Q1=\"" << _cPos._rot.getValue()[1] << "\" Q2=\"" << _cPos._rot.getValue()[2] << "\" Q3=\"" << _cPos._rot.getValue()[3] << "\"";
518
writer.Stream() <<"/>" << endl;
521
void PropertyPlacement::Restore(Base::XMLReader &reader)
524
reader.readElement("PropertyPlacement");
525
// get the value of my Attribute
527
_cPos._pos.x = reader.getAttributeAsFloat("Px");
528
_cPos._pos.y = reader.getAttributeAsFloat("Py");
529
_cPos._pos.z = reader.getAttributeAsFloat("Pz");
531
_cPos._rot.setValue(reader.getAttributeAsFloat("Q0"),
532
reader.getAttributeAsFloat("Q1"),
533
reader.getAttributeAsFloat("Q2"),
534
reader.getAttributeAsFloat("Q3"));
539
Property *PropertyPlacement::Copy(void) const
541
PropertyPlacement *p= new PropertyPlacement();
546
void PropertyPlacement::Paste(const Property &from)
549
_cPos = dynamic_cast<const PropertyPlacement&>(from)._cPos;
553
//**************************************************************************
554
//**************************************************************************
556
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
558
TYPESYSTEM_SOURCE(App::PropertyPlacementLink , App::PropertyLink);
560
//**************************************************************************
561
// Construction/Destruction
564
PropertyPlacementLink::PropertyPlacementLink()
570
PropertyPlacementLink::~PropertyPlacementLink()
575
App::Placement * PropertyPlacementLink::getPlacementObject(void) const
577
if (_pcLink->getTypeId().isDerivedFrom(App::Placement::getClassTypeId()))
578
return dynamic_cast<App::Placement*>(_pcLink);
584
//**************************************************************************
585
// Base class implementer
587
Property *PropertyPlacementLink::Copy(void) const
589
PropertyPlacementLink *p= new PropertyPlacementLink();
590
p->_pcLink = _pcLink;
594
void PropertyPlacementLink::Paste(const Property &from)
597
_pcLink = dynamic_cast<const PropertyPlacementLink&>(from)._pcLink;
601
// ------------------------------------------------------------
603
TYPESYSTEM_SOURCE_ABSTRACT(App::PropertyComplexGeoData , App::Property);
605
PropertyComplexGeoData::PropertyComplexGeoData()
610
PropertyComplexGeoData::~PropertyComplexGeoData()