00001
00002
00003
00004
00005
00006 #include <boost/filesystem/path.hpp>
00007 #include <boost/filesystem/operations.hpp>
00008 #include <boost/filesystem/exception.hpp>
00009 #include <Base/PyObjectBase.h>
00010 #include <Base/Console.h>
00011 #include <Base/Exception.h>
00012 #include <CXX/Objects.hxx>
00013
00014 #define new DEBUG_CLIENTBLOCK
00015
00016 using Base::streq;
00017 using namespace Sketcher;
00018
00020 PyTypeObject ConstraintPy::Type = {
00021 PyObject_HEAD_INIT(&PyType_Type)
00022 0,
00023 "Sketcher.Constraint",
00024 sizeof(ConstraintPy),
00025 0,
00026
00027 PyDestructor,
00028 0,
00029 __getattr,
00030 __setattr,
00031 0,
00032 __repr,
00033 0,
00034 0,
00035 0,
00036 0,
00037 0,
00038 0,
00039 0,
00040 0,
00041
00042 0,
00043
00044 Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_CLASS,
00045 "With this objects you can handle sketches",
00046 0,
00047 0,
00048 0,
00049 0,
00050 0,
00051 0,
00052 Sketcher::ConstraintPy::Methods,
00053 0,
00054 Sketcher::ConstraintPy::GetterSetter,
00055 &Base::PersistencePy::Type,
00056 0,
00057 0,
00058 0,
00059 0,
00060 __PyInit,
00061 0,
00062 Sketcher::ConstraintPy::PyMake,
00063 0,
00064 0,
00065 0,
00066 0,
00067 0,
00068 0,
00069 0,
00070 0
00071 };
00072
00074 PyMethodDef ConstraintPy::Methods[] = {
00075 {NULL, NULL, 0, NULL}
00076 };
00077
00078
00079
00081 PyGetSetDef ConstraintPy::GetterSetter[] = {
00082 {"First",
00083 (getter) staticCallback_getFirst,
00084 (setter) staticCallback_setFirst,
00085 "First geometry index the Constraint referse to",
00086 NULL
00087 },
00088 {"Second",
00089 (getter) staticCallback_getSecond,
00090 (setter) staticCallback_setSecond,
00091 "Second geometry index the Constraint referse to",
00092 NULL
00093 },
00094 {NULL, NULL, NULL, NULL, NULL}
00095 };
00096
00097
00098
00099
00100 PyObject * ConstraintPy::staticCallback_getFirst (PyObject *self, void * )
00101 {
00102 if (!((PyObjectBase*) self)->isValid()){
00103 PyErr_SetString(PyExc_ReferenceError, "This object is already deleted most likely through closing a document. This reference is no longer valid!");
00104 return NULL;
00105 }
00106
00107 try {
00108 return Py::new_reference_to(((ConstraintPy*)self)->getFirst());
00109 } catch (const Py::Exception&) {
00110
00111 return NULL;
00112 } catch (...) {
00113 PyErr_SetString(PyExc_Exception, "Unknown exception while reading attribute 'First' of object 'Constraint'");
00114 return NULL;
00115 }
00116 }
00117
00118 int ConstraintPy::staticCallback_setFirst (PyObject *self, PyObject *value, void * )
00119 {
00120 if (!((PyObjectBase*) self)->isValid()){
00121 PyErr_SetString(PyExc_ReferenceError, "This object is already deleted most likely through closing a document. This reference is no longer valid!");
00122 return -1;
00123 }
00124 if (((PyObjectBase*) self)->isConst()){
00125 PyErr_SetString(PyExc_ReferenceError, "This object is immutable, you can not set any attribute or call a method");
00126 return -1;
00127 }
00128
00129 try {
00130 ((ConstraintPy*)self)->setFirst(Py::Int(value,false));
00131 return 0;
00132 } catch (const Py::Exception&) {
00133
00134 return -1;
00135 } catch (...) {
00136 PyErr_SetString(PyExc_Exception, "Unknown exception while writing attribute 'First' of object 'Constraint'");
00137 return -1;
00138 }
00139 }
00140
00141
00142
00143
00144 PyObject * ConstraintPy::staticCallback_getSecond (PyObject *self, void * )
00145 {
00146 if (!((PyObjectBase*) self)->isValid()){
00147 PyErr_SetString(PyExc_ReferenceError, "This object is already deleted most likely through closing a document. This reference is no longer valid!");
00148 return NULL;
00149 }
00150
00151 try {
00152 return Py::new_reference_to(((ConstraintPy*)self)->getSecond());
00153 } catch (const Py::Exception&) {
00154
00155 return NULL;
00156 } catch (...) {
00157 PyErr_SetString(PyExc_Exception, "Unknown exception while reading attribute 'Second' of object 'Constraint'");
00158 return NULL;
00159 }
00160 }
00161
00162 int ConstraintPy::staticCallback_setSecond (PyObject *self, PyObject *value, void * )
00163 {
00164 if (!((PyObjectBase*) self)->isValid()){
00165 PyErr_SetString(PyExc_ReferenceError, "This object is already deleted most likely through closing a document. This reference is no longer valid!");
00166 return -1;
00167 }
00168 if (((PyObjectBase*) self)->isConst()){
00169 PyErr_SetString(PyExc_ReferenceError, "This object is immutable, you can not set any attribute or call a method");
00170 return -1;
00171 }
00172
00173 try {
00174 ((ConstraintPy*)self)->setSecond(Py::Int(value,false));
00175 return 0;
00176 } catch (const Py::Exception&) {
00177
00178 return -1;
00179 } catch (...) {
00180 PyErr_SetString(PyExc_Exception, "Unknown exception while writing attribute 'Second' of object 'Constraint'");
00181 return -1;
00182 }
00183 }
00184
00185
00186
00187
00188
00189
00190 PyParentObject ConstraintPy::Parents[] = { PARENTSSketcherConstraintPy };
00191
00192
00193
00194
00195 ConstraintPy::ConstraintPy(Constraint *pcObject, PyTypeObject *T)
00196 : PersistencePy(reinterpret_cast<PersistencePy::PointerType>(pcObject), T)
00197 {
00198 }
00199
00200
00201
00202
00203
00204 ConstraintPy::~ConstraintPy()
00205 {
00206 }
00207
00208
00209
00210
00211 PyObject *ConstraintPy::_repr(void)
00212 {
00213 return Py_BuildValue("s", representation().c_str());
00214 }
00215
00216
00217
00218
00219 PyObject *ConstraintPy::_getattr(char *attr)
00220 {
00221 try {
00222
00223 PyObject *r = getCustomAttributes(attr);
00224 if(r) return r;
00225 }
00226 #ifndef DONT_CATCH_CXX_EXCEPTIONS
00227 catch(const Base::Exception& e)
00228 {
00229 std::string str;
00230 str += "FreeCAD exception thrown (";
00231 str += e.what();
00232 str += ")";
00233 e.ReportException();
00234 PyErr_SetString(PyExc_Exception,str.c_str());
00235 return NULL;
00236 }
00237 catch(const std::exception& e)
00238 {
00239 std::string str;
00240 str += "FC++ exception thrown (";
00241 str += e.what();
00242 str += ")";
00243 Base::Console().Error(str.c_str());
00244 PyErr_SetString(PyExc_Exception,str.c_str());
00245 return NULL;
00246 }
00247 catch(const Py::Exception&)
00248 {
00249
00250 return NULL;
00251 }
00252 catch(...)
00253 {
00254 PyErr_SetString(PyExc_Exception,"Unknown C++ exception");
00255 return NULL;
00256 }
00257 #else // DONT_CATCH_CXX_EXCEPTIONS
00258 catch(const Base::Exception& e)
00259 {
00260 std::string str;
00261 str += "FreeCAD exception thrown (";
00262 str += e.what();
00263 str += ")";
00264 e.ReportException();
00265 PyErr_SetString(PyExc_Exception,str.c_str());
00266 return NULL;
00267 }
00268 catch(const Py::Exception&)
00269 {
00270
00271 return NULL;
00272 }
00273 #endif // DONT_CATCH_CXX_EXCEPTIONS
00274
00275 PyObject *rvalue = Py_FindMethod(Methods, this, attr);
00276 if (rvalue == NULL)
00277 {
00278 PyErr_Clear();
00279 return PersistencePy::_getattr(attr);
00280 }
00281 else
00282 {
00283 return rvalue;
00284 }
00285 }
00286
00287 int ConstraintPy::_setattr(char *attr, PyObject *value)
00288 {
00289 try {
00290
00291 int r = setCustomAttributes(attr, value);
00292 if(r==1) return 0;
00293 }
00294 #ifndef DONT_CATCH_CXX_EXCEPTIONS
00295 catch(const Base::Exception& e)
00296 {
00297 std::string str;
00298 str += "FreeCAD exception thrown (";
00299 str += e.what();
00300 str += ")";
00301 e.ReportException();
00302 PyErr_SetString(PyExc_Exception,str.c_str());
00303 return -1;
00304 }
00305 catch(const std::exception& e)
00306 {
00307 std::string str;
00308 str += "FC++ exception thrown (";
00309 str += e.what();
00310 str += ")";
00311 Base::Console().Error(str.c_str());
00312 PyErr_SetString(PyExc_Exception,str.c_str());
00313 return -1;
00314 }
00315 catch(const Py::Exception&)
00316 {
00317
00318 return -1;
00319 }
00320 catch(...)
00321 {
00322 PyErr_SetString(PyExc_Exception,"Unknown C++ exception");
00323 return -1;
00324 }
00325 #else // DONT_CATCH_CXX_EXCEPTIONS
00326 catch(const Base::Exception& e)
00327 {
00328 std::string str;
00329 str += "FreeCAD exception thrown (";
00330 str += e.what();
00331 str += ")";
00332 e.ReportException();
00333 PyErr_SetString(PyExc_Exception,str.c_str());
00334 return -1;
00335 }
00336 catch(const Py::Exception&)
00337 {
00338
00339 return -1;
00340 }
00341 #endif // DONT_CATCH_CXX_EXCEPTIONS
00342
00343 return PersistencePy::_setattr(attr, value);
00344 }
00345
00346 Constraint *ConstraintPy::getConstraintPtr(void) const
00347 {
00348 return static_cast<Constraint *>(_pcTwinPointer);
00349 }
00350
00351 #if 0
00352
00353
00354
00355
00356 PyObject *ConstraintPy::PyMake(struct _typeobject *, PyObject *, PyObject *)
00357 {
00358
00359 return new ConstraintPy(new Constraint);
00360 }
00361
00362
00363 int ConstraintPy::PyInit(PyObject* , PyObject* )
00364 {
00365 return 0;
00366 }
00367
00368
00369 std::string ConstraintPy::representation(void) const
00370 {
00371 return std::string("<Constraint object>");
00372 }
00373
00374
00375
00376 Py::Int ConstraintPy::getFirst(void) const
00377 {
00378
00379 throw Py::AttributeError("Not yet implemented");
00380 }
00381
00382 void ConstraintPy::setFirst(Py::Int arg)
00383 {
00384 throw Py::AttributeError("Not yet implemented");
00385 }
00386
00387 Py::Int ConstraintPy::getSecond(void) const
00388 {
00389
00390 throw Py::AttributeError("Not yet implemented");
00391 }
00392
00393 void ConstraintPy::setSecond(Py::Int arg)
00394 {
00395 throw Py::AttributeError("Not yet implemented");
00396 }
00397
00398 PyObject *ConstraintPy::getCustomAttributes(const char* attr) const
00399 {
00400 return 0;
00401 }
00402
00403 int ConstraintPy::setCustomAttributes(const char* attr, PyObject *obj)
00404 {
00405 return 0;
00406 }
00407 #endif
00408
00409
00410