packages feed

opencascade-hs (empty) → 0.0.0.1

raw patch · 160 files changed

+7223/−0 lines, 160 filesdep +basedep +resourcet

Dependencies added: base, resourcet

Files

+ CHANGELOG.md view
@@ -0,0 +1,11 @@+# Changelog for `opencascade-hs`++All notable changes to this project will be documented in this file.++The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),+and this project adheres to the+[Haskell Package Versioning Policy](https://pvp.haskell.org/).++## Unreleased++## 0.0.0.1 - YYYY-MM-DD
+ LICENSE view
@@ -0,0 +1,502 @@+		  GNU LESSER GENERAL PUBLIC LICENSE+		       Version 2.1, February 1999++ Copyright (C) 1991, 1999 Free Software Foundation, Inc.+ 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA+ Everyone is permitted to copy and distribute verbatim copies+ of this license document, but changing it is not allowed.++[This is the first released version of the Lesser GPL.  It also counts+ as the successor of the GNU Library Public License, version 2, hence+ the version number 2.1.]++			    Preamble++  The licenses for most software are designed to take away your+freedom to share and change it.  By contrast, the GNU General Public+Licenses are intended to guarantee your freedom to share and change+free software--to make sure the software is free for all its users.++  This license, the Lesser General Public License, applies to some+specially designated software packages--typically libraries--of the+Free Software Foundation and other authors who decide to use it.  You+can use it too, but we suggest you first think carefully about whether+this license or the ordinary General Public License is the better+strategy to use in any particular case, based on the explanations below.++  When we speak of free software, we are referring to freedom of use,+not price.  Our General Public Licenses are designed to make sure that+you have the freedom to distribute copies of free software (and charge+for this service if you wish); that you receive source code or can get+it if you want it; that you can change the software and use pieces of+it in new free programs; and that you are informed that you can do+these things.++  To protect your rights, we need to make restrictions that forbid+distributors to deny you these rights or to ask you to surrender these+rights.  These restrictions translate to certain responsibilities for+you if you distribute copies of the library or if you modify it.++  For example, if you distribute copies of the library, whether gratis+or for a fee, you must give the recipients all the rights that we gave+you.  You must make sure that they, too, receive or can get the source+code.  If you link other code with the library, you must provide+complete object files to the recipients, so that they can relink them+with the library after making changes to the library and recompiling+it.  And you must show them these terms so they know their rights.++  We protect your rights with a two-step method: (1) we copyright the+library, and (2) we offer you this license, which gives you legal+permission to copy, distribute and/or modify the library.++  To protect each distributor, we want to make it very clear that+there is no warranty for the free library.  Also, if the library is+modified by someone else and passed on, the recipients should know+that what they have is not the original version, so that the original+author's reputation will not be affected by problems that might be+introduced by others.++  Finally, software patents pose a constant threat to the existence of+any free program.  We wish to make sure that a company cannot+effectively restrict the users of a free program by obtaining a+restrictive license from a patent holder.  Therefore, we insist that+any patent license obtained for a version of the library must be+consistent with the full freedom of use specified in this license.++  Most GNU software, including some libraries, is covered by the+ordinary GNU General Public License.  This license, the GNU Lesser+General Public License, applies to certain designated libraries, and+is quite different from the ordinary General Public License.  We use+this license for certain libraries in order to permit linking those+libraries into non-free programs.++  When a program is linked with a library, whether statically or using+a shared library, the combination of the two is legally speaking a+combined work, a derivative of the original library.  The ordinary+General Public License therefore permits such linking only if the+entire combination fits its criteria of freedom.  The Lesser General+Public License permits more lax criteria for linking other code with+the library.++  We call this license the "Lesser" General Public License because it+does Less to protect the user's freedom than the ordinary General+Public License.  It also provides other free software developers Less+of an advantage over competing non-free programs.  These disadvantages+are the reason we use the ordinary General Public License for many+libraries.  However, the Lesser license provides advantages in certain+special circumstances.++  For example, on rare occasions, there may be a special need to+encourage the widest possible use of a certain library, so that it becomes+a de-facto standard.  To achieve this, non-free programs must be+allowed to use the library.  A more frequent case is that a free+library does the same job as widely used non-free libraries.  In this+case, there is little to gain by limiting the free library to free+software only, so we use the Lesser General Public License.++  In other cases, permission to use a particular library in non-free+programs enables a greater number of people to use a large body of+free software.  For example, permission to use the GNU C Library in+non-free programs enables many more people to use the whole GNU+operating system, as well as its variant, the GNU/Linux operating+system.++  Although the Lesser General Public License is Less protective of the+users' freedom, it does ensure that the user of a program that is+linked with the Library has the freedom and the wherewithal to run+that program using a modified version of the Library.++  The precise terms and conditions for copying, distribution and+modification follow.  Pay close attention to the difference between a+"work based on the library" and a "work that uses the library".  The+former contains code derived from the library, whereas the latter must+be combined with the library in order to run.++		  GNU LESSER GENERAL PUBLIC LICENSE+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION++  0. This License Agreement applies to any software library or other+program which contains a notice placed by the copyright holder or+other authorized party saying it may be distributed under the terms of+this Lesser General Public License (also called "this License").+Each licensee is addressed as "you".++  A "library" means a collection of software functions and/or data+prepared so as to be conveniently linked with application programs+(which use some of those functions and data) to form executables.++  The "Library", below, refers to any such software library or work+which has been distributed under these terms.  A "work based on the+Library" means either the Library or any derivative work under+copyright law: that is to say, a work containing the Library or a+portion of it, either verbatim or with modifications and/or translated+straightforwardly into another language.  (Hereinafter, translation is+included without limitation in the term "modification".)++  "Source code" for a work means the preferred form of the work for+making modifications to it.  For a library, complete source code means+all the source code for all modules it contains, plus any associated+interface definition files, plus the scripts used to control compilation+and installation of the library.++  Activities other than copying, distribution and modification are not+covered by this License; they are outside its scope.  The act of+running a program using the Library is not restricted, and output from+such a program is covered only if its contents constitute a work based+on the Library (independent of the use of the Library in a tool for+writing it).  Whether that is true depends on what the Library does+and what the program that uses the Library does.+  +  1. You may copy and distribute verbatim copies of the Library's+complete source code as you receive it, in any medium, provided that+you conspicuously and appropriately publish on each copy an+appropriate copyright notice and disclaimer of warranty; keep intact+all the notices that refer to this License and to the absence of any+warranty; and distribute a copy of this License along with the+Library.++  You may charge a fee for the physical act of transferring a copy,+and you may at your option offer warranty protection in exchange for a+fee.++  2. You may modify your copy or copies of the Library or any portion+of it, thus forming a work based on the Library, and copy and+distribute such modifications or work under the terms of Section 1+above, provided that you also meet all of these conditions:++    a) The modified work must itself be a software library.++    b) You must cause the files modified to carry prominent notices+    stating that you changed the files and the date of any change.++    c) You must cause the whole of the work to be licensed at no+    charge to all third parties under the terms of this License.++    d) If a facility in the modified Library refers to a function or a+    table of data to be supplied by an application program that uses+    the facility, other than as an argument passed when the facility+    is invoked, then you must make a good faith effort to ensure that,+    in the event an application does not supply such function or+    table, the facility still operates, and performs whatever part of+    its purpose remains meaningful.++    (For example, a function in a library to compute square roots has+    a purpose that is entirely well-defined independent of the+    application.  Therefore, Subsection 2d requires that any+    application-supplied function or table used by this function must+    be optional: if the application does not supply it, the square+    root function must still compute square roots.)++These requirements apply to the modified work as a whole.  If+identifiable sections of that work are not derived from the Library,+and can be reasonably considered independent and separate works in+themselves, then this License, and its terms, do not apply to those+sections when you distribute them as separate works.  But when you+distribute the same sections as part of a whole which is a work based+on the Library, the distribution of the whole must be on the terms of+this License, whose permissions for other licensees extend to the+entire whole, and thus to each and every part regardless of who wrote+it.++Thus, it is not the intent of this section to claim rights or contest+your rights to work written entirely by you; rather, the intent is to+exercise the right to control the distribution of derivative or+collective works based on the Library.++In addition, mere aggregation of another work not based on the Library+with the Library (or with a work based on the Library) on a volume of+a storage or distribution medium does not bring the other work under+the scope of this License.++  3. You may opt to apply the terms of the ordinary GNU General Public+License instead of this License to a given copy of the Library.  To do+this, you must alter all the notices that refer to this License, so+that they refer to the ordinary GNU General Public License, version 2,+instead of to this License.  (If a newer version than version 2 of the+ordinary GNU General Public License has appeared, then you can specify+that version instead if you wish.)  Do not make any other change in+these notices.++  Once this change is made in a given copy, it is irreversible for+that copy, so the ordinary GNU General Public License applies to all+subsequent copies and derivative works made from that copy.++  This option is useful when you wish to copy part of the code of+the Library into a program that is not a library.++  4. You may copy and distribute the Library (or a portion or+derivative of it, under Section 2) in object code or executable form+under the terms of Sections 1 and 2 above provided that you accompany+it with the complete corresponding machine-readable source code, which+must be distributed under the terms of Sections 1 and 2 above on a+medium customarily used for software interchange.++  If distribution of object code is made by offering access to copy+from a designated place, then offering equivalent access to copy the+source code from the same place satisfies the requirement to+distribute the source code, even though third parties are not+compelled to copy the source along with the object code.++  5. A program that contains no derivative of any portion of the+Library, but is designed to work with the Library by being compiled or+linked with it, is called a "work that uses the Library".  Such a+work, in isolation, is not a derivative work of the Library, and+therefore falls outside the scope of this License.++  However, linking a "work that uses the Library" with the Library+creates an executable that is a derivative of the Library (because it+contains portions of the Library), rather than a "work that uses the+library".  The executable is therefore covered by this License.+Section 6 states terms for distribution of such executables.++  When a "work that uses the Library" uses material from a header file+that is part of the Library, the object code for the work may be a+derivative work of the Library even though the source code is not.+Whether this is true is especially significant if the work can be+linked without the Library, or if the work is itself a library.  The+threshold for this to be true is not precisely defined by law.++  If such an object file uses only numerical parameters, data+structure layouts and accessors, and small macros and small inline+functions (ten lines or less in length), then the use of the object+file is unrestricted, regardless of whether it is legally a derivative+work.  (Executables containing this object code plus portions of the+Library will still fall under Section 6.)++  Otherwise, if the work is a derivative of the Library, you may+distribute the object code for the work under the terms of Section 6.+Any executables containing that work also fall under Section 6,+whether or not they are linked directly with the Library itself.++  6. As an exception to the Sections above, you may also combine or+link a "work that uses the Library" with the Library to produce a+work containing portions of the Library, and distribute that work+under terms of your choice, provided that the terms permit+modification of the work for the customer's own use and reverse+engineering for debugging such modifications.++  You must give prominent notice with each copy of the work that the+Library is used in it and that the Library and its use are covered by+this License.  You must supply a copy of this License.  If the work+during execution displays copyright notices, you must include the+copyright notice for the Library among them, as well as a reference+directing the user to the copy of this License.  Also, you must do one+of these things:++    a) Accompany the work with the complete corresponding+    machine-readable source code for the Library including whatever+    changes were used in the work (which must be distributed under+    Sections 1 and 2 above); and, if the work is an executable linked+    with the Library, with the complete machine-readable "work that+    uses the Library", as object code and/or source code, so that the+    user can modify the Library and then relink to produce a modified+    executable containing the modified Library.  (It is understood+    that the user who changes the contents of definitions files in the+    Library will not necessarily be able to recompile the application+    to use the modified definitions.)++    b) Use a suitable shared library mechanism for linking with the+    Library.  A suitable mechanism is one that (1) uses at run time a+    copy of the library already present on the user's computer system,+    rather than copying library functions into the executable, and (2)+    will operate properly with a modified version of the library, if+    the user installs one, as long as the modified version is+    interface-compatible with the version that the work was made with.++    c) Accompany the work with a written offer, valid for at+    least three years, to give the same user the materials+    specified in Subsection 6a, above, for a charge no more+    than the cost of performing this distribution.++    d) If distribution of the work is made by offering access to copy+    from a designated place, offer equivalent access to copy the above+    specified materials from the same place.++    e) Verify that the user has already received a copy of these+    materials or that you have already sent this user a copy.++  For an executable, the required form of the "work that uses the+Library" must include any data and utility programs needed for+reproducing the executable from it.  However, as a special exception,+the materials to be distributed need not include anything that is+normally distributed (in either source or binary form) with the major+components (compiler, kernel, and so on) of the operating system on+which the executable runs, unless that component itself accompanies+the executable.++  It may happen that this requirement contradicts the license+restrictions of other proprietary libraries that do not normally+accompany the operating system.  Such a contradiction means you cannot+use both them and the Library together in an executable that you+distribute.++  7. You may place library facilities that are a work based on the+Library side-by-side in a single library together with other library+facilities not covered by this License, and distribute such a combined+library, provided that the separate distribution of the work based on+the Library and of the other library facilities is otherwise+permitted, and provided that you do these two things:++    a) Accompany the combined library with a copy of the same work+    based on the Library, uncombined with any other library+    facilities.  This must be distributed under the terms of the+    Sections above.++    b) Give prominent notice with the combined library of the fact+    that part of it is a work based on the Library, and explaining+    where to find the accompanying uncombined form of the same work.++  8. You may not copy, modify, sublicense, link with, or distribute+the Library except as expressly provided under this License.  Any+attempt otherwise to copy, modify, sublicense, link with, or+distribute the Library is void, and will automatically terminate your+rights under this License.  However, parties who have received copies,+or rights, from you under this License will not have their licenses+terminated so long as such parties remain in full compliance.++  9. You are not required to accept this License, since you have not+signed it.  However, nothing else grants you permission to modify or+distribute the Library or its derivative works.  These actions are+prohibited by law if you do not accept this License.  Therefore, by+modifying or distributing the Library (or any work based on the+Library), you indicate your acceptance of this License to do so, and+all its terms and conditions for copying, distributing or modifying+the Library or works based on it.++  10. Each time you redistribute the Library (or any work based on the+Library), the recipient automatically receives a license from the+original licensor to copy, distribute, link with or modify the Library+subject to these terms and conditions.  You may not impose any further+restrictions on the recipients' exercise of the rights granted herein.+You are not responsible for enforcing compliance by third parties with+this License.++  11. If, as a consequence of a court judgment or allegation of patent+infringement or for any other reason (not limited to patent issues),+conditions are imposed on you (whether by court order, agreement or+otherwise) that contradict the conditions of this License, they do not+excuse you from the conditions of this License.  If you cannot+distribute so as to satisfy simultaneously your obligations under this+License and any other pertinent obligations, then as a consequence you+may not distribute the Library at all.  For example, if a patent+license would not permit royalty-free redistribution of the Library by+all those who receive copies directly or indirectly through you, then+the only way you could satisfy both it and this License would be to+refrain entirely from distribution of the Library.++If any portion of this section is held invalid or unenforceable under any+particular circumstance, the balance of the section is intended to apply,+and the section as a whole is intended to apply in other circumstances.++It is not the purpose of this section to induce you to infringe any+patents or other property right claims or to contest validity of any+such claims; this section has the sole purpose of protecting the+integrity of the free software distribution system which is+implemented by public license practices.  Many people have made+generous contributions to the wide range of software distributed+through that system in reliance on consistent application of that+system; it is up to the author/donor to decide if he or she is willing+to distribute software through any other system and a licensee cannot+impose that choice.++This section is intended to make thoroughly clear what is believed to+be a consequence of the rest of this License.++  12. If the distribution and/or use of the Library is restricted in+certain countries either by patents or by copyrighted interfaces, the+original copyright holder who places the Library under this License may add+an explicit geographical distribution limitation excluding those countries,+so that distribution is permitted only in or among countries not thus+excluded.  In such case, this License incorporates the limitation as if+written in the body of this License.++  13. The Free Software Foundation may publish revised and/or new+versions of the Lesser General Public License from time to time.+Such new versions will be similar in spirit to the present version,+but may differ in detail to address new problems or concerns.++Each version is given a distinguishing version number.  If the Library+specifies a version number of this License which applies to it and+"any later version", you have the option of following the terms and+conditions either of that version or of any later version published by+the Free Software Foundation.  If the Library does not specify a+license version number, you may choose any version ever published by+the Free Software Foundation.++  14. If you wish to incorporate parts of the Library into other free+programs whose distribution conditions are incompatible with these,+write to the author to ask for permission.  For software which is+copyrighted by the Free Software Foundation, write to the Free+Software Foundation; we sometimes make exceptions for this.  Our+decision will be guided by the two goals of preserving the free status+of all derivatives of our free software and of promoting the sharing+and reuse of software generally.++			    NO WARRANTY++  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.++  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH+DAMAGES.++		     END OF TERMS AND CONDITIONS++           How to Apply These Terms to Your New Libraries++  If you develop a new library, and you want it to be of the greatest+possible use to the public, we recommend making it free software that+everyone can redistribute and change.  You can do so by permitting+redistribution under these terms (or, alternatively, under the terms of the+ordinary General Public License).++  To apply these terms, attach the following notices to the library.  It is+safest to attach them to the start of each source file to most effectively+convey the exclusion of warranty; and each file should have at least the+"copyright" line and a pointer to where the full notice is found.++    <one line to give the library's name and a brief idea of what it does.>+    Copyright (C) <year>  <name of author>++    This library is free software; you can redistribute it and/or+    modify it under the terms of the GNU Lesser General Public+    License as published by the Free Software Foundation; either+    version 2.1 of the License, or (at your option) any later version.++    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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA++Also add information on how to contact you by electronic and paper mail.++You should also get your employer (if you work as a programmer) or your+school, if any, to sign a "copyright disclaimer" for the library, if+necessary.  Here is a sample; alter the names:++  Yoyodyne, Inc., hereby disclaims all copyright interest in the+  library `Frob' (a library for tweaking knobs) written by James Random Hacker.++  <signature of Ty Coon>, 1 April 1990+  Ty Coon, President of Vice++That's all there is to it!
+ README.md view
@@ -0,0 +1,1 @@+# OpenCASCADE-hs
+ cpp/hs_BRepAlgoAPI_Common.cpp view
@@ -0,0 +1,9 @@+#include <BRepAlgoAPI_Common.hxx>+#include "hs_BRepAlgoAPI_Common.h"++#include <TopoDS_Shape.hxx>++TopoDS_Shape * hs_BRepAlgoAPI_Common(TopoDS_Shape * a, TopoDS_Shape * b){+    auto builder = BRepAlgoAPI_Common(*a, *b);+    return new TopoDS_Shape(builder.Shape());+}
+ cpp/hs_BRepAlgoAPI_Cut.cpp view
@@ -0,0 +1,9 @@+#include <BRepAlgoAPI_Cut.hxx>+#include "hs_BRepAlgoAPI_Cut.h"++#include <TopoDS_Shape.hxx>++TopoDS_Shape * hs_BRepAlgoAPI_Cut(TopoDS_Shape * a, TopoDS_Shape * b){+    auto builder = BRepAlgoAPI_Cut(*a, *b);+    return new TopoDS_Shape(builder.Shape());+}
+ cpp/hs_BRepAlgoAPI_Fuse.cpp view
@@ -0,0 +1,9 @@+#include <BRepAlgoAPI_Fuse.hxx>+#include "hs_BRepAlgoAPI_Fuse.h"++#include <TopoDS_Shape.hxx>++TopoDS_Shape * hs_BRepAlgoAPI_Fuse(TopoDS_Shape * a, TopoDS_Shape * b){+    auto builder = BRepAlgoAPI_Fuse(*a, *b);+    return new TopoDS_Shape(builder.Shape());+}
+ cpp/hs_BRepBuilderAPI_GTransform.cpp view
@@ -0,0 +1,10 @@+#include <BRepBuilderAPI_GTransform.hxx>+#include <TopoDS_Shape.hxx>+#include "hs_BRepBuilderAPI_GTransform.h"++TopoDS_Shape * hs_BRepBuilderAPI_GTransform_gtransform(TopoDS_Shape * shape, gp_GTrsf * trsf, bool copy){+    auto builder = BRepBuilderAPI_GTransform(*shape, *trsf, copy);+    return new TopoDS_Shape(builder.Shape());+}++
+ cpp/hs_BRepBuilderAPI_MakeEdge.cpp view
@@ -0,0 +1,36 @@+#include <BRepBuilderAPI_MakeEdge.hxx>+#include <TopoDS_Edge.hxx>+#include "hs_BRepBuilderAPI_MakeEdge.h"++TopoDS_Edge * hs_BRepBuilderAPI_MakeEdge_fromVertices(TopoDS_Vertex *a, TopoDS_Vertex *b){+    return new TopoDS_Edge(BRepBuilderAPI_MakeEdge(*a, *b));+}++TopoDS_Edge * hs_BRepBuilderAPI_MakeEdge_fromPnts(gp_Pnt *a, gp_Pnt *b){+    return new TopoDS_Edge(BRepBuilderAPI_MakeEdge(*a, *b));+}++TopoDS_Edge * hs_BRepBuilderAPI_MakeEdge_fromCurve(Handle(Geom_Curve) * curve){+    return new TopoDS_Edge(BRepBuilderAPI_MakeEdge(*curve));+}++TopoDS_Edge * hs_BRepBuilderAPI_MakeEdge_fromCurveAndParameters(Handle(Geom_Curve) * curve, double a, double b){+    return new TopoDS_Edge(BRepBuilderAPI_MakeEdge(*curve, a, b));+}++TopoDS_Edge * hs_BRepBuilderAPI_MakeEdge_fromCurveAndVertices(Handle(Geom_Curve) * curve, TopoDS_Vertex* a, TopoDS_Vertex* b){+    return new TopoDS_Edge(BRepBuilderAPI_MakeEdge(*curve, *a, *b));+}++TopoDS_Edge * hs_BRepBuilderAPI_MakeEdge_fromCurveAndPnts(Handle(Geom_Curve) * curve, gp_Pnt* a, gp_Pnt* b){+    return new TopoDS_Edge(BRepBuilderAPI_MakeEdge(*curve, *a, *b));+}++TopoDS_Edge * hs_BRepBuilderAPI_MakeEdge_fromCurveVerticesAndParameters(Handle(Geom_Curve) * curve, TopoDS_Vertex* a, TopoDS_Vertex* b, double ap, double bp){+    return new TopoDS_Edge(BRepBuilderAPI_MakeEdge(*curve, *a, *b, ap, bp));+}+++TopoDS_Edge * hs_BRepBuilderAPI_MakeEdge_fromCurvePntsAndParameters(Handle(Geom_Curve) * curve, gp_Pnt* a, gp_Pnt* b, double ap, double bp){+    return new TopoDS_Edge(BRepBuilderAPI_MakeEdge(*curve, *a, *b, ap, bp));+}
+ cpp/hs_BRepBuilderAPI_MakeFace.cpp view
@@ -0,0 +1,47 @@+#include <BRepBuilderAPI_MakeFace.hxx>+#include <TopoDS_Face.hxx>+#include "hs_BRepBuilderAPI_MakeFace.h"++BRepBuilderAPI_MakeFace * hs_new_BRepBuilderAPI_MakeFace(){+    return new BRepBuilderAPI_MakeFace();+}++void hs_delete_BRepBuilderAPI_MakeFace(BRepBuilderAPI_MakeFace * builder){+    delete builder;+}++BRepBuilderAPI_MakeFace * hs_new_BRepBuilderAPI_MakeFace_fromFace(TopoDS_Face * face){+    return new BRepBuilderAPI_MakeFace(*face);+}++BRepBuilderAPI_MakeFace * hs_new_BRepBuilderAPI_MakeFace_fromSurface(Handle(Geom_Surface)* surface, double tolerance){+    return new BRepBuilderAPI_MakeFace(*surface, tolerance);+}++BRepBuilderAPI_MakeFace * hs_new_BRepBuilderAPI_MakeFace_fromSurfaceAndBounds(Handle(Geom_Surface)* surface, double uMin, double uMax, double vMin, double vMax, double tolerance){+    return new BRepBuilderAPI_MakeFace(*surface, uMin, uMax, vMin, vMax, tolerance);+}++BRepBuilderAPI_MakeFace * hs_new_BRepBuilderAPI_MakeFace_fromSurfaceAndWire(Handle(Geom_Surface)* surface, TopoDS_Wire* wire, bool inside){+    return new BRepBuilderAPI_MakeFace(*surface, *wire, inside);+}++BRepBuilderAPI_MakeFace * hs_new_BRepBuilderAPI_MakeFace_fromWire(TopoDS_Wire* wire, bool onlyPlane){+    return new BRepBuilderAPI_MakeFace(*wire, onlyPlane);+}++void hs_BRepBuilderAPI_MakeFace_Add(BRepBuilderAPI_MakeFace* builder, TopoDS_Wire* wire){+    builder->Add(*wire);+}++bool hs_BRepBuilderAPI_MakeFace_IsDone(BRepBuilderAPI_MakeFace* builder){+    return builder->IsDone();+}++BRepBuilderAPI_FaceError hs_BRepBuilderAPI_MakeFace_Error(BRepBuilderAPI_MakeFace * builder){+    return builder->Error();+}++TopoDS_Face * hs_BRepBuilderAPI_MakeFace_Face(BRepBuilderAPI_MakeFace * builder){+    return new TopoDS_Face(builder->Face());+}
+ cpp/hs_BRepBuilderAPI_MakeShape.cpp view
@@ -0,0 +1,7 @@+#include <BRepBuilderAPI_MakeShape.hxx>+#include <TopoDS_Shape.hxx>+#include "hs_BRepBuilderAPI_MakeShape.h"++TopoDS_Shape * hs_BRepBuilderAPI_MakeShape_shape(BRepBuilderAPI_MakeShape* builder){+    return new TopoDS_Shape(builder->Shape());+}
+ cpp/hs_BRepBuilderAPI_MakeSolid.cpp view
@@ -0,0 +1,20 @@+#include <BRepBuilderAPI_MakeSolid.hxx>+#include <TopoDS_Solid.hxx>+#include "hs_BRepBuilderAPI_MakeSolid.h"++BRepBuilderAPI_MakeSolid * hs_new_BRepBuilderAPI_MakeSolid(){+    auto everywhere = BRepBuilderAPI_MakeSolid().Shape();+    return new BRepBuilderAPI_MakeSolid();+}++void hs_delete_BRepBuilderAPI_MakeSolid(BRepBuilderAPI_MakeSolid * builder){+    delete builder;+}++void hs_BRepBuilderAPI_MakeSolid_add(BRepBuilderAPI_MakeSolid * builder, TopoDS_Shell * shell){+    builder->Add(*shell);+}++TopoDS_Solid * hs_BRepBuilderAPI_MakeSolid_solid(BRepBuilderAPI_MakeSolid * builder){+    return new TopoDS_Solid(builder->Solid());+}
+ cpp/hs_BRepBuilderAPI_MakeWire.cpp view
@@ -0,0 +1,35 @@+#include <BRepBuilderAPI_MakeWire.hxx>+#include <TopoDS_Wire.hxx>+#include "hs_BRepBuilderAPI_MakeWire.h"++BRepBuilderAPI_MakeWire * hs_new_BRepBuilderAPI_MakeWire(){+    return new BRepBuilderAPI_MakeWire();+}++void hs_delete_BRepBuilderAPI_MakeWire(BRepBuilderAPI_MakeWire* builder){+    delete builder;+}++void hs_BRepBuilderAPI_MakeWire_AddEdge(BRepBuilderAPI_MakeWire* builder, TopoDS_Edge* edge){+    builder->Add(*edge);+}++void hs_BRepBuilderAPI_MakeWire_AddWire(BRepBuilderAPI_MakeWire* builder, TopoDS_Wire* wire){+    builder->Add(*wire);+}++void hs_BRepBuilderAPI_MakeWire_AddListOfShape(BRepBuilderAPI_MakeWire* builder, TopTools_ListOfShape *list){+    builder->Add(*list);+}++TopoDS_Wire * hs_BRepBuilderAPI_MakeWire_Wire(BRepBuilderAPI_MakeWire* builder){+    return new TopoDS_Wire(builder->Wire());+}++bool hs_BRepBuilderAPI_MakeWire_IsDone(BRepBuilderAPI_MakeWire* builder){+    return builder->IsDone();+}++BRepBuilderAPI_WireError hs_BRepBuilderAPI_MakeWire_Error(BRepBuilderAPI_MakeWire* builder){+    return builder->Error();+}
+ cpp/hs_BRepBuilderAPI_Transform.cpp view
@@ -0,0 +1,10 @@+#include <BRepBuilderAPI_Transform.hxx>+#include <TopoDS_Shape.hxx>+#include "hs_BRepBuilderAPI_Transform.h"++TopoDS_Shape * hs_BRepBuilderAPI_Transform_transform(TopoDS_Shape * shape, gp_Trsf * trsf, bool copy){+    auto builder = BRepBuilderAPI_Transform(*shape, *trsf, copy);+    return new TopoDS_Shape(builder.Shape());+}++
+ cpp/hs_BRepFilletAPI_MakeFillet.cpp view
@@ -0,0 +1,25 @@+#include <BRepFilletAPI_MakeFillet.hxx>+#include <TopoDS_Shape.hxx>+#include "hs_BRepFilletAPI_MakeFillet.h"++BRepFilletAPI_MakeFillet * hs_new_BRepFilletAPI_MakeFillet_fromShape(TopoDS_Shape * shape) {+    return new BRepFilletAPI_MakeFillet(*shape);+}++void hs_delete_BRepFilletAPI_MakeFillet(BRepFilletAPI_MakeFillet * builder) {+    delete builder;+}++void hs_BRepFilletAPI_MakeFillet_addEdge(BRepFilletAPI_MakeFillet * builder, TopoDS_Edge *edge ){+    builder->Add(*edge);+}++void hs_BRepFilletAPI_MakeFillet_addEdgeWithRadius(BRepFilletAPI_MakeFillet * builder, double r, TopoDS_Edge *edge ){+    builder->Add(r, *edge);+}+++void hs_BRepFilletAPI_MakeFillet_addEdgeWithTwoRadiuses(BRepFilletAPI_MakeFillet * builder, double r1, double r2, TopoDS_Edge *edge ){+    builder->Add(r1, r2, *edge);+}+
+ cpp/hs_BRepMesh_IncrementalMesh.cpp view
@@ -0,0 +1,15 @@+#include <BRepMesh_IncrementalMesh.hxx>+#include "hs_BRepMesh_IncrementalMesh.h"+++BRepMesh_IncrementalMesh * hs_BRepMesh_IncrementalMesh_fromShapeAndLinDeflection(TopoDS_Shape *shape, double theLinDeflection){+    return new BRepMesh_IncrementalMesh(*shape, theLinDeflection);+}++void hs_delete_BRepMesh_IncrementalMesh(BRepMesh_IncrementalMesh * mesh){+    delete mesh;+}++void hs_BRepMesh_IncrementalMesh_Perform(BRepMesh_IncrementalMesh * mesh){+    mesh->Perform();+}
+ cpp/hs_BRepOffsetAPI_MakePipe.cpp view
@@ -0,0 +1,13 @@+#include <BRepOffsetAPI_MakePipe.hxx>+#include "hs_BRepOffsetAPI_MakePipe.h"++BRepOffsetAPI_MakePipe * hs_new_BRepOffsetAPI_MakePipe_fromWireAndShape(TopoDS_Wire * wire, TopoDS_Shape * profile){+    return new BRepOffsetAPI_MakePipe(*wire, *profile);+}+++void hs_delete_BRepOffsetAPI_MakePipe(BRepOffsetAPI_MakePipe * builder){+    delete builder;+}++
+ cpp/hs_BRepPrimAPI_MakeBox.cpp view
@@ -0,0 +1,21 @@+#include <BRepPrimAPI_MakeBox.hxx>+#include <TopoDS_Solid.hxx>+#include <TopoDS_Shell.hxx>+#include "hs_BRepPrimAPI_MakeBox.h"+++BRepPrimAPI_MakeBox * hs_new_BRepPrimAPI_MakeBox_fromPnts(gp_Pnt *a, gp_Pnt *b){+    return new BRepPrimAPI_MakeBox(*a, *b);+}++void hs_delete_BRepPrimAPI_MakeBox(BRepPrimAPI_MakeBox* builder){+    delete builder;+}++TopoDS_Shape * hs_BRepPrimAPI_MakeBox_Solid(BRepPrimAPI_MakeBox* builder){+    return new TopoDS_Shape(builder->Solid());+}++TopoDS_Shell * hs_BRepPrimAPI_MakeBox_Shell(BRepPrimAPI_MakeBox* builder){+    return new TopoDS_Shell(builder->Shell());+}
+ cpp/hs_BRepPrimAPI_MakeCylinder.cpp view
@@ -0,0 +1,7 @@+#include <BRepPrimAPI_MakeCylinder.hxx>+#include "hs_BRepPrimAPI_MakeCylinder.h"++TopoDS_Solid * hs_BRepPrimAPI_MakeCylinder_fromRadiusAndHeight(double r, double h){+    auto builder = BRepPrimAPI_MakeCylinder(r, h);+    return new TopoDS_Solid(builder.Solid());+}
+ cpp/hs_BRepPrimAPI_MakePrism.cpp view
@@ -0,0 +1,13 @@+#include <BRepPrimAPI_MakePrism.hxx>+#include "hs_BRepPrimAPI_MakePrism.h"+++TopoDS_Shape * hs_BRepPrimAPI_MakePrism_fromVec(TopoDS_Shape * shape, gp_Vec * vec, bool copy, bool canonize){+    auto builder = BRepPrimAPI_MakePrism(*shape, *vec, copy, canonize);+    return new TopoDS_Shape(builder.Shape());+}++TopoDS_Shape * hs_BRepPrimAPI_MakePrism_fromDir(TopoDS_Shape * shape, gp_Dir * dir, bool inf, bool copy, bool canonize){+    auto builder = BRepPrimAPI_MakePrism(*shape, *dir, inf, copy, canonize);+    return new TopoDS_Shape(builder.Shape());+}
+ cpp/hs_BRepPrimAPI_MakeRevol.cpp view
@@ -0,0 +1,10 @@+#include <BRepPrimAPI_MakeRevol.hxx>+#include "hs_BRepPrimAPI_MakeRevol.h"++BRepPrimAPI_MakeRevol * hs_new_BRepPrimAPI_MakeRevol_fromShapeAndAx1(TopoDS_Shape * shape, gp_Ax1 * axis, bool copy){+    return new BRepPrimAPI_MakeRevol(*shape, *axis, copy);+}++void hs_delete_BRepPrimAPI_MakeRevol(BRepPrimAPI_MakeRevol * builder){+    delete builder;+}
+ cpp/hs_BRepPrimAPI_MakeSphere.cpp view
@@ -0,0 +1,13 @@+#include <BRepPrimAPI_MakeSphere.hxx>+#include "hs_BRepPrimAPI_MakeSphere.h"+++TopoDS_Solid * hs_BRepPrimAPI_MakeSphere_fromRadius(double r){+    auto builder = BRepPrimAPI_MakeSphere(r);+    return new TopoDS_Solid(builder.Solid());+}++TopoDS_Solid * hs_BRepPrimAPI_MakeSphere_fromPntAndRadius(gp_Pnt * center, double r){+    auto builder = BRepPrimAPI_MakeSphere(*center, r);+    return new TopoDS_Solid(builder.Solid());+}
+ cpp/hs_BRepTools_WireExplorer.cpp view
@@ -0,0 +1,26 @@+#include <BRepTools_WireExplorer.hxx>+#include "hs_BRepTools_WireExplorer.h"++BRepTools_WireExplorer * hs_new_BRepTools_WireExplorer_fromWire(TopoDS_Wire *wire){+    return new BRepTools_WireExplorer(*wire);+}++void hs_delete_BRepTools_WireExplorer(BRepTools_WireExplorer * explorer){+    delete explorer;+}++bool hs_BRepTools_WireExplorer_more(BRepTools_WireExplorer * explorer){+    return explorer->More();+}++void hs_BRepTools_WireExplorer_next(BRepTools_WireExplorer * explorer){+    explorer->Next();+}++TopoDS_Edge * hs_BRepTools_WireExplorer_current(BRepTools_WireExplorer * explorer){+    return (TopoDS_Edge *) &(explorer->Current());+}++TopAbs_Orientation hs_BRepTools_WireExplorer_orientation(BRepTools_WireExplorer * explorer){+    return explorer->Orientation();+}
+ cpp/hs_BRep_Tool.cpp view
@@ -0,0 +1,22 @@+#include <BRep_Tool.hxx>+#include <Standard_Handle.hxx>+#include "hs_BRep_Tool.h"++Handle(Geom_Curve) * hs_BRep_Tool_curve(TopoDS_Edge * edge){+    double s, e;+    return new Handle(Geom_Curve)(BRep_Tool::Curve(*edge, s, e));+}++double hs_BRep_Tool_curveParamFirst(TopoDS_Edge * edge){+    double s, e;+    BRep_Tool::Curve(*edge, s, e);+    return s;+}++double hs_BRep_Tool_curveParamLast(TopoDS_Edge * edge){+    double s, e;+    BRep_Tool::Curve(*edge, s, e);+    return e;+} ++
+ cpp/hs_GC_MakeArcOfCircle.cpp view
@@ -0,0 +1,10 @@+#include <GC_MakeArcOfCircle.hxx>+#include "hs_GC_MakeArcOfCircle.h"++Handle(Geom_TrimmedCurve) * hs_GC_MakeArcOfCircle_from3Pnts(gp_Pnt * a, gp_Pnt * b, gp_Pnt * c){+    return new opencascade::handle(GC_MakeArcOfCircle(*a, *b, *c).Value());+}++Handle(Geom_TrimmedCurve) * hs_GC_MakeArcOfCircle_fromPntsAndVec(gp_Pnt * a, gp_Vec * b, gp_Pnt * c){+    return new opencascade::handle(GC_MakeArcOfCircle(*a, *b, *c).Value());+}
+ cpp/hs_GC_MakeSegment.cpp view
@@ -0,0 +1,6 @@+#include <GC_MakeSegment.hxx>+#include "hs_GC_MakeSegment.h"++Handle(Geom_TrimmedCurve) * hs_GC_MakeSegment_fromPnts(gp_Pnt* a, gp_Pnt* b){+    return new opencascade::handle(GC_MakeSegment(*a, *b).Value());+}
+ cpp/hs_Geom_BezierCurve.cpp view
@@ -0,0 +1,21 @@+#include <Geom_BezierCurve.hxx>+#include <NCollection_Array1.hxx>+#include <gp_Pnt.hxx>+#include <Standard_Handle.hxx>+#include "hs_Geom_BezierCurve.h"++Geom_BezierCurve * hs_new_Geom_BezierCurve_fromPnts(ARRAY_1(gp_Pnt) * pnts){+    return new Geom_BezierCurve(*pnts);+}++Handle(Geom_BezierCurve) * hs_Geom_BezierCurve_toHandle(Geom_BezierCurve * curve){+    return new Handle(Geom_BezierCurve)(new Geom_BezierCurve(*curve));+}++void hs_delete_Handle_Geom_BezierCurve(Handle(Geom_BezierCurve)* h){+    delete h;+}++void hs_delete_Geom_BezierCurve(Geom_BezierCurve * curve){+    delete curve;+}
+ cpp/hs_Geom_Curve.cpp view
@@ -0,0 +1,12 @@+#include <Geom_Curve.hxx>+#include <gp_Pnt.hxx>+#include "hs_Geom_Curve.h"++void hs_delete_Handle_Geom_Curve(Handle(Geom_Curve) * handle){+    delete handle;+}++gp_Pnt * hs_Geom_Curve_value(Handle(Geom_Curve) * curve, double u){+    return new gp_Pnt((*curve)->Value(u));+}+
+ cpp/hs_Geom_TrimmedCurve.cpp view
@@ -0,0 +1,8 @@+#include <Geom_TrimmedCurve.hxx>+#include "hs_Geom_TrimmedCurve.h"++void hs_delete_Handle_Geom_TrimmedCurve(Handle(Geom_TrimmedCurve)* h){+    delete h;+}++
+ cpp/hs_NCollection_Array1.cpp view
@@ -0,0 +1,15 @@+#include <NCollection_Array1.hxx>+#include <gp_Pnt.hxx>+#include "hs_NCollection_Array1.h"++ARRAY_1(gp_Pnt) * hs_new_NCollection_Array1_gp_Pnt(int lower, int upper){+    return new NCollection_Array1<gp_Pnt>(lower, upper);+}++void hs_NCollection_Array1_gp_Pnt_setValue(ARRAY_1(gp_Pnt) * arr, int index, gp_Pnt * value){+    arr->SetValue(index, *value);+}++void hs_delete_NCollection_Array1_gp_Pnt(ARRAY_1(gp_Pnt) * arr){+    delete arr;+}
+ cpp/hs_STEPControl_Writer.cpp view
@@ -0,0 +1,26 @@+#include <STEPControl_Writer.hxx>+#include "hs_STEPControl_Writer.h"++STEPControl_Writer * hs_new_STEPControl_Writer(){+    return new STEPControl_Writer();+}++void hs_delete_STEPControl_Writer(STEPControl_Writer * writer){+    delete writer;+}++void hs_STEPControl_Writer_setTolerance(STEPControl_Writer * writer, double tolerance){+    writer->SetTolerance(tolerance);+}++void hs_STEPControl_Writer_unsetTolerance(STEPControl_Writer * writer){+    writer->UnsetTolerance();+}++IFSelect_ReturnStatus hs_STEPControl_Writer_transfer(STEPControl_Writer * writer, TopoDS_Shape * shape, STEPControl_StepModelType mode, bool compgraph){+    return writer->Transfer(*shape, mode, compgraph);+}++IFSelect_ReturnStatus hs_STEPControl_Writer_write(STEPControl_Writer* writer, char* filename){+    return writer->Write(filename);+}
+ cpp/hs_StlAPI_Writer.cpp view
@@ -0,0 +1,18 @@+#include <StlAPI_Writer.hxx>+#include "hs_StlAPI_Writer.h"++StlAPI_Writer * hs_new_StlAPI_Writer(){+    return new StlAPI_Writer();+}++void hs_delete_StlAPI_Writer(StlAPI_Writer * writer){+    delete writer;+}++void hs_StlAPI_Writer_setAsciiMode(StlAPI_Writer * writer, bool asciiMode){+    writer->ASCIIMode() = asciiMode;+}++bool hs_StlAPI_Writer_write(StlAPI_Writer * writer, TopoDS_Shape * shape, char* filename){+    return writer->Write(*shape, filename);+}
+ cpp/hs_TopExp_Explorer.cpp view
@@ -0,0 +1,22 @@+#include <TopExp_Explorer.hxx>+#include "hs_TopExp_Explorer.h"++TopExp_Explorer * hs_new_TopExp_Explorer(TopoDS_Shape * shape, TopAbs_ShapeEnum toFind){+    return new TopExp_Explorer(*shape, toFind);+}++void hs_delete_TopExp_Explorer(TopExp_Explorer * explorer){+    delete explorer;+}++bool hs_TopExp_Explorer_more(TopExp_Explorer * explorer){+    return explorer->More();+}++void hs_TopExp_Explorer_next(TopExp_Explorer * explorer){+    return explorer->Next();+}++TopoDS_Shape * hs_TopExp_Explorer_value(TopExp_Explorer * explorer){+    return (TopoDS_Shape *) &(explorer->Value());+}
+ cpp/hs_TopLoc_Location.cpp view
@@ -0,0 +1,62 @@+#include <TopLoc_Location.hxx>+#include "hs_TopLoc_Location.h"++TopLoc_Location * hs_new_TopLoc_Location(){+    return new TopLoc_Location();+}++TopLoc_Location * hs_new_TopLoc_Location_fromGPTrsf(gp_Trsf * trsf){+    return new TopLoc_Location(*trsf);+}++void hs_delete_TopLoc_Location(TopLoc_Location * l){+    delete l;+}++bool hs_TopLoc_Location_IsIdentity(TopLoc_Location * l){+    return l->IsIdentity();+}++int hs_TopLoc_Location_FirstPower(TopLoc_Location * l){+    return l->FirstPower();+}++TopLoc_Location * hs_TopLoc_Location_NextLocation(TopLoc_Location * l){+    return new TopLoc_Location(l->NextLocation());+}++TopLoc_Location * hs_TopLoc_Location_Inverted(TopLoc_Location * l){+    return new TopLoc_Location(l->Inverted());+}++TopLoc_Location * hs_TopLoc_Location_Multiplied(TopLoc_Location * a, TopLoc_Location * b){+    return new TopLoc_Location(a->Multiplied(*b));+}++TopLoc_Location * hs_TopLoc_Location_Divided(TopLoc_Location * a, TopLoc_Location * b){+    return new TopLoc_Location(a->Divided(*b));+}++TopLoc_Location * hs_TopLoc_Location_Predivided(TopLoc_Location * a, TopLoc_Location * b){+    return new TopLoc_Location(a->Predivided(*b));+}++TopLoc_Location * hs_TopLoc_Location_Powered(TopLoc_Location * l, int p){+    return new TopLoc_Location(l->Powered(p));+}++gp_Trsf * hs_TopLoc_Location_toGPTrsf(TopLoc_Location * l){+    return new gp_Trsf(gp_Trsf(*l));+}++bool hs_TopLoc_Location_IsEqual(TopLoc_Location * a, TopLoc_Location * b){+    return a->IsEqual(*b);+}++bool hs_TopLoc_Location_IsDifferent(TopLoc_Location * a, TopLoc_Location * b){+    return a->IsDifferent(*b);+}++void hs_TopLoc_Location_Clear(TopLoc_Location * l){+    l->Clear();+}
+ cpp/hs_TopoDS_CompSolid.cpp view
@@ -0,0 +1,7 @@+#include <TopoDS_CompSolid.hxx>+#include "hs_TopoDS_CompSolid.h"++TopoDS_CompSolid * hs_new_TopoDS_CompSolid(){+    return new TopoDS_CompSolid();+}+
+ cpp/hs_TopoDS_Compound.cpp view
@@ -0,0 +1,7 @@+#include <TopoDS_Compound.hxx>+#include "hs_TopoDS_Compound.h"++TopoDS_Compound * hs_new_TopoDS_Compound(){+    return new TopoDS_Compound();+}+
+ cpp/hs_TopoDS_Edge.cpp view
@@ -0,0 +1,7 @@+#include <TopoDS_Edge.hxx>+#include "hs_TopoDS_Edge.h"++TopoDS_Edge * hs_new_TopoDS_Edge(){+    return new TopoDS_Edge();+}+
+ cpp/hs_TopoDS_Face.cpp view
@@ -0,0 +1,7 @@+#include <TopoDS_Face.hxx>+#include "hs_TopoDS_Face.h"++TopoDS_Face * hs_new_TopoDS_Face(){+    return new TopoDS_Face();+}+
+ cpp/hs_TopoDS_Shape.cpp view
@@ -0,0 +1,185 @@+#include <TopoDS_Shape.hxx>+#include "hs_TopoDS_Shape.h"++TopoDS_Shape * hs_new_TopoDS_Shape(){+    return new TopoDS_Shape();+}++TopoDS_Shape * hs_new_TopoDS_Shape_copy(TopoDS_Shape * shape){+    return new TopoDS_Shape(*shape);+}++void hs_delete_TopoDS_Shape(TopoDS_Shape * shape){+    delete shape;+}++bool hs_TopoDS_Shape_IsNull(TopoDS_Shape * shape){+    return shape->IsNull();+}++void hs_TopoDS_Shape_Nullify(TopoDS_Shape * shape){+    shape->Nullify();+}++TopLoc_Location * hs_TopoDS_Shape_Location(TopoDS_Shape * shape){+    return new TopLoc_Location(shape->Location());+}++void hs_TopoDS_Shape_SetLocation(TopoDS_Shape * shape, TopLoc_Location * location){+    shape->Location(*location);+}++TopoDS_Shape * hs_TopoDS_Shape_Located(TopoDS_Shape * shape, TopLoc_Location * location){+    return new TopoDS_Shape(shape->Located(*location));+}++TopAbs_Orientation hs_TopoDS_Shape_Orientation(TopoDS_Shape * shape){+    return shape->Orientation();+}++void hs_TopoDS_Shape_SetOrientation(TopoDS_Shape * shape, TopAbs_Orientation orientation){+    return shape->Orientation(orientation);+}++TopoDS_Shape * hs_TopoDS_Shape_Oriented(TopoDS_Shape * shape, TopAbs_Orientation orientation){+    return new TopoDS_Shape(shape->Oriented(orientation));+}++TopAbs_ShapeEnum hs_TopoDS_Shape_ShapeType(TopoDS_Shape * shape){+    return shape->ShapeType();+}++bool hs_TopoDS_Shape_Free(TopoDS_Shape * shape){+    return shape->Free();+}++void hs_TopoDS_Shape_SetFree(TopoDS_Shape * shape, bool b){+    shape->Free(b);+}+++bool hs_TopoDS_Shape_Locked(TopoDS_Shape * shape){+    return shape->Locked();+}++void hs_TopoDS_Shape_SetLocked(TopoDS_Shape * shape, bool b){+    shape->Locked(b);+}++bool hs_TopoDS_Shape_Modified(TopoDS_Shape * shape){+    return shape->Modified();+}++void hs_TopoDS_Shape_SetModified(TopoDS_Shape * shape, bool b){+    shape->Modified(b);+}+++bool hs_TopoDS_Shape_Checked(TopoDS_Shape * shape){+    return shape->Checked();+}++void hs_TopoDS_Shape_SetChecked(TopoDS_Shape * shape, bool b){+    shape->Checked(b);+}+++bool hs_TopoDS_Shape_Orientable(TopoDS_Shape * shape){+    return shape->Orientable();+}++void hs_TopoDS_Shape_SetOrientable(TopoDS_Shape * shape, bool b){+    shape->Orientable(b);+}++bool hs_TopoDS_Shape_Closed(TopoDS_Shape * shape){+    return shape->Closed();+}++void hs_TopoDS_Shape_SetClosed(TopoDS_Shape * shape, bool b){+    shape->Closed(b);+}+++bool hs_TopoDS_Shape_Infinite(TopoDS_Shape * shape){+    return shape->Infinite();+}++void hs_TopoDS_Shape_SetInfinite(TopoDS_Shape * shape, bool b){+    shape->Infinite(b);+}+++bool hs_TopoDS_Shape_Convex(TopoDS_Shape * shape){+    return shape->Convex();+}++void hs_TopoDS_Shape_SetConvex(TopoDS_Shape * shape, bool b){+    shape->Convex(b);+}++void hs_TopoDS_Shape_Move(TopoDS_Shape * shape, TopLoc_Location * position){+    shape->Move(*position);+}++TopoDS_Shape * hs_TopoDS_Shape_Moved(TopoDS_Shape * shape, TopLoc_Location * position){+    return new TopoDS_Shape(shape->Moved(*position));+}++int hs_TopoDS_Shape_NbChildren(TopoDS_Shape * shape){+    return shape->NbChildren();+}++void hs_TopoDS_Shape_Reverse(TopoDS_Shape * shape){+    shape->Reverse();+}++TopoDS_Shape * hs_TopoDS_Shape_Reversed(TopoDS_Shape * shape){+    return new TopoDS_Shape(shape->Reversed());+}+++void hs_TopoDS_Shape_Complement(TopoDS_Shape * shape){+    shape->Complement();+}++TopoDS_Shape * hs_TopoDS_Shape_Complemented(TopoDS_Shape * shape){+    return new TopoDS_Shape(shape->Complemented());+}++void hs_TopoDS_Shape_Compose(TopoDS_Shape * shape, TopAbs_Orientation orient){+    shape->Compose(orient);+}++TopoDS_Shape * hs_TopoDS_Shape_Composed(TopoDS_Shape * shape, TopAbs_Orientation orient){+    return new TopoDS_Shape(shape->Composed(orient));+}++bool hs_TopoDS_Shape_IsEqual(TopoDS_Shape * a, TopoDS_Shape* b){+    return a->IsEqual(*b);+}++bool hs_TopoDS_Shape_IsSame(TopoDS_Shape * a, TopoDS_Shape* b){+    return a->IsSame(*b);+}++bool hs_TopoDS_Shape_IsPartner(TopoDS_Shape * a, TopoDS_Shape* b){+    return a->IsPartner(*b);+}++bool hs_TopoDS_Shape_IsNotEqual(TopoDS_Shape * a, TopoDS_Shape* b){+    return a->IsNotEqual(*b);+}+++void hs_TopoDS_Shape_EmptyCopy(TopoDS_Shape * shape){+    shape->EmptyCopy();+}++TopoDS_Shape * hs_TopoDS_Shape_EmptyCopied(TopoDS_Shape * shape){+    return new TopoDS_Shape(shape->EmptyCopied());+}++int hs_TopoDS_Shape_hashCode(TopoDS_Shape * shape, int maxN){+    return shape->HashCode(maxN);+}
+ cpp/hs_TopoDS_Shell.cpp view
@@ -0,0 +1,7 @@+#include <TopoDS_Shell.hxx>+#include "hs_TopoDS_Shell.h"++TopoDS_Shell * hs_new_TopoDS_Shell(){+    return new TopoDS_Shell();+}+
+ cpp/hs_TopoDS_Solid.cpp view
@@ -0,0 +1,7 @@+#include <TopoDS_Solid.hxx>+#include "hs_TopoDS_Solid.h"++TopoDS_Solid * hs_new_TopoDS_Solid(){+    return new TopoDS_Solid();+}+
+ cpp/hs_TopoDS_Vertex.cpp view
@@ -0,0 +1,7 @@+#include <TopoDS_Vertex.hxx>+#include "hs_TopoDS_Vertex.h"++TopoDS_Vertex * hs_new_TopoDS_Vertex(){+    return new TopoDS_Vertex();+}+
+ cpp/hs_TopoDS_Wire.cpp view
@@ -0,0 +1,7 @@+#include <TopoDS_Wire.hxx>+#include "hs_TopoDS_Wire.h"++TopoDS_Wire * hs_new_TopoDS_Wire(){+    return new TopoDS_Wire();+}+
+ cpp/hs_gp.cpp view
@@ -0,0 +1,69 @@+#include <gp.hxx>+#include <gp_Pnt.hxx>+#include <gp_Pnt2d.hxx>+#include <gp_Dir.hxx>+#include <gp_Dir2d.hxx>+#include <gp_Ax1.hxx>+#include <gp_Ax2.hxx>+#include <gp_Ax2d.hxx>+#include "hs_gp.h"++gp_Pnt * hs_gp_Origin(){ +    return new gp_Pnt(gp::Origin());+}++gp_Dir * hs_gp_DX(){ +    return new gp_Dir(gp::DX());+}++gp_Dir * hs_gp_DY(){ +    return new gp_Dir(gp::DY());+}++gp_Dir * hs_gp_DZ(){ +    return new gp_Dir(gp::DZ());+}++gp_Ax1 * hs_gp_OX(){ +    return new gp_Ax1(gp::OX());+}++gp_Ax1 * hs_gp_OY(){ +    return new gp_Ax1(gp::OY());+}++gp_Ax1 * hs_gp_OZ(){ +    return new gp_Ax1(gp::OZ());+}++gp_Ax2 * hs_gp_XOY(){ +    return new gp_Ax2(gp::XOY());+}++gp_Ax2 * hs_gp_YOZ(){ +    return new gp_Ax2(gp::YOZ());+}++gp_Ax2 * hs_gp_ZOX(){ +    return new gp_Ax2(gp::ZOX());+}++gp_Pnt2d * hs_gp_Origin2d(){ +    return new gp_Pnt2d(gp::Origin2d());+}++gp_Dir2d * hs_gp_DX2d(){ +    return new gp_Dir2d(gp::DX2d());+}++gp_Dir2d * hs_gp_DY2d(){ +    return new gp_Dir2d(gp::DY2d());+}++gp_Ax2d * hs_gp_OX2d(){ +    return new gp_Ax2d(gp::OX2d());+}++gp_Ax2d * hs_gp_OY2d(){ +    return new gp_Ax2d(gp::OY2d());+}
+ cpp/hs_gp_Ax1.cpp view
@@ -0,0 +1,118 @@+#include <gp_Ax1.hxx>+#include "hs_gp_Ax1.h"++gp_Ax1 * hs_new_gp_Ax1(gp_Pnt * origin, gp_Dir * direction){+    return new gp_Ax1(*origin, *direction);+}++void hs_delete_gp_Ax1(gp_Ax1* ax1){+    delete ax1;+}++gp_Dir * hs_gp_Ax1_Direction(gp_Ax1* ax1){+    return new gp_Dir(ax1->Direction());+}++gp_Pnt * hs_gp_Ax1_Location(gp_Ax1* ax1){+    return new gp_Pnt(ax1->Location());+}++void hs_gp_Ax1_SetDirection(gp_Ax1* ax1, gp_Dir* direction){+    ax1->SetDirection(*direction);+}++void hs_gp_Ax1_SetLocation(gp_Ax1* ax1, gp_Pnt* origin){+    ax1->SetLocation(*origin);+}++bool hs_gp_Ax1_IsCoaxial(gp_Ax1* axis1, gp_Ax1* axis2, double angularTolerance, double linearTolerance){+    return axis1->IsCoaxial(*axis2, angularTolerance, linearTolerance);+}++bool hs_gp_Ax1_IsNormal(gp_Ax1* axis1, gp_Ax1* axis2, double angularTolerance){+    return axis1->IsNormal(*axis2, angularTolerance);+}++bool hs_gp_Ax1_IsOpposite(gp_Ax1* axis1, gp_Ax1* axis2, double angularTolerance){+    return axis1->IsOpposite(*axis2, angularTolerance);+}++bool hs_gp_Ax1_IsParallel(gp_Ax1* axis1, gp_Ax1* axis2, double angularTolerance){+    return axis1->IsParallel(*axis2, angularTolerance);+}++double hs_gp_Ax1_Angle(gp_Ax1* axis1, gp_Ax1* axis2){+    return axis1->Angle(*axis2);+}++void hs_gp_Ax1_Reverse(gp_Ax1* ax1){+    ax1->Reverse();+}++gp_Ax1 * hs_gp_Ax1_Reversed(gp_Ax1* ax1){+    return new gp_Ax1(ax1->Reversed());+}++void hs_gp_Ax1_Mirror(gp_Ax1* ax1, gp_Ax1* mirror){+    ax1->Mirror(*mirror);+}++gp_Ax1 * hs_gp_Ax1_Mirrored(gp_Ax1* ax1, gp_Ax1* mirror){+    return new gp_Ax1(ax1->Mirrored(*mirror));+}++void hs_gp_Ax1_MirrorAboutPnt(gp_Ax1* ax1, gp_Pnt* mirror){+    ax1->Mirror(*mirror);+}++gp_Ax1 * hs_gp_Ax1_MirroredAboutPnt(gp_Ax1* ax1, gp_Pnt* mirror){+    return new gp_Ax1(ax1->Mirrored(*mirror));+}++void hs_gp_Ax1_MirrorAboutAx2(gp_Ax1* ax1, gp_Ax2* mirror){+    ax1->Mirror(*mirror);+}++gp_Ax1 * hs_gp_Ax1_MirroredAboutAx2(gp_Ax1* ax1, gp_Ax2* mirror){+    return new gp_Ax1(ax1->Mirrored(*mirror));+}++void hs_gp_Ax1_Rotate(gp_Ax1* ax1, gp_Ax1* axisOfRotation, double angle){+    ax1->Rotate(*axisOfRotation, angle);+}++gp_Ax1 * hs_gp_Ax1_Rotated(gp_Ax1* ax1, gp_Ax1* axisOfRotation, double angle){+    return new gp_Ax1(ax1->Rotated(*axisOfRotation, angle));+}++void hs_gp_Ax1_Scale(gp_Ax1* ax1, gp_Pnt* origin, double amount){+    ax1->Scale(*origin, amount);+}++gp_Ax1 * hs_gp_Ax1_Scaled(gp_Ax1* ax1, gp_Pnt* origin, double amount){+    return new gp_Ax1(ax1->Scaled(*origin, amount));+}++void hs_gp_Ax1_Transform(gp_Ax1* ax1, gp_Trsf* trsf){+    ax1->Transform(*trsf);+}++gp_Ax1 * hs_gp_Ax1_Transformed(gp_Ax1* ax1, gp_Trsf* trsf){+    return new gp_Ax1(ax1->Transformed(*trsf));+}++void hs_gp_Ax1_Translate(gp_Ax1* ax1, gp_Vec* vec){+    ax1->Translate(*vec);+}++gp_Ax1 * hs_gp_Ax1_Translated(gp_Ax1* ax1, gp_Vec* vec){+    return new gp_Ax1(ax1->Translated(*vec));+}++void hs_gp_Ax1_TranslateRelative(gp_Ax1* ax1, gp_Pnt* from, gp_Pnt* to){+    ax1->Translate(*from, *to);+}++gp_Ax1 * hs_gp_Ax1_TranslatedRelative(gp_Ax1* ax1, gp_Pnt* from, gp_Pnt* to){+    return new gp_Ax1(ax1->Translated(*from, *to));+}
+ cpp/hs_gp_Ax2.cpp view
@@ -0,0 +1,126 @@+#include <gp_Ax2.hxx>+#include "hs_gp_Ax2.h"++gp_Ax2 * hs_new_gp_Ax2(gp_Pnt * origin, gp_Dir * north, gp_Dir * vX){+    return new gp_Ax2(*origin, *north, *vX);+}++void hs_delete_gp_Ax2(gp_Ax2* ax2){+    delete ax2;+}++gp_Ax2 * hs_new_gp_Ax2_autoX(gp_Pnt * origin, gp_Dir * north){+    return new gp_Ax2(*origin, *north);+}++gp_Dir * hs_gp_Ax2_Direction(gp_Ax2* ax2){+    return new gp_Dir(ax2->Direction());+}++gp_Pnt * hs_gp_Ax2_Location(gp_Ax2* ax2){+    return new gp_Pnt(ax2->Location());+}++gp_Dir * hs_gp_Ax2_XDirection(gp_Ax2* ax2){+    return new gp_Dir(ax2->XDirection());+}++gp_Dir * hs_gp_Ax2_YDirection(gp_Ax2* ax2){+    return new gp_Dir(ax2->YDirection());+}++gp_Ax1 * hs_gp_Ax2_Axis(gp_Ax2* ax2){+    return new gp_Ax1(ax2->Axis());+}++void hs_gp_Ax2_SetDirection(gp_Ax2* ax2, gp_Dir* direction){+    ax2->SetDirection(*direction);+}++void hs_gp_Ax2_SetLocation(gp_Ax2* ax2, gp_Pnt* origin){+    ax2->SetLocation(*origin);+}++void hs_gp_Ax2_SetXDirection(gp_Ax2* ax2, gp_Dir* direction){+    ax2->SetXDirection(*direction);+}++void hs_gp_Ax2_SetYDirection(gp_Ax2* ax2, gp_Dir* direction){+    ax2->SetYDirection(*direction);+}++void hs_gp_Ax2_SetAxis(gp_Ax2* ax2, gp_Ax1* ax1){+    ax2->SetAxis(*ax1);+}++bool hs_gp_Ax2_IsCoplanar(gp_Ax2* axis1, gp_Ax2* axis2, double linearTolerance, double angularTolerance){+    return axis1->IsCoplanar(*axis2, linearTolerance, angularTolerance);+}++bool hs_gp_Ax2_IsCoplanarWithAx1(gp_Ax2* axis1, gp_Ax1* axis2, double linearTolerance, double angularTolerance){+    return axis1->IsCoplanar(*axis2, linearTolerance, angularTolerance);+}++void hs_gp_Ax2_Mirror(gp_Ax2* ax2, gp_Ax2* mirror){+    ax2->Mirror(*mirror);+}++gp_Ax2 * hs_gp_Ax2_Mirrored(gp_Ax2* ax2, gp_Ax2* mirror){+    return new gp_Ax2(ax2->Mirrored(*mirror));+}++void hs_gp_Ax2_MirrorAboutPnt(gp_Ax2* ax2, gp_Pnt* mirror){+    ax2->Mirror(*mirror);+}++gp_Ax2 * hs_gp_Ax2_MirroredAboutPnt(gp_Ax2* ax2, gp_Pnt* mirror){+    return new gp_Ax2(ax2->Mirrored(*mirror));+}++void hs_gp_Ax2_MirrorAboutAx1(gp_Ax2* ax2, gp_Ax1* mirror){+    ax2->Mirror(*mirror);+}++gp_Ax2 * hs_gp_Ax2_MirroredAboutAx1(gp_Ax2* ax2, gp_Ax1* mirror){+    return new gp_Ax2(ax2->Mirrored(*mirror));+}++void hs_gp_Ax2_Rotate(gp_Ax2* ax2, gp_Ax1* axisOfRotation, double angle){+    ax2->Rotate(*axisOfRotation, angle);+}++gp_Ax2 * hs_gp_Ax2_Rotated(gp_Ax2* ax2, gp_Ax1* axisOfRotation, double angle){+    return new gp_Ax2(ax2->Rotated(*axisOfRotation, angle));+}++void hs_gp_Ax2_Scale(gp_Ax2* ax2, gp_Pnt* origin, double amount){+    ax2->Scale(*origin, amount);+}++gp_Ax2 * hs_gp_Ax2_Scaled(gp_Ax2* ax2, gp_Pnt* origin, double amount){+    return new gp_Ax2(ax2->Scaled(*origin, amount));+}++void hs_gp_Ax2_Transform(gp_Ax2* ax2, gp_Trsf* trsf){+    ax2->Transform(*trsf);+}++gp_Ax2 * hs_gp_Ax2_Transformed(gp_Ax2* ax2, gp_Trsf* trsf){+    return new gp_Ax2(ax2->Transformed(*trsf));+}++void hs_gp_Ax2_Translate(gp_Ax2* ax2, gp_Vec* vec){+    ax2->Translate(*vec);+}++gp_Ax2 * hs_gp_Ax2_Translated(gp_Ax2* ax2, gp_Vec* vec){+    return new gp_Ax2(ax2->Translated(*vec));+}++void hs_gp_Ax2_TranslateRelative(gp_Ax2* ax2, gp_Pnt* from, gp_Pnt* to){+    ax2->Translate(*from, *to);+}++gp_Ax2 * hs_gp_Ax2_TranslatedRelative(gp_Ax2* ax2, gp_Pnt* from, gp_Pnt* to){+    return new gp_Ax2(ax2->Translated(*from, *to));+}
+ cpp/hs_gp_Ax2d.cpp view
@@ -0,0 +1,110 @@+#include <gp_Ax2d.hxx>+#include "hs_gp_Ax2d.h"++gp_Ax2d* hs_new_gp_Ax2d(gp_Pnt2d* location, gp_Dir2d* direction){+    return new gp_Ax2d(*location, *direction);+}++void hs_delete_gp_Ax2d(gp_Ax2d* ax2d){+    delete ax2d;+}++gp_Dir2d * hs_gp_Ax2d_Direction(gp_Ax2d* ax2d){+    return new gp_Dir2d(ax2d->Direction());+}++gp_Pnt2d * hs_gp_Ax2d_Location(gp_Ax2d* ax2d){+    return new gp_Pnt2d(ax2d->Location());+}++void hs_gp_Ax2d_SetDirection(gp_Ax2d* ax2d, gp_Dir2d* direction){+    ax2d->SetDirection(*direction);+}++void hs_gp_Ax2d_SetLocation(gp_Ax2d* ax2d, gp_Pnt2d* origin){+    ax2d->SetLocation(*origin);+}++bool hs_gp_Ax2d_IsCoaxial(gp_Ax2d* axis1, gp_Ax2d* axis2, double angularTolerance, double linearTolerance){+    return axis1->IsCoaxial(*axis2, angularTolerance, linearTolerance);+}++bool hs_gp_Ax2d_IsNormal(gp_Ax2d* axis1, gp_Ax2d* axis2, double angularTolerance){+    return axis1->IsNormal(*axis2, angularTolerance);+}++bool hs_gp_Ax2d_IsOpposite(gp_Ax2d* axis1, gp_Ax2d* axis2, double angularTolerance){+    return axis1->IsOpposite(*axis2, angularTolerance);+}++bool hs_gp_Ax2d_IsParallel(gp_Ax2d* axis1, gp_Ax2d* axis2, double angularTolerance){+    return axis1->IsParallel(*axis2, angularTolerance);+}++double hs_gp_Ax2d_Angle(gp_Ax2d* axis1, gp_Ax2d* axis2){+    return axis1->Angle(*axis2);+}++void hs_gp_Ax2d_Reverse(gp_Ax2d* ax2d){+    ax2d->Reverse();+}++gp_Ax2d * hs_gp_Ax2d_Reversed(gp_Ax2d* ax2d){+    return new gp_Ax2d(ax2d->Reversed());+}++void hs_gp_Ax2d_Mirror(gp_Ax2d* ax2d, gp_Ax2d* mirror){+    ax2d->Mirror(*mirror);+}++gp_Ax2d * hs_gp_Ax2d_Mirrored(gp_Ax2d* ax2d, gp_Ax2d* mirror){+    return new gp_Ax2d(ax2d->Mirrored(*mirror));+}++void hs_gp_Ax2d_MirrorAboutPnt2d(gp_Ax2d* ax2d, gp_Pnt2d* mirror){+    ax2d->Mirror(*mirror);+}++gp_Ax2d * hs_gp_Ax2d_MirroredAboutPnt2d(gp_Ax2d* ax2d, gp_Pnt2d* mirror){+    return new gp_Ax2d(ax2d->Mirrored(*mirror));+}++void hs_gp_Ax2d_Rotate(gp_Ax2d* ax2d, gp_Pnt2d* axisOfRotation, double angle){+    ax2d->Rotate(*axisOfRotation, angle);+}++gp_Ax2d * hs_gp_Ax2d_Rotated(gp_Ax2d* ax2d, gp_Pnt2d* axisOfRotation, double angle){+    return new gp_Ax2d(ax2d->Rotated(*axisOfRotation, angle));+}++void hs_gp_Ax2d_Scale(gp_Ax2d* ax2d, gp_Pnt2d* origin, double amount){+    ax2d->Scale(*origin, amount);+}++gp_Ax2d * hs_gp_Ax2d_Scaled(gp_Ax2d* ax2d, gp_Pnt2d* origin, double amount){+    return new gp_Ax2d(ax2d->Scaled(*origin, amount));+}++void hs_gp_Ax2d_Transform(gp_Ax2d* ax2d, gp_Trsf2d* trsf){+    ax2d->Transform(*trsf);+}++gp_Ax2d * hs_gp_Ax2d_Transformed(gp_Ax2d* ax2d, gp_Trsf2d* trsf){+    return new gp_Ax2d(ax2d->Transformed(*trsf));+}++void hs_gp_Ax2d_Translate(gp_Ax2d* ax2d, gp_Vec2d* vec){+    ax2d->Translate(*vec);+}++gp_Ax2d * hs_gp_Ax2d_Translated(gp_Ax2d* ax2d, gp_Vec2d* vec){+    return new gp_Ax2d(ax2d->Translated(*vec));+}++void hs_gp_Ax2d_TranslateRelative(gp_Ax2d* ax2d, gp_Pnt2d* from, gp_Pnt2d* to){+    ax2d->Translate(*from, *to);+}++gp_Ax2d * hs_gp_Ax2d_TranslatedRelative(gp_Ax2d* ax2d, gp_Pnt2d* from, gp_Pnt2d* to){+    return new gp_Ax2d(ax2d->Translated(*from, *to));+}
+ cpp/hs_gp_Dir.cpp view
@@ -0,0 +1,131 @@+#include <gp_Dir.hxx>+#include "hs_gp_Dir.h"++gp_Dir * hs_new_gp_Dir(double x, double y, double z) {+    return new gp_Dir(x, y, z);+}++void hs_delete_gp_Dir(gp_Dir* dir){+    delete dir;+}++double hs_gp_Dir_X(gp_Dir * pnt){+    return pnt->X();+}++double hs_gp_Dir_Y(gp_Dir * pnt){+    return pnt->Y();+}++double hs_gp_Dir_Z(gp_Dir * pnt){+    return pnt->Z();+}++void hs_gp_Dir_SetX(gp_Dir * pnt, double x){+    pnt->SetX(x);+}++void hs_gp_Dir_SetY(gp_Dir * pnt, double y){+    pnt->SetY(y);+}++void hs_gp_Dir_SetZ(gp_Dir * pnt, double z){+    pnt->SetZ(z);+}++bool hs_gp_Dir_IsEqual(gp_Dir * a, gp_Dir * b, double angularTolerance){+    return a->IsEqual(*b, angularTolerance);+}++bool hs_gp_Dir_IsNormal(gp_Dir * a, gp_Dir * b, double angularTolerance){+    return a->IsNormal(*b, angularTolerance);+}++bool hs_gp_Dir_IsOpposite(gp_Dir * a, gp_Dir * b, double angularTolerance){+    return a->IsOpposite(*b, angularTolerance);+}++bool hs_gp_Dir_IsParallel(gp_Dir * a, gp_Dir * b, double angularTolerance){+    return a->IsParallel(*b, angularTolerance);+}++double hs_gp_Dir_Angle(gp_Dir * a, gp_Dir * b){+    return a->Angle(*b);+}++double hs_gp_Dir_AngleWithRef(gp_Dir * a, gp_Dir * b, gp_Dir* theVRef){+    return a->AngleWithRef(*b, *theVRef);+}++void hs_gp_Dir_Cross(gp_Dir * a, gp_Dir * b){+    a->Cross(*b);+}++gp_Dir * hs_gp_Dir_Crossed(gp_Dir * a, gp_Dir * b){+    return new gp_Dir(a->Crossed(*b));+}++void hs_gp_Dir_CrossCross(gp_Dir * a, gp_Dir * b, gp_Dir * c){+    return a->CrossCross(*b, *c);+}++gp_Dir * hs_gp_Dir_CrossCrossed(gp_Dir * a, gp_Dir * b, gp_Dir * c){+    return new gp_Dir(a->CrossCrossed(*b, *c));+}++double hs_gp_Dir_Dot(gp_Dir * a, gp_Dir * b){+    return a->Dot(*b);+}++double hs_gp_Dir_DotCross(gp_Dir * a, gp_Dir * b, gp_Dir * c){+    return a->DotCross(*b, *c);+}+++void hs_gp_Dir_Reverse(gp_Dir* ax1){+    ax1->Reverse();+}++gp_Dir * hs_gp_Dir_Reversed(gp_Dir* ax1){+    return new gp_Dir(ax1->Reversed());+}++void hs_gp_Dir_Mirror(gp_Dir * theDir, gp_Dir * theAxis){+    theDir->Mirror(*theAxis);+}++gp_Dir * hs_gp_Dir_Mirrored(gp_Dir * theDir, gp_Dir * theAxis){+    return new gp_Dir(theDir->Mirrored(*theAxis));+}++void hs_gp_Dir_MirrorAboutAx1(gp_Dir * theDir, gp_Ax1 * theAxis){+    theDir->Mirror(*theAxis);+}++gp_Dir * hs_gp_Dir_MirroredAboutAx1(gp_Dir * theDir, gp_Ax1 * theAxis){+    return new gp_Dir(theDir->Mirrored(*theAxis));+}++void hs_gp_Dir_MirrorAboutAx2(gp_Dir * theDir, gp_Ax2 * theAxis){+    theDir->Mirror(*theAxis);+}++gp_Dir * hs_gp_Dir_MirroredAboutAx2(gp_Dir * theDir, gp_Ax2 * theAxis){+    return new gp_Dir(theDir->Mirrored(*theAxis));+}++void hs_gp_Dir_Rotate(gp_Dir * theDir, gp_Ax1 * theAxis, double amount){+    theDir->Rotate(*theAxis, amount);+}++gp_Dir * hs_gp_Dir_Rotated(gp_Dir * theDir, gp_Ax1 * theAxis, double amount){+    return new gp_Dir(theDir->Rotated(*theAxis, amount));+}++void hs_gp_Dir_Transform(gp_Dir * theDir, gp_Trsf * trsf){+    theDir->Transform(*trsf);+}++gp_Dir * hs_gp_Dir_Transformed(gp_Dir * theDir, gp_Trsf * trsf){+    return new gp_Dir(theDir->Transformed(*trsf));+}
+ cpp/hs_gp_Dir2d.cpp view
@@ -0,0 +1,95 @@+#include <gp_Dir2d.hxx>+#include "hs_gp_Dir2d.h"++gp_Dir2d * hs_new_gp_Dir2d(double x, double y) {+    return new gp_Dir2d(x, y);+}++void hs_delete_gp_Dir2d(gp_Dir2d* dir){+    delete dir;+}++double hs_gp_Dir2d_X(gp_Dir2d * pnt){+    return pnt->X();+}++double hs_gp_Dir2d_Y(gp_Dir2d * pnt){+    return pnt->Y();+}+++void hs_gp_Dir2d_SetX(gp_Dir2d * pnt, double x){+    pnt->SetX(x);+}++void hs_gp_Dir2d_SetY(gp_Dir2d * pnt, double y){+    pnt->SetY(y);+}++bool hs_gp_Dir2d_IsEqual(gp_Dir2d * a, gp_Dir2d * b, double angularTolerance){+    return a->IsEqual(*b, angularTolerance);+}++bool hs_gp_Dir2d_IsNormal(gp_Dir2d * a, gp_Dir2d * b, double angularTolerance){+    return a->IsNormal(*b, angularTolerance);+}++bool hs_gp_Dir2d_IsOpposite(gp_Dir2d * a, gp_Dir2d * b, double angularTolerance){+    return a->IsOpposite(*b, angularTolerance);+}++bool hs_gp_Dir2d_IsParallel(gp_Dir2d * a, gp_Dir2d * b, double angularTolerance){+    return a->IsParallel(*b, angularTolerance);+}++double hs_gp_Dir2d_Angle(gp_Dir2d * a, gp_Dir2d * b){+    return a->Angle(*b);+}++double hs_gp_Dir2d_Crossed(gp_Dir2d * a, gp_Dir2d * b){+    return a->Crossed(*b);+}++double hs_gp_Dir2d_Dot(gp_Dir2d * a, gp_Dir2d * b){+    return a->Dot(*b);+}++void hs_gp_Dir2d_Reverse(gp_Dir2d* ax1){+    ax1->Reverse();+}++gp_Dir2d * hs_gp_Dir2d_Reversed(gp_Dir2d* ax1){+    return new gp_Dir2d(ax1->Reversed());+}++void hs_gp_Dir2d_Mirror(gp_Dir2d * theDir2d, gp_Dir2d * theAxis){+    theDir2d->Mirror(*theAxis);+}++gp_Dir2d * hs_gp_Dir2d_Mirrored(gp_Dir2d * theDir2d, gp_Dir2d * theAxis){+    return new gp_Dir2d(theDir2d->Mirrored(*theAxis));+}++void hs_gp_Dir2d_MirrorAboutAx2d(gp_Dir2d * theDir2d, gp_Ax2d * theAxis){+    theDir2d->Mirror(*theAxis);+}++gp_Dir2d * hs_gp_Dir2d_MirroredAboutAx2d(gp_Dir2d * theDir2d, gp_Ax2d * theAxis){+    return new gp_Dir2d(theDir2d->Mirrored(*theAxis));+}++void hs_gp_Dir2d_Rotate(gp_Dir2d * theDir2d, double amount){+    theDir2d->Rotate(amount);+}++gp_Dir2d * hs_gp_Dir2d_Rotated(gp_Dir2d * theDir2d, double amount){+    return new gp_Dir2d(theDir2d->Rotated(amount));+}++void hs_gp_Dir2d_Transform(gp_Dir2d * theDir2d, gp_Trsf2d * trsf){+    theDir2d->Transform(*trsf);+}++gp_Dir2d * hs_gp_Dir2d_Transformed(gp_Dir2d * theDir2d, gp_Trsf2d * trsf){+    return new gp_Dir2d(theDir2d->Transformed(*trsf));+}
+ cpp/hs_gp_GTrsf.cpp view
@@ -0,0 +1,19 @@+#include <gp_GTrsf.hxx>+#include "hs_gp_GTrsf.h"++gp_GTrsf * hs_new_gp_GTrsf(){+    return new gp_GTrsf();+}++void hs_delete_gp_GTrsf(gp_GTrsf * t){+    delete t;+}++void hs_gp_GTrsf_setValue(gp_GTrsf * trsf, int row, int col, double value){+    trsf->SetValue(row, col, value);+}+++void hs_gp_GTrsf_setForm(gp_GTrsf * trsf){+    trsf->SetForm();+}
+ cpp/hs_gp_Pnt.cpp view
@@ -0,0 +1,117 @@+#include <gp_Pnt.hxx>+#include "hs_gp_Pnt.h"++gp_Pnt * hs_new_gp_Pnt(double x, double y, double z) {+    return new gp_Pnt(x, y, z);+}++void hs_delete_gp_Pnt(gp_Pnt* pnt){+    delete pnt;+}++double hs_gp_Pnt_X(gp_Pnt * pnt){+    return pnt->X();+}++double hs_gp_Pnt_Y(gp_Pnt * pnt){+    return pnt->Y();+}++double hs_gp_Pnt_Z(gp_Pnt * pnt){+    return pnt->Z();+}++void hs_gp_Pnt_SetX(gp_Pnt * pnt, double x){+    pnt->SetX(x);+}++void hs_gp_Pnt_SetY(gp_Pnt * pnt, double y){+    pnt->SetY(y);+}++void hs_gp_Pnt_SetZ(gp_Pnt * pnt, double z){+    pnt->SetZ(z);+}++double hs_gp_Pnt_Distance(gp_Pnt * a, gp_Pnt * b ){+    return a->Distance(*b);+}++double hs_gp_Pnt_SquareDistance(gp_Pnt * a, gp_Pnt * b ){+    return a->SquareDistance(*b);+}++void hs_gp_Pnt_BaryCenter(gp_Pnt * a, double alpha, gp_Pnt * b, double beta){+    a->BaryCenter(alpha, *b, beta);+}++bool hs_gp_Pnt_IsEqual(gp_Pnt * a, gp_Pnt * b, double tolerance){+    return a->IsEqual(*b, tolerance);+}++void hs_gp_Pnt_Mirror(gp_Pnt * thePnt, gp_Pnt * theAxis){+    thePnt->Mirror(*theAxis);+}++gp_Pnt * hs_gp_Pnt_Mirrored(gp_Pnt * thePnt, gp_Pnt * theAxis){+    return new gp_Pnt(thePnt->Mirrored(*theAxis));+}++void hs_gp_Pnt_MirrorAboutAx1(gp_Pnt * thePnt, gp_Ax1 * theAxis){+    thePnt->Mirror(*theAxis);+}++gp_Pnt * hs_gp_Pnt_MirroredAboutAx1(gp_Pnt * thePnt, gp_Ax1 * theAxis){+    return new gp_Pnt(thePnt->Mirrored(*theAxis));+}++void hs_gp_Pnt_MirrorAboutAx2(gp_Pnt * thePnt, gp_Ax2 * theAxis){+    thePnt->Mirror(*theAxis);+}++gp_Pnt * hs_gp_Pnt_MirroredAboutAx2(gp_Pnt * thePnt, gp_Ax2 * theAxis){+    return new gp_Pnt(thePnt->Mirrored(*theAxis));+}++void hs_gp_Pnt_Rotate(gp_Pnt * thePnt, gp_Ax1 * theAxis, double amount){+    thePnt->Rotate(*theAxis, amount);+}++gp_Pnt * hs_gp_Pnt_Rotated(gp_Pnt * thePnt, gp_Ax1 * theAxis, double amount){+    return new gp_Pnt(thePnt->Rotated(*theAxis, amount));+}++void hs_gp_Pnt_Scale(gp_Pnt * thePnt, gp_Pnt * origin, double amount){+    thePnt->Scale(*origin, amount);+}++gp_Pnt * hs_gp_Pnt_Scaled(gp_Pnt * thePnt, gp_Pnt * origin, double amount){+    return new gp_Pnt(thePnt->Scaled(*origin, amount));+}++void hs_gp_Pnt_Transform(gp_Pnt * thePnt, gp_Trsf * trsf){+    thePnt->Transform(*trsf);+}++gp_Pnt * hs_gp_Pnt_Transformed(gp_Pnt * thePnt, gp_Trsf * trsf){+    return new gp_Pnt(thePnt->Transformed(*trsf));+}++void hs_gp_Pnt_Translate(gp_Pnt * thePnt, gp_Vec * vec){+    thePnt->Translate(*vec);+}++gp_Pnt * hs_gp_Pnt_Translated(gp_Pnt * thePnt, gp_Vec * vec){+    return new gp_Pnt(thePnt->Translated(*vec));+}++void hs_gp_Pnt_TranslateRelative(gp_Pnt * thePnt, gp_Pnt * from, gp_Pnt * to){+    thePnt->Translate(*from, *to);+}++gp_Pnt * hs_gp_Pnt_TranslatedRelative(gp_Pnt * thePnt, gp_Pnt * from, gp_Pnt * to){+    return new gp_Pnt(thePnt->Translated(*from, *to));+}+++
+ cpp/hs_gp_Pnt2d.cpp view
@@ -0,0 +1,95 @@+#include <gp_Pnt2d.hxx>+#include "hs_gp_Pnt2d.h"++gp_Pnt2d * hs_new_gp_Pnt2d(double x, double y) {+    return new gp_Pnt2d(x, y);+}++void hs_delete_gp_Pnt2d(gp_Pnt2d* pnt){+    delete pnt;+}++double hs_gp_Pnt2d_X(gp_Pnt2d * pnt){+    return pnt->X();+}++double hs_gp_Pnt2d_Y(gp_Pnt2d * pnt){+    return pnt->Y();+}++void hs_gp_Pnt2d_SetX(gp_Pnt2d * pnt, double x){+    pnt->SetX(x);+}++void hs_gp_Pnt2d_SetY(gp_Pnt2d * pnt, double y){+    pnt->SetY(y);+}++double hs_gp_Pnt2d_Distance(gp_Pnt2d * a, gp_Pnt2d * b ){+    return a->Distance(*b);+}++double hs_gp_Pnt2d_SquareDistance(gp_Pnt2d * a, gp_Pnt2d * b ){+    return a->SquareDistance(*b);+}++bool hs_gp_Pnt2d_IsEqual(gp_Pnt2d * a, gp_Pnt2d * b, double tolerance){+    return a->IsEqual(*b, tolerance);+}++void hs_gp_Pnt2d_Mirror(gp_Pnt2d * thePnt2d, gp_Pnt2d * theAxis){+    thePnt2d->Mirror(*theAxis);+}++gp_Pnt2d * hs_gp_Pnt2d_Mirrored(gp_Pnt2d * thePnt2d, gp_Pnt2d * theAxis){+    return new gp_Pnt2d(thePnt2d->Mirrored(*theAxis));+}++void hs_gp_Pnt2d_MirrorAboutAx2d(gp_Pnt2d * thePnt2d, gp_Ax2d * theAxis){+    thePnt2d->Mirror(*theAxis);+}++gp_Pnt2d * hs_gp_Pnt2d_MirroredAboutAx2d(gp_Pnt2d * thePnt2d, gp_Ax2d * theAxis){+    return new gp_Pnt2d(thePnt2d->Mirrored(*theAxis));+}++void hs_gp_Pnt2d_Rotate(gp_Pnt2d * thePnt2d, gp_Pnt2d * theAxis, double amount){+    thePnt2d->Rotate(*theAxis, amount);+}++gp_Pnt2d * hs_gp_Pnt2d_Rotated(gp_Pnt2d * thePnt2d, gp_Pnt2d * theAxis, double amount){+    return new gp_Pnt2d(thePnt2d->Rotated(*theAxis, amount));+}++void hs_gp_Pnt2d_Scale(gp_Pnt2d * thePnt2d, gp_Pnt2d * origin, double amount){+    thePnt2d->Scale(*origin, amount);+}++gp_Pnt2d * hs_gp_Pnt2d_Scaled(gp_Pnt2d * thePnt2d, gp_Pnt2d * origin, double amount){+    return new gp_Pnt2d(thePnt2d->Scaled(*origin, amount));+}++void hs_gp_Pnt2d_Transform(gp_Pnt2d * thePnt2d, gp_Trsf2d * trsf){+    thePnt2d->Transform(*trsf);+}++gp_Pnt2d * hs_gp_Pnt2d_Transformed(gp_Pnt2d * thePnt2d, gp_Trsf2d * trsf){+    return new gp_Pnt2d(thePnt2d->Transformed(*trsf));+}++void hs_gp_Pnt2d_Translate(gp_Pnt2d * thePnt2d, gp_Vec2d * vec){+    thePnt2d->Translate(*vec);+}++gp_Pnt2d * hs_gp_Pnt2d_Translated(gp_Pnt2d * thePnt2d, gp_Vec2d * vec){+    return new gp_Pnt2d(thePnt2d->Translated(*vec));+}++void hs_gp_Pnt2d_TranslateRelative(gp_Pnt2d * thePnt2d, gp_Pnt2d * from, gp_Pnt2d * to){+    thePnt2d->Translate(*from, *to);+}++gp_Pnt2d * hs_gp_Pnt2d_TranslatedRelative(gp_Pnt2d * thePnt2d, gp_Pnt2d * from, gp_Pnt2d * to){+    return new gp_Pnt2d(thePnt2d->Translated(*from, *to));+}+
+ cpp/hs_gp_Trsf.cpp view
@@ -0,0 +1,98 @@+#include <gp_Trsf.hxx>+#include "hs_gp_Trsf.h"++gp_Trsf * hs_new_gp_Trsf(){+    return new gp_Trsf();+}++void hs_delete_gp_Trsf(gp_Trsf * t){+    delete t;+}++gp_Trsf * hs_new_gp_Trsf_fromTrsf2d(gp_Trsf2d * t){+    return new gp_Trsf(*t);+}++void hs_gp_Trsf_SetMirrorAboutPnt(gp_Trsf * trsf, gp_Pnt * pnt){+    trsf->SetMirror(*pnt);+}++void hs_gp_Trsf_SetMirrorAboutAx1(gp_Trsf * trsf, gp_Ax1 * ax){+    trsf->SetMirror(*ax);+}++void hs_gp_Trsf_SetMirrorAboutAx2(gp_Trsf * trsf, gp_Ax2 * ax){+    trsf->SetMirror(*ax);+}++void hs_gp_Trsf_SetRotationAboutAxisAngle(gp_Trsf * trsf, gp_Ax1 * ax, double angle){+    trsf->SetRotation(*ax, angle);+}++void hs_gp_Trsf_SetScale(gp_Trsf * trsf, gp_Pnt * origin, double factor){+    trsf->SetScale(*origin, factor);+}++void hs_gp_Trsf_SetTranslation(gp_Trsf * trsf, gp_Vec * trans){+    trsf->SetTranslation(*trans);+}++void hs_gp_Trsf_SetTranslationPart(gp_Trsf * trsf, gp_Vec * trans){+    trsf->SetTranslationPart(*trans);+}++void hs_gp_Trsf_SetScaleFactor(gp_Trsf * trsf, double s){+    trsf->SetScaleFactor(s);+}++void hs_gp_Trsf_SetValues(gp_Trsf * trsf, +        double a11, double a12, double a13, double a14,+        double a21, double a22, double a23, double a24,+        double a31, double a32, double a33, double a34){+    trsf->SetValues(+         a11, a12, a13, a14,+         a21, a22, a23, a24,+         a31, a32, a33, a34+    );+}++bool hs_gp_Trsf_IsNegative(gp_Trsf * trsf){+    return trsf->IsNegative();+}++double hs_gp_Trsf_ScaleFactor(gp_Trsf * trsf){+    return trsf->ScaleFactor();+}++double hs_gp_Trsf_Value(gp_Trsf* trsf, int row, int col){+    return trsf->Value(row, col);+}++void hs_gp_Trsf_Invert(gp_Trsf* trsf){+    trsf->Invert();+}++gp_Trsf * hs_gp_Trsf_Inverted(gp_Trsf* trsf){+    return new gp_Trsf(trsf->Inverted());+}++void hs_gp_Trsf_Multiply(gp_Trsf * trsf, gp_Trsf* b){+    trsf->Multiply(*b);+}++gp_Trsf * hs_gp_Trsf_Multiplied(gp_Trsf* a, gp_Trsf* b){+    return new gp_Trsf(a->Multiplied(*b));+}++void hs_gp_Trsf_PreMultiply(gp_Trsf * trsf, gp_Trsf* b){+    trsf->PreMultiply(*b);+}++void hs_gp_Trsf_Power(gp_Trsf * trsf, int b){+    trsf->Power(b);+}++gp_Trsf * hs_gp_Trsf_Powered(gp_Trsf* a, int b){+    return new gp_Trsf(a->Powered(b));+}+
+ cpp/hs_gp_Trsf2d.cpp view
@@ -0,0 +1,104 @@+#include <gp_Trsf2d.hxx>+#include "hs_gp_Trsf2d.h"++gp_Trsf2d * hs_new_gp_Trsf2d(){+    return new gp_Trsf2d();+}++void hs_delete_gp_Trsf2d(gp_Trsf2d * t){+    delete t;+}++gp_Trsf2d * hs_new_gp_Trsf2d_fromTrsf(gp_Trsf * t){+    return new gp_Trsf2d(*t);+}++void hs_gp_Trsf2d_SetMirrorAboutPnt2d(gp_Trsf2d * trsf, gp_Pnt2d * pnt){+    trsf->SetMirror(*pnt);+}++void hs_gp_Trsf2d_SetMirrorAboutAx2d(gp_Trsf2d * trsf, gp_Ax2d * ax){+    trsf->SetMirror(*ax);+}++void hs_gp_Trsf2d_SetRotation(gp_Trsf2d * trsf, gp_Pnt2d * ax, double angle){+    trsf->SetRotation(*ax, angle);+}++void hs_gp_Trsf2d_SetScale(gp_Trsf2d * trsf, gp_Pnt2d * origin, double factor){+    trsf->SetScale(*origin, factor);+}++void hs_gp_Trsf2d_SetTransformation(gp_Trsf2d * trsf, gp_Ax2d * to){+    trsf->SetTransformation(*to);+}++void hs_gp_Trsf2d_SetTransformationRelative(gp_Trsf2d * trsf, gp_Ax2d * from, gp_Ax2d * to){+    trsf->SetTransformation(*from, *to);+}++void hs_gp_Trsf2d_SetTranslation(gp_Trsf2d * trsf, gp_Vec2d * trans){+    trsf->SetTranslation(*trans);+}++void hs_gp_Trsf2d_SetTranslationRelative(gp_Trsf2d * trsf, gp_Pnt2d * from, gp_Pnt2d * to){+    trsf->SetTranslation(*from, *to);+}++void hs_gp_Trsf2d_SetTranslationPart(gp_Trsf2d * trsf, gp_Vec2d * trans){+    trsf->SetTranslationPart(*trans);+}++void hs_gp_Trsf2d_SetScaleFactor(gp_Trsf2d * trsf, double s){+    trsf->SetScaleFactor(s);+}++void hs_gp_Trsf2d_SetValues(gp_Trsf2d * trsf, +        double a11, double a12, double a13, +        double a21, double a22, double a23){+    trsf->SetValues(+         a11, a12, a13,+         a21, a22, a23+    );+}++bool hs_gp_Trsf2d_IsNegative(gp_Trsf2d * trsf){+    return trsf->IsNegative();+}++double hs_gp_Trsf2d_ScaleFactor(gp_Trsf2d * trsf){+    return trsf->ScaleFactor();+}++double hs_gp_Trsf2d_Value(gp_Trsf2d* trsf, int row, int col){+    return trsf->Value(row, col);+}++void hs_gp_Trsf2d_Invert(gp_Trsf2d* trsf){+    trsf->Invert();+}++gp_Trsf2d * hs_gp_Trsf2d_Inverted(gp_Trsf2d* trsf){+    return new gp_Trsf2d(trsf->Inverted());+}++void hs_gp_Trsf2d_Multiply(gp_Trsf2d * trsf, gp_Trsf2d* b){+    trsf->Multiply(*b);+}++gp_Trsf2d * hs_gp_Trsf2d_Multiplied(gp_Trsf2d* a, gp_Trsf2d* b){+    return new gp_Trsf2d(a->Multiplied(*b));+}++void hs_gp_Trsf2d_PreMultiply(gp_Trsf2d * trsf, gp_Trsf2d* b){+    trsf->PreMultiply(*b);+}++void hs_gp_Trsf2d_Power(gp_Trsf2d * trsf, int b){+    trsf->Power(b);+}++gp_Trsf2d * hs_gp_Trsf2d_Powered(gp_Trsf2d* a, int b){+    return new gp_Trsf2d(a->Powered(b));+}+
+ cpp/hs_gp_Vec.cpp view
@@ -0,0 +1,197 @@+#include <gp_Vec.hxx>+#include "hs_gp_Vec.h"++gp_Vec * hs_new_gp_Vec(double x, double y, double z) {+    return new gp_Vec(x, y, z);+}++void hs_delete_gp_Vec(gp_Vec* vec){+    delete vec;+}+++double hs_gp_Vec_X(gp_Vec * vec){+    return vec->X();+}++double hs_gp_Vec_Y(gp_Vec * vec){+    return vec->Y();+}++double hs_gp_Vec_Z(gp_Vec * vec){+    return vec->Z();+}++void hs_gp_Vec_SetX(gp_Vec * vec, double x){+    vec->SetX(x);+}++void hs_gp_Vec_SetY(gp_Vec * vec, double y){+    vec->SetY(y);+}++void hs_gp_Vec_SetZ(gp_Vec * vec, double z){+    vec->SetZ(z);+}++bool hs_gp_Vec_IsEqual(gp_Vec * a, gp_Vec * b, double linearTolerance, double angularTolerance){+    return a->IsEqual(*b, linearTolerance, angularTolerance);+}++bool hs_gp_Vec_IsNormal(gp_Vec * a, gp_Vec * b, double angularTolerance){+    return a->IsNormal(*b, angularTolerance);+}++bool hs_gp_Vec_IsOpposite(gp_Vec * a, gp_Vec * b, double angularTolerance){+    return a->IsOpposite(*b, angularTolerance);+}++bool hs_gp_Vec_IsParallel(gp_Vec * a, gp_Vec * b, double angularTolerance){+    return a->IsParallel(*b, angularTolerance);+}++double hs_gp_Vec_Angle(gp_Vec * a, gp_Vec * b){+    return a->Angle(*b);+}++double hs_gp_Vec_AngleWithRef(gp_Vec * a, gp_Vec * b, gp_Vec* theVRef){+    return a->AngleWithRef(*b, *theVRef);+}++double hs_gp_Vec_Magnitude(gp_Vec * a){+    return a->Magnitude();+}++double hs_gp_Vec_SquareMagnitude(gp_Vec * a){+    return a->SquareMagnitude();+}++void hs_gp_Vec_Add(gp_Vec * a, gp_Vec * b){+    a->Add(*b);+}++gp_Vec * hs_gp_Vec_Added(gp_Vec * a, gp_Vec * b){+    return new gp_Vec(a->Added(*b));+}+++void hs_gp_Vec_Subtract(gp_Vec * a, gp_Vec * b){+    a->Subtract(*b);+}++gp_Vec * hs_gp_Vec_Subtracted(gp_Vec * a, gp_Vec * b){+    return new gp_Vec(a->Subtracted(*b));+}++void hs_gp_Vec_Multiply(gp_Vec * a, double b){+    a->Multiply(b);+}++gp_Vec * hs_gp_Vec_Multiplied(gp_Vec * a, double b){+    return new gp_Vec(a->Multiplied(b));+}+++void hs_gp_Vec_Divide(gp_Vec * a, double b){+    a->Divide(b);+}++gp_Vec * hs_gp_Vec_Divided(gp_Vec * a, double b){+    return new gp_Vec(a->Divided(b));+}++void hs_gp_Vec_Cross(gp_Vec * a, gp_Vec * b){+    a->Cross(*b);+}++gp_Vec * hs_gp_Vec_Crossed(gp_Vec * a, gp_Vec * b){+    return new gp_Vec(a->Crossed(*b));+}++void hs_gp_Vec_CrossCross(gp_Vec * a, gp_Vec * b, gp_Vec * c){+    return a->CrossCross(*b, *c);+}++double hs_gp_Vec_CrossMagnitude(gp_Vec * a, gp_Vec * b){+    return a->CrossMagnitude(*b);+}++double hs_gp_Vec_CrossSquareMagnitude(gp_Vec * a, gp_Vec * b){+    return a->CrossSquareMagnitude(*b);+}++gp_Vec * hs_gp_Vec_CrossCrossed(gp_Vec * a, gp_Vec * b, gp_Vec * c){+    return new gp_Vec(a->CrossCrossed(*b, *c));+}++double hs_gp_Vec_Dot(gp_Vec * a, gp_Vec * b){+    return a->Dot(*b);+}++double hs_gp_Vec_DotCross(gp_Vec * a, gp_Vec * b, gp_Vec * c){+    return a->DotCross(*b, *c);+}++void hs_gp_Vec_Normalize(gp_Vec * a){+    a->Normalize();+}++gp_Vec * hs_gp_Vec_Normalized(gp_Vec * a){+    return new gp_Vec(a->Normalized());+}++void hs_gp_Vec_Reverse(gp_Vec* a){+    a->Reverse();+}++gp_Vec * hs_gp_Vec_Reversed(gp_Vec* a){+    return new gp_Vec(a->Reversed());+}++void hs_gp_Vec_Mirror(gp_Vec * theVec, gp_Vec * theAxis){+    theVec->Mirror(*theAxis);+}++gp_Vec * hs_gp_Vec_Mirrored(gp_Vec * theVec, gp_Vec * theAxis){+    return new gp_Vec(theVec->Mirrored(*theAxis));+}++void hs_gp_Vec_MirrorAboutAx1(gp_Vec * theVec, gp_Ax1 * theAxis){+    theVec->Mirror(*theAxis);+}++gp_Vec * hs_gp_Vec_MirroredAboutAx1(gp_Vec * theVec, gp_Ax1 * theAxis){+    return new gp_Vec(theVec->Mirrored(*theAxis));+}++void hs_gp_Vec_MirrorAboutAx2(gp_Vec * theVec, gp_Ax2 * theAxis){+    theVec->Mirror(*theAxis);+}++gp_Vec * hs_gp_Vec_MirroredAboutAx2(gp_Vec * theVec, gp_Ax2 * theAxis){+    return new gp_Vec(theVec->Mirrored(*theAxis));+}++void hs_gp_Vec_Rotate(gp_Vec * theVec, gp_Ax1 * theAxis, double amount){+    theVec->Rotate(*theAxis, amount);+}++gp_Vec * hs_gp_Vec_Rotated(gp_Vec * theVec, gp_Ax1 * theAxis, double amount){+    return new gp_Vec(theVec->Rotated(*theAxis, amount));+}++void hs_gp_Vec_Scale(gp_Vec * theVec, double s){+    theVec->Scale(s);+}++gp_Vec * hs_gp_Vec_Scaled(gp_Vec * theVec, double s){+    return new gp_Vec(theVec->Scaled(s));+}++void hs_gp_Vec_Transform(gp_Vec * theVec, gp_Trsf * trsf){+    theVec->Transform(*trsf);+}++gp_Vec * hs_gp_Vec_Transformed(gp_Vec * theVec, gp_Trsf * trsf){+    return new gp_Vec(theVec->Transformed(*trsf));+}
+ cpp/hs_gp_Vec2d.cpp view
@@ -0,0 +1,159 @@+#include <gp_Vec2d.hxx>+#include "hs_gp_Vec2d.h"++gp_Vec2d * hs_new_gp_Vec2d(double x, double y) {+    return new gp_Vec2d(x, y);+}++void hs_delete_gp_Vec2d(gp_Vec2d* vec){+    delete vec;+}++double hs_gp_Vec2d_X(gp_Vec2d * vec){+    return vec->X();+}++double hs_gp_Vec2d_Y(gp_Vec2d * vec){+    return vec->Y();+}++void hs_gp_Vec2d_SetX(gp_Vec2d * vec, double x){+    vec->SetX(x);+}++void hs_gp_Vec2d_SetY(gp_Vec2d * vec, double y){+    vec->SetY(y);+}++bool hs_gp_Vec2d_IsEqual(gp_Vec2d * a, gp_Vec2d * b, double linearTolerance, double angularTolerance){+    return a->IsEqual(*b, linearTolerance, angularTolerance);+}++bool hs_gp_Vec2d_IsNormal(gp_Vec2d * a, gp_Vec2d * b, double angularTolerance){+    return a->IsNormal(*b, angularTolerance);+}++bool hs_gp_Vec2d_IsOpposite(gp_Vec2d * a, gp_Vec2d * b, double angularTolerance){+    return a->IsOpposite(*b, angularTolerance);+}++bool hs_gp_Vec2d_IsParallel(gp_Vec2d * a, gp_Vec2d * b, double angularTolerance){+    return a->IsParallel(*b, angularTolerance);+}++double hs_gp_Vec2d_Angle(gp_Vec2d * a, gp_Vec2d * b){+    return a->Angle(*b);+}++double hs_gp_Vec2d_Magnitude(gp_Vec2d * a){+    return a->Magnitude();+}++double hs_gp_Vec2d_SquareMagnitude(gp_Vec2d * a){+    return a->SquareMagnitude();+}++void hs_gp_Vec2d_Add(gp_Vec2d * a, gp_Vec2d * b){+    a->Add(*b);+}++gp_Vec2d * hs_gp_Vec2d_Added(gp_Vec2d * a, gp_Vec2d * b){+    return new gp_Vec2d(a->Added(*b));+}++void hs_gp_Vec2d_Subtract(gp_Vec2d * a, gp_Vec2d * b){+    a->Subtract(*b);+}++gp_Vec2d * hs_gp_Vec2d_Subtracted(gp_Vec2d * a, gp_Vec2d * b){+    return new gp_Vec2d(a->Subtracted(*b));+}++void hs_gp_Vec2d_Multiply(gp_Vec2d * a, double b){+    a->Multiply(b);+}++gp_Vec2d * hs_gp_Vec2d_Multiplied(gp_Vec2d * a, double b){+    return new gp_Vec2d(a->Multiplied(b));+}+++void hs_gp_Vec2d_Divide(gp_Vec2d * a, double b){+    a->Divide(b);+}++gp_Vec2d * hs_gp_Vec2d_Divided(gp_Vec2d * a, double b){+    return new gp_Vec2d(a->Divided(b));+}++double hs_gp_Vec2d_Crossed(gp_Vec2d * a, gp_Vec2d * b){+    return a->Crossed(*b);+}++double hs_gp_Vec2d_CrossMagnitude(gp_Vec2d * a, gp_Vec2d * b){+    return a->CrossMagnitude(*b);+}++double hs_gp_Vec2d_CrossSquareMagnitude(gp_Vec2d * a, gp_Vec2d * b){+    return a->CrossSquareMagnitude(*b);+}++double hs_gp_Vec2d_Dot(gp_Vec2d * a, gp_Vec2d * b){+    return a->Dot(*b);+}++void hs_gp_Vec2d_Normalize(gp_Vec2d * a){+    a->Normalize();+}++gp_Vec2d * hs_gp_Vec2d_Normalized(gp_Vec2d * a){+    return new gp_Vec2d(a->Normalized());+}++void hs_gp_Vec2d_Reverse(gp_Vec2d* a){+    a->Reverse();+}++gp_Vec2d * hs_gp_Vec2d_Reversed(gp_Vec2d* a){+    return new gp_Vec2d(a->Reversed());+}++void hs_gp_Vec2d_Mirror(gp_Vec2d * theVec2d, gp_Vec2d * theAxis){+    theVec2d->Mirror(*theAxis);+}++gp_Vec2d * hs_gp_Vec2d_Mirrored(gp_Vec2d * theVec2d, gp_Vec2d * theAxis){+    return new gp_Vec2d(theVec2d->Mirrored(*theAxis));+}++void hs_gp_Vec2d_MirrorAboutAx2d(gp_Vec2d * theVec2d, gp_Ax2d * theAxis){+    theVec2d->Mirror(*theAxis);+}++gp_Vec2d * hs_gp_Vec2d_MirroredAboutAx2d(gp_Vec2d * theVec2d, gp_Ax2d * theAxis){+    return new gp_Vec2d(theVec2d->Mirrored(*theAxis));+}++void hs_gp_Vec2d_Rotate(gp_Vec2d * theVec2d, double amount){+    theVec2d->Rotate(amount);+}++gp_Vec2d * hs_gp_Vec2d_Rotated(gp_Vec2d * theVec2d, double amount){+    return new gp_Vec2d(theVec2d->Rotated(amount));+}++void hs_gp_Vec2d_Scale(gp_Vec2d * theVec2d, double s){+    theVec2d->Scale(s);+}++gp_Vec2d * hs_gp_Vec2d_Scaled(gp_Vec2d * theVec2d, double s){+    return new gp_Vec2d(theVec2d->Scaled(s));+}++void hs_gp_Vec2d_Transform(gp_Vec2d * theVec2d, gp_Trsf2d * trsf){+    theVec2d->Transform(*trsf);+}++gp_Vec2d * hs_gp_Vec2d_Transformed(gp_Vec2d * theVec2d, gp_Trsf2d * trsf){+    return new gp_Vec2d(theVec2d->Transformed(*trsf));+}
+ opencascade-hs.cabal view
@@ -0,0 +1,222 @@+cabal-version: 2.2++-- This file has been generated from package.yaml by hpack version 0.36.0.+--+-- see: https://github.com/sol/hpack++name:           opencascade-hs+version:        0.0.0.1+synopsis:       Thin Wrapper for the OpenCASCADE CAD Kernel+description:    Please see the README on GitHub at <https://github.com/joe-warren/opencascade-hs#readme>+category:       Graphics,FFI+homepage:       https://github.com/joe-warren/opencascade-hs#readme+bug-reports:    https://github.com/joe-warren/opencascade-hs/issues+author:         Joe Warren+maintainer:     josephmarkwarren@gmail.com+copyright:      2023 Joe Warren+license:        LGPL-2.1-only+license-file:   LICENSE+build-type:     Simple+extra-source-files:+    LICENSE+    README.md+    CHANGELOG.md++source-repository head+  type: git+  location: https://github.com/joe-warren/opencascade-hs++library+  exposed-modules:+      OpenCascade.BRep.Tool+      OpenCascade.BRepAlgoAPI.Common+      OpenCascade.BRepAlgoAPI.Cut+      OpenCascade.BRepAlgoAPI.Fuse+      OpenCascade.BRepBuilderAPI+      OpenCascade.BRepBuilderAPI.FaceError+      OpenCascade.BRepBuilderAPI.GTransform+      OpenCascade.BRepBuilderAPI.Internal.Destructors+      OpenCascade.BRepBuilderAPI.MakeEdge+      OpenCascade.BRepBuilderAPI.MakeFace+      OpenCascade.BRepBuilderAPI.MakeShape+      OpenCascade.BRepBuilderAPI.MakeSolid+      OpenCascade.BRepBuilderAPI.MakeWire+      OpenCascade.BRepBuilderAPI.Transform+      OpenCascade.BRepBuilderAPI.Types+      OpenCascade.BRepBuilderAPI.WireError+      OpenCascade.BRepFilletAPI+      OpenCascade.BRepFilletAPI.Internal.Destructors+      OpenCascade.BRepFilletAPI.MakeFillet+      OpenCascade.BRepFilletAPI.Types+      OpenCascade.BRepMesh+      OpenCascade.BRepMesh.IncrementalMesh+      OpenCascade.BRepMesh.Internal.Destructors+      OpenCascade.BRepMesh.Types+      OpenCascade.BRepOffsetAPI+      OpenCascade.BRepOffsetAPI.Internal.Destructors+      OpenCascade.BRepOffsetAPI.MakePipe+      OpenCascade.BRepOffsetAPI.Types+      OpenCascade.BRepPrimAPI+      OpenCascade.BRepPrimAPI.Internal.Destructors+      OpenCascade.BRepPrimAPI.MakeBox+      OpenCascade.BRepPrimAPI.MakeCylinder+      OpenCascade.BRepPrimAPI.MakePrism+      OpenCascade.BRepPrimAPI.MakeRevol+      OpenCascade.BRepPrimAPI.MakeSphere+      OpenCascade.BRepPrimAPI.Types+      OpenCascade.BRepTools+      OpenCascade.BRepTools.Internal.Destructors+      OpenCascade.BRepTools.Types+      OpenCascade.BRepTools.WireExplorer+      OpenCascade.GC.MakeArcOfCircle+      OpenCascade.GC.MakeSegment+      OpenCascade.Geom+      OpenCascade.Geom.BezierCurve+      OpenCascade.Geom.Curve+      OpenCascade.Geom.Internal.Destructors+      OpenCascade.Geom.Types+      OpenCascade.GP+      OpenCascade.GP.Ax1+      OpenCascade.GP.Ax2+      OpenCascade.GP.Ax2d+      OpenCascade.GP.Dir+      OpenCascade.GP.Dir2d+      OpenCascade.GP.GTrsf+      OpenCascade.GP.Internal.Destructors+      OpenCascade.GP.Pnt+      OpenCascade.GP.Pnt2d+      OpenCascade.GP.Trsf+      OpenCascade.GP.Trsf2d+      OpenCascade.GP.Types+      OpenCascade.GP.Vec+      OpenCascade.GP.Vec2d+      OpenCascade.Handle+      OpenCascade.IFSelect.ReturnStatus+      OpenCascade.Inheritance+      OpenCascade.Internal.Bool+      OpenCascade.NCollection+      OpenCascade.NCollection.Array1+      OpenCascade.NCollection.Internal.Destructors+      OpenCascade.NCollection.Types+      OpenCascade.STEPControl+      OpenCascade.STEPControl.Internal.Destructors+      OpenCascade.STEPControl.StepModelType+      OpenCascade.STEPControl.Types+      OpenCascade.STEPControl.Writer+      OpenCascade.StlAPI+      OpenCascade.StlAPI.Internal.Destructors+      OpenCascade.StlAPI.Types+      OpenCascade.StlAPI.Writer+      OpenCascade.TopAbs+      OpenCascade.TopAbs.Orientation+      OpenCascade.TopAbs.ShapeEnum+      OpenCascade.TopExp+      OpenCascade.TopExp.Explorer+      OpenCascade.TopExp.Internal.Destructors+      OpenCascade.TopExp.Types+      OpenCascade.TopLoc+      OpenCascade.TopLoc.Internal.Destructors+      OpenCascade.TopLoc.Location+      OpenCascade.TopLoc.Types+      OpenCascade.TopoDS+      OpenCascade.TopoDS.Compound+      OpenCascade.TopoDS.CompSolid+      OpenCascade.TopoDS.Edge+      OpenCascade.TopoDS.Face+      OpenCascade.TopoDS.Internal.Destructors+      OpenCascade.TopoDS.Shape+      OpenCascade.TopoDS.Shell+      OpenCascade.TopoDS.Solid+      OpenCascade.TopoDS.Types+      OpenCascade.TopoDS.Vertex+      OpenCascade.TopoDS.Wire+      OpenCascade.TopTools+      OpenCascade.TopTools.Types+  other-modules:+      Paths_opencascade_hs+  autogen-modules:+      Paths_opencascade_hs+  hs-source-dirs:+      src+  ghc-options: -Wall -Wcompat -Widentities -Wincomplete-record-updates -Wincomplete-uni-patterns -Wmissing-export-lists -Wmissing-home-modules -Wpartial-fields -Wredundant-constraints+  cc-options: -Werror+  cxx-options: -std=c++17+  include-dirs:+      cpp+      /usr/include/opencascade+  c-sources:+      cpp/hs_BRep_Tool.cpp+      cpp/hs_BRepAlgoAPI_Common.cpp+      cpp/hs_BRepAlgoAPI_Cut.cpp+      cpp/hs_BRepAlgoAPI_Fuse.cpp+      cpp/hs_BRepBuilderAPI_GTransform.cpp+      cpp/hs_BRepBuilderAPI_MakeEdge.cpp+      cpp/hs_BRepBuilderAPI_MakeFace.cpp+      cpp/hs_BRepBuilderAPI_MakeShape.cpp+      cpp/hs_BRepBuilderAPI_MakeSolid.cpp+      cpp/hs_BRepBuilderAPI_MakeWire.cpp+      cpp/hs_BRepBuilderAPI_Transform.cpp+      cpp/hs_BRepFilletAPI_MakeFillet.cpp+      cpp/hs_BRepMesh_IncrementalMesh.cpp+      cpp/hs_BRepOffsetAPI_MakePipe.cpp+      cpp/hs_BRepPrimAPI_MakeBox.cpp+      cpp/hs_BRepPrimAPI_MakeCylinder.cpp+      cpp/hs_BRepPrimAPI_MakePrism.cpp+      cpp/hs_BRepPrimAPI_MakeRevol.cpp+      cpp/hs_BRepPrimAPI_MakeSphere.cpp+      cpp/hs_BRepTools_WireExplorer.cpp+      cpp/hs_GC_MakeArcOfCircle.cpp+      cpp/hs_GC_MakeSegment.cpp+      cpp/hs_Geom_BezierCurve.cpp+      cpp/hs_Geom_Curve.cpp+      cpp/hs_Geom_TrimmedCurve.cpp+      cpp/hs_gp.cpp+      cpp/hs_gp_Ax1.cpp+      cpp/hs_gp_Ax2.cpp+      cpp/hs_gp_Ax2d.cpp+      cpp/hs_gp_Dir.cpp+      cpp/hs_gp_Dir2d.cpp+      cpp/hs_gp_GTrsf.cpp+      cpp/hs_gp_Pnt.cpp+      cpp/hs_gp_Pnt2d.cpp+      cpp/hs_gp_Trsf.cpp+      cpp/hs_gp_Trsf2d.cpp+      cpp/hs_gp_Vec.cpp+      cpp/hs_gp_Vec2d.cpp+      cpp/hs_NCollection_Array1.cpp+      cpp/hs_STEPControl_Writer.cpp+      cpp/hs_StlAPI_Writer.cpp+      cpp/hs_TopExp_Explorer.cpp+      cpp/hs_TopLoc_Location.cpp+      cpp/hs_TopoDS_Compound.cpp+      cpp/hs_TopoDS_CompSolid.cpp+      cpp/hs_TopoDS_Edge.cpp+      cpp/hs_TopoDS_Face.cpp+      cpp/hs_TopoDS_Shape.cpp+      cpp/hs_TopoDS_Shell.cpp+      cpp/hs_TopoDS_Solid.cpp+      cpp/hs_TopoDS_Vertex.cpp+      cpp/hs_TopoDS_Wire.cpp+  extra-libraries:+      stdc+++      TKGeomBase+      TKStd+      TKG3d+      TKG2d+      TKMath+      TKernel+      TKBRep+      TKGeomBase+      TKOffset+      TKFillet+      TKBO+      TKPrim+      TKTopAlgo+      TKSTL+      TKSTEP+      TKV3d+      TKMesh+  build-depends:+      base >=4.7 && <5+    , resourcet >=1.2 && <1.4+  default-language: Haskell2010
+ src/OpenCascade/BRep/Tool.hs view
@@ -0,0 +1,32 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.BRep.Tool+( curve+, curveParamFirst+, curveParamLast+) where++import qualified OpenCascade.Geom as Geom+import qualified OpenCascade.TopoDS as TopoDS+import OpenCascade.Handle (Handle)+import OpenCascade.Geom.Internal.Destructors (deleteHandleCurve)+import Foreign.Ptr+import Foreign.C+import Data.Coerce+import Data.Acquire+import qualified Data.Acquire as Data++foreign import capi unsafe "hs_BRep_Tool.h hs_BRep_Tool_curve" rawCurve :: Ptr (TopoDS.Edge) -> IO(Ptr (Handle Geom.Curve))++curve :: Ptr TopoDS.Edge -> Data.Acquire (Ptr (Handle Geom.Curve))+curve edge = mkAcquire (rawCurve edge) deleteHandleCurve++foreign import capi unsafe "hs_BRep_Tool.h hs_BRep_Tool_curveParamFirst" rawCurveParamFirst :: Ptr (TopoDS.Edge) -> IO(CDouble)++curveParamFirst :: Ptr TopoDS.Edge -> IO Double +curveParamFirst = coerce rawCurveParamFirst++foreign import capi unsafe "hs_BRep_Tool.h hs_BRep_Tool_curveParamLast" rawCurveParamLast :: Ptr (TopoDS.Edge) -> IO(CDouble)++curveParamLast :: Ptr TopoDS.Edge -> IO Double +curveParamLast = coerce rawCurveParamLast+
+ src/OpenCascade/BRepAlgoAPI/Common.hs view
@@ -0,0 +1,15 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.BRepAlgoAPI.Common+( common+) where++import qualified OpenCascade.TopoDS as TopoDS+import OpenCascade.TopoDS.Internal.Destructors (deleteShape)+import Foreign.Ptr+import Data.Acquire+++foreign import capi unsafe "hs_BRepAlgoAPI_Common.h hs_BRepAlgoAPI_Common" rawCommon :: Ptr TopoDS.Shape -> Ptr TopoDS.Shape ->  IO (Ptr TopoDS.Shape)++common :: Ptr TopoDS.Shape -> Ptr TopoDS.Shape -> Acquire (Ptr TopoDS.Shape)+common a b = mkAcquire (rawCommon a b) deleteShape
+ src/OpenCascade/BRepAlgoAPI/Cut.hs view
@@ -0,0 +1,15 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.BRepAlgoAPI.Cut+( cut+) where++import qualified OpenCascade.TopoDS as TopoDS+import OpenCascade.TopoDS.Internal.Destructors (deleteShape)+import Foreign.Ptr+import Data.Acquire+++foreign import capi unsafe "hs_BRepAlgoAPI_Cut.h hs_BRepAlgoAPI_Cut" rawCut :: Ptr TopoDS.Shape -> Ptr TopoDS.Shape ->  IO (Ptr TopoDS.Shape)++cut :: Ptr TopoDS.Shape -> Ptr TopoDS.Shape -> Acquire (Ptr TopoDS.Shape)+cut a b = mkAcquire (rawCut a b) deleteShape
+ src/OpenCascade/BRepAlgoAPI/Fuse.hs view
@@ -0,0 +1,15 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.BRepAlgoAPI.Fuse+( fuse+) where++import qualified OpenCascade.TopoDS as TopoDS+import OpenCascade.TopoDS.Internal.Destructors (deleteShape)+import Foreign.Ptr+import Data.Acquire+++foreign import capi unsafe "hs_BRepAlgoAPI_Fuse.h hs_BRepAlgoAPI_Fuse" rawFuse :: Ptr TopoDS.Shape -> Ptr TopoDS.Shape ->  IO (Ptr TopoDS.Shape)++fuse :: Ptr TopoDS.Shape -> Ptr TopoDS.Shape -> Acquire (Ptr TopoDS.Shape)+fuse a b = mkAcquire (rawFuse a b) deleteShape
+ src/OpenCascade/BRepBuilderAPI.hs view
@@ -0,0 +1,5 @@+module OpenCascade.BRepBuilderAPI +( module OpenCascade.BRepBuilderAPI.Types+) where++import OpenCascade.BRepBuilderAPI.Types
+ src/OpenCascade/BRepBuilderAPI/FaceError.hs view
@@ -0,0 +1,6 @@+module OpenCascade.BRepBuilderAPI.FaceError+( FaceError (..)+) where++-- order must match the definition of BRepBuilderAPI FaceError+data FaceError = FaceDone | NoFace | NotPlanar | CurveProjectionFailed | ParametersOutOfRange deriving (Eq, Enum)
+ src/OpenCascade/BRepBuilderAPI/GTransform.hs view
@@ -0,0 +1,17 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.BRepBuilderAPI.GTransform +( gtransform+) where++import qualified OpenCascade.GP as GP+import qualified OpenCascade.TopoDS as TopoDS+import OpenCascade.Internal.Bool+import qualified OpenCascade.TopoDS.Internal.Destructors as TopoDS.Destructors+import Foreign.C+import Foreign.Ptr+import Data.Acquire ++foreign import capi unsafe "hs_BRepBuilderAPI_GTransform.h hs_BRepBuilderAPI_GTransform_gtransform" rawGTransform :: Ptr TopoDS.Shape -> Ptr GP.GTrsf -> CBool -> IO (Ptr TopoDS.Shape)++gtransform :: Ptr TopoDS.Shape -> Ptr GP.GTrsf -> Bool -> Acquire (Ptr TopoDS.Shape)+gtransform shape trsf copy = mkAcquire (rawGTransform shape trsf (boolToCBool copy)) TopoDS.Destructors.deleteShape
+ src/OpenCascade/BRepBuilderAPI/Internal/Destructors.hs view
@@ -0,0 +1,12 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.BRepBuilderAPI.Internal.Destructors where++import OpenCascade.BRepBuilderAPI.Types++import Foreign.Ptr++foreign import capi unsafe "hs_BRepBuilderAPI_MakeWire.h hs_delete_BRepBuilderAPI_MakeWire" deleteMakeWire :: Ptr MakeWire -> IO ()+foreign import capi unsafe "hs_BRepBuilderAPI_MakeFace.h hs_delete_BRepBuilderAPI_MakeFace" deleteMakeFace :: Ptr MakeFace -> IO ()+foreign import capi unsafe "hs_BRepBuilderAPI_MakeSolid.h hs_delete_BRepBuilderAPI_MakeSolid" deleteMakeSolid :: Ptr MakeSolid -> IO ()++
+ src/OpenCascade/BRepBuilderAPI/MakeEdge.hs view
@@ -0,0 +1,84 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.BRepBuilderAPI.MakeEdge+( fromVertices +, fromPnts+, fromCurve +, fromCurveAndParameters+, fromCurveAndVertices+, fromCurveAndPnts +, fromCurveVerticesAndParameters+, fromCurvePntsAndParameters +) where++import OpenCascade.TopoDS.Internal.Destructors as TopoDS.Destructors+import qualified OpenCascade.TopoDS as TopoDS+import qualified OpenCascade.GP as GP+import qualified OpenCascade.Geom as Geom+import OpenCascade.Handle+import OpenCascade.Inheritance+import Foreign.C+import Foreign.Ptr+import Data.Acquire +++-- fromVertices++foreign import capi unsafe "hs_BRepBuilderAPI_MakeEdge.h hs_BRepBuilderAPI_MakeEdge_fromVertices" rawFromVertices :: Ptr TopoDS.Vertex -> Ptr TopoDS.Vertex -> IO (Ptr TopoDS.Edge)++fromVertices :: Ptr TopoDS.Vertex -> Ptr TopoDS.Vertex -> Acquire (Ptr TopoDS.Edge)+fromVertices start end = mkAcquire (rawFromVertices start end) (TopoDS.Destructors.deleteShape . upcast)+++-- fromPnts++foreign import capi unsafe "hs_BRepBuilderAPI_MakeEdge.h hs_BRepBuilderAPI_MakeEdge_fromPnts" rawFromPnts :: Ptr GP.Pnt -> Ptr GP.Pnt -> IO (Ptr TopoDS.Edge)++fromPnts :: Ptr GP.Pnt -> Ptr GP.Pnt -> Acquire (Ptr TopoDS.Edge)+fromPnts start end = mkAcquire (rawFromPnts start end) (TopoDS.Destructors.deleteShape . upcast)+++-- fromCurve++foreign import capi unsafe "hs_BRepBuilderAPI_MakeEdge.h hs_BRepBuilderAPI_MakeEdge_fromCurve" rawFromCurve :: Ptr (Handle Geom.Curve) -> IO (Ptr TopoDS.Edge)++fromCurve :: Ptr (Handle Geom.Curve) -> Acquire (Ptr TopoDS.Edge)+fromCurve curve = mkAcquire (rawFromCurve curve) (TopoDS.Destructors.deleteShape . upcast)++-- fromCurveAndParameters++foreign import capi unsafe "hs_BRepBuilderAPI_MakeEdge.h hs_BRepBuilderAPI_MakeEdge_fromCurveAndParameters" rawFromCurveAndParameters :: Ptr (Handle Geom.Curve) -> CDouble -> CDouble -> IO (Ptr TopoDS.Edge)++fromCurveAndParameters :: Ptr (Handle Geom.Curve) -> Double -> Double -> Acquire (Ptr TopoDS.Edge)+fromCurveAndParameters curve p1 p2 = mkAcquire (rawFromCurveAndParameters curve (CDouble p1) (CDouble p2)) (TopoDS.Destructors.deleteShape . upcast)+++-- fromCurveAndVertices++foreign import capi unsafe "hs_BRepBuilderAPI_MakeEdge.h hs_BRepBuilderAPI_MakeEdge_fromCurveAndVertices" rawFromCurveAndVertices :: Ptr (Handle Geom.Curve) -> Ptr TopoDS.Vertex -> Ptr TopoDS.Vertex -> IO (Ptr TopoDS.Edge)++fromCurveAndVertices :: Ptr (Handle Geom.Curve) -> Ptr TopoDS.Vertex -> Ptr TopoDS.Vertex -> Acquire (Ptr TopoDS.Edge)+fromCurveAndVertices curve v1 v2 = mkAcquire (rawFromCurveAndVertices curve v1 v2) (TopoDS.Destructors.deleteShape . upcast)+++-- fromCurveAndPnts++foreign import capi unsafe "hs_BRepBuilderAPI_MakeEdge.h hs_BRepBuilderAPI_MakeEdge_fromCurveAndPnts" rawFromCurveAndPnts :: Ptr (Handle Geom.Curve) -> Ptr GP.Pnt -> Ptr GP.Pnt -> IO (Ptr TopoDS.Edge)++fromCurveAndPnts :: Ptr (Handle Geom.Curve) -> Ptr GP.Pnt -> Ptr GP.Pnt -> Acquire (Ptr TopoDS.Edge)+fromCurveAndPnts curve v1 v2 = mkAcquire (rawFromCurveAndPnts curve v1 v2) (TopoDS.Destructors.deleteShape . upcast)+++-- fromCurveVerticesAndParameters++foreign import capi unsafe "hs_BRepBuilderAPI_MakeEdge.h hs_BRepBuilderAPI_MakeEdge_fromCurveVerticesAndParameters" rawFromCurveVerticesAndParameters :: Ptr (Handle Geom.Curve) -> Ptr TopoDS.Vertex -> Ptr TopoDS.Vertex -> CDouble -> CDouble -> IO (Ptr TopoDS.Edge)++fromCurveVerticesAndParameters :: Ptr (Handle Geom.Curve) -> Ptr TopoDS.Vertex -> Ptr TopoDS.Vertex -> Double -> Double -> Acquire (Ptr TopoDS.Edge)+fromCurveVerticesAndParameters curve v1 v2 p1 p2 = mkAcquire (rawFromCurveVerticesAndParameters curve v1 v2 (CDouble p1) (CDouble p2)) (TopoDS.Destructors.deleteShape . upcast)+++-- fromCurvePntsAndParameters++foreign import capi unsafe "hs_BRepBuilderAPI_MakeEdge.h hs_BRepBuilderAPI_MakeEdge_fromCurvePntsAndParameters" rawFromCurvePntsAndParameters :: Ptr (Handle Geom.Curve) -> Ptr GP.Pnt -> Ptr GP.Pnt -> CDouble -> CDouble -> IO (Ptr TopoDS.Edge)++fromCurvePntsAndParameters :: Ptr (Handle Geom.Curve) -> Ptr GP.Pnt -> Ptr GP.Pnt -> Double -> Double -> Acquire (Ptr TopoDS.Edge)+fromCurvePntsAndParameters curve v1 v2 p1 p2 = mkAcquire (rawFromCurvePntsAndParameters curve v1 v2 (CDouble p1) (CDouble p2)) (TopoDS.Destructors.deleteShape . upcast)
+ src/OpenCascade/BRepBuilderAPI/MakeFace.hs view
@@ -0,0 +1,93 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.BRepBuilderAPI.MakeFace +( MakeFace+, new+, face+, fromFace+, fromSurface+, fromSurfaceAndBounds+, fromSurfaceAndWire+, fromWire+, add+, isDone+, error+) where++import Prelude hiding (error)+import OpenCascade.BRepBuilderAPI.Types+import OpenCascade.BRepBuilderAPI.Internal.Destructors+import OpenCascade.Handle+import OpenCascade.Internal.Bool+import qualified OpenCascade.TopoDS as TopoDS+import OpenCascade.TopoDS.Internal.Destructors (deleteShape)+import OpenCascade.Inheritance (upcast)+import qualified OpenCascade.Geom as Geom+import OpenCascade.BRepBuilderAPI.FaceError (FaceError)+import Foreign.C+import Foreign.Ptr+import Data.Acquire ++-- new++foreign import capi unsafe "hs_BRepBuilderAPI_MakeFace.h hs_new_BRepBuilderAPI_MakeFace" rawNew :: IO (Ptr MakeFace)++new :: Acquire (Ptr MakeFace)+new = mkAcquire rawNew deleteMakeFace++-- fromFace++foreign import capi unsafe "hs_BRepBuilderAPI_MakeFace.h hs_new_BRepBuilderAPI_MakeFace_fromFace" rawFromFace :: Ptr TopoDS.Face ->  IO (Ptr MakeFace)++fromFace :: Ptr TopoDS.Face -> Acquire (Ptr MakeFace)+fromFace face = mkAcquire (rawFromFace face) deleteMakeFace++-- fromSurface++foreign import capi unsafe "hs_BRepBuilderAPI_MakeFace.h hs_new_BRepBuilderAPI_MakeFace_fromSurface" rawFromSurface :: Ptr (Handle (Geom.Surface)) -> CDouble -> IO (Ptr MakeFace)++fromSurface :: Ptr (Handle Geom.Surface) -> Double -> Acquire (Ptr MakeFace)+fromSurface surf tolerance = mkAcquire (rawFromSurface surf (CDouble tolerance)) deleteMakeFace++-- fromSurfaceAndBounds++foreign import capi unsafe "hs_BRepBuilderAPI_MakeFace.h hs_new_BRepBuilderAPI_MakeFace_fromSurfaceAndBounds" rawFromSurfaceAndBounds :: Ptr (Handle (Geom.Surface)) -> CDouble -> CDouble -> CDouble -> CDouble -> CDouble -> IO (Ptr MakeFace)++fromSurfaceAndBounds :: Ptr (Handle Geom.Surface) -> Double -> Double -> Double -> Double -> Double -> Acquire (Ptr MakeFace)+fromSurfaceAndBounds surf uMin uMax vMin vMax tolerance = mkAcquire (rawFromSurfaceAndBounds surf (CDouble uMin) (CDouble uMax) (CDouble vMin) (CDouble vMax) (CDouble tolerance)) deleteMakeFace++-- fromSurfaceAndWire+--+foreign import capi unsafe "hs_BRepBuilderAPI_MakeFace.h hs_new_BRepBuilderAPI_MakeFace_fromSurfaceAndWire" rawFromSurfaceAndWire :: Ptr (Handle (Geom.Surface)) -> Ptr TopoDS.Wire -> CBool -> IO (Ptr MakeFace)++fromSurfaceAndWire :: Ptr (Handle Geom.Surface) -> Ptr TopoDS.Wire -> Bool -> Acquire (Ptr MakeFace)+fromSurfaceAndWire surf wire inside = mkAcquire (rawFromSurfaceAndWire surf wire (boolToCBool inside)) deleteMakeFace++-- fromWire++foreign import capi unsafe "hs_BRepBuilderAPI_MakeFace.h hs_new_BRepBuilderAPI_MakeFace_fromWire" rawFromWire :: Ptr TopoDS.Wire -> CBool ->  IO (Ptr MakeFace)++fromWire :: Ptr TopoDS.Wire -> Bool -> Acquire (Ptr MakeFace)+fromWire wire onlyPlane = mkAcquire (rawFromWire wire (boolToCBool onlyPlane)) deleteMakeFace++-- add +foreign import capi unsafe "hs_BRepBuilderAPI_MakeFace.h hs_BRepBuilderAPI_MakeFace_Add" add :: Ptr MakeFace -> Ptr TopoDS.Wire -> IO ()++-- isDone+--+foreign import capi unsafe "hs_BRepBuilderAPI_MakeFace.h hs_BRepBuilderAPI_MakeFace_IsDone" rawIsDone :: Ptr MakeFace -> IO (CBool)++isDone :: Ptr MakeFace -> IO Bool+isDone p = cBoolToBool <$> rawIsDone p++-- error+--+foreign import capi unsafe "hs_BRepBuilderAPI_MakeFace.h hs_BRepBuilderAPI_MakeFace_Error" rawError :: Ptr MakeFace -> IO (CInt)++error :: Ptr MakeFace -> IO FaceError +error p = toEnum . fromIntegral <$> rawError p+++foreign import capi unsafe "hs_BRepBuilderAPI_MakeFace.h hs_BRepBuilderAPI_MakeFace_Face" rawFace :: Ptr MakeFace ->  IO (Ptr TopoDS.Face)++face :: Ptr MakeFace -> Acquire (Ptr TopoDS.Face)+face builder = mkAcquire (rawFace builder) (deleteShape . upcast)
+ src/OpenCascade/BRepBuilderAPI/MakeShape.hs view
@@ -0,0 +1,18 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.BRepBuilderAPI.MakeShape+( MakeShape+, shape+) where+import OpenCascade.BRepBuilderAPI.Types+import OpenCascade.BRepBuilderAPI.Internal.Destructors+import qualified OpenCascade.TopoDS as TopoDS+import OpenCascade.Inheritance (upcast)+import OpenCascade.TopoDS.Internal.Destructors (deleteShape)+import Foreign.C+import Foreign.Ptr+import Data.Acquire ++foreign import capi unsafe "hs_BRepBuilderAPI_MakeShape.h hs_BRepBuilderAPI_MakeShape_shape" rawShape :: Ptr MakeShape -> IO (Ptr TopoDS.Shape)++shape :: Ptr MakeShape -> Acquire (Ptr TopoDS.Shape)+shape builder = mkAcquire (rawShape builder) (deleteShape)
+ src/OpenCascade/BRepBuilderAPI/MakeSolid.hs view
@@ -0,0 +1,31 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.BRepBuilderAPI.MakeSolid+( MakeSolid+, new+, add+, solid+) where+import OpenCascade.BRepBuilderAPI.Types+import OpenCascade.BRepBuilderAPI.Internal.Destructors+import qualified OpenCascade.TopoDS as TopoDS+import OpenCascade.Inheritance (upcast)+import OpenCascade.TopoDS.Internal.Destructors (deleteShape)+import Foreign.C+import Foreign.Ptr+import Data.Acquire ++-- new++foreign import capi unsafe "hs_BRepBuilderAPI_MakeSolid.h hs_new_BRepBuilderAPI_MakeSolid" rawNew :: IO (Ptr MakeSolid)++new :: Acquire (Ptr MakeSolid)+new = mkAcquire rawNew deleteMakeSolid++-- add +foreign import capi unsafe "hs_BRepBuilderAPI_MakeSolid.h hs_BRepBuilderAPI_MakeSolid_add" add :: Ptr MakeSolid -> Ptr TopoDS.Shell -> IO ()++foreign import capi unsafe "hs_BRepBuilderAPI_MakeSolid.h hs_BRepBuilderAPI_MakeSolid_solid" rawSolid :: Ptr MakeSolid -> IO (Ptr TopoDS.Solid)++solid :: Ptr MakeSolid -> Acquire (Ptr TopoDS.Solid)+solid builder = mkAcquire (rawSolid builder) (deleteShape . upcast)  +
+ src/OpenCascade/BRepBuilderAPI/MakeWire.hs view
@@ -0,0 +1,66 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.BRepBuilderAPI.MakeWire +( MakeWire+, new +, addEdge+, addWire+, addListOfShape+, wire+, isDone+, error+) where++import Prelude hiding (error)+import OpenCascade.BRepBuilderAPI.Types+import OpenCascade.BRepBuilderAPI.Internal.Destructors+import OpenCascade.Inheritance+import OpenCascade.Internal.Bool+import qualified OpenCascade.TopoDS as TopoDS+import qualified OpenCascade.TopoDS.Internal.Destructors as TopoDS.Destructors+import qualified OpenCascade.TopTools as TopTools+import OpenCascade.BRepBuilderAPI.WireError (WireError)+import Foreign.C+import Foreign.Ptr+import Data.Acquire ++-- new++foreign import capi unsafe "hs_BRepBuilderAPI_MakeWire.h hs_new_BRepBuilderAPI_MakeWire" rawNew :: IO (Ptr MakeWire)++new :: Acquire (Ptr MakeWire)+new = mkAcquire rawNew deleteMakeWire++-- addEdge ++foreign import capi unsafe "hs_BRepBuilderAPI_MakeWire.h hs_BRepBuilderAPI_MakeWire_AddEdge" addEdge :: Ptr MakeWire -> Ptr TopoDS.Edge -> IO ()+++-- addWire ++foreign import capi unsafe "hs_BRepBuilderAPI_MakeWire.h hs_BRepBuilderAPI_MakeWire_AddWire" addWire :: Ptr MakeWire -> Ptr TopoDS.Wire -> IO ()+++-- addListOfShape++foreign import capi unsafe "hs_BRepBuilderAPI_MakeWire.h hs_BRepBuilderAPI_MakeWire_AddListOfShape" addListOfShape :: Ptr MakeWire -> Ptr TopTools.ListOfShape -> IO ()++-- wire+--+foreign import capi unsafe "hs_BRepBuilderAPI_MakeWire.h hs_BRepBuilderAPI_MakeWire_Wire" rawWire :: Ptr MakeWire -> IO (Ptr TopoDS.Wire)++wire :: Ptr MakeWire -> Acquire (Ptr TopoDS.Wire)+wire builder = mkAcquire (rawWire builder) (TopoDS.Destructors.deleteShape . upcast)++-- isDone+--+foreign import capi unsafe "hs_BRepBuilderAPI_MakeWire.h hs_BRepBuilderAPI_MakeWire_IsDone" rawIsDone :: Ptr MakeWire -> IO (CBool)++isDone :: Ptr MakeWire -> IO Bool+isDone p = cBoolToBool <$> rawIsDone p++-- error+--+foreign import capi unsafe "hs_BRepBuilderAPI_MakeWire.h hs_BRepBuilderAPI_MakeWire_Error" rawError :: Ptr MakeWire -> IO (CInt)++error :: Ptr MakeWire -> IO WireError +error p = toEnum . fromIntegral <$> rawError p
+ src/OpenCascade/BRepBuilderAPI/Transform.hs view
@@ -0,0 +1,17 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.BRepBuilderAPI.Transform +( transform+) where++import qualified OpenCascade.GP as GP+import qualified OpenCascade.TopoDS as TopoDS+import OpenCascade.Internal.Bool+import qualified OpenCascade.TopoDS.Internal.Destructors as TopoDS.Destructors+import Foreign.C+import Foreign.Ptr+import Data.Acquire ++foreign import capi unsafe "hs_BRepBuilderAPI_Transform.h hs_BRepBuilderAPI_Transform_transform" rawTransform :: Ptr TopoDS.Shape -> Ptr GP.Trsf -> CBool -> IO (Ptr TopoDS.Shape)++transform :: Ptr TopoDS.Shape -> Ptr GP.Trsf -> Bool -> Acquire (Ptr TopoDS.Shape)+transform shape trsf copy = mkAcquire (rawTransform shape trsf (boolToCBool copy)) TopoDS.Destructors.deleteShape
+ src/OpenCascade/BRepBuilderAPI/Types.hs view
@@ -0,0 +1,16 @@+{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE EmptyDataDecls #-}+module OpenCascade.BRepBuilderAPI.Types where++import qualified OpenCascade.Inheritance as Inheritance++data MakeWire+data MakeFace+data MakeSolid++data MakeShape++instance Inheritance.SubTypeOf MakeShape MakeWire+instance Inheritance.SubTypeOf MakeShape MakeSolid+instance Inheritance.SubTypeOf MakeShape MakeFace+
+ src/OpenCascade/BRepBuilderAPI/WireError.hs view
@@ -0,0 +1,6 @@+module OpenCascade.BRepBuilderAPI.WireError+( WireError (..)+) where++-- order must match the definition of BRepBuilderAPI_WireError+data WireError = WireDone | EmptyWire | DisconnectedWire | NonManifoldWire deriving (Eq, Enum)
+ src/OpenCascade/BRepFilletAPI.hs view
@@ -0,0 +1,5 @@+module OpenCascade.BRepFilletAPI+( module OpenCascade.BRepFilletAPI.Types+) where++import OpenCascade.BRepFilletAPI.Types
+ src/OpenCascade/BRepFilletAPI/Internal/Destructors.hs view
@@ -0,0 +1,10 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.BRepFilletAPI.Internal.Destructors where++import OpenCascade.BRepFilletAPI.Types++import Foreign.Ptr++foreign import capi unsafe "hs_BRepFilletAPI_MakeFillet.h hs_delete_BRepFilletAPI_MakeFillet" deleteMakeFillet :: Ptr MakeFillet -> IO ()++
+ src/OpenCascade/BRepFilletAPI/MakeFillet.hs view
@@ -0,0 +1,34 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.BRepFilletAPI.MakeFillet +( MakeFillet+, fromShape+, addEdge+, addEdgeWithRadius+, addEdgeWithTwoRadiuses+) where++import OpenCascade.BRepFilletAPI.Types (MakeFillet)+import OpenCascade.BRepFilletAPI.Internal.Destructors (deleteMakeFillet)+import qualified OpenCascade.TopoDS as TopoDS+import Foreign.Ptr+import Foreign.C+import Data.Acquire+import Data.Coerce (coerce)++foreign import capi unsafe "hs_BRepFilletAPI_MakeFillet.h hs_new_BRepFilletAPI_MakeFillet_fromShape" rawFromShape :: Ptr TopoDS.Shape -> IO (Ptr MakeFillet)++fromShape :: Ptr TopoDS.Shape  -> Acquire (Ptr MakeFillet)+fromShape shape = mkAcquire (rawFromShape shape) deleteMakeFillet++foreign import capi unsafe "hs_BRepFilletAPI_MakeFillet.h hs_BRepFilletAPI_MakeFillet_addEdge" addEdge :: Ptr MakeFillet -> Ptr TopoDS.Edge -> IO ()++foreign import capi unsafe "hs_BRepFilletAPI_MakeFillet.h hs_BRepFilletAPI_MakeFillet_addEdgeWithRadius" rawAddEdgeWithRadius :: Ptr MakeFillet -> CDouble -> Ptr TopoDS.Edge -> IO ()++addEdgeWithRadius :: Ptr MakeFillet -> Double -> Ptr TopoDS.Edge -> IO ()+addEdgeWithRadius = coerce rawAddEdgeWithRadius+++foreign import capi unsafe "hs_BRepFilletAPI_MakeFillet.h hs_BRepFilletAPI_MakeFillet_addEdgeWithTwoRadiuses" rawAddEdgeWithTwoRadiuses :: Ptr MakeFillet -> CDouble -> CDouble -> Ptr TopoDS.Edge -> IO ()++addEdgeWithTwoRadiuses :: Ptr MakeFillet -> Double -> Double -> Ptr TopoDS.Edge -> IO ()+addEdgeWithTwoRadiuses = coerce rawAddEdgeWithTwoRadiuses
+ src/OpenCascade/BRepFilletAPI/Types.hs view
@@ -0,0 +1,12 @@+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE EmptyDataDecls #-}+module OpenCascade.BRepFilletAPI.Types+( MakeFillet +) where++import qualified OpenCascade.Inheritance as Inheritance+import OpenCascade.BRepBuilderAPI.MakeShape (MakeShape)++data MakeFillet++instance Inheritance.SubTypeOf MakeShape MakeFillet
+ src/OpenCascade/BRepMesh.hs view
@@ -0,0 +1,5 @@+module OpenCascade.BRepMesh+( module OpenCascade.BRepMesh.Types+) where++import OpenCascade.BRepMesh.Types
+ src/OpenCascade/BRepMesh/IncrementalMesh.hs view
@@ -0,0 +1,20 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.BRepMesh.IncrementalMesh+( fromShapeAndLinDeflection+, perform+) where ++import OpenCascade.BRepMesh.Types (IncrementalMesh)+import OpenCascade.BRepMesh.Internal.Destructors (deleteIncrementalMesh)+import qualified OpenCascade.TopoDS as TopoDS+import Foreign.Ptr+import Data.Acquire+import Data.Coerce (coerce)+++foreign import capi unsafe "hs_BRepMesh_IncrementalMesh.h hs_BRepMesh_IncrementalMesh_fromShapeAndLinDeflection" rawFromShapeAndLinDeflection :: Ptr TopoDS.Shape -> Double ->  IO (Ptr IncrementalMesh)++fromShapeAndLinDeflection :: Ptr TopoDS.Shape -> Double -> Acquire (Ptr IncrementalMesh)+fromShapeAndLinDeflection shape linDeflection = mkAcquire (rawFromShapeAndLinDeflection shape (coerce linDeflection)) deleteIncrementalMesh++foreign import capi unsafe "hs_BRepMesh_IncrementalMesh.h hs_BRepMesh_IncrementalMesh_Perform" perform :: Ptr IncrementalMesh -> IO ()
+ src/OpenCascade/BRepMesh/Internal/Destructors.hs view
@@ -0,0 +1,9 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.BRepMesh.Internal.Destructors where++import OpenCascade.BRepMesh.Types++import Foreign.Ptr++foreign import capi unsafe "hs_BRepMesh_IncrementalMesh.h hs_delete_BRepMesh_IncrementalMesh" deleteIncrementalMesh :: Ptr IncrementalMesh -> IO ()+
+ src/OpenCascade/BRepMesh/Types.hs view
@@ -0,0 +1,4 @@+{-# LANGUAGE EmptyDataDecls #-}+module OpenCascade.BRepMesh.Types where++data IncrementalMesh
+ src/OpenCascade/BRepOffsetAPI.hs view
@@ -0,0 +1,5 @@+module OpenCascade.BRepOffsetAPI+( module OpenCascade.BRepOffsetAPI.Types+) where++import OpenCascade.BRepOffsetAPI.Types
+ src/OpenCascade/BRepOffsetAPI/Internal/Destructors.hs view
@@ -0,0 +1,10 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.BRepOffsetAPI.Internal.Destructors where++import OpenCascade.BRepOffsetAPI.Types++import Foreign.Ptr++foreign import capi unsafe "hs_BRepOffsetAPI_MakePipe.h hs_delete_BRepOffsetAPI_MakePipe" deleteMakePipe :: Ptr MakePipe -> IO ()++
+ src/OpenCascade/BRepOffsetAPI/MakePipe.hs view
@@ -0,0 +1,16 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.BRepOffsetAPI.MakePipe +( MakePipe+, fromWireAndShape+) where++import OpenCascade.BRepOffsetAPI.Types (MakePipe)+import OpenCascade.BRepOffsetAPI.Internal.Destructors (deleteMakePipe)+import qualified OpenCascade.TopoDS as TopoDS+import Foreign.Ptr+import Data.Acquire++foreign import capi unsafe "hs_BRepOffsetAPI_MakePipe.h hs_new_BRepOffsetAPI_MakePipe_fromWireAndShape" rawFromWireAndShape :: Ptr TopoDS.Wire -> Ptr TopoDS.Shape -> IO (Ptr MakePipe)++fromWireAndShape :: Ptr TopoDS.Wire -> Ptr TopoDS.Shape -> Acquire (Ptr MakePipe)+fromWireAndShape wire profile = mkAcquire (rawFromWireAndShape wire profile) deleteMakePipe
+ src/OpenCascade/BRepOffsetAPI/Types.hs view
@@ -0,0 +1,12 @@+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE EmptyDataDecls #-}+module OpenCascade.BRepOffsetAPI.Types+( MakePipe+) where++import qualified OpenCascade.Inheritance as Inheritance+import OpenCascade.BRepBuilderAPI.MakeShape (MakeShape)++data MakePipe++instance Inheritance.SubTypeOf MakeShape MakePipe
+ src/OpenCascade/BRepPrimAPI.hs view
@@ -0,0 +1,5 @@+module OpenCascade.BRepPrimAPI+( module OpenCascade.BRepPrimAPI.Types+) where++import OpenCascade.BRepPrimAPI.Types
+ src/OpenCascade/BRepPrimAPI/Internal/Destructors.hs view
@@ -0,0 +1,11 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.BRepPrimAPI.Internal.Destructors where++import OpenCascade.BRepPrimAPI.Types++import Foreign.Ptr++foreign import capi unsafe "hs_BRepPrimAPI_MakeBox.h hs_delete_BRepPrimAPI_MakeBox" deleteMakeBox :: Ptr MakeBox -> IO ()+foreign import capi unsafe "hs_BRepPrimAPI_MakeRevol.h hs_delete_BRepPrimAPI_MakeRevol" deleteMakeRevol :: Ptr MakeRevol -> IO ()++
+ src/OpenCascade/BRepPrimAPI/MakeBox.hs view
@@ -0,0 +1,39 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.BRepPrimAPI.MakeBox+( fromPnts+, solid+, shell+) where++import OpenCascade.BRepPrimAPI.Types (MakeBox)+import OpenCascade.BRepPrimAPI.Internal.Destructors (deleteMakeBox)+import qualified OpenCascade.TopoDS as TopoDS+import OpenCascade.TopoDS.Internal.Destructors (deleteShape)+import qualified OpenCascade.GP as GP+import Foreign.Ptr+import Data.Acquire++-- new++foreign import capi unsafe "hs_BRepPrimAPI_MakeBox.h hs_new_BRepPrimAPI_MakeBox_fromPnts" rawFromPnts :: Ptr GP.Pnt -> Ptr GP.Pnt ->  IO (Ptr MakeBox)++fromPnts :: Ptr GP.Pnt -> Ptr GP.Pnt -> Acquire (Ptr MakeBox)+fromPnts a b = mkAcquire (rawFromPnts a b) deleteMakeBox++-- solid +++foreign import capi unsafe "hs_BRepPrimAPI_MakeBox.h hs_BRepPrimAPI_MakeBox_Solid" rawSolid :: Ptr MakeBox ->  IO (Ptr TopoDS.Solid)++solid :: Ptr MakeBox -> Acquire (Ptr TopoDS.Solid)+solid builder = mkAcquire (rawSolid builder) (deleteShape . castPtr)++-- shell++foreign import capi unsafe "hs_BRepPrimAPI_MakeBox.h hs_BRepPrimAPI_MakeBox_Shell" rawShell :: Ptr MakeBox ->  IO (Ptr TopoDS.Shell)++shell:: Ptr MakeBox -> Acquire (Ptr TopoDS.Shell)+shell builder = mkAcquire (rawShell builder) (deleteShape . castPtr)+++
+ src/OpenCascade/BRepPrimAPI/MakeCylinder.hs view
@@ -0,0 +1,17 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.BRepPrimAPI.MakeCylinder+( fromRadiusAndHeight+) where++import qualified OpenCascade.GP as GP+import qualified OpenCascade.TopoDS as TopoDS+import qualified OpenCascade.TopoDS.Internal.Destructors as TopoDS.Destructors+import Foreign.C+import Foreign.Ptr+import Data.Acquire +import Data.Coerce (coerce)++foreign import capi unsafe "hs_BRepPrimAPI_MakeCylinder.h hs_BRepPrimAPI_MakeCylinder_fromRadiusAndHeight" rawFromRadiusAndHeight :: CDouble -> CDouble -> IO (Ptr TopoDS.Solid)++fromRadiusAndHeight :: Double -> Double -> Acquire (Ptr TopoDS.Solid)+fromRadiusAndHeight r h = mkAcquire (rawFromRadiusAndHeight (coerce r) (coerce h)) (TopoDS.Destructors.deleteShape . castPtr)
+ src/OpenCascade/BRepPrimAPI/MakePrism.hs view
@@ -0,0 +1,24 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.BRepPrimAPI.MakePrism+( fromVec+, fromDir+) where++import qualified OpenCascade.GP as GP+import qualified OpenCascade.TopoDS as TopoDS+import OpenCascade.Internal.Bool+import qualified OpenCascade.TopoDS.Internal.Destructors as TopoDS.Destructors+import Foreign.C+import Foreign.Ptr+import Data.Acquire ++foreign import capi unsafe "hs_BRepPrimAPI_MakePrism.h hs_BRepPrimAPI_MakePrism_fromVec" rawFromVec :: Ptr TopoDS.Shape -> Ptr GP.Vec -> CBool -> CBool -> IO (Ptr TopoDS.Shape)++fromVec :: Ptr TopoDS.Shape -> Ptr GP.Vec -> Bool -> Bool -> Acquire (Ptr TopoDS.Shape)+fromVec shape vec copy canonize = mkAcquire (rawFromVec shape vec (boolToCBool copy) (boolToCBool canonize)) TopoDS.Destructors.deleteShape+++foreign import capi unsafe "hs_BRepPrimAPI_MakePrism.h hs_BRepPrimAPI_MakePrism_fromDir" rawFromDir :: Ptr TopoDS.Shape -> Ptr GP.Dir -> CBool -> CBool -> CBool -> IO (Ptr TopoDS.Shape)++fromDir :: Ptr TopoDS.Shape -> Ptr GP.Dir -> Bool -> Bool -> Bool -> Acquire (Ptr TopoDS.Shape)+fromDir shape dir inf copy canonize = mkAcquire (rawFromDir shape dir (boolToCBool inf) (boolToCBool copy) (boolToCBool canonize)) TopoDS.Destructors.deleteShape
+ src/OpenCascade/BRepPrimAPI/MakeRevol.hs view
@@ -0,0 +1,20 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.BRepPrimAPI.MakeRevol +( MakeRevol+, fromShapeAndAx1+) where++import OpenCascade.BRepPrimAPI.Types (MakeRevol)+import OpenCascade.BRepPrimAPI.Internal.Destructors (deleteMakeRevol)++import qualified OpenCascade.TopoDS as TopoDS+import qualified OpenCascade.GP as GP+import OpenCascade.Internal.Bool (boolToCBool)+import Foreign.C+import Foreign.Ptr+import Data.Acquire++foreign import capi unsafe "hs_BRepPrimAPI_MakeRevol.h hs_new_BRepPrimAPI_MakeRevol_fromShapeAndAx1" rawFromShapeAndAx1 :: Ptr TopoDS.Shape -> Ptr GP.Ax1 -> CBool -> IO (Ptr MakeRevol)++fromShapeAndAx1 :: Ptr TopoDS.Shape -> Ptr GP.Ax1 -> Bool -> Acquire (Ptr MakeRevol)+fromShapeAndAx1 shape axis copy = mkAcquire (rawFromShapeAndAx1 shape axis (boolToCBool copy)) deleteMakeRevol
+ src/OpenCascade/BRepPrimAPI/MakeSphere.hs view
@@ -0,0 +1,23 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.BRepPrimAPI.MakeSphere+( fromRadius+, fromPntAndRadius+) where++import qualified OpenCascade.GP as GP+import qualified OpenCascade.TopoDS as TopoDS+import qualified OpenCascade.TopoDS.Internal.Destructors as TopoDS.Destructors+import Foreign.C+import Foreign.Ptr+import Data.Acquire +import Data.Coerce (coerce)++foreign import capi unsafe "hs_BRepPrimAPI_MakeSphere.h hs_BRepPrimAPI_MakeSphere_fromRadius" rawFromRadius :: CDouble -> IO (Ptr TopoDS.Solid)++fromRadius :: Double -> Acquire (Ptr TopoDS.Solid)+fromRadius r = mkAcquire (rawFromRadius (coerce r)) (TopoDS.Destructors.deleteShape . castPtr)++foreign import capi unsafe "hs_BRepPrimAPI_MakeSphere.h hs_BRepPrimAPI_MakeSphere_fromPntAndRadius" rawFromPntAndRadius :: Ptr GP.Pnt -> CDouble -> IO (Ptr TopoDS.Solid)++fromPntAndRadius :: Ptr GP.Pnt -> Double -> Acquire (Ptr TopoDS.Solid)+fromPntAndRadius center radius = mkAcquire (rawFromPntAndRadius center (coerce radius)) (TopoDS.Destructors.deleteShape . castPtr)
+ src/OpenCascade/BRepPrimAPI/Types.hs view
@@ -0,0 +1,15 @@+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE EmptyDataDecls #-}+module OpenCascade.BRepPrimAPI.Types+( MakeBox+, MakeRevol+) where++import OpenCascade.BRepBuilderAPI.MakeShape+import qualified OpenCascade.Inheritance as Inheritance++data MakeBox+data MakeRevol++instance Inheritance.SubTypeOf MakeShape MakeBox+instance Inheritance.SubTypeOf MakeShape MakeRevol
+ src/OpenCascade/BRepTools.hs view
@@ -0,0 +1,5 @@+module OpenCascade.BRepTools+( module OpenCascade.BRepTools.Types+) where++import OpenCascade.BRepTools.Types
+ src/OpenCascade/BRepTools/Internal/Destructors.hs view
@@ -0,0 +1,8 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.BRepTools.Internal.Destructors where++import OpenCascade.BRepTools.Types++import Foreign.Ptr++foreign import capi unsafe "hs_BRepTools_WireExplorer.h hs_delete_BRepTools_WireExplorer" deleteWireExplorer :: Ptr WireExplorer -> IO ()
+ src/OpenCascade/BRepTools/Types.hs view
@@ -0,0 +1,4 @@+{-# LANGUAGE EmptyDataDecls #-}+module OpenCascade.BRepTools.Types where++data WireExplorer
+ src/OpenCascade/BRepTools/WireExplorer.hs view
@@ -0,0 +1,37 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.BRepTools.WireExplorer+( WireExplorer+, fromWire+, more+, next+, current+, orientation+)where++import qualified OpenCascade.TopoDS as TopoDS+import OpenCascade.BRepTools.Types (WireExplorer)+import OpenCascade.BRepTools.Internal.Destructors (deleteWireExplorer)+import OpenCascade.Internal.Bool (cBoolToBool)+import qualified OpenCascade.TopAbs as TopAbs+import Foreign.Ptr+import Foreign.C+import Data.Acquire+foreign import capi unsafe "hs_BRepTools_WireExplorer.h hs_new_BRepTools_WireExplorer_fromWire" rawNew :: Ptr TopoDS.Wire -> IO (Ptr WireExplorer)++fromWire :: Ptr TopoDS.Wire -> Acquire (Ptr WireExplorer)+fromWire wire = mkAcquire (rawNew wire) deleteWireExplorer++foreign import capi unsafe "hs_BRepTools_WireExplorer.h hs_BRepTools_WireExplorer_more" rawMore :: Ptr WireExplorer -> IO (CBool)++more :: Ptr WireExplorer -> IO Bool+more = fmap (cBoolToBool) . rawMore ++foreign import capi unsafe "hs_BRepTools_WireExplorer.h hs_BRepTools_WireExplorer_next" next :: Ptr WireExplorer -> IO ()++foreign import capi unsafe "hs_BRepTools_WireExplorer.h hs_BRepTools_WireExplorer_current" current :: Ptr WireExplorer -> IO (Ptr TopoDS.Edge)++foreign import capi unsafe "hs_BRepTools_WireExplorer.h hs_BRepTools_WireExplorer_orientation" rawOrientation :: Ptr WireExplorer -> IO (CInt)++orientation :: Ptr WireExplorer -> IO TopAbs.Orientation+orientation explorer = toEnum . fromIntegral <$>  rawOrientation explorer+
+ src/OpenCascade/GC/MakeArcOfCircle.hs view
@@ -0,0 +1,31 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.GC.MakeArcOfCircle+( from3Pnts+, fromPntsAndVec+) where++import qualified OpenCascade.Geom.Internal.Destructors as Geom.Destructors+import qualified OpenCascade.GP as GP+import qualified OpenCascade.Geom as Geom+import OpenCascade.Handle+import Foreign.Ptr+import Data.Acquire +++-- from3Pnts++foreign import capi unsafe "hs_GC_MakeArcOfCircle.h hs_GC_MakeArcOfCircle_from3Pnts" rawFrom3Pnts :: Ptr GP.Pnt -> Ptr GP.Pnt -> Ptr GP.Pnt -> IO (Ptr (Handle (Geom.TrimmedCurve)))++from3Pnts :: Ptr GP.Pnt -> Ptr GP.Pnt -> Ptr GP.Pnt -> Acquire (Ptr (Handle Geom.TrimmedCurve))+from3Pnts start mid end = mkAcquire (rawFrom3Pnts start mid end) Geom.Destructors.deleteHandleTrimmedCurve+++-- fromPntsAndVec++foreign import capi unsafe "hs_GC_MakeArcOfCircle.h hs_GC_MakeArcOfCircle_fromPntsAndVec" rawFromPntsAndVec :: Ptr GP.Pnt -> Ptr GP.Vec -> Ptr GP.Pnt -> IO (Ptr (Handle (Geom.TrimmedCurve)))++fromPntsAndVec :: Ptr GP.Pnt -> Ptr GP.Vec -> Ptr GP.Pnt -> Acquire (Ptr (Handle Geom.TrimmedCurve))+fromPntsAndVec start dir end = mkAcquire (rawFromPntsAndVec start dir end) Geom.Destructors.deleteHandleTrimmedCurve+++
+ src/OpenCascade/GC/MakeSegment.hs view
@@ -0,0 +1,19 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.GC.MakeSegment+( fromPnts+) where++import qualified OpenCascade.Geom.Internal.Destructors as Geom.Destructors+import qualified OpenCascade.GP as GP+import qualified OpenCascade.Geom as Geom+import OpenCascade.Handle+import Foreign.Ptr+import Data.Acquire +++-- fromPnts++foreign import capi unsafe "hs_GC_MakeSegment.h hs_GC_MakeSegment_fromPnts" rawFromPnts :: Ptr GP.Pnt -> Ptr GP.Pnt -> IO (Ptr (Handle (Geom.TrimmedCurve)))++fromPnts :: Ptr GP.Pnt -> Ptr GP.Pnt -> Acquire (Ptr (Handle Geom.TrimmedCurve))+fromPnts start end = mkAcquire (rawFromPnts start end) Geom.Destructors.deleteHandleTrimmedCurve
+ src/OpenCascade/GP.hs view
@@ -0,0 +1,116 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.GP +( origin+, dx+, dy+, dz+, ox+, oy+, oz+, xoy+, yoz+, zox+, origin2d+, dx2d+, dy2d+, ox2d+, oy2d+, module OpenCascade.GP.Types+) where++import OpenCascade.GP.Types+import OpenCascade.GP.Internal.Destructors+import Foreign.Ptr+import Data.Acquire ++-- origin++foreign import capi unsafe "hs_gp.h hs_gp_Origin" rawOrigin :: IO (Ptr Pnt)++origin :: Acquire (Ptr Pnt)+origin = mkAcquire (rawOrigin) deletePnt++-- cardinal directions++foreign import capi unsafe "hs_gp.h hs_gp_DX" rawDX :: IO (Ptr Dir)++dx :: Acquire (Ptr Dir)+dx = mkAcquire (rawDX) deleteDir++foreign import capi unsafe "hs_gp.h hs_gp_DY" rawDY :: IO (Ptr Dir)++dy :: Acquire (Ptr Dir)+dy = mkAcquire (rawDY) deleteDir+++foreign import capi unsafe "hs_gp.h hs_gp_DZ" rawDZ :: IO (Ptr Dir)++dz :: Acquire (Ptr Dir)+dz = mkAcquire (rawDZ) deleteDir++-- cardinal axes++foreign import capi unsafe "hs_gp.h hs_gp_OX" rawOX :: IO (Ptr Ax1)++ox :: Acquire (Ptr Ax1)+ox = mkAcquire (rawOX) deleteAx1++foreign import capi unsafe "hs_gp.h hs_gp_OY" rawOY :: IO (Ptr Ax1)++oy :: Acquire (Ptr Ax1)+oy = mkAcquire (rawOY) deleteAx1+++foreign import capi unsafe "hs_gp.h hs_gp_OZ" rawOZ :: IO (Ptr Ax1)++oz :: Acquire (Ptr Ax1)+oz = mkAcquire (rawOZ) deleteAx1++-- axes - 2++foreign import capi unsafe "hs_gp.h hs_gp_XOY" rawXOY :: IO (Ptr Ax2)++xoy :: Acquire (Ptr Ax2)+xoy = mkAcquire (rawXOY) deleteAx2++foreign import capi unsafe "hs_gp.h hs_gp_YOZ" rawYOZ :: IO (Ptr Ax2)++yoz :: Acquire (Ptr Ax2)+yoz = mkAcquire (rawYOZ) deleteAx2+++foreign import capi unsafe "hs_gp.h hs_gp_ZOX" rawZOX :: IO (Ptr Ax2)++zox :: Acquire (Ptr Ax2)+zox = mkAcquire (rawZOX) deleteAx2++-- origin 2d++foreign import capi unsafe "hs_gp.h hs_gp_Origin2d" rawOrigin2d :: IO (Ptr Pnt2d)++origin2d :: Acquire (Ptr Pnt2d)+origin2d = mkAcquire (rawOrigin2d) deletePnt2d++-- cardinal directions (2d)++foreign import capi unsafe "hs_gp.h hs_gp_DX2d" rawDX2d :: IO (Ptr Dir2d)++dx2d :: Acquire (Ptr Dir2d)+dx2d = mkAcquire (rawDX2d) deleteDir2d++foreign import capi unsafe "hs_gp.h hs_gp_DY2d" rawDY2d :: IO (Ptr Dir2d)++dy2d :: Acquire (Ptr Dir2d)+dy2d = mkAcquire (rawDY2d) deleteDir2d++-- cardinal axes (2d)++foreign import capi unsafe "hs_gp.h hs_gp_OX2d" rawOX2d :: IO (Ptr Ax2d)++ox2d :: Acquire (Ptr Ax2d)+ox2d = mkAcquire (rawOX2d) deleteAx2d++foreign import capi unsafe "hs_gp.h hs_gp_OY2d" rawOY2d :: IO (Ptr Ax2d)++oy2d :: Acquire (Ptr Ax2d)+oy2d = mkAcquire (rawOY2d) deleteAx2d
+ src/OpenCascade/GP/Ax1.hs view
@@ -0,0 +1,187 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.GP.Ax1+( Ax1+, new+, location+, direction+, setLocation+, setDirection+, isCoaxial+, isNormal+, isOpposite+, isParallel+, angle+, reverse+, reversed+, mirror+, mirrored+, mirrorAboutPnt+, mirroredAboutPnt+, mirrorAboutAx2+, mirroredAboutAx2+, rotate+, rotated+, scale+, scaled+, transform+, transformed+, translate+, translated+, translateRelative+, translatedRelative+) where++import Prelude hiding (reverse)+import OpenCascade.GP.Types+import OpenCascade.GP.Internal.Destructors+import Foreign.Ptr+import Foreign.C.Types+import Data.Acquire +import Data.Coerce (coerce)++-- new and delete++foreign import capi unsafe "hs_gp_Ax1.h hs_new_gp_Ax1" rawNew :: Ptr Pnt -> Ptr Dir -> IO (Ptr Ax1)++new :: Ptr Pnt -> Ptr Dir -> Acquire (Ptr Ax1)+new origin dir = mkAcquire (rawNew origin dir) deleteAx1++-- getters++foreign import capi unsafe "hs_gp_Ax1.h hs_gp_Ax1_Location" rawLocation :: Ptr Ax1 -> IO (Ptr Pnt)++location :: Ptr Ax1 -> Acquire (Ptr Pnt)+location ax1 = mkAcquire (rawLocation ax1) deletePnt++foreign import capi unsafe "hs_gp_Ax1.h hs_gp_Ax1_Direction" rawDirection :: Ptr Ax1 -> IO (Ptr Dir)++direction :: Ptr Ax1 -> Acquire (Ptr Dir)+direction ax1 = mkAcquire (rawDirection ax1) deleteDir++-- setters++foreign import capi unsafe "hs_gp_Ax1.h hs_gp_Ax1_SetDirection" setDirection :: Ptr Ax1 -> Ptr Dir -> IO ()++foreign import capi unsafe "hs_gp_Ax1.h hs_gp_Ax1_SetLocation" setLocation :: Ptr Ax1 -> Ptr Pnt -> IO ()++-- tests++-- isCoaxial++foreign import capi unsafe "hs_gp_Ax1.h hs_gp_Ax1_IsCoaxial" rawIsCoaxial :: Ptr Ax1 -> Ptr Ax1 -> CDouble -> CDouble -> IO CBool++isCoaxial :: Ptr Ax1 -> Ptr Ax1 -> Double -> Double -> IO Bool+isCoaxial a b angularTolerance linearTolerance = (/= 0) <$> rawIsCoaxial a b (CDouble angularTolerance) (CDouble linearTolerance)++-- isNormal++foreign import capi unsafe "hs_gp_Ax1.h hs_gp_Ax1_IsNormal" rawIsNormal :: Ptr Ax1 -> Ptr Ax1 -> CDouble -> IO CBool++isNormal :: Ptr Ax1 -> Ptr Ax1 -> Double -> IO Bool+isNormal a b angularTolerance = (/= 0) <$> rawIsNormal a b (CDouble angularTolerance)++-- isOpposite++foreign import capi unsafe "hs_gp_Ax1.h hs_gp_Ax1_IsOpposite" rawIsOpposite :: Ptr Ax1 -> Ptr Ax1 -> CDouble -> IO CBool++isOpposite :: Ptr Ax1 -> Ptr Ax1 -> Double -> IO Bool+isOpposite a b angularTolerance = (/= 0) <$> rawIsOpposite a b (CDouble angularTolerance)++-- isParallel++foreign import capi unsafe "hs_gp_Ax1.h hs_gp_Ax1_IsParallel" rawIsParallel :: Ptr Ax1 -> Ptr Ax1 -> CDouble -> IO CBool++isParallel :: Ptr Ax1 -> Ptr Ax1 -> Double -> IO Bool+isParallel a b angularTolerance = (/= 0) <$> rawIsParallel a b (CDouble angularTolerance)++-- angle++foreign import capi unsafe "hs_gp_Ax1.h hs_gp_Ax1_Angle" rawAngle :: Ptr Ax1 -> Ptr Ax1 -> IO CDouble++angle :: Ptr Ax1 -> Ptr Ax1 -> IO Double+angle = coerce rawAngle++-- reverse/reversed++foreign import capi unsafe "hs_gp_Ax1.h hs_gp_Ax1_Reverse" reverse :: Ptr Ax1 -> IO ()++foreign import capi unsafe "hs_gp_Ax1.h hs_gp_Ax1_Reversed" rawReversed :: Ptr Ax1 -> IO (Ptr Ax1)++reversed :: Ptr Ax1 -> Acquire (Ptr Ax1)+reversed axis = mkAcquire (rawReversed axis) deleteAx1++-- mirror/mirrored++foreign import capi unsafe "hs_gp_Ax1.h hs_gp_Ax1_Mirror" mirror :: Ptr Ax1 -> Ptr Ax1 -> IO ()++foreign import capi unsafe "hs_gp_Ax1.h hs_gp_Ax1_Mirrored" rawMirrored :: Ptr Ax1 -> Ptr Ax1 -> IO (Ptr Ax1)++mirrored :: Ptr Ax1 -> Ptr Ax1 -> Acquire (Ptr Ax1)+mirrored axis mirror = mkAcquire (rawMirrored axis mirror) deleteAx1+++foreign import capi unsafe "hs_gp_Ax1.h hs_gp_Ax1_MirrorAboutPnt" mirrorAboutPnt :: Ptr Ax1 -> Ptr Pnt -> IO ()++foreign import capi unsafe "hs_gp_Ax1.h hs_gp_Ax1_MirroredAboutPnt" rawMirroredAboutPnt :: Ptr Ax1 -> Ptr Pnt -> IO (Ptr Ax1)++mirroredAboutPnt :: Ptr Ax1 -> Ptr Pnt -> Acquire (Ptr Ax1)+mirroredAboutPnt axis mirror = mkAcquire (rawMirroredAboutPnt axis mirror) deleteAx1+++foreign import capi unsafe "hs_gp_Ax1.h hs_gp_Ax1_MirrorAboutAx2" mirrorAboutAx2 :: Ptr Ax1 -> Ptr Ax2 -> IO ()++foreign import capi unsafe "hs_gp_Ax1.h hs_gp_Ax1_MirroredAboutAx2" rawMirroredAboutAx2 :: Ptr Ax1 -> Ptr Ax2 -> IO (Ptr Ax1)++mirroredAboutAx2 :: Ptr Ax1 -> Ptr Ax2 -> Acquire (Ptr Ax1)+mirroredAboutAx2 axis mirror = mkAcquire (rawMirroredAboutAx2 axis mirror) deleteAx1++-- rotate/rotated ++foreign import capi unsafe "hs_gp_Ax1.h hs_gp_Ax1_Rotate" rawRotate :: Ptr Ax1 -> Ptr Ax1 -> CDouble -> IO ()++rotate :: Ptr Ax1 -> Ptr Ax1 -> Double -> IO ()+rotate = coerce rawRotate++foreign import capi unsafe "hs_gp_Ax1.h hs_gp_Ax1_Rotated" rawRotated :: Ptr Ax1 -> Ptr Ax1 -> CDouble -> IO (Ptr Ax1)++rotated :: Ptr Ax1 -> Ptr Ax1 -> Double -> Acquire (Ptr Ax1)+rotated axis axisOfRotation angle = mkAcquire (rawRotated axis axisOfRotation (CDouble angle)) deleteAx1++-- scale/scaled ++foreign import capi unsafe "hs_gp_Ax1.h hs_gp_Ax1_Scale" rawScale :: Ptr Ax1 -> Ptr Pnt -> CDouble -> IO ()++scale :: Ptr Ax1 -> Ptr Pnt -> Double -> IO ()+scale = coerce rawScale++foreign import capi unsafe "hs_gp_Ax1.h hs_gp_Ax1_Scaled" rawScaled :: Ptr Ax1 -> Ptr Pnt -> CDouble -> IO (Ptr Ax1)++scaled :: Ptr Ax1 -> Ptr Pnt -> Double -> Acquire (Ptr Ax1)+scaled axis origin amount = mkAcquire (rawScaled axis origin (CDouble amount)) deleteAx1++-- transform/transformed ++foreign import capi unsafe "hs_gp_Ax1.h hs_gp_Ax1_Transform" transform :: Ptr Ax1 -> Ptr Trsf -> IO ()++foreign import capi unsafe "hs_gp_Ax1.h hs_gp_Ax1_Transformed" rawTransformed :: Ptr Ax1 -> Ptr Trsf -> IO (Ptr Ax1)++transformed :: Ptr Ax1 -> Ptr Trsf -> Acquire (Ptr Ax1)+transformed axis trsf = mkAcquire (rawTransformed axis trsf) deleteAx1+++-- translate/translated++foreign import capi unsafe "hs_gp_Ax1.h hs_gp_Ax1_Translate" translate :: Ptr Ax1 -> Ptr Vec -> IO ()++foreign import capi unsafe "hs_gp_Ax1.h hs_gp_Ax1_Translated" rawTranslated :: Ptr Ax1 -> Ptr Vec -> IO (Ptr Ax1)++translated :: Ptr Ax1 -> Ptr Vec -> Acquire (Ptr Ax1)+translated axis vec = mkAcquire (rawTranslated axis vec) deleteAx1+++foreign import capi unsafe "hs_gp_Ax1.h hs_gp_Ax1_TranslateRelative" translateRelative :: Ptr Ax1 -> Ptr Pnt -> Ptr Pnt -> IO ()++foreign import capi unsafe "hs_gp_Ax1.h hs_gp_Ax1_TranslatedRelative" rawTranslatedRelative :: Ptr Ax1 -> Ptr Pnt -> Ptr Pnt -> IO (Ptr Ax1)++translatedRelative :: Ptr Ax1 -> Ptr Pnt -> Ptr Pnt -> Acquire (Ptr Ax1)+translatedRelative axis from to = mkAcquire (rawTranslatedRelative axis from to) deleteAx1
+ src/OpenCascade/GP/Ax2.hs view
@@ -0,0 +1,184 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.GP.Ax2+( Ax2+, new+, newAutoX+, location+, direction+, xDirection+, yDirection+, axis+, setLocation+, setDirection+, setXDirection+, setYDirection+, setAxis+, isCoplanar+, isCoplanarWithAx1+, mirror+, mirrored+, mirrorAboutPnt+, mirroredAboutPnt+, mirrorAboutAx1+, mirroredAboutAx1+, rotate+, rotated+, scale+, scaled+, transform+, transformed+, translate+, translated+, translateRelative+, translatedRelative+) where++import Prelude hiding (reverse)+import OpenCascade.GP.Types+import OpenCascade.GP.Internal.Destructors+import Foreign.Ptr+import Foreign.C.Types+import Data.Acquire +import Data.Coerce (coerce)++-- new and delete++foreign import capi unsafe "hs_gp_Ax2.h hs_new_gp_Ax2" rawNew :: Ptr Pnt -> Ptr Dir -> Ptr Dir -> IO (Ptr Ax2)++new :: Ptr Pnt -> Ptr Dir -> Ptr Dir -> Acquire (Ptr Ax2)+new origin axis vX = mkAcquire (rawNew origin axis vX) deleteAx2++foreign import capi unsafe "hs_gp_Ax2.h hs_new_gp_Ax2_autoX" rawNewAutoX :: Ptr Pnt -> Ptr Dir -> IO (Ptr Ax2)++newAutoX :: Ptr Pnt -> Ptr Dir -> Acquire (Ptr Ax2)+newAutoX origin axis = mkAcquire (rawNewAutoX origin axis) deleteAx2+++-- getters++foreign import capi unsafe "hs_gp_Ax2.h hs_gp_Ax2_Location" rawLocation :: Ptr Ax2 -> IO (Ptr Pnt)++location :: Ptr Ax2 -> Acquire (Ptr Pnt)+location ax2 = mkAcquire (rawLocation ax2) deletePnt++foreign import capi unsafe "hs_gp_Ax2.h hs_gp_Ax2_Direction" rawDirection :: Ptr Ax2 -> IO (Ptr Dir)++direction :: Ptr Ax2 -> Acquire (Ptr Dir)+direction ax2 = mkAcquire (rawDirection ax2) deleteDir++foreign import capi unsafe "hs_gp_Ax2.h hs_gp_Ax2_XDirection" rawXDirection :: Ptr Ax2 -> IO (Ptr Dir)++xDirection :: Ptr Ax2 -> Acquire (Ptr Dir)+xDirection ax2 = mkAcquire (rawXDirection ax2) deleteDir++foreign import capi unsafe "hs_gp_Ax2.h hs_gp_Ax2_YDirection" rawYDirection :: Ptr Ax2 -> IO (Ptr Dir)++yDirection :: Ptr Ax2 -> Acquire (Ptr Dir)+yDirection ax2 = mkAcquire (rawYDirection ax2) deleteDir++foreign import capi unsafe "hs_gp_Ax2.h hs_gp_Ax2_Axis" rawAxis :: Ptr Ax2 -> IO (Ptr Ax1)++axis :: Ptr Ax2 -> Acquire (Ptr Ax1)+axis ax2 = mkAcquire (rawAxis ax2) deleteAx1++-- setters++foreign import capi unsafe "hs_gp_Ax2.h hs_gp_Ax2_SetDirection" setDirection :: Ptr Ax2 -> Ptr Dir -> IO ()++foreign import capi unsafe "hs_gp_Ax2.h hs_gp_Ax2_SetLocation" setLocation :: Ptr Ax2 -> Ptr Pnt -> IO ()++foreign import capi unsafe "hs_gp_Ax2.h hs_gp_Ax2_SetXDirection" setXDirection :: Ptr Ax2 -> Ptr Dir -> IO ()++foreign import capi unsafe "hs_gp_Ax2.h hs_gp_Ax2_SetYDirection" setYDirection :: Ptr Ax2 -> Ptr Dir -> IO ()++foreign import capi unsafe "hs_gp_Ax2.h hs_gp_Ax2_SetAxis" setAxis :: Ptr Ax2 -> Ptr Ax1 -> IO ()++-- isCoplanar++foreign import capi unsafe "hs_gp_Ax2.h hs_gp_Ax2_IsCoplanar" rawIsCoplanar :: Ptr Ax2 -> Ptr Ax2 -> CDouble -> CDouble -> IO CBool++isCoplanar :: Ptr Ax2 -> Ptr Ax2 -> Double -> Double -> IO Bool+isCoplanar a b linearTolerance angularTolerance = (/= 0) <$> rawIsCoplanar a b (CDouble linearTolerance) (CDouble angularTolerance)++foreign import capi unsafe "hs_gp_Ax2.h hs_gp_Ax2_IsCoplanarWithAx1" rawIsCoplanarWithAx1 :: Ptr Ax2 -> Ptr Ax1 -> CDouble -> CDouble -> IO CBool++isCoplanarWithAx1 :: Ptr Ax2 -> Ptr Ax1 -> Double -> Double -> IO Bool+isCoplanarWithAx1 a b linearTolerance angularTolerance = (/= 0) <$> rawIsCoplanarWithAx1 a b (CDouble linearTolerance) (CDouble angularTolerance)++-- mirror/mirrored++foreign import capi unsafe "hs_gp_Ax2.h hs_gp_Ax2_Mirror" mirror :: Ptr Ax2 -> Ptr Ax2 -> IO ()++foreign import capi unsafe "hs_gp_Ax2.h hs_gp_Ax2_Mirrored" rawMirrored :: Ptr Ax2 -> Ptr Ax2 -> IO (Ptr Ax2)++mirrored :: Ptr Ax2 -> Ptr Ax2 -> Acquire (Ptr Ax2)+mirrored axis mirror = mkAcquire (rawMirrored axis mirror) deleteAx2+++foreign import capi unsafe "hs_gp_Ax2.h hs_gp_Ax2_MirrorAboutPnt" mirrorAboutPnt :: Ptr Ax2 -> Ptr Pnt -> IO ()++foreign import capi unsafe "hs_gp_Ax2.h hs_gp_Ax2_MirroredAboutPnt" rawMirroredAboutPnt :: Ptr Ax2 -> Ptr Pnt -> IO (Ptr Ax2)++mirroredAboutPnt :: Ptr Ax2 -> Ptr Pnt -> Acquire (Ptr Ax2)+mirroredAboutPnt axis mirror = mkAcquire (rawMirroredAboutPnt axis mirror) deleteAx2+++foreign import capi unsafe "hs_gp_Ax2.h hs_gp_Ax2_MirrorAboutAx1" mirrorAboutAx1 :: Ptr Ax2 -> Ptr Ax1 -> IO ()++foreign import capi unsafe "hs_gp_Ax2.h hs_gp_Ax2_MirroredAboutAx1" rawMirroredAboutAx1 :: Ptr Ax2 -> Ptr Ax1 -> IO (Ptr Ax2)++mirroredAboutAx1 :: Ptr Ax2 -> Ptr Ax1 -> Acquire (Ptr Ax2)+mirroredAboutAx1 axis mirror = mkAcquire (rawMirroredAboutAx1 axis mirror) deleteAx2+++-- rotate/rotated ++foreign import capi unsafe "hs_gp_Ax2.h hs_gp_Ax2_Rotate" rawRotate :: Ptr Ax2 -> Ptr Ax1 -> CDouble -> IO ()++rotate :: Ptr Ax2 -> Ptr Ax1 -> Double -> IO ()+rotate = coerce rawRotate++foreign import capi unsafe "hs_gp_Ax2.h hs_gp_Ax2_Rotated" rawRotated :: Ptr Ax2 -> Ptr Ax1 -> CDouble -> IO (Ptr Ax2)++rotated :: Ptr Ax2 -> Ptr Ax1 -> Double -> Acquire (Ptr Ax2)+rotated axis axisOfRotation angle = mkAcquire (rawRotated axis axisOfRotation (CDouble angle)) deleteAx2++-- scale/scaled ++foreign import capi unsafe "hs_gp_Ax2.h hs_gp_Ax2_Scale" rawScale :: Ptr Ax2 -> Ptr Pnt -> CDouble -> IO ()++scale :: Ptr Ax2 -> Ptr Pnt -> Double -> IO ()+scale = coerce rawScale++foreign import capi unsafe "hs_gp_Ax2.h hs_gp_Ax2_Scaled" rawScaled :: Ptr Ax2 -> Ptr Pnt -> CDouble -> IO (Ptr Ax2)++scaled :: Ptr Ax2 -> Ptr Pnt -> Double -> Acquire (Ptr Ax2)+scaled axis origin amount = mkAcquire (rawScaled axis origin (CDouble amount)) deleteAx2++-- transform/transformed ++foreign import capi unsafe "hs_gp_Ax2.h hs_gp_Ax2_Transform" transform :: Ptr Ax2 -> Ptr Trsf -> IO ()++foreign import capi unsafe "hs_gp_Ax2.h hs_gp_Ax2_Transformed" rawTransformed :: Ptr Ax2 -> Ptr Trsf -> IO (Ptr Ax2)++transformed :: Ptr Ax2 -> Ptr Trsf -> Acquire (Ptr Ax2)+transformed axis trsf = mkAcquire (rawTransformed axis trsf) deleteAx2+++-- translate/translated++foreign import capi unsafe "hs_gp_Ax2.h hs_gp_Ax2_Translate" translate :: Ptr Ax2 -> Ptr Vec -> IO ()++foreign import capi unsafe "hs_gp_Ax2.h hs_gp_Ax2_Translated" rawTranslated :: Ptr Ax2 -> Ptr Vec -> IO (Ptr Ax2)++translated :: Ptr Ax2 -> Ptr Vec -> Acquire (Ptr Ax2)+translated axis vec = mkAcquire (rawTranslated axis vec) deleteAx2+++foreign import capi unsafe "hs_gp_Ax2.h hs_gp_Ax2_TranslateRelative" translateRelative :: Ptr Ax2 -> Ptr Pnt -> Ptr Pnt -> IO ()++foreign import capi unsafe "hs_gp_Ax2.h hs_gp_Ax2_TranslatedRelative" rawTranslatedRelative :: Ptr Ax2 -> Ptr Pnt -> Ptr Pnt -> IO (Ptr Ax2)++translatedRelative :: Ptr Ax2 -> Ptr Pnt -> Ptr Pnt -> Acquire (Ptr Ax2)+translatedRelative axis from to = mkAcquire (rawTranslatedRelative axis from to) deleteAx2+
+ src/OpenCascade/GP/Ax2d.hs view
@@ -0,0 +1,179 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.GP.Ax2d+( Ax2d+, new+, location+, direction+, setLocation+, setDirection+, isCoaxial+, isNormal+, isOpposite+, isParallel+, angle+, reverse+, reversed+, mirror+, mirrored+, mirrorAboutPnt2d+, mirroredAboutPnt2d+, rotate+, rotated+, scale+, scaled+, transform+, transformed+, translate+, translated+, translateRelative+, translatedRelative+) where++import Prelude hiding (reverse)+import OpenCascade.GP.Types+import OpenCascade.GP.Internal.Destructors+import Foreign.Ptr+import Foreign.C.Types+import Data.Acquire +import Data.Coerce (coerce)+++-- new and delete++foreign import capi unsafe "hs_gp_Ax2d.h hs_new_gp_Ax2d" rawNew :: Ptr Pnt2d -> Ptr Dir2d -> IO (Ptr Ax2d)++new :: Ptr Pnt2d -> Ptr Dir2d -> Acquire (Ptr Ax2d)+new origin dir = mkAcquire (rawNew origin dir) deleteAx2d++-- getters++foreign import capi unsafe "hs_gp_Ax2d.h hs_gp_Ax2d_Location" rawLocation :: Ptr Ax2d -> IO (Ptr Pnt2d)++location :: Ptr Ax2d -> Acquire (Ptr Pnt2d)+location ax2d = mkAcquire (rawLocation ax2d) deletePnt2d++foreign import capi unsafe "hs_gp_Ax2d.h hs_gp_Ax2d_Direction" rawDirection :: Ptr Ax2d -> IO (Ptr Dir2d)++direction :: Ptr Ax2d -> Acquire (Ptr Dir2d)+direction ax2d = mkAcquire (rawDirection ax2d) deleteDir2d++-- setters++foreign import capi unsafe "hs_gp_Ax2d.h hs_gp_Ax2d_SetDirection" setDirection :: Ptr Ax2d -> Ptr Dir2d -> IO ()++foreign import capi unsafe "hs_gp_Ax2d.h hs_gp_Ax2d_SetLocation" setLocation :: Ptr Ax2d -> Ptr Pnt2d -> IO ()++-- tests++-- isCoaxial++foreign import capi unsafe "hs_gp_Ax2d.h hs_gp_Ax2d_IsCoaxial" rawIsCoaxial :: Ptr Ax2d -> Ptr Ax2d -> CDouble -> CDouble -> IO CBool++isCoaxial :: Ptr Ax2d -> Ptr Ax2d -> Double -> Double -> IO Bool+isCoaxial a b angularTolerance linearTolerance = (/= 0) <$> rawIsCoaxial a b (CDouble angularTolerance) (CDouble linearTolerance)++-- isNormal++foreign import capi unsafe "hs_gp_Ax2d.h hs_gp_Ax2d_IsNormal" rawIsNormal :: Ptr Ax2d -> Ptr Ax2d -> CDouble -> IO CBool++isNormal :: Ptr Ax2d -> Ptr Ax2d -> Double -> IO Bool+isNormal a b angularTolerance = (/= 0) <$> rawIsNormal a b (CDouble angularTolerance)++-- isOpposite++foreign import capi unsafe "hs_gp_Ax2d.h hs_gp_Ax2d_IsOpposite" rawIsOpposite :: Ptr Ax2d -> Ptr Ax2d -> CDouble -> IO CBool++isOpposite :: Ptr Ax2d -> Ptr Ax2d -> Double -> IO Bool+isOpposite a b angularTolerance = (/= 0) <$> rawIsOpposite a b (CDouble angularTolerance)++-- isParallel++foreign import capi unsafe "hs_gp_Ax2d.h hs_gp_Ax2d_IsParallel" rawIsParallel :: Ptr Ax2d -> Ptr Ax2d -> CDouble -> IO CBool++isParallel :: Ptr Ax2d -> Ptr Ax2d -> Double -> IO Bool+isParallel a b angularTolerance = (/= 0) <$> rawIsParallel a b (CDouble angularTolerance)++-- angle++foreign import capi unsafe "hs_gp_Ax2d.h hs_gp_Ax2d_Angle" rawAngle :: Ptr Ax2d -> Ptr Ax2d -> IO CDouble++angle :: Ptr Ax2d -> Ptr Ax2d -> IO Double+angle = coerce rawAngle++-- reverse/reversed++foreign import capi unsafe "hs_gp_Ax2d.h hs_gp_Ax2d_Reverse" reverse :: Ptr Ax2d -> IO ()++foreign import capi unsafe "hs_gp_Ax2d.h hs_gp_Ax2d_Reversed" rawReversed :: Ptr Ax2d -> IO (Ptr Ax2d)++reversed :: Ptr Ax2d -> Acquire (Ptr Ax2d)+reversed axis = mkAcquire (rawReversed axis) deleteAx2d++-- mirror/mirrored++foreign import capi unsafe "hs_gp_Ax2d.h hs_gp_Ax2d_Mirror" mirror :: Ptr Ax2d -> Ptr Ax2d -> IO ()++foreign import capi unsafe "hs_gp_Ax2d.h hs_gp_Ax2d_Mirrored" rawMirrored :: Ptr Ax2d -> Ptr Ax2d -> IO (Ptr Ax2d)++mirrored :: Ptr Ax2d -> Ptr Ax2d -> Acquire (Ptr Ax2d)+mirrored axis mirror = mkAcquire (rawMirrored axis mirror) deleteAx2d+++foreign import capi unsafe "hs_gp_Ax2d.h hs_gp_Ax2d_MirrorAboutPnt2d" mirrorAboutPnt2d :: Ptr Ax2d -> Ptr Pnt2d -> IO ()++foreign import capi unsafe "hs_gp_Ax2d.h hs_gp_Ax2d_MirroredAboutPnt2d" rawMirroredAboutPnt2d :: Ptr Ax2d -> Ptr Pnt2d -> IO (Ptr Ax2d)++mirroredAboutPnt2d :: Ptr Ax2d -> Ptr Pnt2d -> Acquire (Ptr Ax2d)+mirroredAboutPnt2d axis mirror = mkAcquire (rawMirroredAboutPnt2d axis mirror) deleteAx2d++-- rotate/rotated ++foreign import capi unsafe "hs_gp_Ax2d.h hs_gp_Ax2d_Rotate" rawRotate :: Ptr Ax2d -> Ptr Pnt2d -> CDouble -> IO ()++rotate :: Ptr Ax2d -> Ptr Pnt2d -> Double -> IO ()+rotate = coerce rawRotate++foreign import capi unsafe "hs_gp_Ax2d.h hs_gp_Ax2d_Rotated" rawRotated :: Ptr Ax2d -> Ptr Pnt2d -> CDouble -> IO (Ptr Ax2d)++rotated :: Ptr Ax2d -> Ptr Pnt2d -> Double -> Acquire (Ptr Ax2d)+rotated axis axisOfRotation angle = mkAcquire (rawRotated axis axisOfRotation (CDouble angle)) deleteAx2d++-- scale/scaled ++foreign import capi unsafe "hs_gp_Ax2d.h hs_gp_Ax2d_Scale" rawScale :: Ptr Ax2d -> Ptr Pnt2d -> CDouble -> IO ()++scale :: Ptr Ax2d -> Ptr Pnt2d -> Double -> IO ()+scale = coerce rawScale++foreign import capi unsafe "hs_gp_Ax2d.h hs_gp_Ax2d_Scaled" rawScaled :: Ptr Ax2d -> Ptr Pnt2d -> CDouble -> IO (Ptr Ax2d)++scaled :: Ptr Ax2d -> Ptr Pnt2d -> Double -> Acquire (Ptr Ax2d)+scaled axis origin amount = mkAcquire (rawScaled axis origin (CDouble amount)) deleteAx2d++-- transform/transformed ++foreign import capi unsafe "hs_gp_Ax2d.h hs_gp_Ax2d_Transform" transform :: Ptr Ax2d -> Ptr Trsf2d -> IO ()++foreign import capi unsafe "hs_gp_Ax2d.h hs_gp_Ax2d_Transformed" rawTransformed :: Ptr Ax2d -> Ptr Trsf2d -> IO (Ptr Ax2d)++transformed :: Ptr Ax2d -> Ptr Trsf2d -> Acquire (Ptr Ax2d)+transformed axis trsf = mkAcquire (rawTransformed axis trsf) deleteAx2d+++-- translate/translated++foreign import capi unsafe "hs_gp_Ax2d.h hs_gp_Ax2d_Translate" translate :: Ptr Ax2d -> Ptr Vec2d -> IO ()++foreign import capi unsafe "hs_gp_Ax2d.h hs_gp_Ax2d_Translated" rawTranslated :: Ptr Ax2d -> Ptr Vec2d -> IO (Ptr Ax2d)++translated :: Ptr Ax2d -> Ptr Vec2d -> Acquire (Ptr Ax2d)+translated axis vec = mkAcquire (rawTranslated axis vec) deleteAx2d+++foreign import capi unsafe "hs_gp_Ax2d.h hs_gp_Ax2d_TranslateRelative" translateRelative :: Ptr Ax2d -> Ptr Pnt2d -> Ptr Pnt2d -> IO ()++foreign import capi unsafe "hs_gp_Ax2d.h hs_gp_Ax2d_TranslatedRelative" rawTranslatedRelative :: Ptr Ax2d -> Ptr Pnt2d -> Ptr Pnt2d -> IO (Ptr Ax2d)++translatedRelative :: Ptr Ax2d -> Ptr Pnt2d -> Ptr Pnt2d -> Acquire (Ptr Ax2d)+translatedRelative axis from to = mkAcquire (rawTranslatedRelative axis from to) deleteAx2d+
+ src/OpenCascade/GP/Dir.hs view
@@ -0,0 +1,218 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.GP.Dir +( Dir+, new+, getX+, getY+, getZ +, setX+, setY +, setZ+, isEqual+, isOpposite+, isNormal+, isParallel+, angle+, angleWithRef+, cross+, crossed+, crossCross+, crossCrossed+, dot+, dotCross+, reverse+, reversed+, mirror+, mirrored+, mirrorAboutAx1+, mirroredAboutAx1+, mirrorAboutAx2+, mirroredAboutAx2+, rotate+, rotated+, transform+, transformed+) where+++import Prelude hiding (reverse)+import OpenCascade.GP.Types+import OpenCascade.GP.Internal.Destructors+import Foreign.C+import Foreign.Ptr+import Data.Coerce (coerce)+import Data.Acquire ++-- new++foreign import capi unsafe "hs_gp_Dir.h hs_new_gp_Dir" rawNew :: CDouble -> CDouble -> CDouble -> IO (Ptr Dir)++new :: Double -> Double -> Double -> Acquire (Ptr Dir)+new x y z = mkAcquire (rawNew (CDouble x) (CDouble y) (CDouble z)) deleteDir++-- getters++foreign import capi unsafe "hs_gp_Dir.h hs_gp_Dir_X" rawX :: Ptr Dir -> IO (CDouble)++getX :: Ptr Dir -> IO Double+getX = coerce rawX++foreign import capi unsafe "hs_gp_Dir.h hs_gp_Dir_Y" rawY :: Ptr Dir -> IO (CDouble)++getY :: Ptr Dir -> IO Double+getY = coerce rawY++foreign import capi unsafe "hs_gp_Dir.h hs_gp_Dir_Z" rawZ :: Ptr Dir -> IO (CDouble)++getZ :: Ptr Dir -> IO Double+getZ = coerce rawZ++-- setters++foreign import capi unsafe "hs_gp_Dir.h hs_gp_Dir_SetX" rawSetX :: Ptr Dir -> CDouble -> IO ()++setX :: Ptr Dir -> Double -> IO ()+setX = coerce rawSetX+++foreign import capi unsafe "hs_gp_Dir.h hs_gp_Dir_SetY" rawSetY :: Ptr Dir -> CDouble -> IO ()++setY :: Ptr Dir -> Double -> IO ()+setY = coerce rawSetY+++foreign import capi unsafe "hs_gp_Dir.h hs_gp_Dir_SetZ" rawSetZ :: Ptr Dir -> CDouble -> IO ()++setZ :: Ptr Dir -> Double -> IO ()+setZ = coerce rawSetZ++-- tests++-- isEqual++foreign import capi unsafe "hs_gp_Dir.h hs_gp_Dir_IsEqual" rawIsEqual :: Ptr Dir -> Ptr Dir -> CDouble -> IO CBool++isEqual :: Ptr Dir -> Ptr Dir -> Double -> IO Bool+isEqual a b tolerance = (/= 0) <$> rawIsEqual a b (CDouble tolerance)++-- isNormal++foreign import capi unsafe "hs_gp_Dir.h hs_gp_Dir_IsNormal" rawIsNormal :: Ptr Dir -> Ptr Dir -> CDouble -> IO CBool++isNormal :: Ptr Dir -> Ptr Dir -> Double -> IO Bool+isNormal a b tolerance = (/= 0) <$> rawIsNormal a b (CDouble tolerance)+++-- isOpposite++foreign import capi unsafe "hs_gp_Dir.h hs_gp_Dir_IsOpposite" rawIsOpposite :: Ptr Dir -> Ptr Dir -> CDouble -> IO CBool++isOpposite :: Ptr Dir -> Ptr Dir -> Double -> IO Bool+isOpposite a b tolerance = (/= 0) <$> rawIsOpposite a b (CDouble tolerance)++-- isParallel++foreign import capi unsafe "hs_gp_Dir.h hs_gp_Dir_IsParallel" rawIsParallel :: Ptr Dir -> Ptr Dir -> CDouble -> IO CBool++isParallel :: Ptr Dir -> Ptr Dir -> Double -> IO Bool+isParallel a b tolerance = (/= 0) <$> rawIsParallel a b (CDouble tolerance)++-- angle++foreign import capi unsafe "hs_gp_Dir.h hs_gp_Dir_Angle" rawAngle :: Ptr Dir -> Ptr Dir -> IO CDouble++angle :: Ptr Dir -> Ptr Dir -> IO Double+angle = coerce rawAngle++-- angleWithRef++foreign import capi unsafe "hs_gp_Dir.h hs_gp_Dir_AngleWithRef" rawAngleWithRef :: Ptr Dir -> Ptr Dir -> Ptr Dir -> IO CDouble++angleWithRef :: Ptr Dir -> Ptr Dir -> Ptr Dir -> IO Double+angleWithRef = coerce rawAngleWithRef++-- cross/crossed++foreign import capi unsafe "hs_gp_Dir.h hs_gp_Dir_Cross" cross :: Ptr Dir -> Ptr Dir -> IO ()++foreign import capi unsafe "hs_gp_Dir.h hs_gp_Dir_Crossed" rawCrossed :: Ptr Dir -> Ptr Dir -> IO (Ptr Dir)++crossed :: Ptr Dir -> Ptr Dir -> Acquire (Ptr Dir)+crossed a b = mkAcquire (rawCrossed a b) deleteDir+++-- crossCross/crossCrossed++foreign import capi unsafe "hs_gp_Dir.h hs_gp_Dir_CrossCross" crossCross :: Ptr Dir -> Ptr Dir -> Ptr Dir -> IO ()++foreign import capi unsafe "hs_gp_Dir.h hs_gp_Dir_CrossCrossed" rawCrossCrossed :: Ptr Dir -> Ptr Dir -> Ptr Dir -> IO (Ptr Dir)++crossCrossed :: Ptr Dir -> Ptr Dir -> Ptr Dir -> Acquire (Ptr Dir)+crossCrossed a b c = mkAcquire (rawCrossCrossed a b c) deleteDir+++-- dot++foreign import capi unsafe "hs_gp_Dir.h hs_gp_Dir_Dot" rawDot :: Ptr Dir -> Ptr Dir -> IO CDouble++dot :: Ptr Dir -> Ptr Dir -> IO Double+dot = coerce rawDot+++-- dotCross++foreign import capi unsafe "hs_gp_Dir.h hs_gp_Dir_DotCross" rawDotCross :: Ptr Dir -> Ptr Dir -> Ptr Dir -> IO CDouble++dotCross :: Ptr Dir -> Ptr Dir -> Ptr Dir -> IO Double+dotCross = coerce rawDotCross+++-- reverse/reversed++foreign import capi unsafe "hs_gp_Dir.h hs_gp_Dir_Reverse" reverse :: Ptr Dir -> IO ()++foreign import capi unsafe "hs_gp_Dir.h hs_gp_Dir_Reversed" rawReversed :: Ptr Dir -> IO (Ptr Dir)++reversed :: Ptr Dir -> Acquire (Ptr Dir)+reversed axis = mkAcquire (rawReversed axis) deleteDir++-- mirror/mirrored++foreign import capi unsafe "hs_gp_Dir.h hs_gp_Dir_Mirror" mirror :: Ptr Dir -> Ptr Dir -> IO ()++foreign import capi unsafe "hs_gp_Dir.h hs_gp_Dir_Mirrored" rawMirrored :: Ptr Dir -> Ptr Dir -> IO (Ptr Dir)++mirrored :: Ptr Dir -> Ptr Dir -> Acquire (Ptr Dir)+mirrored point axis = mkAcquire (rawMirrored point axis) deleteDir++foreign import capi unsafe "hs_gp_Dir.h hs_gp_Dir_MirrorAboutAx1" mirrorAboutAx1 :: Ptr Dir -> Ptr Ax1 -> IO ()++foreign import capi unsafe "hs_gp_Dir.h hs_gp_Dir_MirroredAboutAx1" rawMirroredAboutAx1 :: Ptr Dir -> Ptr Ax1 -> IO (Ptr Dir)++mirroredAboutAx1 :: Ptr Dir -> Ptr Ax1 -> Acquire (Ptr Dir)+mirroredAboutAx1 point axis = mkAcquire (rawMirroredAboutAx1 point axis) deleteDir++foreign import capi unsafe "hs_gp_Dir.h hs_gp_Dir_MirrorAboutAx2" mirrorAboutAx2 :: Ptr Dir -> Ptr Ax2 -> IO ()++foreign import capi unsafe "hs_gp_Dir.h hs_gp_Dir_MirroredAboutAx2" rawMirroredAboutAx2 :: Ptr Dir -> Ptr Ax2 -> IO (Ptr Dir)++mirroredAboutAx2 :: Ptr Dir -> Ptr Ax2 -> Acquire (Ptr Dir)+mirroredAboutAx2 point axis = mkAcquire (rawMirroredAboutAx2 point axis) deleteDir++-- rotate/rotated++foreign import capi unsafe "hs_gp_Dir.h hs_gp_Dir_Rotate" rotate :: Ptr Dir -> Ptr Ax1 -> CDouble-> IO ()++foreign import capi unsafe "hs_gp_Dir.h hs_gp_Dir_Rotated" rawRotated :: Ptr Dir -> Ptr Ax1 -> CDouble -> IO (Ptr Dir)++rotated :: Ptr Dir -> Ptr Ax1 -> Double -> Acquire (Ptr Dir)+rotated point axis amount = mkAcquire (rawRotated point axis (CDouble amount)) deleteDir++-- transform/transformed++foreign import capi unsafe "hs_gp_Dir.h hs_gp_Dir_Transform" transform :: Ptr Dir -> Ptr Trsf -> IO ()++foreign import capi unsafe "hs_gp_Dir.h hs_gp_Dir_Transformed" rawTransformed :: Ptr Dir -> Ptr Trsf -> IO (Ptr Dir)++transformed :: Ptr Dir -> Ptr Trsf -> Acquire (Ptr Dir)+transformed point trsf = mkAcquire (rawTransformed point trsf) deleteDir
+ src/OpenCascade/GP/Dir2d.hs view
@@ -0,0 +1,162 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.GP.Dir2d+( Dir2d+, new+, getX+, getY+, setX+, setY +, isEqual+, isOpposite+, isNormal+, isParallel+, angle+, crossed+, dot+, reverse+, reversed+, mirror+, mirrored+, mirrorAboutAx2d+, mirroredAboutAx2d+, rotate+, rotated+, transform+, transformed+) where+++import Prelude hiding (reverse)+import OpenCascade.GP.Types+import OpenCascade.GP.Internal.Destructors+import Foreign.C+import Foreign.Ptr+import Data.Coerce (coerce)+import Data.Acquire ++-- new++foreign import capi unsafe "hs_gp_Dir2d.h hs_new_gp_Dir2d" rawNew :: CDouble -> CDouble -> IO (Ptr Dir2d)++new :: Double -> Double -> Acquire (Ptr Dir2d)+new x y = mkAcquire (rawNew (CDouble x) (CDouble y)) deleteDir2d++-- getters++foreign import capi unsafe "hs_gp_Dir2d.h hs_gp_Dir2d_X" rawX :: Ptr Dir2d -> IO (CDouble)++getX :: Ptr Dir2d -> IO Double+getX = coerce rawX++foreign import capi unsafe "hs_gp_Dir2d.h hs_gp_Dir2d_Y" rawY :: Ptr Dir2d -> IO (CDouble)++getY :: Ptr Dir2d -> IO Double+getY = coerce rawY++-- setters++foreign import capi unsafe "hs_gp_Dir2d.h hs_gp_Dir2d_SetX" rawSetX :: Ptr Dir2d -> CDouble -> IO ()++setX :: Ptr Dir2d -> Double -> IO ()+setX = coerce rawSetX+++foreign import capi unsafe "hs_gp_Dir2d.h hs_gp_Dir2d_SetY" rawSetY :: Ptr Dir2d -> CDouble -> IO ()++setY :: Ptr Dir2d -> Double -> IO ()+setY = coerce rawSetY++-- tests++-- isEqual++foreign import capi unsafe "hs_gp_Dir2d.h hs_gp_Dir2d_IsEqual" rawIsEqual :: Ptr Dir2d -> Ptr Dir2d -> CDouble -> IO CBool++isEqual :: Ptr Dir2d -> Ptr Dir2d -> Double -> IO Bool+isEqual a b tolerance = (/= 0) <$> rawIsEqual a b (CDouble tolerance)++-- isNormal++foreign import capi unsafe "hs_gp_Dir2d.h hs_gp_Dir2d_IsNormal" rawIsNormal :: Ptr Dir2d -> Ptr Dir2d -> CDouble -> IO CBool++isNormal :: Ptr Dir2d -> Ptr Dir2d -> Double -> IO Bool+isNormal a b tolerance = (/= 0) <$> rawIsNormal a b (CDouble tolerance)+++-- isOpposite++foreign import capi unsafe "hs_gp_Dir2d.h hs_gp_Dir2d_IsOpposite" rawIsOpposite :: Ptr Dir2d -> Ptr Dir2d -> CDouble -> IO CBool++isOpposite :: Ptr Dir2d -> Ptr Dir2d -> Double -> IO Bool+isOpposite a b tolerance = (/= 0) <$> rawIsOpposite a b (CDouble tolerance)++-- isParallel++foreign import capi unsafe "hs_gp_Dir2d.h hs_gp_Dir2d_IsParallel" rawIsParallel :: Ptr Dir2d -> Ptr Dir2d -> CDouble -> IO CBool++isParallel :: Ptr Dir2d -> Ptr Dir2d -> Double -> IO Bool+isParallel a b tolerance = (/= 0) <$> rawIsParallel a b (CDouble tolerance)++-- angle++foreign import capi unsafe "hs_gp_Dir2d.h hs_gp_Dir2d_Angle" rawAngle :: Ptr Dir2d -> Ptr Dir2d -> IO CDouble++angle :: Ptr Dir2d -> Ptr Dir2d -> IO Double+angle = coerce rawAngle++-- crossed++foreign import capi unsafe "hs_gp_Dir2d.h hs_gp_Dir2d_Crossed" rawCrossed :: Ptr Dir2d -> Ptr Dir2d -> IO CDouble++crossed :: Ptr Dir2d -> Ptr Dir2d -> IO Double+crossed = coerce rawCrossed++-- dot++foreign import capi unsafe "hs_gp_Dir2d.h hs_gp_Dir2d_Dot" rawDot :: Ptr Dir2d -> Ptr Dir2d -> IO CDouble++dot :: Ptr Dir2d -> Ptr Dir2d -> IO Double+dot = coerce rawDot++-- reverse/reversed++foreign import capi unsafe "hs_gp_Dir2d.h hs_gp_Dir2d_Reverse" reverse :: Ptr Dir2d -> IO ()++foreign import capi unsafe "hs_gp_Dir2d.h hs_gp_Dir2d_Reversed" rawReversed :: Ptr Dir2d -> IO (Ptr Dir2d)++reversed :: Ptr Dir2d -> Acquire (Ptr Dir2d)+reversed axis = mkAcquire (rawReversed axis) deleteDir2d++-- mirror/mirrored++foreign import capi unsafe "hs_gp_Dir2d.h hs_gp_Dir2d_Mirror" mirror :: Ptr Dir2d -> Ptr Dir2d -> IO ()++foreign import capi unsafe "hs_gp_Dir2d.h hs_gp_Dir2d_Mirrored" rawMirrored :: Ptr Dir2d -> Ptr Dir2d -> IO (Ptr Dir2d)++mirrored :: Ptr Dir2d -> Ptr Dir2d -> Acquire (Ptr Dir2d)+mirrored point axis = mkAcquire (rawMirrored point axis) deleteDir2d++foreign import capi unsafe "hs_gp_Dir2d.h hs_gp_Dir2d_MirrorAboutAx2d" mirrorAboutAx2d :: Ptr Dir2d -> Ptr Ax2d -> IO ()++foreign import capi unsafe "hs_gp_Dir2d.h hs_gp_Dir2d_MirroredAboutAx2d" rawMirroredAboutAx2d :: Ptr Dir2d -> Ptr Ax2d -> IO (Ptr Dir2d)++mirroredAboutAx2d :: Ptr Dir2d -> Ptr Ax2d -> Acquire (Ptr Dir2d)+mirroredAboutAx2d point axis = mkAcquire (rawMirroredAboutAx2d point axis) deleteDir2d++-- rotate/rotated++foreign import capi unsafe "hs_gp_Dir2d.h hs_gp_Dir2d_Rotate" rotate :: Ptr Dir2d -> CDouble-> IO ()++foreign import capi unsafe "hs_gp_Dir2d.h hs_gp_Dir2d_Rotated" rawRotated :: Ptr Dir2d -> CDouble -> IO (Ptr Dir2d)++rotated :: Ptr Dir2d -> Double -> Acquire (Ptr Dir2d)+rotated point amount = mkAcquire (rawRotated point (CDouble amount)) deleteDir2d++-- transform/transformed++foreign import capi unsafe "hs_gp_Dir2d.h hs_gp_Dir2d_Transform" transform :: Ptr Dir2d -> Ptr Trsf2d -> IO ()++foreign import capi unsafe "hs_gp_Dir2d.h hs_gp_Dir2d_Transformed" rawTransformed :: Ptr Dir2d -> Ptr Trsf2d -> IO (Ptr Dir2d)++transformed :: Ptr Dir2d -> Ptr Trsf2d -> Acquire (Ptr Dir2d)+transformed point trsf = mkAcquire (rawTransformed point trsf) deleteDir2d
+ src/OpenCascade/GP/GTrsf.hs view
@@ -0,0 +1,26 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.GP.GTrsf+( GTrsf+, new+, setValue+, setForm+) where++import OpenCascade.GP.Types+import OpenCascade.GP.Internal.Destructors+import Foreign.C+import Foreign.Ptr+import Data.Coerce (coerce)+import Data.Acquire ++foreign import capi unsafe "hs_gp_GTrsf.h hs_new_gp_GTrsf" rawNew ::IO (Ptr GTrsf)++new :: Acquire (Ptr GTrsf)+new = mkAcquire rawNew deleteGTrsf++foreign import capi unsafe "hs_gp_GTrsf.h hs_gp_GTrsf_setValue" rawSetValue :: Ptr GTrsf -> CInt -> CInt -> CDouble -> IO () ++setValue :: Ptr GTrsf -> Int -> Int -> Double -> IO ()+setValue trsf row column value = rawSetValue trsf (fromIntegral row) (fromIntegral column) (coerce value)++foreign import capi unsafe "hs_gp_GTrsf.h hs_gp_GTrsf_setForm" setForm :: Ptr GTrsf -> IO ()
+ src/OpenCascade/GP/Internal/Destructors.hs view
@@ -0,0 +1,20 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.GP.Internal.Destructors where++import OpenCascade.GP.Types++import Foreign.Ptr++foreign import capi unsafe "hs_gp_Pnt.h hs_delete_gp_Pnt" deletePnt :: Ptr Pnt -> IO ()+foreign import capi unsafe "hs_gp_Pnt2d.h hs_delete_gp_Pnt2d" deletePnt2d :: Ptr Pnt2d -> IO ()+foreign import capi unsafe "hs_gp_Ax1.h hs_delete_gp_Ax1" deleteAx1 :: Ptr Ax1 -> IO ()+foreign import capi unsafe "hs_gp_Ax2.h hs_delete_gp_Ax2" deleteAx2 :: Ptr Ax2 -> IO ()+foreign import capi unsafe "hs_gp_Ax2.h hs_delete_gp_Ax2" deleteAx2d :: Ptr Ax2d -> IO ()+foreign import capi unsafe "hs_gp_Dir.h hs_delete_gp_Dir" deleteDir :: Ptr Dir -> IO ()+foreign import capi unsafe "hs_gp_Dir2d.h hs_delete_gp_Dir2d" deleteDir2d :: Ptr Dir2d -> IO ()+foreign import capi unsafe "hs_gp_Vec.h hs_delete_gp_Vec" deleteVec :: Ptr Vec -> IO ()+foreign import capi unsafe "hs_gp_Vec2d.h hs_delete_gp_Vec2d" deleteVec2d :: Ptr Vec2d -> IO ()+foreign import capi unsafe "hs_gp_Trsf.h hs_delete_gp_Trsf" deleteTrsf :: Ptr Trsf -> IO ()+foreign import capi unsafe "hs_gp_GTrsf.h hs_delete_gp_GTrsf" deleteGTrsf :: Ptr GTrsf -> IO ()+foreign import capi unsafe "hs_gp_Trsf2d.h hs_delete_gp_Trsf2d" deleteTrsf2d :: Ptr Trsf2d -> IO ()+
+ src/OpenCascade/GP/Pnt.hs view
@@ -0,0 +1,178 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.GP.Pnt +( Pnt+, new+, getX+, getY+, getZ +, setX+, setY +, setZ+, distance+, squareDistance+, baryCenter+, isEqual+, mirror+, mirrored+, mirrorAboutAx1+, mirroredAboutAx1+, mirrorAboutAx2+, mirroredAboutAx2+, rotate+, rotated+, scale+, scaled+, transform+, transformed+, translate+, translated+, translateRelative+, translatedRelative+) where++import OpenCascade.GP.Types+import OpenCascade.GP.Internal.Destructors+import Foreign.C+import Foreign.Ptr+import Data.Coerce (coerce)+import Data.Acquire ++-- new++foreign import capi unsafe "hs_gp_Pnt.h hs_new_gp_Pnt" rawNew :: CDouble -> CDouble -> CDouble -> IO (Ptr Pnt)++new :: Double -> Double -> Double -> Acquire (Ptr Pnt)+new x y z = mkAcquire (rawNew (CDouble x) (CDouble y) (CDouble z)) deletePnt++-- getters++foreign import capi unsafe "hs_gp_Pnt.h hs_gp_Pnt_X" rawX :: Ptr Pnt -> IO (CDouble)++getX :: Ptr Pnt -> IO Double+getX = coerce rawX++foreign import capi unsafe "hs_gp_Pnt.h hs_gp_Pnt_Y" rawY :: Ptr Pnt -> IO (CDouble)++getY :: Ptr Pnt -> IO Double+getY = coerce rawY++foreign import capi unsafe "hs_gp_Pnt.h hs_gp_Pnt_Z" rawZ :: Ptr Pnt -> IO (CDouble)++getZ :: Ptr Pnt -> IO Double+getZ = coerce rawZ++-- setters++foreign import capi unsafe "hs_gp_Pnt.h hs_gp_Pnt_SetX" rawSetX :: Ptr Pnt -> CDouble -> IO ()++setX :: Ptr Pnt -> Double -> IO ()+setX = coerce rawSetX+++foreign import capi unsafe "hs_gp_Pnt.h hs_gp_Pnt_SetY" rawSetY :: Ptr Pnt -> CDouble -> IO ()++setY :: Ptr Pnt -> Double -> IO ()+setY = coerce rawSetY+++foreign import capi unsafe "hs_gp_Pnt.h hs_gp_Pnt_SetZ" rawSetZ :: Ptr Pnt -> CDouble -> IO ()++setZ :: Ptr Pnt -> Double -> IO ()+setZ = coerce rawSetZ+++foreign import capi unsafe "hs_gp_Pnt.h hs_gp_Pnt_Distance" rawDistance :: Ptr Pnt -> Ptr Pnt -> IO CDouble+++-- distance and quadrance++distance :: Ptr Pnt -> Ptr Pnt -> IO Double+distance = coerce rawDistance+++foreign import capi unsafe "hs_gp_Pnt.h hs_gp_Pnt_SquareDistance" rawSquareDistance :: Ptr Pnt -> Ptr Pnt -> IO CDouble++squareDistance :: Ptr Pnt -> Ptr Pnt -> IO Double+squareDistance = coerce rawSquareDistance++-- baryCenter++foreign import capi unsafe "hs_gp_Pnt.h hs_gp_Pnt_BaryCenter" rawBaryCenter :: Ptr Pnt -> CDouble -> Ptr Pnt -> CDouble -> IO ()++baryCenter :: Ptr Pnt -> Double -> Ptr Pnt -> Double -> IO ()+baryCenter = coerce rawBaryCenter++-- isEqual++foreign import capi unsafe "hs_gp_Pnt.h hs_gp_Pnt_IsEqual" rawIsEqual :: Ptr Pnt -> Ptr Pnt -> CDouble -> IO CBool++isEqual :: Ptr Pnt -> Ptr Pnt -> Double -> IO Bool+isEqual a b tolerance = (/= 0) <$> rawIsEqual a b (CDouble tolerance)++-- mirror/mirrored++foreign import capi unsafe "hs_gp_Pnt.h hs_gp_Pnt_Mirror" mirror :: Ptr Pnt -> Ptr Pnt -> IO ()++foreign import capi unsafe "hs_gp_Pnt.h hs_gp_Pnt_Mirrored" rawMirrored :: Ptr Pnt -> Ptr Pnt -> IO (Ptr Pnt)++mirrored :: Ptr Pnt -> Ptr Pnt -> Acquire (Ptr Pnt)+mirrored point axis = mkAcquire (rawMirrored point axis) deletePnt++foreign import capi unsafe "hs_gp_Pnt.h hs_gp_Pnt_MirrorAboutAx1" mirrorAboutAx1 :: Ptr Pnt -> Ptr Ax1 -> IO ()++foreign import capi unsafe "hs_gp_Pnt.h hs_gp_Pnt_MirroredAboutAx1" rawMirroredAboutAx1 :: Ptr Pnt -> Ptr Ax1 -> IO (Ptr Pnt)++mirroredAboutAx1 :: Ptr Pnt -> Ptr Ax1 -> Acquire (Ptr Pnt)+mirroredAboutAx1 point axis = mkAcquire (rawMirroredAboutAx1 point axis) deletePnt++foreign import capi unsafe "hs_gp_Pnt.h hs_gp_Pnt_MirrorAboutAx2" mirrorAboutAx2 :: Ptr Pnt -> Ptr Ax2 -> IO ()++foreign import capi unsafe "hs_gp_Pnt.h hs_gp_Pnt_MirroredAboutAx2" rawMirroredAboutAx2 :: Ptr Pnt -> Ptr Ax2 -> IO (Ptr Pnt)++mirroredAboutAx2 :: Ptr Pnt -> Ptr Ax2 -> Acquire (Ptr Pnt)+mirroredAboutAx2 point axis = mkAcquire (rawMirroredAboutAx2 point axis) deletePnt++-- rotate/rotated++foreign import capi unsafe "hs_gp_Pnt.h hs_gp_Pnt_Rotate" rotate :: Ptr Pnt -> Ptr Ax1 -> CDouble-> IO ()++foreign import capi unsafe "hs_gp_Pnt.h hs_gp_Pnt_Rotated" rawRotated :: Ptr Pnt -> Ptr Ax1 -> CDouble -> IO (Ptr Pnt)++rotated :: Ptr Pnt -> Ptr Ax1 -> Double -> Acquire (Ptr Pnt)+rotated point axis amount = mkAcquire (rawRotated point axis (CDouble amount)) deletePnt++-- scale/scaled++foreign import capi unsafe "hs_gp_Pnt.h hs_gp_Pnt_Scale" scale :: Ptr Pnt -> Ptr Pnt -> CDouble-> IO ()++foreign import capi unsafe "hs_gp_Pnt.h hs_gp_Pnt_Scaled" rawScaled :: Ptr Pnt -> Ptr Pnt -> CDouble -> IO (Ptr Pnt)++scaled :: Ptr Pnt -> Ptr Pnt -> Double -> Acquire (Ptr Pnt)+scaled point origin amount = mkAcquire (rawScaled point origin (CDouble amount)) deletePnt++-- transform/transformed++foreign import capi unsafe "hs_gp_Pnt.h hs_gp_Pnt_Transform" transform :: Ptr Pnt -> Ptr Trsf -> IO ()++foreign import capi unsafe "hs_gp_Pnt.h hs_gp_Pnt_Transformed" rawTransformed :: Ptr Pnt -> Ptr Trsf -> IO (Ptr Pnt)++transformed :: Ptr Pnt -> Ptr Trsf -> Acquire (Ptr Pnt)+transformed point trsf = mkAcquire (rawTransformed point trsf) deletePnt++-- translate/translated++foreign import capi unsafe "hs_gp_Pnt.h hs_gp_Pnt_Translate" translate :: Ptr Pnt -> Ptr Vec -> IO ()++foreign import capi unsafe "hs_gp_Pnt.h hs_gp_Pnt_Translated" rawTranslated :: Ptr Pnt -> Ptr Vec -> IO (Ptr Pnt)++translated :: Ptr Pnt -> Ptr Vec -> Acquire (Ptr Pnt)+translated point vec = mkAcquire (rawTranslated point vec) deletePnt++-- translateRelative/translatedRelative++foreign import capi unsafe "hs_gp_Pnt.h hs_gp_Pnt_TranslateRelative" translateRelative :: Ptr Pnt -> Ptr Pnt -> Ptr Pnt -> IO ()++foreign import capi unsafe "hs_gp_Pnt.h hs_gp_Pnt_TranslatedRelative" rawTranslatedRelative :: Ptr Pnt -> Ptr Pnt -> Ptr Pnt -> IO (Ptr Pnt)++translatedRelative :: Ptr Pnt -> Ptr Pnt -> Ptr Pnt -> Acquire (Ptr Pnt)+translatedRelative point from to = mkAcquire (rawTranslatedRelative point from to) deletePnt
+ src/OpenCascade/GP/Pnt2d.hs view
@@ -0,0 +1,147 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.GP.Pnt2d +( Pnt2d+, new+, getX+, getY+, setX+, setY +, distance+, squareDistance+, isEqual+, mirror+, mirrored+, mirrorAboutAx2d+, mirroredAboutAx2d+, rotate+, rotated+, scale+, scaled+, transform+, transformed+, translate+, translated+, translateRelative+, translatedRelative+) where++import OpenCascade.GP.Types+import OpenCascade.GP.Internal.Destructors+import Foreign.C+import Foreign.Ptr+import Data.Coerce (coerce)+import Data.Acquire ++-- new++foreign import capi unsafe "hs_gp_Pnt2d.h hs_new_gp_Pnt2d" rawNew :: CDouble -> CDouble -> IO (Ptr Pnt2d)++new :: Double -> Double -> Acquire (Ptr Pnt2d)+new x y = mkAcquire (rawNew (CDouble x) (CDouble y)) deletePnt2d++-- getters++foreign import capi unsafe "hs_gp_Pnt2d.h hs_gp_Pnt2d_X" rawX :: Ptr Pnt2d -> IO (CDouble)++getX :: Ptr Pnt2d -> IO Double+getX = coerce rawX++foreign import capi unsafe "hs_gp_Pnt2d.h hs_gp_Pnt2d_Y" rawY :: Ptr Pnt2d -> IO (CDouble)++getY :: Ptr Pnt2d -> IO Double+getY = coerce rawY++-- setters++foreign import capi unsafe "hs_gp_Pnt2d.h hs_gp_Pnt2d_SetX" rawSetX :: Ptr Pnt2d -> CDouble -> IO ()++setX :: Ptr Pnt2d -> Double -> IO ()+setX = coerce rawSetX+++foreign import capi unsafe "hs_gp_Pnt2d.h hs_gp_Pnt2d_SetY" rawSetY :: Ptr Pnt2d -> CDouble -> IO ()++setY :: Ptr Pnt2d -> Double -> IO ()+setY = coerce rawSetY++foreign import capi unsafe "hs_gp_Pnt2d.h hs_gp_Pnt2d_Distance" rawDistance :: Ptr Pnt2d -> Ptr Pnt2d -> IO CDouble++-- distance and quadrance++distance :: Ptr Pnt2d -> Ptr Pnt2d -> IO Double+distance = coerce rawDistance+++foreign import capi unsafe "hs_gp_Pnt2d.h hs_gp_Pnt2d_SquareDistance" rawSquareDistance :: Ptr Pnt2d -> Ptr Pnt2d -> IO CDouble++squareDistance :: Ptr Pnt2d -> Ptr Pnt2d -> IO Double+squareDistance = coerce rawSquareDistance++-- isEqual++foreign import capi unsafe "hs_gp_Pnt2d.h hs_gp_Pnt2d_IsEqual" rawIsEqual :: Ptr Pnt2d -> Ptr Pnt2d -> CDouble -> IO CBool++isEqual :: Ptr Pnt2d -> Ptr Pnt2d -> Double -> IO Bool+isEqual a b tolerance = (/= 0) <$> rawIsEqual a b (CDouble tolerance)++-- mirror/mirrored++foreign import capi unsafe "hs_gp_Pnt2d.h hs_gp_Pnt2d_Mirror" mirror :: Ptr Pnt2d -> Ptr Pnt2d -> IO ()++foreign import capi unsafe "hs_gp_Pnt2d.h hs_gp_Pnt2d_Mirrored" rawMirrored :: Ptr Pnt2d -> Ptr Pnt2d -> IO (Ptr Pnt2d)++mirrored :: Ptr Pnt2d -> Ptr Pnt2d -> Acquire (Ptr Pnt2d)+mirrored point axis = mkAcquire (rawMirrored point axis) deletePnt2d++foreign import capi unsafe "hs_gp_Pnt2d.h hs_gp_Pnt2d_MirrorAboutAx2d" mirrorAboutAx2d :: Ptr Pnt2d -> Ptr Ax2d -> IO ()++foreign import capi unsafe "hs_gp_Pnt2d.h hs_gp_Pnt2d_MirroredAboutAx2d" rawMirroredAboutAx2d :: Ptr Pnt2d -> Ptr Ax2d -> IO (Ptr Pnt2d)++mirroredAboutAx2d :: Ptr Pnt2d -> Ptr Ax2d -> Acquire (Ptr Pnt2d)+mirroredAboutAx2d point axis = mkAcquire (rawMirroredAboutAx2d point axis) deletePnt2d++-- rotate/rotated++foreign import capi unsafe "hs_gp_Pnt2d.h hs_gp_Pnt2d_Rotate" rotate :: Ptr Pnt2d -> Ptr Pnt2d -> CDouble-> IO ()++foreign import capi unsafe "hs_gp_Pnt2d.h hs_gp_Pnt2d_Rotated" rawRotated :: Ptr Pnt2d -> Ptr Pnt2d -> CDouble -> IO (Ptr Pnt2d)++rotated :: Ptr Pnt2d -> Ptr Pnt2d -> Double -> Acquire (Ptr Pnt2d)+rotated point axis amount = mkAcquire (rawRotated point axis (CDouble amount)) deletePnt2d++-- scale/scaled++foreign import capi unsafe "hs_gp_Pnt2d.h hs_gp_Pnt2d_Scale" scale :: Ptr Pnt2d -> Ptr Pnt2d -> CDouble-> IO ()++foreign import capi unsafe "hs_gp_Pnt2d.h hs_gp_Pnt2d_Scaled" rawScaled :: Ptr Pnt2d -> Ptr Pnt2d -> CDouble -> IO (Ptr Pnt2d)++scaled :: Ptr Pnt2d -> Ptr Pnt2d -> Double -> Acquire (Ptr Pnt2d)+scaled point origin amount = mkAcquire (rawScaled point origin (CDouble amount)) deletePnt2d++-- transform/transformed++foreign import capi unsafe "hs_gp_Pnt2d.h hs_gp_Pnt2d_Transform" transform :: Ptr Pnt2d -> Ptr Trsf2d -> IO ()++foreign import capi unsafe "hs_gp_Pnt2d.h hs_gp_Pnt2d_Transformed" rawTransformed :: Ptr Pnt2d -> Ptr Trsf2d -> IO (Ptr Pnt2d)++transformed :: Ptr Pnt2d -> Ptr Trsf2d -> Acquire (Ptr Pnt2d)+transformed point trsf = mkAcquire (rawTransformed point trsf) deletePnt2d++-- translate/translated++foreign import capi unsafe "hs_gp_Pnt2d.h hs_gp_Pnt2d_Translate" translate :: Ptr Pnt2d -> Ptr Vec2d -> IO ()++foreign import capi unsafe "hs_gp_Pnt2d.h hs_gp_Pnt2d_Translated" rawTranslated :: Ptr Pnt2d -> Ptr Vec2d -> IO (Ptr Pnt2d)++translated :: Ptr Pnt2d -> Ptr Vec2d -> Acquire (Ptr Pnt2d)+translated point vec = mkAcquire (rawTranslated point vec) deletePnt2d++-- translateRelative/translatedRelative++foreign import capi unsafe "hs_gp_Pnt2d.h hs_gp_Pnt2d_TranslateRelative" translateRelative :: Ptr Pnt2d -> Ptr Pnt2d -> Ptr Pnt2d -> IO ()++foreign import capi unsafe "hs_gp_Pnt2d.h hs_gp_Pnt2d_TranslatedRelative" rawTranslatedRelative :: Ptr Pnt2d -> Ptr Pnt2d -> Ptr Pnt2d -> IO (Ptr Pnt2d)++translatedRelative :: Ptr Pnt2d -> Ptr Pnt2d -> Ptr Pnt2d -> Acquire (Ptr Pnt2d)+translatedRelative point from to = mkAcquire (rawTranslatedRelative point from to) deletePnt2d+
+ src/OpenCascade/GP/Trsf.hs view
@@ -0,0 +1,138 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.GP.Trsf+( Trsf+, new+, fromTrsf2d+, setMirrorAboutPnt+, setMirrorAboutAx1+, setMirrorAboutAx2+, setRotationAboutAxisAngle+, setScale+, setTranslation+, setScaleFactor+, setTranslationPart+, setValues+, isNegative+, scaleFactor+, value+, invert+, inverted+, multiply+, multiplied+, preMultiply+, power+, powered+) where++import OpenCascade.GP.Types+import OpenCascade.GP.Internal.Destructors+import Foreign.C+import Foreign.Ptr+import Data.Coerce (coerce)+import Data.Acquire +++-- new++foreign import capi unsafe "hs_gp_Trsf.h hs_new_gp_Trsf" rawNew ::IO (Ptr Trsf)++new :: Acquire (Ptr Trsf)+new = mkAcquire rawNew deleteTrsf++foreign import capi unsafe "hs_gp_Trsf.h hs_new_gp_Trsf_fromTrsf2d" rawFromTrsf2d :: Ptr Trsf2d -> IO (Ptr Trsf)++fromTrsf2d :: Ptr Trsf2d -> Acquire (Ptr Trsf)+fromTrsf2d t = mkAcquire (rawFromTrsf2d t) deleteTrsf++-- mirror ++foreign import capi unsafe "hs_gp_Trsf.h hs_gp_Trsf_SetMirrorAboutPnt" setMirrorAboutPnt :: Ptr Trsf -> Ptr Pnt -> IO ()++foreign import capi unsafe "hs_gp_Trsf.h hs_gp_Trsf_SetMirrorAboutAx1" setMirrorAboutAx1 :: Ptr Trsf -> Ptr Ax1 -> IO ()++foreign import capi unsafe "hs_gp_Trsf.h hs_gp_Trsf_SetMirrorAboutAx2" setMirrorAboutAx2 :: Ptr Trsf -> Ptr Ax2 -> IO ()++-- rotate++foreign import capi unsafe "hs_gp_Trsf.h hs_gp_Trsf_SetRotationAboutAxisAngle" rawSetRotationAboutAxisAngle :: Ptr Trsf -> Ptr Ax1 -> CDouble -> IO ()++setRotationAboutAxisAngle :: Ptr Trsf -> Ptr Ax1 -> Double -> IO ()+setRotationAboutAxisAngle = coerce rawSetRotationAboutAxisAngle++-- scale++foreign import capi unsafe "hs_gp_Trsf.h hs_gp_Trsf_SetScale" rawSetScale :: Ptr Trsf -> Ptr Pnt -> CDouble -> IO ()++setScale :: Ptr Trsf -> Ptr Pnt -> Double -> IO ()+setScale = coerce rawSetScale++-- translation++foreign import capi unsafe "hs_gp_Trsf.h hs_gp_Trsf_SetTranslation" setTranslation :: Ptr Trsf -> Ptr Vec -> IO ()++foreign import capi unsafe "hs_gp_Trsf.h hs_gp_Trsf_SetTranslationPart" setTranslationPart :: Ptr Trsf -> Ptr Vec -> IO ()++-- scaleFactor++foreign import capi unsafe "hs_gp_Trsf.h hs_gp_Trsf_SetScaleFactor" rawSetScaleFactor :: Ptr Trsf -> CDouble -> IO ()++setScaleFactor :: Ptr Trsf -> Double -> IO ()+setScaleFactor = coerce rawSetScaleFactor++-- setValues++foreign import capi unsafe "hs_gp_Trsf.h hs_gp_Trsf_SetValues" rawSetValues :: Ptr Trsf -> CDouble -> CDouble-> CDouble-> CDouble-> CDouble-> CDouble-> CDouble-> CDouble-> CDouble-> CDouble-> CDouble-> CDouble -> IO ()++setValues :: Ptr Trsf -> Double -> Double-> Double-> Double-> Double-> Double-> Double-> Double-> Double-> Double-> Double-> Double -> IO ()+setValues = coerce rawSetValues++-- tests ++foreign import capi unsafe "hs_gp_Trsf.h hs_gp_Trsf_IsNegative" rawIsNegative :: Ptr Trsf -> IO CBool++isNegative :: Ptr Trsf -> IO Bool+isNegative = fmap (/= 0) . rawIsNegative++foreign import capi unsafe "hs_gp_Trsf.h hs_gp_Trsf_ScaleFactor" rawScaleFactor :: Ptr Trsf -> IO CDouble++scaleFactor :: Ptr Trsf -> IO Double+scaleFactor = coerce rawScaleFactor++foreign import capi unsafe "hs_gp_Trsf.h hs_gp_Trsf_Value" rawValue :: Ptr Trsf -> CInt -> CInt -> IO CDouble++value :: Ptr Trsf -> Int -> Int -> IO Double+value t row col = coerce $ rawValue t (fromIntegral row) (fromIntegral col)++-- invert/inverted++foreign import capi unsafe "hs_gp_Trsf.h hs_gp_Trsf_Invert" invert :: Ptr Trsf-> IO ()++foreign import capi unsafe "hs_gp_Trsf.h hs_gp_Trsf_Inverted" rawInverted :: Ptr Trsf-> IO (Ptr Trsf)++inverted :: Ptr Trsf -> Acquire (Ptr Trsf)+inverted t = mkAcquire (rawInverted t) deleteTrsf++-- multiply/multiplied++foreign import capi unsafe "hs_gp_Trsf.h hs_gp_Trsf_Multiply" multiply :: Ptr Trsf -> Ptr Trsf -> IO ()++foreign import capi unsafe "hs_gp_Trsf.h hs_gp_Trsf_Multiplied" rawMultiplied :: Ptr Trsf -> Ptr Trsf -> IO (Ptr Trsf)++multiplied :: Ptr Trsf -> Ptr Trsf -> Acquire (Ptr Trsf)+multiplied a b = mkAcquire (rawMultiplied a b) deleteTrsf++-- PreMultiply++foreign import capi unsafe "hs_gp_Trsf.h hs_gp_Trsf_PreMultiply" preMultiply :: Ptr Trsf -> Ptr Trsf -> IO ()++-- power/powered++foreign import capi unsafe "hs_gp_Trsf.h hs_gp_Trsf_Power" rawPower :: Ptr Trsf -> CInt -> IO ()++power :: Ptr Trsf -> Int -> IO ()+power trsf times = rawPower trsf (fromIntegral times)++foreign import capi unsafe "hs_gp_Trsf.h hs_gp_Trsf_Powered" rawPowered :: Ptr Trsf -> CInt -> IO (Ptr Trsf)++powered :: Ptr Trsf -> Int -> Acquire (Ptr Trsf)+powered trsf times = mkAcquire (rawPowered trsf (fromIntegral times)) deleteTrsf
+ src/OpenCascade/GP/Trsf2d.hs view
@@ -0,0 +1,146 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.GP.Trsf2d+( Trsf2d+, new+, fromTrsf+, setMirrorAboutPnt2d+, setMirrorAboutAx2d+, setRotation+, setScale+, setTransformation+, setTransformationRelative+, setTranslation+, setScaleFactor+, setTranslationPart+, setTranslationRelative+, setValues+, isNegative+, scaleFactor+, value+, invert+, inverted+, multiply+, multiplied+, preMultiply+, power+, powered+) where++import OpenCascade.GP.Types+import OpenCascade.GP.Internal.Destructors+import Foreign.C+import Foreign.Ptr+import Data.Coerce (coerce)+import Data.Acquire +++-- new++foreign import capi unsafe "hs_gp_Trsf2d.h hs_new_gp_Trsf2d" rawNew ::IO (Ptr Trsf2d)++new :: Acquire (Ptr Trsf2d)+new = mkAcquire rawNew deleteTrsf2d++foreign import capi unsafe "hs_gp_Trsf2d.h hs_new_gp_Trsf2d_fromTrsf" rawFromTrsf :: Ptr Trsf -> IO (Ptr Trsf2d)++fromTrsf :: Ptr Trsf -> Acquire (Ptr Trsf2d)+fromTrsf t = mkAcquire (rawFromTrsf t) deleteTrsf2d++-- mirror ++foreign import capi unsafe "hs_gp_Trsf2d.h hs_gp_Trsf2d_SetMirrorAboutPnt2d" setMirrorAboutPnt2d :: Ptr Trsf2d -> Ptr Pnt2d -> IO ()++foreign import capi unsafe "hs_gp_Trsf2d.h hs_gp_Trsf2d_SetMirrorAboutAx2d" setMirrorAboutAx2d :: Ptr Trsf2d -> Ptr Ax2d -> IO ()++-- rotate++foreign import capi unsafe "hs_gp_Trsf2d.h hs_gp_Trsf2d_SetRotation" rawSetRotation :: Ptr Trsf2d -> Ptr Pnt2d -> CDouble -> IO ()++setRotation :: Ptr Trsf2d -> Ptr Pnt2d -> Double -> IO ()+setRotation = coerce rawSetRotation++-- scale++foreign import capi unsafe "hs_gp_Trsf2d.h hs_gp_Trsf2d_SetScale" rawSetScale :: Ptr Trsf2d -> Ptr Pnt2d -> CDouble -> IO ()++setScale :: Ptr Trsf2d -> Ptr Pnt2d -> Double -> IO ()+setScale = coerce rawSetScale++-- transformation++foreign import capi unsafe "hs_gp_Trsf2d.h hs_gp_Trsf2d_SetTransformation" setTransformation :: Ptr Trsf2d -> Ptr Ax2d -> IO ()++foreign import capi unsafe "hs_gp_Trsf2d.h hs_gp_Trsf2d_SetTransformationRelative" setTransformationRelative :: Ptr Trsf2d -> Ptr Ax2d -> Ptr Ax2d -> IO ()++-- translation++foreign import capi unsafe "hs_gp_Trsf2d.h hs_gp_Trsf2d_SetTranslation" setTranslation :: Ptr Trsf2d -> Ptr Vec2d -> IO ()++foreign import capi unsafe "hs_gp_Trsf2d.h hs_gp_Trsf2d_SetTranslationPart" setTranslationPart :: Ptr Trsf2d -> Ptr Vec2d -> IO ()++foreign import capi unsafe "hs_gp_Trsf2d.h hs_gp_Trsf2d_SetTranslationRelative" setTranslationRelative :: Ptr Trsf2d -> Ptr Pnt2d -> Ptr Pnt2d -> IO ()++-- scaleFactor++foreign import capi unsafe "hs_gp_Trsf2d.h hs_gp_Trsf2d_SetScaleFactor" rawSetScaleFactor :: Ptr Trsf2d -> CDouble -> IO ()++setScaleFactor :: Ptr Trsf2d -> Double -> IO ()+setScaleFactor = coerce rawSetScaleFactor++-- setValues++foreign import capi unsafe "hs_gp_Trsf2d.h hs_gp_Trsf2d_SetValues" rawSetValues :: Ptr Trsf2d -> CDouble -> CDouble-> CDouble-> CDouble-> CDouble-> CDouble-> IO ()++setValues :: Ptr Trsf2d -> Double -> Double -> Double -> Double-> Double -> Double -> IO ()+setValues = coerce rawSetValues++-- tests ++foreign import capi unsafe "hs_gp_Trsf2d.h hs_gp_Trsf2d_IsNegative" rawIsNegative :: Ptr Trsf2d -> IO CBool++isNegative :: Ptr Trsf2d -> IO Bool+isNegative = fmap (/= 0) . rawIsNegative++foreign import capi unsafe "hs_gp_Trsf2d.h hs_gp_Trsf2d_ScaleFactor" rawScaleFactor :: Ptr Trsf2d -> IO CDouble++scaleFactor :: Ptr Trsf2d -> IO Double+scaleFactor = coerce rawScaleFactor++foreign import capi unsafe "hs_gp_Trsf2d.h hs_gp_Trsf2d_Value" rawValue :: Ptr Trsf2d -> CInt -> CInt -> IO CDouble++value :: Ptr Trsf2d -> Int -> Int -> IO Double+value t row col = coerce $ rawValue t (fromIntegral row) (fromIntegral col)++-- invert/inverted++foreign import capi unsafe "hs_gp_Trsf2d.h hs_gp_Trsf2d_Invert" invert :: Ptr Trsf2d-> IO ()++foreign import capi unsafe "hs_gp_Trsf2d.h hs_gp_Trsf2d_Inverted" rawInverted :: Ptr Trsf2d-> IO (Ptr Trsf2d)++inverted :: Ptr Trsf2d -> Acquire (Ptr Trsf2d)+inverted t = mkAcquire (rawInverted t) deleteTrsf2d++-- multiply/multiplied++foreign import capi unsafe "hs_gp_Trsf2d.h hs_gp_Trsf2d_Multiply" multiply :: Ptr Trsf2d -> Ptr Trsf2d -> IO ()++foreign import capi unsafe "hs_gp_Trsf2d.h hs_gp_Trsf2d_Multiplied" rawMultiplied :: Ptr Trsf2d -> Ptr Trsf2d -> IO (Ptr Trsf2d)++multiplied :: Ptr Trsf2d -> Ptr Trsf2d -> Acquire (Ptr Trsf2d)+multiplied a b = mkAcquire (rawMultiplied a b) deleteTrsf2d++-- PreMultiply++foreign import capi unsafe "hs_gp_Trsf2d.h hs_gp_Trsf2d_PreMultiply" preMultiply :: Ptr Trsf2d -> Ptr Trsf2d -> IO ()++-- power/powered++foreign import capi unsafe "hs_gp_Trsf2d.h hs_gp_Trsf2d_Power" rawPower :: Ptr Trsf2d -> CInt -> IO ()++power :: Ptr Trsf2d -> Int -> IO ()+power trsf times = rawPower trsf (fromIntegral times)++foreign import capi unsafe "hs_gp_Trsf2d.h hs_gp_Trsf2d_Powered" rawPowered :: Ptr Trsf2d -> CInt -> IO (Ptr Trsf2d)++powered :: Ptr Trsf2d -> Int -> Acquire (Ptr Trsf2d)+powered trsf times = mkAcquire (rawPowered trsf (fromIntegral times)) deleteTrsf2d
+ src/OpenCascade/GP/Types.hs view
@@ -0,0 +1,16 @@+{-# LANGUAGE EmptyDataDecls #-}+module OpenCascade.GP.Types where++data Pnt+data Pnt2d+data Ax1+data Ax2+data Ax2d+data Dir+data Dir2d+data Vec+data Vec2d+data Trsf+data Trsf2d+data GTrsf+
+ src/OpenCascade/GP/Vec.hs view
@@ -0,0 +1,316 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.GP.Vec+( Vec+, new+, getX+, getY+, getZ +, setX+, setY +, setZ+, isEqual+, isOpposite+, isNormal+, isParallel+, angle+, angleWithRef+, magnitude+, squareMagnitude+, add+, added+, subtract+, subtracted+, multiply+, multiplied+, divide+, divided+, cross+, crossed+, crossCross+, crossCrossed+, crossMagnitude+, crossSquareMagnitude+, dot+, dotCross+, reverse+, reversed+, mirror+, mirrored+, mirrorAboutAx1+, mirroredAboutAx1+, mirrorAboutAx2+, mirroredAboutAx2+, rotate+, rotated+, scale+, scaled+, transform+, transformed+) where+++import Prelude hiding (reverse, subtract)+import OpenCascade.GP.Types+import OpenCascade.GP.Internal.Destructors+import Foreign.C+import Foreign.Ptr+import Data.Coerce (coerce)+import Data.Acquire ++-- new++foreign import capi unsafe "hs_gp_Vec.h hs_new_gp_Vec" rawNew :: CDouble -> CDouble -> CDouble -> IO (Ptr Vec)++new :: Double -> Double -> Double -> Acquire (Ptr Vec)+new x y z = mkAcquire (rawNew (CDouble x) (CDouble y) (CDouble z)) deleteVec++-- getters++foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_X" rawX :: Ptr Vec -> IO (CDouble)++getX :: Ptr Vec -> IO Double+getX = coerce rawX++foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_Y" rawY :: Ptr Vec -> IO (CDouble)++getY :: Ptr Vec -> IO Double+getY = coerce rawY++foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_Z" rawZ :: Ptr Vec -> IO (CDouble)++getZ :: Ptr Vec -> IO Double+getZ = coerce rawZ++-- setters++foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_SetX" rawSetX :: Ptr Vec -> CDouble -> IO ()++setX :: Ptr Vec -> Double -> IO ()+setX = coerce rawSetX+++foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_SetY" rawSetY :: Ptr Vec -> CDouble -> IO ()++setY :: Ptr Vec -> Double -> IO ()+setY = coerce rawSetY+++foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_SetZ" rawSetZ :: Ptr Vec -> CDouble -> IO ()++setZ :: Ptr Vec -> Double -> IO ()+setZ = coerce rawSetZ++-- tests++-- isEqual++foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_IsEqual" rawIsEqual :: Ptr Vec -> Ptr Vec -> CDouble -> CDouble -> IO CBool++isEqual :: Ptr Vec -> Ptr Vec -> Double -> Double -> IO Bool+isEqual a b linearTolerance angularTolerance = (/= 0) <$> rawIsEqual a b (CDouble linearTolerance) (CDouble angularTolerance)++-- isNormal++foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_IsNormal" rawIsNormal :: Ptr Vec -> Ptr Vec -> CDouble -> IO CBool++isNormal :: Ptr Vec -> Ptr Vec -> Double -> IO Bool+isNormal a b tolerance = (/= 0) <$> rawIsNormal a b (CDouble tolerance)++-- isOpposite++foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_IsOpposite" rawIsOpposite :: Ptr Vec -> Ptr Vec -> CDouble -> IO CBool++isOpposite :: Ptr Vec -> Ptr Vec -> Double -> IO Bool+isOpposite a b tolerance = (/= 0) <$> rawIsOpposite a b (CDouble tolerance)++-- isParallel++foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_IsParallel" rawIsParallel :: Ptr Vec -> Ptr Vec -> CDouble -> IO CBool++isParallel :: Ptr Vec -> Ptr Vec -> Double -> IO Bool+isParallel a b tolerance = (/= 0) <$> rawIsParallel a b (CDouble tolerance)++-- angle++foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_Angle" rawAngle :: Ptr Vec -> Ptr Vec -> IO CDouble++angle :: Ptr Vec -> Ptr Vec -> IO Double+angle = coerce rawAngle++-- angleWithRef++foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_AngleWithRef" rawAngleWithRef :: Ptr Vec -> Ptr Vec -> Ptr Vec -> IO CDouble++angleWithRef :: Ptr Vec -> Ptr Vec -> Ptr Vec -> IO Double+angleWithRef = coerce rawAngleWithRef+++-- magnitude++foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_Magnitude" rawMagnitude :: Ptr Vec -> IO CDouble++magnitude :: Ptr Vec -> IO Double+magnitude = coerce rawMagnitude+++-- squareMagnitude++foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_SquareMagnitude" rawSquareMagnitude :: Ptr Vec -> IO CDouble++squareMagnitude :: Ptr Vec -> IO Double+squareMagnitude = coerce rawSquareMagnitude++-- add/added++foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_Add" add :: Ptr Vec -> Ptr Vec -> IO ()++foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_Added" rawAdded :: Ptr Vec -> Ptr Vec -> IO (Ptr Vec)++added :: Ptr Vec -> Ptr Vec -> Acquire (Ptr Vec)+added a b = mkAcquire (rawAdded a b) deleteVec+++-- subtract/subtracted++foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_Subtract" subtract :: Ptr Vec -> Ptr Vec -> IO ()++foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_Subtracted" rawSubtracted :: Ptr Vec -> Ptr Vec -> IO (Ptr Vec)++subtracted :: Ptr Vec -> Ptr Vec -> Acquire (Ptr Vec)+subtracted a b = mkAcquire (rawSubtracted a b) deleteVec+++-- multiply/multiplied++foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_Multiply" rawMultiply :: Ptr Vec -> CDouble -> IO ()++multiply :: Ptr Vec -> Double -> IO ()+multiply = coerce rawMultiply++foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_Multiplied" rawMultiplied :: Ptr Vec -> CDouble -> IO (Ptr Vec)++multiplied :: Ptr Vec -> Double -> Acquire (Ptr Vec)+multiplied a b = mkAcquire (rawMultiplied a (CDouble b)) deleteVec++-- divide/divided++foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_Divide" rawDivide :: Ptr Vec -> CDouble -> IO ()++divide :: Ptr Vec -> Double -> IO ()+divide = coerce rawDivide++foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_Divided" rawDivided :: Ptr Vec -> CDouble -> IO (Ptr Vec)++divided :: Ptr Vec -> Double -> Acquire (Ptr Vec)+divided a b = mkAcquire (rawDivided a (CDouble b)) deleteVec++-- cross/crossed++foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_Cross" cross :: Ptr Vec -> Ptr Vec -> IO ()++foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_Crossed" rawCrossed :: Ptr Vec -> Ptr Vec -> IO (Ptr Vec)++crossed :: Ptr Vec -> Ptr Vec -> Acquire (Ptr Vec)+crossed a b = mkAcquire (rawCrossed a b) deleteVec++-- crossCross/crossCrossed++foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_CrossCross" crossCross :: Ptr Vec -> Ptr Vec -> Ptr Vec -> IO ()++foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_CrossCrossed" rawCrossCrossed :: Ptr Vec -> Ptr Vec -> Ptr Vec -> IO (Ptr Vec)++crossCrossed :: Ptr Vec -> Ptr Vec -> Ptr Vec -> Acquire (Ptr Vec)+crossCrossed a b c = mkAcquire (rawCrossCrossed a b c) deleteVec++-- crossMagnitude++foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_CrossMagnitude" rawCrossMagnitude :: Ptr Vec -> Ptr Vec -> IO CDouble++crossMagnitude :: Ptr Vec -> Ptr Vec -> IO Double+crossMagnitude = coerce rawCrossMagnitude++-- crossSquareMagnitude++foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_CrossSquareMagnitude" rawCrossSquareMagnitude :: Ptr Vec -> Ptr Vec -> IO CDouble++crossSquareMagnitude :: Ptr Vec -> Ptr Vec -> IO Double+crossSquareMagnitude = coerce rawCrossSquareMagnitude++-- dot++foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_Dot" rawDot :: Ptr Vec -> Ptr Vec -> IO CDouble++dot :: Ptr Vec -> Ptr Vec -> IO Double+dot = coerce rawDot+++-- dotCross++foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_DotCross" rawDotCross :: Ptr Vec -> Ptr Vec -> Ptr Vec -> IO CDouble++dotCross :: Ptr Vec -> Ptr Vec -> Ptr Vec -> IO Double+dotCross = coerce rawDotCross+++-- reverse/reversed++foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_Reverse" reverse :: Ptr Vec -> IO ()++foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_Reversed" rawReversed :: Ptr Vec -> IO (Ptr Vec)++reversed :: Ptr Vec -> Acquire (Ptr Vec)+reversed axis = mkAcquire (rawReversed axis) deleteVec++-- mirror/mirrored++foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_Mirror" mirror :: Ptr Vec -> Ptr Vec -> IO ()++foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_Mirrored" rawMirrored :: Ptr Vec -> Ptr Vec -> IO (Ptr Vec)++mirrored :: Ptr Vec -> Ptr Vec -> Acquire (Ptr Vec)+mirrored point axis = mkAcquire (rawMirrored point axis) deleteVec++foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_MirrorAboutAx1" mirrorAboutAx1 :: Ptr Vec -> Ptr Ax1 -> IO ()++foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_MirroredAboutAx1" rawMirroredAboutAx1 :: Ptr Vec -> Ptr Ax1 -> IO (Ptr Vec)++mirroredAboutAx1 :: Ptr Vec -> Ptr Ax1 -> Acquire (Ptr Vec)+mirroredAboutAx1 point axis = mkAcquire (rawMirroredAboutAx1 point axis) deleteVec++foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_MirrorAboutAx2" mirrorAboutAx2 :: Ptr Vec -> Ptr Ax2 -> IO ()++foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_MirroredAboutAx2" rawMirroredAboutAx2 :: Ptr Vec -> Ptr Ax2 -> IO (Ptr Vec)++mirroredAboutAx2 :: Ptr Vec -> Ptr Ax2 -> Acquire (Ptr Vec)+mirroredAboutAx2 point axis = mkAcquire (rawMirroredAboutAx2 point axis) deleteVec++-- rotate/rotated++foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_Rotate" rotate :: Ptr Vec -> Ptr Ax1 -> CDouble-> IO ()++foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_Rotated" rawRotated :: Ptr Vec -> Ptr Ax1 -> CDouble -> IO (Ptr Vec)++rotated :: Ptr Vec -> Ptr Ax1 -> Double -> Acquire (Ptr Vec)+rotated point axis amount = mkAcquire (rawRotated point axis (CDouble amount)) deleteVec++-- scale/scaled++foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_Scale" rawScale :: Ptr Vec -> CDouble -> IO ()++scale :: Ptr Vec -> Double -> IO ()+scale = coerce rawScale++foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_Scaled" rawScaled :: Ptr Vec -> CDouble -> IO (Ptr Vec)++scaled :: Ptr Vec -> Double -> Acquire (Ptr Vec)+scaled a b = mkAcquire (rawScaled a (CDouble b)) deleteVec+++-- transform/transformed++foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_Transform" transform :: Ptr Vec -> Ptr Trsf -> IO ()++foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_Transformed" rawTransformed :: Ptr Vec -> Ptr Trsf -> IO (Ptr Vec)++transformed :: Ptr Vec -> Ptr Trsf -> Acquire (Ptr Vec)+transformed point trsf = mkAcquire (rawTransformed point trsf) deleteVec
+ src/OpenCascade/GP/Vec2d.hs view
@@ -0,0 +1,262 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.GP.Vec2d+( Vec2d+, new+, getX+, getY+, setX+, setY +, isEqual+, isOpposite+, isNormal+, isParallel+, angle+, magnitude+, squareMagnitude+, add+, added+, subtract+, subtracted+, multiply+, multiplied+, divide+, divided+, crossed+, crossMagnitude+, crossSquareMagnitude+, dot+, reverse+, reversed+, mirror+, mirrored+, mirrorAboutAx2d+, mirroredAboutAx2d+, rotate+, rotated+, scale+, scaled+, transform+, transformed+) where+++import Prelude hiding (reverse, subtract)+import OpenCascade.GP.Types+import OpenCascade.GP.Internal.Destructors+import Foreign.C+import Foreign.Ptr+import Data.Coerce (coerce)+import Data.Acquire ++-- new++foreign import capi unsafe "hs_gp_Vec2d.h hs_new_gp_Vec2d" rawNew :: CDouble -> CDouble -> IO (Ptr Vec2d)++new :: Double -> Double -> Acquire (Ptr Vec2d)+new x y = mkAcquire (rawNew (CDouble x) (CDouble y)) deleteVec2d++-- getters++foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_X" rawX :: Ptr Vec2d -> IO (CDouble)++getX :: Ptr Vec2d -> IO Double+getX = coerce rawX++foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_Y" rawY :: Ptr Vec2d -> IO (CDouble)++getY :: Ptr Vec2d -> IO Double+getY = coerce rawY++-- setters++foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_SetX" rawSetX :: Ptr Vec2d -> CDouble -> IO ()++setX :: Ptr Vec2d -> Double -> IO ()+setX = coerce rawSetX+++foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_SetY" rawSetY :: Ptr Vec2d -> CDouble -> IO ()++setY :: Ptr Vec2d -> Double -> IO ()+setY = coerce rawSetY++-- tests++-- isEqual++foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_IsEqual" rawIsEqual :: Ptr Vec2d -> Ptr Vec2d -> CDouble -> CDouble -> IO CBool++isEqual :: Ptr Vec2d -> Ptr Vec2d -> Double -> Double -> IO Bool+isEqual a b linearTolerance angularTolerance = (/= 0) <$> rawIsEqual a b (CDouble linearTolerance) (CDouble angularTolerance)++-- isNormal++foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_IsNormal" rawIsNormal :: Ptr Vec2d -> Ptr Vec2d -> CDouble -> IO CBool++isNormal :: Ptr Vec2d -> Ptr Vec2d -> Double -> IO Bool+isNormal a b tolerance = (/= 0) <$> rawIsNormal a b (CDouble tolerance)++-- isOpposite++foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_IsOpposite" rawIsOpposite :: Ptr Vec2d -> Ptr Vec2d -> CDouble -> IO CBool++isOpposite :: Ptr Vec2d -> Ptr Vec2d -> Double -> IO Bool+isOpposite a b tolerance = (/= 0) <$> rawIsOpposite a b (CDouble tolerance)++-- isParallel++foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_IsParallel" rawIsParallel :: Ptr Vec2d -> Ptr Vec2d -> CDouble -> IO CBool++isParallel :: Ptr Vec2d -> Ptr Vec2d -> Double -> IO Bool+isParallel a b tolerance = (/= 0) <$> rawIsParallel a b (CDouble tolerance)++-- angle++foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_Angle" rawAngle :: Ptr Vec2d -> Ptr Vec2d -> IO CDouble++angle :: Ptr Vec2d -> Ptr Vec2d -> IO Double+angle = coerce rawAngle+++-- magnitude++foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_Magnitude" rawMagnitude :: Ptr Vec2d -> IO CDouble++magnitude :: Ptr Vec2d -> IO Double+magnitude = coerce rawMagnitude+++-- squareMagnitude++foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_SquareMagnitude" rawSquareMagnitude :: Ptr Vec2d -> IO CDouble++squareMagnitude :: Ptr Vec2d -> IO Double+squareMagnitude = coerce rawSquareMagnitude++-- add/added++foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_Add" add :: Ptr Vec2d -> Ptr Vec2d -> IO ()++foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_Added" rawAdded :: Ptr Vec2d -> Ptr Vec2d -> IO (Ptr Vec2d)++added :: Ptr Vec2d -> Ptr Vec2d -> Acquire (Ptr Vec2d)+added a b = mkAcquire (rawAdded a b) deleteVec2d+++-- subtract/subtracted++foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_Subtract" subtract :: Ptr Vec2d -> Ptr Vec2d -> IO ()++foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_Subtracted" rawSubtracted :: Ptr Vec2d -> Ptr Vec2d -> IO (Ptr Vec2d)++subtracted :: Ptr Vec2d -> Ptr Vec2d -> Acquire (Ptr Vec2d)+subtracted a b = mkAcquire (rawSubtracted a b) deleteVec2d+++-- multiply/multiplied++foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_Multiply" rawMultiply :: Ptr Vec2d -> CDouble -> IO ()++multiply :: Ptr Vec2d -> Double -> IO ()+multiply = coerce rawMultiply++foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_Multiplied" rawMultiplied :: Ptr Vec2d -> CDouble -> IO (Ptr Vec2d)++multiplied :: Ptr Vec2d -> Double -> Acquire (Ptr Vec2d)+multiplied a b = mkAcquire (rawMultiplied a (CDouble b)) deleteVec2d++-- divide/divided++foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_Divide" rawDivide :: Ptr Vec2d -> CDouble -> IO ()++divide :: Ptr Vec2d -> Double -> IO ()+divide = coerce rawDivide++foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_Divided" rawDivided :: Ptr Vec2d -> CDouble -> IO (Ptr Vec2d)++divided :: Ptr Vec2d -> Double -> Acquire (Ptr Vec2d)+divided a b = mkAcquire (rawDivided a (CDouble b)) deleteVec2d++-- cross/crossed++foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_Crossed" rawCrossed :: Ptr Vec2d -> Ptr Vec2d -> IO (CDouble)++crossed :: Ptr Vec2d -> Ptr Vec2d -> IO CDouble+crossed = coerce rawCrossed++-- crossMagnitude++foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_CrossMagnitude" rawCrossMagnitude :: Ptr Vec2d -> Ptr Vec2d -> IO CDouble++crossMagnitude :: Ptr Vec2d -> Ptr Vec2d -> IO Double+crossMagnitude = coerce rawCrossMagnitude++-- crossSquareMagnitude++foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_CrossSquareMagnitude" rawCrossSquareMagnitude :: Ptr Vec2d -> Ptr Vec2d -> IO CDouble++crossSquareMagnitude :: Ptr Vec2d -> Ptr Vec2d -> IO Double+crossSquareMagnitude = coerce rawCrossSquareMagnitude++-- dot++foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_Dot" rawDot :: Ptr Vec2d -> Ptr Vec2d -> IO CDouble++dot :: Ptr Vec2d -> Ptr Vec2d -> IO Double+dot = coerce rawDot++-- reverse/reversed++foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_Reverse" reverse :: Ptr Vec2d -> IO ()++foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_Reversed" rawReversed :: Ptr Vec2d -> IO (Ptr Vec2d)++reversed :: Ptr Vec2d -> Acquire (Ptr Vec2d)+reversed axis = mkAcquire (rawReversed axis) deleteVec2d++-- mirror/mirrored++foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_Mirror" mirror :: Ptr Vec2d -> Ptr Vec2d -> IO ()++foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_Mirrored" rawMirrored :: Ptr Vec2d -> Ptr Vec2d -> IO (Ptr Vec2d)++mirrored :: Ptr Vec2d -> Ptr Vec2d -> Acquire (Ptr Vec2d)+mirrored point axis = mkAcquire (rawMirrored point axis) deleteVec2d++foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_MirrorAboutAx2d" mirrorAboutAx2d :: Ptr Vec2d -> Ptr Ax2d -> IO ()++foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_MirroredAboutAx2d" rawMirroredAboutAx2d :: Ptr Vec2d -> Ptr Ax2d -> IO (Ptr Vec2d)++mirroredAboutAx2d :: Ptr Vec2d -> Ptr Ax2d -> Acquire (Ptr Vec2d)+mirroredAboutAx2d point axis = mkAcquire (rawMirroredAboutAx2d point axis) deleteVec2d++-- rotate/rotated++foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_Rotate" rotate :: Ptr Vec2d -> CDouble-> IO ()++foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_Rotated" rawRotated :: Ptr Vec2d -> CDouble -> IO (Ptr Vec2d)++rotated :: Ptr Vec2d -> Double -> Acquire (Ptr Vec2d)+rotated point angle = mkAcquire (rawRotated point (CDouble angle)) deleteVec2d++-- scale/scaled++foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_Scale" rawScale :: Ptr Vec2d -> CDouble -> IO ()++scale :: Ptr Vec2d -> Double -> IO ()+scale = coerce rawScale++foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_Scaled" rawScaled :: Ptr Vec2d -> CDouble -> IO (Ptr Vec2d)++scaled :: Ptr Vec2d -> Double -> Acquire (Ptr Vec2d)+scaled a b = mkAcquire (rawScaled a (CDouble b)) deleteVec2d+++-- transform/transformed++foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_Transform" transform :: Ptr Vec2d -> Ptr Trsf -> IO ()++foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_Transformed" rawTransformed :: Ptr Vec2d -> Ptr Trsf -> IO (Ptr Vec2d)++transformed :: Ptr Vec2d -> Ptr Trsf -> Acquire (Ptr Vec2d)+transformed point trsf = mkAcquire (rawTransformed point trsf) deleteVec2d
+ src/OpenCascade/Geom.hs view
@@ -0,0 +1,5 @@+module OpenCascade.Geom +( module OpenCascade.Geom.Types+) where++import OpenCascade.Geom.Types
+ src/OpenCascade/Geom/BezierCurve.hs view
@@ -0,0 +1,24 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.Geom.BezierCurve +( fromPnts+, toHandle+) where+import Foreign.Ptr+import Data.Acquire+import OpenCascade.Geom.Types (BezierCurve)+import OpenCascade.Geom.Internal.Destructors (deleteBezierCurve, deleteHandleBezierCurve)+import OpenCascade.GP (Pnt(..))+import OpenCascade.NCollection (Array1)+import OpenCascade.Handle (Handle)+foreign import capi unsafe "hs_Geom_BezierCurve.h hs_new_Geom_BezierCurve_fromPnts" rawFromPnts :: Ptr (Array1 Pnt) -> IO(Ptr BezierCurve)++fromPnts :: Ptr (Array1 Pnt) -> Acquire (Ptr BezierCurve)+fromPnts arr = mkAcquire (rawFromPnts arr) (deleteBezierCurve)++foreign import capi unsafe "hs_Geom_BezierCurve.h hs_Geom_BezierCurve_toHandle" rawToHandle :: Ptr BezierCurve -> IO (Ptr (Handle BezierCurve))++toHandle :: Ptr BezierCurve -> Acquire (Ptr (Handle BezierCurve))+toHandle curve = mkAcquire (rawToHandle curve) deleteHandleBezierCurve+++
+ src/OpenCascade/Geom/Curve.hs view
@@ -0,0 +1,16 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.Geom.Curve +( value+) where+import Foreign.Ptr+import Foreign.C+import Data.Coerce+import Data.Acquire+import OpenCascade.Geom.Types (Curve)+import OpenCascade.GP (Pnt)+import OpenCascade.GP.Internal.Destructors (deletePnt)+import OpenCascade.Handle (Handle)+foreign import capi unsafe "hs_Geom_Curve.h hs_Geom_Curve_value" rawValue :: Ptr (Handle Curve) -> CDouble -> IO(Ptr Pnt)++value :: Ptr (Handle Curve) -> Double -> Acquire (Ptr Pnt)+value curve u = mkAcquire (rawValue curve (coerce u)) deletePnt
+ src/OpenCascade/Geom/Internal/Destructors.hs view
@@ -0,0 +1,16 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.Geom.Internal.Destructors where++import OpenCascade.Geom.Types++import OpenCascade.Handle++import Foreign.Ptr++foreign import capi unsafe "hs_Geom_Curve.h hs_delete_Handle_Geom_Curve" deleteHandleCurve :: Ptr (Handle Curve) -> IO ()++foreign import capi unsafe "hs_Geom_TrimmedCurve.h hs_delete_Handle_Geom_TrimmedCurve" deleteHandleTrimmedCurve :: Ptr (Handle TrimmedCurve) -> IO ()++foreign import capi unsafe "hs_Geom_BezierCurve.h hs_delete_Handle_Geom_BezierCurve" deleteHandleBezierCurve :: Ptr (Handle BezierCurve) -> IO ()++foreign import capi unsafe "hs_Geom_BezierCurve.h hs_delete_Geom_BezierCurve" deleteBezierCurve :: Ptr BezierCurve -> IO ()
+ src/OpenCascade/Geom/Types.hs view
@@ -0,0 +1,18 @@+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE EmptyDataDecls #-}+module OpenCascade.Geom.Types+( Curve+, TrimmedCurve+, BezierCurve+, Surface+) where++import OpenCascade.Inheritance ++data Curve+data TrimmedCurve+data BezierCurve+data Surface++instance SubTypeOf Curve TrimmedCurve+instance SubTypeOf Curve BezierCurve
+ src/OpenCascade/Handle.hs view
@@ -0,0 +1,14 @@+{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE EmptyDataDecls #-}+module OpenCascade.Handle +( Handle+) where+import OpenCascade.Inheritance++data Handle a ++instance SubTypeOf a b => SubTypeOf (Handle a) (Handle b)++++
+ src/OpenCascade/IFSelect/ReturnStatus.hs view
@@ -0,0 +1,6 @@+module OpenCascade.IFSelect.ReturnStatus +( ReturnStatus (..)+) where++-- Should match the order in IFSelect_ReturnStatus.hxx+data ReturnStatus = Void | Done | Error | Fail | Stop deriving Enum
+ src/OpenCascade/Inheritance.hs view
@@ -0,0 +1,23 @@+{-# LANGUAGE MultiParamTypeClasses #-} ++module OpenCascade.Inheritance +( SubTypeOf (..)+, DiscriminatedSubTypeOf (..)+, unsafeDowncast+) where++import Foreign.Ptr++class SubTypeOf a b where+    upcast :: Ptr b -> Ptr a+    upcast = castPtr++class SubTypeOf a b => DiscriminatedSubTypeOf a b where+    downcast :: Ptr a -> IO (Maybe (Ptr b))++unsafeDowncast :: DiscriminatedSubTypeOf a b => Ptr a -> IO (Ptr b)+unsafeDowncast p = do+    maybeT <- downcast p+    maybe (error "Incorrect subtype in cast") pure maybeT+    +
+ src/OpenCascade/Internal/Bool.hs view
@@ -0,0 +1,14 @@+module OpenCascade.Internal.Bool+( boolToCBool +, cBoolToBool+) where+++import Foreign.C++boolToCBool :: Bool -> CBool +boolToCBool b = if b then 1 else 0++cBoolToBool :: CBool -> Bool+cBoolToBool = (/=0)+
+ src/OpenCascade/NCollection.hs view
@@ -0,0 +1,5 @@+module OpenCascade.NCollection (+    module OpenCascade.NCollection.Types+) where++import OpenCascade.NCollection.Types
+ src/OpenCascade/NCollection/Array1.hs view
@@ -0,0 +1,23 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.NCollection.Array1+(+    newGPPntArray,+    setValueGPPnt+) where++import Data.Acquire+import Foreign.Ptr+import Foreign.C+import OpenCascade.GP.Types+import OpenCascade.NCollection.Types+import OpenCascade.NCollection.Internal.Destructors++foreign import capi unsafe "hs_NCollection_Array1.h hs_new_NCollection_Array1_gp_Pnt" rawNewGPPntArray :: CInt -> CInt -> IO (Ptr (Array1 Pnt))++newGPPntArray :: Int -> Int -> Acquire (Ptr (Array1 Pnt))+newGPPntArray lo hi = mkAcquire (rawNewGPPntArray (fromIntegral lo) (fromIntegral hi)) deletePntArray++foreign import capi unsafe "hs_NCollection_Array1.h hs_NCollection_Array1_gp_Pnt_setValue" rawSetValueGPPnt :: Ptr (Array1 Pnt) -> CInt -> Ptr Pnt -> IO ()++setValueGPPnt :: Ptr (Array1 Pnt) -> Int -> Ptr Pnt -> IO ()+setValueGPPnt arr i p = rawSetValueGPPnt arr (fromIntegral i) p
+ src/OpenCascade/NCollection/Internal/Destructors.hs view
@@ -0,0 +1,9 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.NCollection.Internal.Destructors where++import OpenCascade.NCollection.Types+import OpenCascade.GP.Types+import Foreign.Ptr++foreign import capi unsafe "hs_NCollection_Array1.h hs_delete_NCollection_Array1_gp_Pnt" deletePntArray :: Ptr (Array1 Pnt) -> IO ()+
+ src/OpenCascade/NCollection/Types.hs view
@@ -0,0 +1,4 @@+{-# LANGUAGE EmptyDataDecls #-}+module OpenCascade.NCollection.Types where++data Array1 a
+ src/OpenCascade/STEPControl.hs view
@@ -0,0 +1,5 @@+module OpenCascade.STEPControl+( module OpenCascade.STEPControl.Types+) where++import OpenCascade.STEPControl.Types
+ src/OpenCascade/STEPControl/Internal/Destructors.hs view
@@ -0,0 +1,8 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.STEPControl.Internal.Destructors where++import OpenCascade.STEPControl.Types++import Foreign.Ptr++foreign import capi unsafe "hs_STEPControl_Writer.h hs_delete_STEPControl_Writer" deleteWriter :: Ptr Writer -> IO ()
+ src/OpenCascade/STEPControl/StepModelType.hs view
@@ -0,0 +1,15 @@+module OpenCascade.STEPControl.StepModelType+( StepModelType(..)+) where++-- this should match the order defined in StepModelType+data StepModelType = +    Asls |+    ManifoldSolidBrep |+    BrepWithVoids | +    FacetedBrep |+    FacetedBrepAndBrepWithVoids |+    ShellBasedSurfaceModel |+    GeometricCurveSet |+    Hybrid +    deriving Enum
+ src/OpenCascade/STEPControl/Types.hs view
@@ -0,0 +1,4 @@+{-# LANGUAGE EmptyDataDecls #-}+module OpenCascade.STEPControl.Types where++data Writer
+ src/OpenCascade/STEPControl/Writer.hs view
@@ -0,0 +1,41 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.STEPControl.Writer+( new+, setTolerance+, unsetTolerance+, transfer+, write+) where++import OpenCascade.STEPControl.Types (Writer)+import OpenCascade.STEPControl.Internal.Destructors (deleteWriter)+import qualified OpenCascade.TopoDS as TopoDS+import Foreign.C+import Foreign.Ptr+import Data.Acquire+import OpenCascade.Internal.Bool (boolToCBool)+import qualified OpenCascade.IFSelect.ReturnStatus as IFSelect.ReturnStatus+import OpenCascade.STEPControl.StepModelType (StepModelType)+import Data.Coerce (coerce)++foreign import capi unsafe "hs_STEPControl_Writer.h hs_new_STEPControl_Writer" rawNew :: IO (Ptr Writer)++new :: Acquire (Ptr Writer)+new = mkAcquire rawNew deleteWriter++foreign import capi unsafe "hs_STEPControl_Writer.h hs_STEPControl_Writer_setTolerance" rawSetTolerance :: Ptr Writer -> CDouble -> IO ()++setTolerance :: Ptr Writer -> Double -> IO ()+setTolerance = coerce rawSetTolerance ++foreign import capi unsafe "hs_STEPControl_Writer.h hs_STEPControl_Writer_unsetTolerance" unsetTolerance :: Ptr Writer -> IO ()++foreign import capi unsafe "hs_STEPControl_Writer.h hs_STEPControl_Writer_transfer" rawTransfer :: Ptr Writer -> Ptr TopoDS.Shape -> CInt -> CBool -> IO CInt++transfer :: Ptr Writer -> Ptr TopoDS.Shape -> StepModelType -> Bool -> IO IFSelect.ReturnStatus.ReturnStatus+transfer writer shape mode compgraph = toEnum . fromIntegral <$> rawTransfer writer shape (fromIntegral . fromEnum $ mode) (boolToCBool compgraph)++foreign import capi unsafe "hs_STEPControl_Writer.h hs_STEPControl_Writer_write" rawWrite :: Ptr Writer -> CString -> IO CInt++write :: Ptr Writer -> String -> IO IFSelect.ReturnStatus.ReturnStatus+write writer filename = toEnum . fromIntegral <$> withCString filename (rawWrite writer)
+ src/OpenCascade/StlAPI.hs view
@@ -0,0 +1,5 @@+module OpenCascade.StlAPI+( module OpenCascade.StlAPI.Types+) where++import OpenCascade.StlAPI.Types
+ src/OpenCascade/StlAPI/Internal/Destructors.hs view
@@ -0,0 +1,8 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.StlAPI.Internal.Destructors where++import OpenCascade.StlAPI.Types++import Foreign.Ptr++foreign import capi unsafe "hs_StlAPI_Writer.h hs_delete_StlAPI_Writer" deleteWriter :: Ptr Writer -> IO ()
+ src/OpenCascade/StlAPI/Types.hs view
@@ -0,0 +1,5 @@++{-# LANGUAGE EmptyDataDecls #-}+module OpenCascade.StlAPI.Types where++data Writer
+ src/OpenCascade/StlAPI/Writer.hs view
@@ -0,0 +1,30 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.StlAPI.Writer+( new+, setAsciiMode+, write+) where++import OpenCascade.StlAPI.Types (Writer)+import OpenCascade.StlAPI.Internal.Destructors (deleteWriter)+import qualified OpenCascade.TopoDS as TopoDS+import Foreign.C+import Foreign.Ptr+import Data.Acquire+import OpenCascade.Internal.Bool (boolToCBool, cBoolToBool)++foreign import capi unsafe "hs_StlAPI_Writer.h hs_new_StlAPI_Writer" rawNew :: IO (Ptr Writer)++new :: Acquire (Ptr Writer)+new = mkAcquire rawNew deleteWriter++foreign import capi unsafe "hs_StlAPI_Writer.h hs_StlAPI_Writer_setAsciiMode" rawSetAsciiMode :: Ptr Writer -> CBool -> IO ()++setAsciiMode :: Ptr Writer -> Bool -> IO ()+setAsciiMode writer mode = rawSetAsciiMode writer (boolToCBool mode)+++foreign import capi unsafe "hs_StlAPI_Writer.h hs_StlAPI_Writer_write" rawWrite :: Ptr Writer -> Ptr TopoDS.Shape -> CString -> IO (CBool)++write :: Ptr Writer -> Ptr TopoDS.Shape -> String -> IO (Bool)+write writer shape filename = cBoolToBool <$> withCString filename (rawWrite writer shape)
+ src/OpenCascade/TopAbs.hs view
@@ -0,0 +1,7 @@+module OpenCascade.TopAbs +( Orientation+, ShapeEnum+) +where +import OpenCascade.TopAbs.Orientation+import OpenCascade.TopAbs.ShapeEnum
+ src/OpenCascade/TopAbs/Orientation.hs view
@@ -0,0 +1,6 @@+module OpenCascade.TopAbs.Orientation +( Orientation (..)+) where++-- this should match the orientation in TopAbs_Orientation+data Orientation = Forward | Reversed | Internal | External deriving (Show, Enum)
+ src/OpenCascade/TopAbs/ShapeEnum.hs view
@@ -0,0 +1,6 @@+module OpenCascade.TopAbs.ShapeEnum+( ShapeEnum (..)+) where++-- this should match the enumeration in TopAbs_ShapeEnum+data ShapeEnum = Compound | CompSolid | Solid | Shell | Face | Wire | Edge | Vertex | Shape deriving (Show, Eq, Enum)
+ src/OpenCascade/TopExp.hs view
@@ -0,0 +1,5 @@+module OpenCascade.TopExp+( module OpenCascade.TopExp.Types+) where++import OpenCascade.TopExp.Types
+ src/OpenCascade/TopExp/Explorer.hs view
@@ -0,0 +1,31 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.TopExp.Explorer+( Explorer+, new+, more+, next+, value+) where++import OpenCascade.TopExp.Types (Explorer)+import OpenCascade.TopExp.Internal.Destructors (deleteExplorer)+import qualified OpenCascade.TopoDS as TopoDS+import qualified OpenCascade.TopAbs as TopAbs+import Data.Acquire+import Foreign.Ptr+import Foreign.C+import OpenCascade.Internal.Bool (cBoolToBool)++foreign import capi unsafe "hs_TopExp_Explorer.h hs_new_TopExp_Explorer" rawNew :: Ptr TopoDS.Shape -> CInt -> IO (Ptr Explorer)++new :: Ptr TopoDS.Shape -> TopAbs.ShapeEnum -> Acquire (Ptr Explorer)+new shape theType = mkAcquire (rawNew shape (fromIntegral . fromEnum $ theType)) deleteExplorer++foreign import capi unsafe "hs_TopExp_Explorer.h hs_TopExp_Explorer_more" rawMore :: Ptr Explorer -> IO (CBool)++more :: Ptr Explorer -> IO Bool+more = fmap (cBoolToBool) . rawMore ++foreign import capi unsafe "hs_TopExp_Explorer.h hs_TopExp_Explorer_next" next :: Ptr Explorer -> IO ()++foreign import capi unsafe "hs_TopExp_Explorer.h hs_TopExp_Explorer_value" value :: Ptr Explorer -> IO (Ptr TopoDS.Shape)
+ src/OpenCascade/TopExp/Internal/Destructors.hs view
@@ -0,0 +1,10 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.TopExp.Internal.Destructors where++import OpenCascade.TopExp.Types++import Foreign.Ptr++foreign import capi unsafe "hs_TopExp_Explorer.h hs_delete_TopExp_Explorer" deleteExplorer :: Ptr Explorer -> IO ()++
+ src/OpenCascade/TopExp/Types.hs view
@@ -0,0 +1,4 @@+{-# LANGUAGE EmptyDataDecls #-}+module OpenCascade.TopExp.Types where++data Explorer
+ src/OpenCascade/TopLoc.hs view
@@ -0,0 +1,4 @@+module OpenCascade.TopLoc +( module OpenCascade.TopLoc.Types+) where+import OpenCascade.TopLoc.Types
+ src/OpenCascade/TopLoc/Internal/Destructors.hs view
@@ -0,0 +1,8 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.TopLoc.Internal.Destructors where++import OpenCascade.TopLoc.Types++import Foreign.Ptr++foreign import capi unsafe "hs_TopLoc_Location.h hs_delete_TopLoc_Location" deleteLocation :: Ptr Location -> IO ()
+ src/OpenCascade/TopLoc/Location.hs view
@@ -0,0 +1,126 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.TopLoc.Location+( Location+, new+, fromGPTrsf+, isIdentity+, firstPower+, nextLocation+, inverted+, multiplied+, divided+, predivided+, powered+, isEqual+, isDifferent+, clear+, toGPTrsf+) where++import OpenCascade.TopLoc.Types+import OpenCascade.TopLoc.Internal.Destructors+import OpenCascade.GP.Internal.Destructors (deleteTrsf)+import Foreign.C+import Foreign.Ptr+import Data.Acquire +import qualified OpenCascade.GP as GP++-- new ++foreign import capi unsafe "hs_TopLoc_Location.h hs_new_TopLoc_Location" rawNew :: IO (Ptr Location)++new :: Acquire (Ptr Location)+new = mkAcquire rawNew deleteLocation++-- from GP.Trsf++foreign import capi unsafe "hs_TopLoc_Location.h hs_new_TopLoc_Location_fromGPTrsf" rawFromGPTrsf :: Ptr GP.Trsf -> IO (Ptr Location)++fromGPTrsf :: Ptr (GP.Trsf) -> Acquire (Ptr Location)+fromGPTrsf t = mkAcquire (rawFromGPTrsf t) deleteLocation++-- isIdentity++foreign import capi unsafe "hs_TopLoc_Location.h hs_TopLoc_Location_IsIdentity" rawIsIdentity :: Ptr Location -> IO (CBool)++isIdentity :: Ptr Location -> IO Bool+isIdentity l = (/=0) <$>  rawIsIdentity l++-- firstPower +--+foreign import capi unsafe "hs_TopLoc_Location.h hs_TopLoc_Location_FirstPower" rawFirstPower :: Ptr Location -> IO (CInt)++firstPower :: Ptr Location -> IO Int+firstPower l = fromIntegral <$> rawFirstPower l ++-- nextLocation++foreign import capi unsafe "hs_TopLoc_Location.h hs_TopLoc_Location_NextLocation" rawNextLocation :: Ptr Location -> IO (Ptr Location)++nextLocation :: Ptr Location -> Acquire (Ptr Location)+nextLocation l = mkAcquire (rawNextLocation l) deleteLocation++-- inverted++foreign import capi unsafe "hs_TopLoc_Location.h hs_TopLoc_Location_Inverted" rawInverted :: Ptr Location -> IO (Ptr Location)++inverted :: Ptr Location -> Acquire (Ptr Location)+inverted l = mkAcquire (rawInverted l) deleteLocation++-- multiplied++foreign import capi unsafe "hs_TopLoc_Location.h hs_TopLoc_Location_Multiplied" rawMultiplied :: Ptr Location -> Ptr Location -> IO (Ptr Location)++multiplied :: Ptr Location -> Ptr Location -> Acquire (Ptr Location)+multiplied a b = mkAcquire (rawMultiplied a b) deleteLocation+++-- divided++foreign import capi unsafe "hs_TopLoc_Location.h hs_TopLoc_Location_Divided" rawDivided :: Ptr Location -> Ptr Location -> IO (Ptr Location)++divided :: Ptr Location -> Ptr Location -> Acquire (Ptr Location)+divided a b = mkAcquire (rawDivided a b) deleteLocation+++-- predivided++foreign import capi unsafe "hs_TopLoc_Location.h hs_TopLoc_Location_Predivided" rawPredivided :: Ptr Location -> Ptr Location -> IO (Ptr Location)++predivided :: Ptr Location -> Ptr Location -> Acquire (Ptr Location)+predivided a b = mkAcquire (rawPredivided a b) deleteLocation++-- powered++foreign import capi unsafe "hs_TopLoc_Location.h hs_TopLoc_Location_Powered" rawPowered :: Ptr Location -> CInt -> IO (Ptr Location)++powered :: Ptr Location -> Int -> Acquire (Ptr Location)+powered l p = mkAcquire (rawPowered l (fromIntegral p)) deleteLocation++-- isEqual++foreign import capi unsafe "hs_TopLoc_Location.h hs_TopLoc_Location_IsEqual" rawIsEqual :: Ptr Location -> Ptr Location -> IO (CBool)++isEqual :: Ptr Location -> Ptr Location -> IO Bool+isEqual a b = (/=0) <$> rawIsEqual a b+++-- isDifferent++foreign import capi unsafe "hs_TopLoc_Location.h hs_TopLoc_Location_IsDifferent" rawIsDifferent :: Ptr Location -> Ptr Location -> IO (CBool)++isDifferent :: Ptr Location -> Ptr Location -> IO Bool+isDifferent a b = (/=0) <$> rawIsDifferent a b+++-- clear++foreign import capi unsafe "hs_TopLoc_Location.h hs_TopLoc_Location_Clear" clear :: Ptr Location -> IO ()++-- toGPTrsf+--++foreign import capi unsafe "hs_TopLoc_Location.h hs_TopLoc_Location_toGPTrsf" rawToGPTrsf :: Ptr Location -> IO (Ptr GP.Trsf)++toGPTrsf :: Ptr Location -> Acquire (Ptr GP.Trsf)+toGPTrsf l = mkAcquire (rawToGPTrsf l) deleteTrsf
+ src/OpenCascade/TopLoc/Types.hs view
@@ -0,0 +1,5 @@+{-# LANGUAGE EmptyDataDecls #-}+module OpenCascade.TopLoc.Types where++data Location+
+ src/OpenCascade/TopTools.hs view
@@ -0,0 +1,4 @@+module OpenCascade.TopTools +( module OpenCascade.TopTools.Types+) where+import OpenCascade.TopTools.Types
+ src/OpenCascade/TopTools/Types.hs view
@@ -0,0 +1,4 @@+{-# LANGUAGE EmptyDataDecls #-}+module OpenCascade.TopTools.Types where++data ListOfShape
+ src/OpenCascade/TopoDS.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE MultiParamTypeClasses #-}+module OpenCascade.TopoDS +( module OpenCascade.TopoDS.Types+) where+    +import OpenCascade.TopoDS.Types
+ src/OpenCascade/TopoDS/CompSolid.hs view
@@ -0,0 +1,17 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.TopoDS.CompSolid+( CompSolid+, new+) where ++import OpenCascade.TopoDS.Types+import OpenCascade.TopoDS.Internal.Destructors+import Foreign.Ptr+import Data.Acquire ++-- new++foreign import capi unsafe "hs_TopoDS_CompSolid.h hs_new_TopoDS_CompSolid" rawNew :: IO (Ptr CompSolid)++new :: Acquire (Ptr CompSolid)+new = mkAcquire rawNew (deleteShape . castPtr)
+ src/OpenCascade/TopoDS/Compound.hs view
@@ -0,0 +1,17 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.TopoDS.Compound+( Compound+, new+) where ++import OpenCascade.TopoDS.Types+import OpenCascade.TopoDS.Internal.Destructors+import Foreign.Ptr+import Data.Acquire ++-- new++foreign import capi unsafe "hs_TopoDS_Compound.h hs_new_TopoDS_Compound" rawNew :: IO (Ptr Compound)++new :: Acquire (Ptr Compound)+new = mkAcquire rawNew (deleteShape . castPtr)
+ src/OpenCascade/TopoDS/Edge.hs view
@@ -0,0 +1,17 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.TopoDS.Edge+( Edge+, new+) where ++import OpenCascade.TopoDS.Types+import OpenCascade.TopoDS.Internal.Destructors+import Foreign.Ptr+import Data.Acquire ++-- new++foreign import capi unsafe "hs_TopoDS_Edge.h hs_new_TopoDS_Edge" rawNew :: IO (Ptr Edge)++new :: Acquire (Ptr Edge)+new = mkAcquire rawNew (deleteShape . castPtr)
+ src/OpenCascade/TopoDS/Face.hs view
@@ -0,0 +1,17 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.TopoDS.Face+( Face+, new+) where ++import OpenCascade.TopoDS.Types+import OpenCascade.TopoDS.Internal.Destructors+import Foreign.Ptr+import Data.Acquire ++-- new++foreign import capi unsafe "hs_TopoDS_Face.h hs_new_TopoDS_Face" rawNew :: IO (Ptr Face)++new :: Acquire (Ptr Face)+new = mkAcquire rawNew (deleteShape . castPtr)
+ src/OpenCascade/TopoDS/Internal/Destructors.hs view
@@ -0,0 +1,10 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.TopoDS.Internal.Destructors where++import OpenCascade.TopoDS.Types++import Foreign.Ptr++foreign import capi unsafe "hs_TopoDS_Shape.h hs_delete_TopoDS_Shape" deleteShape :: Ptr Shape -> IO ()++
+ src/OpenCascade/TopoDS/Shape.hs view
@@ -0,0 +1,341 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.TopoDS.Shape+( Shape+, new+, copy+, isNull+, nullify+, location+, setLocation+, located+, orientation+, setOrientation+, oriented+, shapeType+, free+, setFree+, locked+, setLocked+, modified+, setModified+, checked+, setChecked+, orientable+, setOrientable+, closed+, setClosed+, infinite+, setInfinite+, convex+, setConvex+, move+, moved+, nbChildren+, reverse+, reversed+, complement+, complemented+, isEqual+, isPartner+, isSame+, isNotEqual+, emptyCopy+, emptyCopied+, hashCode+) where++import Prelude hiding (reverse)+import OpenCascade.TopoDS.Types+import OpenCascade.TopoDS.Internal.Destructors+import OpenCascade.Internal.Bool+import Foreign.C+import Foreign.Ptr+import Data.Acquire ++import qualified OpenCascade.TopLoc as TopLoc+import qualified OpenCascade.TopLoc.Internal.Destructors as TopLoc.Destructors+import qualified OpenCascade.TopAbs as TopAbs+-- new++foreign import capi unsafe "hs_TopoDS_Shape.h hs_new_TopoDS_Shape" rawNew :: IO (Ptr Shape)++new :: Acquire (Ptr Shape)+new = mkAcquire rawNew  deleteShape++-- copy++foreign import capi unsafe "hs_TopoDS_Shape.h hs_new_TopoDS_Shape" rawCopy :: Ptr Shape -> IO (Ptr Shape)++copy :: Ptr Shape -> Acquire (Ptr Shape)+copy shape = mkAcquire (rawCopy shape)  deleteShape++-- isNull +--+foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_IsNull" rawIsNull :: Ptr Shape -> IO CBool++isNull :: Ptr Shape -> IO Bool+isNull s = cBoolToBool <$> rawIsNull s++-- Nullify +--+foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_Nullify" nullify :: Ptr Shape -> IO ()++-- location +--+foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_Location" rawLocation :: Ptr Shape -> IO (Ptr TopLoc.Location)++location :: Ptr Shape -> Acquire (Ptr TopLoc.Location)+location s = mkAcquire (rawLocation s) TopLoc.Destructors.deleteLocation  ++-- setLocation +--++foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_SetLocation" setLocation :: Ptr Shape -> Ptr TopLoc.Location -> IO ()++-- located+--+foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_Located" rawLocated :: Ptr Shape -> Ptr TopLoc.Location -> IO (Ptr Shape)++located :: Ptr Shape -> Ptr TopLoc.Location -> Acquire (Ptr Shape)+located s l = mkAcquire (rawLocated s l) deleteShape+++-- orientation++foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_Orientation" rawOrientation :: Ptr Shape -> IO (CInt)++orientation :: Ptr Shape -> IO TopAbs.Orientation+orientation s = toEnum . fromIntegral <$> rawOrientation s++-- setOrientation++foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_SetOrientation" rawSetOrientation :: Ptr Shape -> CInt -> IO ()++setOrientation :: Ptr Shape -> TopAbs.Orientation -> IO ()+setOrientation s o = rawSetOrientation s (fromIntegral . fromEnum $ o) +++-- oriented+--+foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_Oriented" rawOriented :: Ptr Shape -> CInt -> IO (Ptr Shape)++oriented :: Ptr Shape -> TopAbs.Orientation -> Acquire (Ptr Shape)+oriented s o = mkAcquire (rawOriented s (fromIntegral . fromEnum $ o)) deleteShape++-- shapeType +--+foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_ShapeType" rawShapeType :: Ptr Shape -> IO CInt++shapeType :: Ptr Shape -> IO TopAbs.ShapeEnum+shapeType s = toEnum . fromIntegral <$> rawShapeType s++-- free++foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_Free" rawFree :: Ptr Shape -> IO CBool++free :: Ptr Shape -> IO Bool+free s = cBoolToBool <$> rawFree s++--setFree ++foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_SetFree" rawSetFree :: Ptr Shape -> CBool-> IO ()++setFree :: Ptr Shape -> Bool -> IO ()+setFree s b = rawSetFree s (boolToCBool b)++-- locked++foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_Locked" rawLocked :: Ptr Shape -> IO CBool++locked :: Ptr Shape -> IO Bool+locked s = cBoolToBool <$> rawLocked s++--setLocked ++foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_SetLocked" rawSetLocked :: Ptr Shape -> CBool-> IO ()++setLocked :: Ptr Shape -> Bool -> IO ()+setLocked s b = rawSetLocked s (boolToCBool b)++++-- modified++foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_Modified" rawModified :: Ptr Shape -> IO CBool++modified :: Ptr Shape -> IO Bool+modified s = cBoolToBool <$> rawModified s++--setModified ++foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_SetModified" rawSetModified :: Ptr Shape -> CBool-> IO ()++setModified :: Ptr Shape -> Bool -> IO ()+setModified s b = rawSetModified s (boolToCBool b)+++-- checked++foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_Checked" rawChecked :: Ptr Shape -> IO CBool++checked :: Ptr Shape -> IO Bool+checked s = cBoolToBool <$> rawChecked s++--setChecked ++foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_SetChecked" rawSetChecked :: Ptr Shape -> CBool-> IO ()++setChecked :: Ptr Shape -> Bool -> IO ()+setChecked s b = rawSetChecked s (boolToCBool b)++-- orientable++foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_Orientable" rawOrientable :: Ptr Shape -> IO CBool++orientable :: Ptr Shape -> IO Bool+orientable s = cBoolToBool <$> rawOrientable s++--setOrientable ++foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_SetOrientable" rawSetOrientable :: Ptr Shape -> CBool-> IO ()++setOrientable :: Ptr Shape -> Bool -> IO ()+setOrientable s b = rawSetOrientable s (boolToCBool b)++-- closed++foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_Closed" rawClosed :: Ptr Shape -> IO CBool++closed :: Ptr Shape -> IO Bool+closed s = cBoolToBool <$> rawClosed s++--setClosed ++foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_SetClosed" rawSetClosed :: Ptr Shape -> CBool-> IO ()++setClosed :: Ptr Shape -> Bool -> IO ()+setClosed s b = rawSetClosed s (boolToCBool b)+++-- infinite++foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_Infinite" rawInfinite :: Ptr Shape -> IO CBool++infinite :: Ptr Shape -> IO Bool+infinite s = cBoolToBool <$> rawInfinite s++--setInfinite ++foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_SetInfinite" rawSetInfinite :: Ptr Shape -> CBool-> IO ()++setInfinite :: Ptr Shape -> Bool -> IO ()+setInfinite s b = rawSetInfinite s (boolToCBool b)++++-- convex++foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_Convex" rawConvex :: Ptr Shape -> IO CBool++convex :: Ptr Shape -> IO Bool+convex s = cBoolToBool <$> rawConvex s++--setConvex ++foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_SetConvex" rawSetConvex :: Ptr Shape -> CBool-> IO ()++setConvex :: Ptr Shape -> Bool -> IO ()+setConvex s b = rawSetConvex s (boolToCBool b)+++-- move+--++foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_Move" move :: Ptr Shape -> Ptr TopLoc.Location -> IO ()++-- moved+--+foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_Moved" rawMoved :: Ptr Shape -> Ptr TopLoc.Location -> IO (Ptr Shape)++moved :: Ptr Shape -> Ptr TopLoc.Location -> Acquire (Ptr Shape)+moved s l = mkAcquire (rawMoved s l) deleteShape++-- nbChildren++foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_NbChildren" rawNbChildren :: Ptr Shape -> IO (CInt)++nbChildren :: Ptr Shape -> IO Int+nbChildren s = fromIntegral <$> rawNbChildren s++-- reverse+--++foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_Reverse" reverse :: Ptr Shape -> IO ()++-- reversed+--+foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_Reversed" rawReversed :: Ptr Shape -> IO (Ptr Shape)++reversed :: Ptr Shape -> Acquire (Ptr Shape)+reversed s = mkAcquire (rawReversed s) deleteShape+++-- complement+--++foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_Complement" complement :: Ptr Shape -> IO ()++-- complemented+--+foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_Complemented" rawComplemented :: Ptr Shape -> IO (Ptr Shape)++complemented :: Ptr Shape -> Acquire (Ptr Shape)+complemented s = mkAcquire (rawComplemented s) deleteShape++-- isEqual++foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_IsEqual" rawIsEqual :: Ptr Shape -> Ptr Shape -> IO CBool++isEqual :: Ptr Shape -> Ptr Shape -> IO Bool+isEqual a b = cBoolToBool <$> rawIsEqual a b+++-- isSame++foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_IsSame" rawIsSame :: Ptr Shape -> Ptr Shape -> IO CBool++isSame :: Ptr Shape -> Ptr Shape -> IO Bool+isSame a b = cBoolToBool <$> rawIsSame a b+++-- isPartner++foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_IsPartner" rawIsPartner :: Ptr Shape -> Ptr Shape -> IO CBool++isPartner :: Ptr Shape -> Ptr Shape -> IO Bool+isPartner a b = cBoolToBool <$> rawIsPartner a b++-- isNotEqual++foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_IsNotEqual" rawIsNotEqual :: Ptr Shape -> Ptr Shape -> IO CBool++isNotEqual :: Ptr Shape -> Ptr Shape -> IO Bool+isNotEqual a b = cBoolToBool <$> rawIsNotEqual a b++-- emptyCopy+--++foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_EmptyCopy" emptyCopy :: Ptr Shape -> IO ()++-- emptyCopied+--+foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_EmptyCopied" rawEmptyCopied :: Ptr Shape -> IO (Ptr Shape)++emptyCopied :: Ptr Shape -> Acquire (Ptr Shape)+emptyCopied s = mkAcquire (rawEmptyCopied s) deleteShape+++foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_hashCode" rawHashCode :: Ptr Shape -> CInt -> IO CInt++hashCode :: Ptr Shape -> Int -> IO Int+hashCode shape upperBound = fromIntegral <$> rawHashCode shape (fromIntegral upperBound)
+ src/OpenCascade/TopoDS/Shell.hs view
@@ -0,0 +1,17 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.TopoDS.Shell+( Shell+, new+) where ++import OpenCascade.TopoDS.Types+import OpenCascade.TopoDS.Internal.Destructors+import Foreign.Ptr+import Data.Acquire ++-- new++foreign import capi unsafe "hs_TopoDS_Shell.h hs_new_TopoDS_Shell" rawNew :: IO (Ptr Shell)++new :: Acquire (Ptr Shell)+new = mkAcquire rawNew (deleteShape . castPtr)
+ src/OpenCascade/TopoDS/Solid.hs view
@@ -0,0 +1,17 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.TopoDS.Solid+( Solid+, new+) where ++import OpenCascade.TopoDS.Types+import OpenCascade.TopoDS.Internal.Destructors+import Foreign.Ptr+import Data.Acquire ++-- new++foreign import capi unsafe "hs_TopoDS_Solid.h hs_new_TopoDS_Solid" rawNew :: IO (Ptr Solid)++new :: Acquire (Ptr Solid)+new = mkAcquire rawNew (deleteShape . castPtr)
+ src/OpenCascade/TopoDS/Types.hs view
@@ -0,0 +1,96 @@+{-# LANGUAGE EmptyDataDecls #-}+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE CApiFFI #-}+module OpenCascade.TopoDS.Types+( Shape+, CompSolid+, Compound+, Edge+, Face+, Shell+, Solid+, Vertex+, Wire+)++where+++import OpenCascade.Inheritance+import OpenCascade.TopAbs.ShapeEnum+import qualified OpenCascade.TopAbs.ShapeEnum as ShapeEnum+import Foreign.Ptr+import Foreign.C+++data Shape+data CompSolid+data Compound+data Edge+data Face+data Shell+data Solid+data Vertex+data Wire++-- duplicate definition of shape type from TopoDS.Shape+-- to simultaniously avoid Orphan Instances + circular dependencies+foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_ShapeType" rawShapeType :: Ptr Shape -> IO CInt++shapeType :: Ptr Shape -> IO ShapeEnum+shapeType s = toEnum . fromIntegral <$> rawShapeType s++enumDowncast :: ShapeEnum -> Ptr Shape -> IO (Maybe (Ptr t))+enumDowncast enum p = do+    e <- shapeType p+    return $ if e == enum +                then Just (castPtr p)+                else Nothing+++instance SubTypeOf Shape Compound++instance DiscriminatedSubTypeOf Shape Compound where+    downcast = enumDowncast ShapeEnum.Compound+++instance SubTypeOf Shape CompSolid++instance DiscriminatedSubTypeOf Shape CompSolid where+    downcast = enumDowncast ShapeEnum.CompSolid+++instance SubTypeOf Shape Solid++instance DiscriminatedSubTypeOf Shape Solid where+    downcast = enumDowncast ShapeEnum.Solid+++instance SubTypeOf Shape Shell++instance DiscriminatedSubTypeOf Shape Shell where+    downcast = enumDowncast ShapeEnum.Shell+++instance SubTypeOf Shape Face++instance DiscriminatedSubTypeOf Shape Face where+    downcast = enumDowncast ShapeEnum.Face++instance SubTypeOf Shape Wire++instance DiscriminatedSubTypeOf Shape Wire where+    downcast = enumDowncast ShapeEnum.Wire+++instance SubTypeOf Shape Edge++instance DiscriminatedSubTypeOf Shape Edge where+    downcast = enumDowncast ShapeEnum.Edge+++instance SubTypeOf Shape Vertex++instance DiscriminatedSubTypeOf Shape Vertex where+    downcast = enumDowncast ShapeEnum.Vertex+
+ src/OpenCascade/TopoDS/Vertex.hs view
@@ -0,0 +1,17 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.TopoDS.Vertex+( Vertex+, new+) where ++import OpenCascade.TopoDS.Types+import OpenCascade.TopoDS.Internal.Destructors+import Foreign.Ptr+import Data.Acquire ++-- new++foreign import capi unsafe "hs_TopoDS_Vertex.h hs_new_TopoDS_Vertex" rawNew :: IO (Ptr Vertex)++new :: Acquire (Ptr Vertex)+new = mkAcquire rawNew (deleteShape . castPtr)
+ src/OpenCascade/TopoDS/Wire.hs view
@@ -0,0 +1,17 @@+{-# LANGUAGE CApiFFI #-}+module OpenCascade.TopoDS.Wire+( Wire+, new+) where ++import OpenCascade.TopoDS.Types+import OpenCascade.TopoDS.Internal.Destructors+import Foreign.Ptr+import Data.Acquire ++-- new++foreign import capi unsafe "hs_TopoDS_Wire.h hs_new_TopoDS_Wire" rawNew :: IO (Ptr Wire)++new :: Acquire (Ptr Wire)+new = mkAcquire rawNew (deleteShape . castPtr)