kindred/create
1
1
Fork 0
Code Issues 37 Pull Requests Actions Packages Projects 9 Releases 2 Wiki Activity

Sketcher: App - Clang-format

Browse Source
This commit is contained in:
Abdullah Tahiri
2023-05-18 19:01:34 +02:00
committed by abdullahtahiriyo
parent c33cdcd68a
commit 987b4bda2a
40 changed files with 9714 additions and 7322 deletions
Download Patch File Download Diff File Expand all files Collapse all files

193
src/Mod/Sketcher/App/GeometryFacadePyImp.cpp
View File

@@ -24,14 +24,15 @@
#include <Base/GeometryPyCXX.h>
#include <Base/MatrixPy.h>
#include <Base/PlacementPy.h>
#include <Base/Vector3D.h>
#include <Base/VectorPy.h>
#include <Base/PlacementPy.h>
#include <Mod/Part/App/GeometryExtensionPy.h>
#include <Mod/Part/App/GeometryPy.h>
#include <Mod/Part/App/OCCError.h>
#include "GeometryFacadePy.h"
#include "GeometryFacadePy.cpp"
@@ -47,7 +48,7 @@ std::string GeometryFacadePy::representation() const
return str.str();
}
PyObject *GeometryFacadePy::PyMake(struct _typeobject *, PyObject *, PyObject *) // Python wrapper
PyObject* GeometryFacadePy::PyMake(struct _typeobject*, PyObject*, PyObject*)// Python wrapper
{
// create a new instance of PointPy and the Twin object
return new GeometryFacadePy(new GeometryFacade());
@@ -56,18 +57,18 @@ PyObject *GeometryFacadePy::PyMake(struct _typeobject *, PyObject *, PyObject *)
// constructor method
int GeometryFacadePy::PyInit(PyObject* args, PyObject* /*kwd*/)
{
PyObject *object;
if (PyArg_ParseTuple(args,"O!",&(Part::GeometryPy::Type), &object)) {
Part::Geometry * geo = static_cast<Part::GeometryPy *>(object)->getGeometryPtr();
PyObject* object;
if (PyArg_ParseTuple(args, "O!", &(Part::GeometryPy::Type), &object)) {
Part::Geometry* geo = static_cast<Part::GeometryPy*>(object)->getGeometryPtr();
getGeometryFacadePtr()->setGeometry(geo->clone());
return 0;
}
PyErr_SetString(PyExc_TypeError, "Sketcher::GeometryFacade constructor accepts:\n"
"-- Part.Geometry\n"
);
PyErr_SetString(PyExc_TypeError,
"Sketcher::GeometryFacade constructor accepts:\n"
"-- Part.Geometry\n");
return -1;
}
@@ -85,12 +86,12 @@ Py::String GeometryFacadePy::getInternalType() const
{
int internaltypeindex = (int)this->getGeometryFacadePtr()->getInternalType();
if(internaltypeindex >= InternalType::NumInternalGeometryType)
if (internaltypeindex >= InternalType::NumInternalGeometryType)
throw Py::NotImplementedError("String name of enum not implemented");
std::string typestr = SketchGeometryExtension::internaltype2str[internaltypeindex];
return Py::String(typestr);
return Py::String(typestr);
}
void GeometryFacadePy::setInternalType(Py::String arg)
@@ -98,7 +99,7 @@ void GeometryFacadePy::setInternalType(Py::String arg)
std::string argstr = arg;
InternalType::InternalType type;
if(SketchGeometryExtension::getInternalTypeFromName(argstr, type)) {
if (SketchGeometryExtension::getInternalTypeFromName(argstr, type)) {
this->getGeometryFacadePtr()->setInternalType(type);
return;
}
@@ -116,14 +117,14 @@ void GeometryFacadePy::setBlocked(Py::Boolean arg)
getGeometryFacadePtr()->setBlocked(arg);
}
PyObject* GeometryFacadePy::testGeometryMode(PyObject *args)
PyObject* GeometryFacadePy::testGeometryMode(PyObject* args)
{
char* flag;
if (PyArg_ParseTuple(args, "s",&flag)) {
if (PyArg_ParseTuple(args, "s", &flag)) {
GeometryMode::GeometryMode mode;
if(SketchGeometryExtension::getGeometryModeFromName(flag, mode))
if (SketchGeometryExtension::getGeometryModeFromName(flag, mode))
return new_reference_to(Py::Boolean(getGeometryFacadePtr()->testGeometryMode(mode)));
PyErr_SetString(PyExc_TypeError, "Flag string does not exist.");
@@ -134,15 +135,15 @@ PyObject* GeometryFacadePy::testGeometryMode(PyObject *args)
return nullptr;
}
PyObject* GeometryFacadePy::setGeometryMode(PyObject *args)
PyObject* GeometryFacadePy::setGeometryMode(PyObject* args)
{
char * flag;
PyObject * bflag = Py_True;
char* flag;
PyObject* bflag = Py_True;
if (PyArg_ParseTuple(args, "s|O!", &flag, &PyBool_Type, &bflag)) {
GeometryMode::GeometryMode mode;
if(SketchGeometryExtension::getGeometryModeFromName(flag, mode)) {
if (SketchGeometryExtension::getGeometryModeFromName(flag, mode)) {
getGeometryFacadePtr()->setGeometryMode(mode, Base::asBoolean(bflag));
Py_Return;
}
@@ -156,10 +157,10 @@ PyObject* GeometryFacadePy::setGeometryMode(PyObject *args)
}
PyObject* GeometryFacadePy::mirror(PyObject *args)
PyObject* GeometryFacadePy::mirror(PyObject* args)
{
PyObject* o;
if (PyArg_ParseTuple(args, "O!", &(Base::VectorPy::Type),&o)) {
if (PyArg_ParseTuple(args, "O!", &(Base::VectorPy::Type), &o)) {
Base::Vector3d vec = static_cast<Base::VectorPy*>(o)->value();
getGeometryFacadePtr()->mirror(vec);
Py_Return;
@@ -167,22 +168,23 @@ PyObject* GeometryFacadePy::mirror(PyObject *args)
PyErr_Clear();
PyObject* axis;
if (PyArg_ParseTuple(args, "O!O!", &(Base::VectorPy::Type),&o,
&(Base::VectorPy::Type),&axis)) {
if (PyArg_ParseTuple(
args, "O!O!", &(Base::VectorPy::Type), &o, &(Base::VectorPy::Type), &axis)) {
Base::Vector3d pnt = static_cast<Base::VectorPy*>(o)->value();
Base::Vector3d dir = static_cast<Base::VectorPy*>(axis)->value();
getGeometryFacadePtr()->mirror(pnt, dir);
Py_Return;
}
PyErr_SetString(Part::PartExceptionOCCError, "either a point (vector) or axis (vector, vector) must be given");
PyErr_SetString(Part::PartExceptionOCCError,
"either a point (vector) or axis (vector, vector) must be given");
return nullptr;
}
PyObject* GeometryFacadePy::rotate(PyObject *args)
PyObject* GeometryFacadePy::rotate(PyObject* args)
{
PyObject* o;
if (!PyArg_ParseTuple(args, "O!", &(Base::PlacementPy::Type),&o))
if (!PyArg_ParseTuple(args, "O!", &(Base::PlacementPy::Type), &o))
return nullptr;
Base::Placement* plm = static_cast<Base::PlacementPy*>(o)->getPlacementPtr();
@@ -190,19 +192,19 @@ PyObject* GeometryFacadePy::rotate(PyObject *args)
Py_Return;
}
PyObject* GeometryFacadePy::scale(PyObject *args)
PyObject* GeometryFacadePy::scale(PyObject* args)
{
PyObject* o;
double scale;
Base::Vector3d vec;
if (PyArg_ParseTuple(args, "O!d", &(Base::VectorPy::Type),&o, &scale)) {
if (PyArg_ParseTuple(args, "O!d", &(Base::VectorPy::Type), &o, &scale)) {
vec = static_cast<Base::VectorPy*>(o)->value();
getGeometryFacadePtr()->scale(vec, scale);
Py_Return;
}
PyErr_Clear();
if (PyArg_ParseTuple(args, "O!d", &PyTuple_Type,&o, &scale)) {
if (PyArg_ParseTuple(args, "O!d", &PyTuple_Type, &o, &scale)) {
vec = Base::getVectorFromTuple<double>(o);
getGeometryFacadePtr()->scale(vec, scale);
Py_Return;
@@ -212,28 +214,28 @@ PyObject* GeometryFacadePy::scale(PyObject *args)
return nullptr;
}
PyObject* GeometryFacadePy::transform(PyObject *args)
PyObject* GeometryFacadePy::transform(PyObject* args)
{
PyObject* o;
if (!PyArg_ParseTuple(args, "O!", &(Base::MatrixPy::Type),&o))
if (!PyArg_ParseTuple(args, "O!", &(Base::MatrixPy::Type), &o))
return nullptr;
Base::Matrix4D mat = static_cast<Base::MatrixPy*>(o)->value();
getGeometryFacadePtr()->transform(mat);
Py_Return;
}
PyObject* GeometryFacadePy::translate(PyObject *args)
PyObject* GeometryFacadePy::translate(PyObject* args)
{
PyObject* o;
Base::Vector3d vec;
if (PyArg_ParseTuple(args, "O!", &(Base::VectorPy::Type),&o)) {
if (PyArg_ParseTuple(args, "O!", &(Base::VectorPy::Type), &o)) {
vec = static_cast<Base::VectorPy*>(o)->value();
getGeometryFacadePtr()->translate(vec);
Py_Return;
}
PyErr_Clear();
if (PyArg_ParseTuple(args, "O!", &PyTuple_Type,&o)) {
if (PyArg_ParseTuple(args, "O!", &PyTuple_Type, &o)) {
vec = Base::getVectorFromTuple<double>(o);
getGeometryFacadePtr()->translate(vec);
Py_Return;
@@ -243,12 +245,12 @@ PyObject* GeometryFacadePy::translate(PyObject *args)
return nullptr;
}
PyObject* GeometryFacadePy::setExtension(PyObject *args)
PyObject* GeometryFacadePy::setExtension(PyObject* args)
{
PyObject* o;
if (PyArg_ParseTuple(args, "O!", &(Part::GeometryExtensionPy::Type),&o)) {
Part::GeometryExtension * ext;
ext = static_cast<Part::GeometryExtensionPy *>(o)->getGeometryExtensionPtr();
if (PyArg_ParseTuple(args, "O!", &(Part::GeometryExtensionPy::Type), &o)) {
Part::GeometryExtension* ext;
ext = static_cast<Part::GeometryExtensionPy*>(o)->getGeometryExtensionPtr();
// make copy of Python managed memory and wrap it in smart pointer
auto cpy = ext->copy();
@@ -261,153 +263,159 @@ PyObject* GeometryFacadePy::setExtension(PyObject *args)
return nullptr;
}
PyObject* GeometryFacadePy::getExtensionOfType(PyObject *args)
PyObject* GeometryFacadePy::getExtensionOfType(PyObject* args)
{
char* o;
if (PyArg_ParseTuple(args, "s", &o)) {
Base::Type type = Base::Type::fromName(o);
if(type != Base::Type::badType()) {
if (type != Base::Type::badType()) {
try {
std::shared_ptr<const Part::GeometryExtension> ext(this->getGeometryFacadePtr()->getExtension(type));
std::shared_ptr<const Part::GeometryExtension> ext(
this->getGeometryFacadePtr()->getExtension(type));
// we create a copy and transfer this copy's memory management responsibility to Python
// we create a copy and transfer this copy's memory management responsibility to
// Python
PyObject* cpy = ext->copyPyObject();
return cpy;
}
catch(const Base::ValueError& e) {
catch (const Base::ValueError& e) {
PyErr_SetString(Part::PartExceptionOCCError, e.what());
return nullptr;
}
catch(const std::bad_weak_ptr&) {
PyErr_SetString(Part::PartExceptionOCCError, "Geometry extension does not exist anymore.");
catch (const std::bad_weak_ptr&) {
PyErr_SetString(Part::PartExceptionOCCError,
"Geometry extension does not exist anymore.");
return nullptr;
}
catch(Base::NotImplementedError&) {
PyErr_SetString(Part::PartExceptionOCCError, "Geometry extension does not implement a Python counterpart.");
catch (Base::NotImplementedError&) {
PyErr_SetString(Part::PartExceptionOCCError,
"Geometry extension does not implement a Python counterpart.");
return nullptr;
}
}
else
{
else {
PyErr_SetString(Part::PartExceptionOCCError, "Exception type does not exist");
return nullptr;
}
}
PyErr_SetString(Part::PartExceptionOCCError, "A string with the name of the geometry extension type was expected");
PyErr_SetString(Part::PartExceptionOCCError,
"A string with the name of the geometry extension type was expected");
return nullptr;
}
PyObject* GeometryFacadePy::getExtensionOfName(PyObject *args)
PyObject* GeometryFacadePy::getExtensionOfName(PyObject* args)
{
char* o;
if (PyArg_ParseTuple(args, "s", &o)) {
try {
std::shared_ptr<const Part::GeometryExtension> ext(this->getGeometryFacadePtr()->getExtension(std::string(o)));
std::shared_ptr<const Part::GeometryExtension> ext(
this->getGeometryFacadePtr()->getExtension(std::string(o)));
// we create a copy and transfer this copy's memory management responsibility to Python
PyObject* cpy = ext->copyPyObject();
return cpy;
}
catch(const Base::ValueError& e) {
catch (const Base::ValueError& e) {
PyErr_SetString(Part::PartExceptionOCCError, e.what());
return nullptr;
}
catch(const std::bad_weak_ptr&) {
PyErr_SetString(Part::PartExceptionOCCError, "Geometry extension does not exist anymore.");
catch (const std::bad_weak_ptr&) {
PyErr_SetString(Part::PartExceptionOCCError,
"Geometry extension does not exist anymore.");
return nullptr;
}
catch(Base::NotImplementedError&) {
PyErr_SetString(Part::PartExceptionOCCError, "Geometry extension does not implement a Python counterpart.");
catch (Base::NotImplementedError&) {
PyErr_SetString(Part::PartExceptionOCCError,
"Geometry extension does not implement a Python counterpart.");
return nullptr;
}
}
PyErr_SetString(Part::PartExceptionOCCError, "A string with the name of the geometry extension was expected");
PyErr_SetString(Part::PartExceptionOCCError,
"A string with the name of the geometry extension was expected");
return nullptr;
}
PyObject* GeometryFacadePy::hasExtensionOfType(PyObject *args)
PyObject* GeometryFacadePy::hasExtensionOfType(PyObject* args)
{
char* o;
if (PyArg_ParseTuple(args, "s", &o)) {
Base::Type type = Base::Type::fromName(o);
if(type != Base::Type::badType()) {
if (type != Base::Type::badType()) {
try {
return Py::new_reference_to(Py::Boolean(this->getGeometryFacadePtr()->hasExtension(type)));
return Py::new_reference_to(
Py::Boolean(this->getGeometryFacadePtr()->hasExtension(type)));
}
catch(const Base::ValueError& e) {
catch (const Base::ValueError& e) {
PyErr_SetString(Part::PartExceptionOCCError, e.what());
return nullptr;
}
}
else
{
else {
PyErr_SetString(Part::PartExceptionOCCError, "Exception type does not exist");
return nullptr;
}
}
PyErr_SetString(Part::PartExceptionOCCError, "A string with the type of the geometry extension was expected");
PyErr_SetString(Part::PartExceptionOCCError,
"A string with the type of the geometry extension was expected");
return nullptr;
}
PyObject* GeometryFacadePy::hasExtensionOfName(PyObject *args)
PyObject* GeometryFacadePy::hasExtensionOfName(PyObject* args)
{
char* o;
if (PyArg_ParseTuple(args, "s", &o)) {
try {
return Py::new_reference_to(Py::Boolean(this->getGeometryFacadePtr()->hasExtension(std::string(o))));
return Py::new_reference_to(
Py::Boolean(this->getGeometryFacadePtr()->hasExtension(std::string(o))));
}
catch(const Base::ValueError& e) {
catch (const Base::ValueError& e) {
PyErr_SetString(Part::PartExceptionOCCError, e.what());
return nullptr;
}
}
PyErr_SetString(Part::PartExceptionOCCError, "A string with the type of the geometry extension was expected");
PyErr_SetString(Part::PartExceptionOCCError,
"A string with the type of the geometry extension was expected");
return nullptr;
}
PyObject* GeometryFacadePy::deleteExtensionOfType(PyObject *args)
PyObject* GeometryFacadePy::deleteExtensionOfType(PyObject* args)
{
char* o;
if (PyArg_ParseTuple(args, "s", &o)) {
Base::Type type = Base::Type::fromName(o);
if(type != Base::Type::badType()) {
if (type != Base::Type::badType()) {
try {
this->getGeometryFacadePtr()->deleteExtension(type);
Py_Return;
}
catch(const Base::ValueError& e) {
catch (const Base::ValueError& e) {
PyErr_SetString(Part::PartExceptionOCCError, e.what());
return nullptr;
}
}
else
{
else {
PyErr_SetString(Part::PartExceptionOCCError, "Type does not exist");
return nullptr;
}
}
PyErr_SetString(Part::PartExceptionOCCError, "A string with a type object was expected");
return nullptr;
}
PyObject* GeometryFacadePy::deleteExtensionOfName(PyObject *args)
PyObject* GeometryFacadePy::deleteExtensionOfName(PyObject* args)
{
char* o;
if (PyArg_ParseTuple(args, "s", &o)) {
@@ -416,38 +424,40 @@ PyObject* GeometryFacadePy::deleteExtensionOfName(PyObject *args)
this->getGeometryFacadePtr()->deleteExtension(std::string(o));
Py_Return;
}
catch(const Base::ValueError& e) {
catch (const Base::ValueError& e) {
PyErr_SetString(Part::PartExceptionOCCError, e.what());
return nullptr;
}
}
PyErr_SetString(Part::PartExceptionOCCError, "A string with the name of the extension was expected");
PyErr_SetString(Part::PartExceptionOCCError,
"A string with the name of the extension was expected");
return nullptr;
}
PyObject* GeometryFacadePy::getExtensions(PyObject *args)
PyObject* GeometryFacadePy::getExtensions(PyObject* args)
{
if (!PyArg_ParseTuple(args, "")){
if (!PyArg_ParseTuple(args, "")) {
PyErr_SetString(Part::PartExceptionOCCError, "No arguments were expected");
return nullptr;
}
try {
const std::vector<std::weak_ptr<const Part::GeometryExtension>> ext = this->getGeometryFacadePtr()->getExtensions();
const std::vector<std::weak_ptr<const Part::GeometryExtension>> ext =
this->getGeometryFacadePtr()->getExtensions();
Py::List list;
for (std::size_t i=0; i<ext.size(); ++i) {
for (std::size_t i = 0; i < ext.size(); ++i) {
std::shared_ptr<const Part::GeometryExtension> p = ext[i].lock();
if(p) {
if (p) {
// we create a python copy and add it to the list
try {
list.append(Py::asObject(p->copyPyObject()));
}
catch(Base::NotImplementedError&) {
catch (Base::NotImplementedError&) {
// silently ignoring extensions not having a Python object
}
}
@@ -455,11 +465,10 @@ PyObject* GeometryFacadePy::getExtensions(PyObject *args)
return Py::new_reference_to(list);
}
catch(const Base::ValueError& e) {
catch (const Base::ValueError& e) {
PyErr_SetString(Part::PartExceptionOCCError, e.what());
return nullptr;
}
}
Py::Boolean GeometryFacadePy::getConstruction() const
@@ -467,7 +476,7 @@ Py::Boolean GeometryFacadePy::getConstruction() const
return Py::Boolean(getGeometryFacadePtr()->getConstruction());
}
void GeometryFacadePy::setConstruction(Py::Boolean arg)
void GeometryFacadePy::setConstruction(Py::Boolean arg)
{
getGeometryFacadePtr()->setConstruction(arg);
}
@@ -495,17 +504,17 @@ Py::Object GeometryFacadePy::getGeometry() const
return Py::Object(geo->getPyObject(), true);
}
void GeometryFacadePy::setGeometry(Py::Object arg)
void GeometryFacadePy::setGeometry(Py::Object arg)
{
if (PyObject_TypeCheck(arg.ptr(), &(Part::GeometryPy::Type))) {
Part::GeometryPy * gp = static_cast<Part::GeometryPy *>(arg.ptr());
Part::GeometryPy* gp = static_cast<Part::GeometryPy*>(arg.ptr());
getGeometryFacadePtr()->setGeometry(gp->getGeometryPtr()->clone());
}
}
PyObject *GeometryFacadePy::getCustomAttributes(const char* /*attr*/) const
PyObject* GeometryFacadePy::getCustomAttributes(const char* /*attr*/) const
{
return nullptr;
}