drop old, unused and error prone dxf2svg extension

(bzr r12075)

22 files changed, 0 insertions, 4001 deletions

diff --git a/src/extension/CMakeLists.txt b/src/extension/CMakeLists.txt
index e1f04fa10..b5634f42f 100644
--- a/src/extension/CMakeLists.txt
+++ b/src/extension/CMakeLists.txt
@@ -63,17 +63,6 @@ set(extension_SRC
 
 	script/InkscapeScript.cpp
 
-	# dxf2svg/aci2rgb.cpp
-	# dxf2svg/entities2elements.cpp
-	# dxf2svg/tables2svg_info.cpp
-	# dxf2svg/blocks.cpp
-	# dxf2svg/entities.cpp
-	# dxf2svg/tables.cpp
-	# dxf2svg/dxf2svg.cpp
-	# dxf2svg/read_dxf.cpp
-	# dxf2svg/test_dxf.cpp
-
-
 	# ------
 	# Header
 	db.h
diff --git a/src/extension/dxf2svg/GPL.txt b/src/extension/dxf2svg/GPL.txt
deleted file mode 100644
index 3912109b5..000000000
--- a/src/extension/dxf2svg/GPL.txt
+++ /dev/null
@@ -1,340 +0,0 @@
-		    GNU GENERAL PUBLIC LICENSE
-		       Version 2, June 1991
-
- Copyright (C) 1989, 1991 Free Software Foundation, Inc.
-                       51 Franklin St, 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.
-
-			    Preamble
-
-  The licenses for most software are designed to take away your
-freedom to share and change it.  By contrast, the GNU General Public
-License is intended to guarantee your freedom to share and change free
-software--to make sure the software is free for all its users.  This
-General Public License applies to most of the Free Software
-Foundation's software and to any other program whose authors commit to
-using it.  (Some other Free Software Foundation software is covered by
-the GNU Library General Public License instead.)  You can apply it to
-your programs, too.
-
-  When we speak of free software, we are referring to freedom, 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 or use pieces of it
-in new free programs; and that you know you can do these things.
-
-  To protect your rights, we need to make restrictions that forbid
-anyone to deny you these rights or to ask you to surrender the rights.
-These restrictions translate to certain responsibilities for you if you
-distribute copies of the software, or if you modify it.
-
-  For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must give the recipients all the rights that
-you have.  You must make sure that they, too, receive or can get the
-source code.  And you must show them these terms so they know their
-rights.
-
-  We protect your rights with two steps: (1) copyright the software, and
-(2) offer you this license which gives you legal permission to copy,
-distribute and/or modify the software.
-
-  Also, for each author's protection and ours, we want to make certain
-that everyone understands that there is no warranty for this free
-software.  If the software is modified by someone else and passed on, we
-want its recipients to know that what they have is not the original, so
-that any problems introduced by others will not reflect on the original
-authors' reputations.
-
-  Finally, any free program is threatened constantly by software
-patents.  We wish to avoid the danger that redistributors of a free
-program will individually obtain patent licenses, in effect making the
-program proprietary.  To prevent this, we have made it clear that any
-patent must be licensed for everyone's free use or not licensed at all.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.
-
-		    GNU GENERAL PUBLIC LICENSE
-   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-
-  0. This License applies to any program or other work which contains
-a notice placed by the copyright holder saying it may be distributed
-under the terms of this General Public License.  The "Program", below,
-refers to any such program or work, and a "work based on the Program"
-means either the Program or any derivative work under copyright law:
-that is to say, a work containing the Program or a portion of it,
-either verbatim or with modifications and/or translated into another
-language.  (Hereinafter, translation is included without limitation in
-the term "modification".)  Each licensee is addressed as "you".
-
-Activities other than copying, distribution and modification are not
-covered by this License; they are outside its scope.  The act of
-running the Program is not restricted, and the output from the Program
-is covered only if its contents constitute a work based on the
-Program (independent of having been made by running the Program).
-Whether that is true depends on what the Program does.
-
-  1. You may copy and distribute verbatim copies of the Program's
-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 give any other recipients of the Program a copy of this License
-along with the Program.
-
-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 Program or any portion
-of it, thus forming a work based on the Program, 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) You must cause the modified files to carry prominent notices
-    stating that you changed the files and the date of any change.
-
-    b) You must cause any work that you distribute or publish, that in
-    whole or in part contains or is derived from the Program or any
-    part thereof, to be licensed as a whole at no charge to all third
-    parties under the terms of this License.
-
-    c) If the modified program normally reads commands interactively
-    when run, you must cause it, when started running for such
-    interactive use in the most ordinary way, to print or display an
-    announcement including an appropriate copyright notice and a
-    notice that there is no warranty (or else, saying that you provide
-    a warranty) and that users may redistribute the program under
-    these conditions, and telling the user how to view a copy of this
-    License.  (Exception: if the Program itself is interactive but
-    does not normally print such an announcement, your work based on
-    the Program is not required to print an announcement.)
-
-These requirements apply to the modified work as a whole.  If
-identifiable sections of that work are not derived from the Program,
-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 Program, 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 Program.
-
-In addition, mere aggregation of another work not based on the Program
-with the Program (or with a work based on the Program) on a volume of
-a storage or distribution medium does not bring the other work under
-the scope of this License.
-
-  3. You may copy and distribute the Program (or a work based on it,
-under Section 2) in object code or executable form under the terms of
-Sections 1 and 2 above provided that you also do one of the following:
-
-    a) 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; or,
-
-    b) Accompany it with a written offer, valid for at least three
-    years, to give any third party, for a charge no more than your
-    cost of physically performing source distribution, a complete
-    machine-readable copy of the corresponding source code, to be
-    distributed under the terms of Sections 1 and 2 above on a medium
-    customarily used for software interchange; or,
-
-    c) Accompany it with the information you received as to the offer
-    to distribute corresponding source code.  (This alternative is
-    allowed only for noncommercial distribution and only if you
-    received the program in object code or executable form with such
-    an offer, in accord with Subsection b above.)
-
-The source code for a work means the preferred form of the work for
-making modifications to it.  For an executable work, 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 executable.  However, as a
-special exception, the source code 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.
-
-If distribution of executable or 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 counts as
-distribution of the source code, even though third parties are not
-compelled to copy the source along with the object code.
-
-  4. You may not copy, modify, sublicense, or distribute the Program
-except as expressly provided under this License.  Any attempt
-otherwise to copy, modify, sublicense or distribute the Program 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.
-
-  5. 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 Program or its derivative works.  These actions are
-prohibited by law if you do not accept this License.  Therefore, by
-modifying or distributing the Program (or any work based on the
-Program), you indicate your acceptance of this License to do so, and
-all its terms and conditions for copying, distributing or modifying
-the Program or works based on it.
-
-  6. Each time you redistribute the Program (or any work based on the
-Program), the recipient automatically receives a license from the
-original licensor to copy, distribute or modify the Program 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 to
-this License.
-
-  7. 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 Program at all.  For example, if a patent
-license would not permit royalty-free redistribution of the Program 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 Program.
-
-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.
-
-  8. If the distribution and/or use of the Program is restricted in
-certain countries either by patents or by copyrighted interfaces, the
-original copyright holder who places the Program 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.
-
-  9. The Free Software Foundation may publish revised and/or new versions
-of the 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 Program
-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 Program does not specify a version number of
-this License, you may choose any version ever published by the Free Software
-Foundation.
-
-  10. If you wish to incorporate parts of the Program into other free
-programs whose distribution conditions are different, 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
-
-  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
-FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
-OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
-PROVIDE THE PROGRAM "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 PROGRAM IS WITH YOU.  SHOULD THE
-PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
-REPAIR OR CORRECTION.
-
-  12. 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 PROGRAM 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 PROGRAM (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 PROGRAM TO OPERATE WITH ANY OTHER
-PROGRAMS), 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 Programs
-
-  If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these terms.
-
-  To do so, attach the following notices to the program.  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 program's name and a brief idea of what it does.>
-    Copyright (C) <year>  <name of author>
-
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
-
-    This program 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 General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program; if not, write to the Free Software
-    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
-
-
-Also add information on how to contact you by electronic and paper mail.
-
-If the program is interactive, make it output a short notice like this
-when it starts in an interactive mode:
-
-    Gnomovision version 69, Copyright (C) year name of author
-    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
-    This is free software, and you are welcome to redistribute it
-    under certain conditions; type `show c' for details.
-
-The hypothetical commands `show w' and `show c' should show the appropriate
-parts of the General Public License.  Of course, the commands you use may
-be called something other than `show w' and `show c'; they could even be
-mouse-clicks or menu items--whatever suits your program.
-
-You should also get your employer (if you work as a programmer) or your
-school, if any, to sign a "copyright disclaimer" for the program, if
-necessary.  Here is a sample; alter the names:
-
-  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
-  `Gnomovision' (which makes passes at compilers) written by James Hacker.
-
-  <signature of Ty Coon>, 1 April 1989
-  Ty Coon, President of Vice
-
-This General Public License does not permit incorporating your program into
-proprietary programs.  If your program is a subroutine library, you may
-consider it more useful to permit linking proprietary applications with the
-library.  If this is what you want to do, use the GNU Library General
-Public License instead of this License.
diff --git a/src/extension/dxf2svg/LGPL.txt b/src/extension/dxf2svg/LGPL.txt
deleted file mode 100644
index 8add30ad5..000000000
--- a/src/extension/dxf2svg/LGPL.txt
+++ /dev/null
@@ -1,504 +0,0 @@
-		  GNU LESSER GENERAL PUBLIC LICENSE
-		       Version 2.1, February 1999
-
- Copyright (C) 1991, 1999 Free Software Foundation, Inc.
-     51 Franklin St, 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 St, 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!
-
-
diff --git a/src/extension/dxf2svg/Makefile b/src/extension/dxf2svg/Makefile
deleted file mode 100644
index d0f06daf0..000000000
--- a/src/extension/dxf2svg/Makefile
+++ /dev/null
@@ -1,21 +0,0 @@
-objs = read_dxf.o entities.o entities2elements.o tables.o tables2svg_info.o blocks.o
-flags = -O1
-
-dxf2svg : dxf2svg.cpp $(objs)
-	g++ $(flags) -o dxf2svg dxf2svg.cpp $(objs)
-
-test : test_dxf.cpp $(objs)
-	g++ $(flags) -o test test_dxf.cpp $(objs)
-	
-%.o : %.cpp %.h 
-	g++ $(flags) -c $<
-	
-clean :
-	rm dxf2svg $(objs)
-
-install:
-	echo ****User intervention required****
-	echo
-	echo Copy dxf2svg executable and dxf2svg.inx to share/extension directory
-	echo Make sure file permissions are set correctly
-	
diff --git a/src/extension/dxf2svg/README b/src/extension/dxf2svg/README
deleted file mode 100644
index dbf98d2cc..000000000
--- a/src/extension/dxf2svg/README
+++ /dev/null
@@ -1,41 +0,0 @@
-26 Aug 05
-
-To use:
-I have only gotten this to work with Inkscape under linux (debian sarge).  But the converter works from the commandline if you want to test it otherwise.
-
-1.  Run make and copy dxf2svg to somewhere that is looked at by the PATH variable.  Or add the current directory to your path
-2.  Copy the dxf_import.inx to ../Inkscape/share/extensions
-3.  Run Inkscape
-4.  Click on open or import and the dxf option should be there
-
-I have compiled and then succesfully converted dxf files to svg files with the following setups
-
-WinXP Pro, Cygwin, g++ 3.3.3
-Debian Sarge, AMD x86_64, g++ 4.0.2
-RedHat(?), x86(?), g++ 3.2.3
-
-I have weakly tried and failed to compile using 
-Borland's free compiler bcc32
-MinGW
-
-What is supported:
-polylines, lines, arc, circles, blocks, text, and a little linetypes
-
-currently not supported but I hope will be in the near future (probably after Sept 05)
-layers, colors, trace, splines, dimentions
-
-If you don't have dxf files of your own, but would like to easily test some I would suggest a few places...
-
-www.newfocus.com -- look under optomechanics.  There are a variety of mounts and such that are posted in dxf and pdf
-www.thorlabs.com -- dido what I said about newfocus
-
-Free CAD programs:
-Windows -- A free and not too bad CAD program for windows is CadStd Lite.  It exports to dxf and has a variety of samples.
-Windows/Linux -- QCad is ok.  It has a lot of nice features but when I used it a year ago it would import dxf files but then you couldn't edit what was imported.  It is free but with a time limit.  My experience is that it can be a little annoying.  Because of that and others comments I didn't use their libraries for dxf reading.
-
-
-Matt Squires
-squiresm@colorado.edu
-
-27 Aug 05,  Fixed a fair number of bugs, and broken conversions.  LWPOLYLINE works now,  text rotation is ok but needs multiple transfomations to get it right, can read broken dxf files (w/o dxf EOF information)
-
diff --git a/src/extension/dxf2svg/aci2rgb.cpp b/src/extension/dxf2svg/aci2rgb.cpp
deleted file mode 100644
index 57e488bfc..000000000
--- a/src/extension/dxf2svg/aci2rgb.cpp
+++ /dev/null
@@ -1,114 +0,0 @@
-#include <iostream>
-#include <sstream>
-#include <string>
-
-
-char* RGB(double R, double G, double B);
-char* RGB(double R, double G, double B){
-	int r = int (R);
-	int g = int (G);
-	int b = int (B);
-	
-	char out[6];
-	char *chr_ptr;
-	string output;
-	stringstream oss;
-	
-	if (r < 16 ){
-		oss << 0;
-	}	
-	oss << hex << r;
-	
-	if (g < 16 ){
-		oss << 0;
-	}
-	oss << hex << g;
-	
-	if (b < 16 ){
-		oss << 0;
-	}
-	oss << hex << b;
-	
-	output = oss.str();
-	
-	for (int i = 0; i < 6; i++){
-		out[i] = output[i];
-	}
-	chr_ptr = &out;
-	return chr_ptr;
-}
-	
-
-float aci_to_rgb(int aci);
-
-float aci_to_rgb(int aci)
- {
- 	aci = abs(aci);			// hidden layers have negative color values
- 	if (aci<10 || aci>249)	// values of these ranges are special colors
- 	{
- 		switch (aci)
- 		{
- 			case 1: return RGB(255,0,0);		// basic colors
- 			case 2: return RGB(255,255,0);
- 			case 3: return RGB(0,255,0);
- 			case 4: return RGB(0,255,255);
- 			case 5: return RGB(0,0,255);
- 			case 6: return RGB(255,0,255);
- 			case 7: return RGB(255,255,255);
- 			case 8: return RGB(128,128,128);
- 			case 9: return RGB(192,192,192);
- 			case 250: return RGB(51,51,51);		// grey shades
- 			case 251: return RGB(91,91,91);
- 			case 252: return RGB(132,132,132);
- 			case 253: return RGB(173,173,173);
- 			case 254: return RGB(214,214,214);
- 			case 255: return RGB(255,255,255);
- 			case 256:							// "by layer"
- 			// Here you should decide how to handle "by layer" logical color.
- 			// Maybe it is a good idea to return a value like -1.
- 			// The outer code will find what is the color of the layer which
- 			// this entity belongs to.
- 				return -1;
- 		}
- 	}
- 	// for all the rest of ACI codes
- 	float H,S,L,	R,G,B;
- 	int remainder = aci % 10;					
- 	H = 1.5f * (aci - remainder - 10);	// hue in range 0-360
- 	S = ((aci % 2) ? 0.5f : 1.0f);		// odd colors have 50% of saturation, even - 100%
- 	// set lighteness, the last digit of aci code stands for this
- 	if (reminder == 0 || reminder == 1) L = 1.0f; 
- 	if (reminder == 2 || reminder == 3) L = 0.8f;
- 	if (reminder == 4 || reminder == 5) L = 0.6f;
- 	if (reminder == 6 || reminder == 7) L = 0.5f;
- 	if (reminder == 8 || reminder == 9) L = 0.3f;
- 	// here we have H,S,L set already
- 	// let's convert it to RGB, first without consideration of S and L
- 	if (H<=120)
- 	{
- 		R = (120-H)/60;
- 		G = H/60;
- 		B = 0;
- 	}
-  	if (H>120 && H<=240)
- 	{
- 		R = 0;
- 		G = (240-H)/60;
- 		B = (H-120)/60;
- 	}
- 	if (H>240 && H<=360)
- 	{
- 		R = (H-240)/60;
- 		G = 0;
- 		B = (360-H)/60;
- 	}
- 	R = min(R, 1);
- 	G = min(G, 1);
- 	B = min(B, 1);
- 	// influence of S and L
- 	float max_value = max(R,max(G,B));
- 	R = (max_value-S*(max_value-R)) * L * 255;
- 	G = (max_value-S*(max_value-G)) * L * 255;
- 	B = (max_value-S*(max_value-B)) * L * 255;
- 	return RGB(R,G,B);
- }
\ No newline at end of file
diff --git a/src/extension/dxf2svg/blocks.cpp b/src/extension/dxf2svg/blocks.cpp
deleted file mode 100644
index 36f2b9e7e..000000000
--- a/src/extension/dxf2svg/blocks.cpp
+++ /dev/null
@@ -1,83 +0,0 @@
-/*
- * Read Blocks from file and convert to vectors of entities
- *
- * Author:
- *   Matt Squires <squiresm@colorado.edu>
- *
- * Copyright (C) 2005 Matt Squires
- *
- * Released under GNU GPL and LGPL, read the file 'GPL.txt' and 'LGPL.txt' for details
- */
-
-
-#include"blocks.h"
-#include<iostream>
-
-block::block(std::vector< std::vector< dxfpair > > sections) : entities( sections ){
-	// Inherit most of the functionality of the entitites section
-	
-	basic_entity( sections[0] );
-	block_info( sections[0] );
-}
-
-char* block::name(char* string){
-	return( strcpy(string,block_name) );
-}
-
-
-void block::block_info( std::vector< dxfpair > info){
-	static char string[10000];
-	for (int i = 0; i < info.size(); i++){
-		switch( info[i].group_code ){
-			case 2: // Block name
-				strcpy( string," "); // Clear the string out
-				info[i].value_char(string);
-				strcpy(block_name,string);
-				break;
-		}
-	}
-}
-
-
-blocks::blocks(std::vector< std::vector< dxfpair > > sections){
-	// Read the main information about the entities section and then put it in the enetites class
-	char string[10000];
-	std::vector< dxfpair > single_line;
-	std::vector< std::vector< dxfpair > > ents;
-	ents.clear();
-	single_line.clear();
-	
-	int n_loop = sections.size();
-	n_loop--;
-	//for(int i = 0; i < (sections.size()-1); i++){ // It is odd but the last value seems to be bad so don't use it
-	// I am not really sure if I need the -1.  I needed it once upon a time to make things work but I don't have time to test it well right now 
-	// But sections.size() is an unsigned int so when you subtract 1 it becomes 4294967295 and tries to run the loop so work around that by making n_loop that is signed
-	for(int i = 0; i < n_loop; i++){ // It is odd but the last value seems to be bad so don't use it
-		sections[i][0].value_char(string);
-		ents.clear();  // First clear out the pline information
-		
-		
-		// Get everything from the start of the BLOCK designation to an ENDBLK value
-		if ( strncmp(string,"BLOCK",5) == 0 && (i < sections.size())){
-			do{
-				ents.push_back( sections[i] );
-				sections[++i][0].value_char(string);
-			}while( strncmp(string,"ENDBLK",6) != 0  && (i < sections.size()-1) );
-			blocks_blocks.push_back( block( ents ) );
-		}
-	}
-}
-
-block blocks::ret_block(char block_name[10000]){
-	int string_len = 0;
-	char temp[10000];
-	
-	for (int i = 0; i < blocks_blocks.size();i++){
-		string_len = strlen(blocks_blocks[i].name(temp));	
-		if (strncmp(blocks_blocks[i].name(temp),block_name,string_len) == 0 ) return blocks_blocks[i];	
-	}
-	return blocks_blocks[0];
-}
-
-
-
diff --git a/src/extension/dxf2svg/blocks.h b/src/extension/dxf2svg/blocks.h
deleted file mode 100644
index 27e0b8be1..000000000
--- a/src/extension/dxf2svg/blocks.h
+++ /dev/null
@@ -1,38 +0,0 @@
-/* Read Blocks from file and convert to vectors of entities
-Matt Squires
-Google SOC 2005
-*/
-
-#ifndef DXF_BLOCKS_H
-#define DXF_BLOCKS_H
-
-#include"read_dxf.h"
-#include"entities.h"
-#include<vector>
-
-
-class block : public entity, public entities{// : public entities, {
-	public:
-		block( std::vector< std::vector< dxfpair > > sections ); // Group all of the blocks as entities
-		char* name(char* string);
-		//void blocks_display();
-		
-	
-	protected:
-		char block_name[10000];
-		double rotation;
-		
-	private:
-		void block_info(std::vector< dxfpair > info);
-};
-
-class blocks{
-	public:
-		blocks(std::vector< std::vector< dxfpair > > sections);
-		block ret_block(char block_name[10000]);
-		
-	protected:
-		std::vector< block > blocks_blocks;
-};
-
-#endif
diff --git a/src/extension/dxf2svg/dxf2svg.cpp b/src/extension/dxf2svg/dxf2svg.cpp
deleted file mode 100644
index 4884ed3fe..000000000
--- a/src/extension/dxf2svg/dxf2svg.cpp
+++ /dev/null
@@ -1,99 +0,0 @@
-/*
- * Build a SVG from an dxf, will support conversion to Inkscape types
- *
- * Author:
- *   Matt Squires <squiresm@colorado.edu>
- *
- * Copyright (C) 2005 Matt Squires
- *
- * Released under GNU GPL and LGPL, read the file 'GPL.txt' and 'LGPL.txt' for details
- */
-
-
-#include<fstream>
-#include<iostream>
-#include"read_dxf.h"
-#include"entities.h"
-#include"blocks.h"
-#include"entities2elements.h"
-
-
-int main(int argc,char *argv[]){
-	// Later include options for different conversions like converting as much as possible into paths
-	
-	if(argc > 1){
-		double scaling = 90;  // converstion from in to pt
-		
-		// Read the DXF file
-		std::vector< std::vector< dxfpair > >  output, entities_info, tables_info, blocks_info;
-		//std::cout << "About to read file \n" << std::endl;
-		output =  dxf_get_sections(argv[1]);
-		//std::cout << "Finished reading file \n" << std::endl;
-		
-		entities_info = separate_parts(output[4]); // Entities is the 5th part of the file.
-		entities ents(entities_info); // Sort entities into their respective parts
-		
-		tables_info = separate_parts(output[2]); // Tables is the 3rd part of a dxf file.
-		tables tbls(tables_info);  // Sort the information in the tables
-			
-		blocks_info = separate_parts(output[3]); // Tables is the 4th part of a dxf file.
-		blocks blks(blocks_info);  // Sort the information in the tables
-		
-		
-		
-		// Get the various file informations
-		/*std::vector< polyline > plines = ents.ret_plines();
-		std::vector< lwpolyline > lwplines = ents.ret_lwplines();
-		std::vector< arc > arcs = ents.ret_arcs();
-		std::vector< circle > circs = ents.ret_circles();
-		std::vector< line > lns = ents.ret_lines();
-		std::vector< text > txts = ents.ret_texts();
-		std::vector< insert > ins = ents.ret_inserts();
-		*/
-		
-
-		std::vector< layer >  layers = tbls.ret_layers();
-		
-		char units[5] = "in";
-		char tmp_char[100000];
-		char layer_string[500];
-		// int ink = 1; // Assume for now there is no inkscape stuff to add extra
-		
-		/*if (ink < 1){
-			// Write a general svg header
-			std::cout << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\n\t\"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n<svg xmlns=\"http://www.w3.org/2000/svg\"\n\txmlns:xlink=\"http://www.w3.org/1999/xlink\">\n";
-			std::cout << "\tx=\"0.00000000\"\n\ty=\"0.00000000\"\n\twidth=\"744.09448\"\n\theight=\"-1052.3622\"" << std::endl;
-		}
-		else{*/
-			std::cout << "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>" << std::endl;
-			std::cout << "<!-- Created with dxf2svg -->" << std::endl;
-			std::cout << "<svg" << std::endl;
-   			std::cout << "\txmlns:dc=\"http://purl.org/dc/elements/1.1/\"" << std::endl;
-   			std::cout << "\txmlns:cc=\"http://web.resource.org/cc/\"" << std::endl;
-   			std::cout << "\txmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\"" << std::endl;
-   			std::cout << "\txmlns:svg=\"http://www.w3.org/2000/svg\"" << std::endl;
-   			std::cout << "\txmlns=\"http://www.w3.org/2000/svg\"" << std::endl;
-   			std::cout << "\txmlns:sodipodi=\"http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd\"" << std::endl;
-   			std::cout << "\txmlns:inkscape=\"http://www.inkscape.org/namespaces/inkscape\"" << std::endl;
-   			std::cout << "\t>" << std::endl;
-		//}
-
-		
-		// Now write SVG elements to file
-		if ( layers.size() < 1 ){
-			write_all(0, ents, tbls, blks, scaling, units, tmp_char);
-		}
-		else{
-			for (int i = 0; i < layers.size(); i++){
-				std::cout << "\t<g\n\t\tinkscape:label=\"" << layers[i].name(layer_string) <<  "\"\n\t\tinkscape:groupmode=\"layer\"\n\t\tid=\"layer" << i+1 << "\">" << std::endl;
-				write_by_layer(0, ents, tbls, blks, scaling, units, layers[i].name(layer_string), tmp_char);
-				std::cout << "\t</g>" << std::endl;
-			}
-		}
-		
-		// Close SVG
-		std::cout << "</svg>";
-	}
-	
-	return 0;
-}
diff --git a/src/extension/dxf2svg/dxf_input.inx b/src/extension/dxf2svg/dxf_input.inx
deleted file mode 100644
index b96274ade..000000000
--- a/src/extension/dxf2svg/dxf_input.inx
+++ /dev/null
@@ -1,16 +0,0 @@
-<inkscape-extension>
-    <name>DXF Input</name>
-    <id>org.inkscape.input.dxf</id>
-    <dependency type="executable" description="dxf2svg may come with Inkscape, but is also at http://dxf-svg-convert.sourceforge.net/" location="extensions">dxf2svg</dependency>
-    <dependency type="extension">org.inkscape.input.svg</dependency>
-    <input>
-        <extension>.dxf</extension>
-        <mimetype>image/x-svgz</mimetype>
-        <filetypename>AutoCAD DXF (*.dxf)</filetypename>
-        <filetypetooltip>Import AutoCAD's Document Exchange Format</filetypetooltip>
-        <output_extension>org.inkscape.output.svg</output_extension>
-    </input>
-    <script>
-        <command reldir="extensions">dxf2svg</command>
-    </script>
-</inkscape-extension>
diff --git a/src/extension/dxf2svg/dxf_input_windows.inx b/src/extension/dxf2svg/dxf_input_windows.inx
deleted file mode 100644
index 7dbe6a11b..000000000
--- a/src/extension/dxf2svg/dxf_input_windows.inx
+++ /dev/null
@@ -1,17 +0,0 @@
-<inkscape-extension>
-    <name>DXF Input</name>
-    <id>org.inkscape.input.dxf</id>
-    <dependency type="executable" description="dxf2svg may come with Inkscape, but is also at 
-http://dxf-svg-convert.sourceforge.net/" location="extensions">dxf2svg.exe</dependency>
-    <dependency type="extension">org.inkscape.input.svg</dependency>
-    <input>
-        <extension>.dxf</extension>
-        <mimetype>image/x-svgz</mimetype>
-        <filetypename>AutoCAD DXF (*.dxf)</filetypename>
-        <filetypetooltip>Import AutoCAD's Document Exchange Format</filetypetooltip>
-        <output_extension>org.inkscape.output.svg</output_extension>
-    </input>
-    <script>
-        <command reldir="extensions">dxf2svg.exe</command>
-    </script>
-</inkscape-extension>
diff --git a/src/extension/dxf2svg/entities.cpp b/src/extension/dxf2svg/entities.cpp
deleted file mode 100644
index 4e2f83ee7..000000000
--- a/src/extension/dxf2svg/entities.cpp
+++ /dev/null
@@ -1,996 +0,0 @@
-/*
- * Class for interpereting the entities found in a DXF file
- *
- * Author:
- *   Matt Squires <squiresm@colorado.edu>
- *
- * Copyright (C) 2005 Matt Squires
- *
- * Released under GNU GPL and LGPL, read the file 'GPL.txt' and 'LGPL.txt' for details
- */
-
-
-#include"entities.h"
-#include<iostream>
-#include<math.h>
-
-int detmine_entity(char* value){
-    // Common Elements as far as I am concerend
-    if ( strncmp(value,"POLYLINE",8) == 0 ) return 0;    
-    if ( strncmp(value,"ARC",3) == 0 ) return 1;    
-    if ( strncmp(value,"CIRCLE",6) == 0 ) return 2;
-    if ( strncmp(value,"LINE",4) == 0 ) return 3;
-    if ( strncmp(value,"SPLINE",6) == 0 ) return 4;
-    if ( strncmp(value,"XLINE",5) == 0 ) return 5;
-    if ( strncmp(value,"RAY",3) == 0 ) return 6;
-    if ( strncmp(value,"DIMENSION",9) == 0 ) return 7;
-    if ( strncmp(value,"ELLIPSE",7) == 0 ) return 8;
-    if ( strncmp(value,"INSERT",6) == 0 ) return 9;
-    if ( strncmp(value,"VERTEX",6) == 0 ) return 10;
-    if ( strncmp(value,"TEXT",4) == 0 ) return 11;
-    
-    // Less Common eletities as far as I am concerend
-    if ( strncmp(value,"3DSOLID",7) == 0 ) return 12;
-    if ( strncmp(value,"ACAD_PROXY_ENTITY",17) == 0 ) return 13;    
-    if ( strncmp(value,"ARCALIGNEDTEXT",14) == 0 ) return 14;
-    if ( strncmp(value,"ATTDEF",6) == 0 ) return 15;
-    if ( strncmp(value,"ATTRIB",6) == 0 ) return 16;
-    if ( strncmp(value,"BODY",4) == 0 ) return 17;
-    if ( strncmp(value,"HATCH",5) == 0 ) return 18;
-    if ( strncmp(value,"IMAGE",5) == 0 ) return 19;
-    if ( strncmp(value,"LEADER",6) == 0 ) return 20;
-    if ( strncmp(value,"LWPOLYLINE",10) == 0 ) return 21;
-    if ( strncmp(value,"MLINE",5) == 0 ) return 22;
-    if ( strncmp(value,"MTEXT",5) == 0 ) return 23;
-    if ( strncmp(value,"OLEFRAME",8) == 0 ) return 24;
-    if ( strncmp(value,"POINT",5) == 0 ) return 25;    
-    if ( strncmp(value,"REGION",6) == 0 ) return 26;
-    if ( strncmp(value,"RTEXT",5) == 0 ) return 27;
-    if ( strncmp(value,"SEQEND",6) == 0 ) return 28;
-    if ( strncmp(value,"SHAPE",5) == 0 ) return 29;
-    if ( strncmp(value,"SOLID",5) == 0 ) return 30;    
-    if ( strncmp(value,"3DFACE",6) == 0 ) return 31;
-    if ( strncmp(value,"TOLERANCE",9) == 0 ) return 32;
-    if ( strncmp(value,"TRACE",5) == 0 ) return 33;
-    if ( strncmp(value,"VIEWPORT",8) == 0 ) return 34;
-    if ( strncmp(value,"WIPEOUT",7) == 0 ) return 35;
-    else return -1;
-}
-
-
-void entity::basic_entity( std::vector< dxfpair > info){
-    // Extract all of the typical entity information (e.g. layer name, positions)
-    static char string[10000];
-    for (int i = 0; i < info.size(); i++){
-        switch( info[i].group_code ){
-            case 6:
-                strcpy( string," "); // Clear the string out
-                info[i].value_char(string);
-                strcpy(linetype,string);
-                break;
-            case 8:
-                strcpy( string," ");  // Clear the string out
-                info[i].value_char(string);
-                strcpy(layer,string);
-                break;
-            case 10:
-                info[i].value_char(string);
-                x = atof(string);
-                if ( x < min_x ){
-                    min_x = x;
-                }
-                if ( x > max_x ){
-                    max_x = x;
-                }                
-                break;
-            case 20:
-                info[i].value_char(string);
-                y = atof(string);
-                if ( y < min_y ){
-                    min_y = y;
-                }
-                if ( y > max_y ){
-                    max_y = y;
-                }
-                break;
-            case 30:
-                info[i].value_char(string);
-                z = atof(string);
-                break;
-        }
-    }
-    
-}
-
-void entity::entity_display(){
-    std::cout << "\tlayer = " << layer << "\n\tlinetype = " << linetype << "\n\tx = " << x << "\ty = " << y << "\tz = " << z << std::flush;
-}
-
-double entity::ret_x(){
-    return x;
-}
-
-double entity::ret_y(){
-    return y;
-}
-
-double entity::ret_z(){
-    return z;
-}
-
-
-char* entity::ret_layer_name(char* string){
-    return( strcpy(string,layer) );
-}
-
-char* entity::ret_ltype_name(char* string){
-    return( strcpy(string,linetype) );
-}
-
-double entity::ret_min_x(){
-    return min_x;
-}
-
-double entity::ret_max_x(){
-    return max_x;
-}
-
-double entity::ret_min_y(){
-    return min_y;
-}
-
-double entity::ret_max_y(){
-    return max_y;
-}
-
-void entity::test_coord(double x, double y){
-    if ( x < min_x ){
-        min_x = x;
-    }
-    if ( x > max_x ){
-        max_x = x;
-    }
-    if ( y < min_y ){
-        min_y = y;
-    }
-    if ( y > max_y ){
-        max_y = y;
-    }
-}
-
-
-void entity::reset_extents(){
-    min_x = -1e20;
-    max_x = 1e20;
-    min_y = -1e20;
-    max_y = 1e20;
-}
-
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// VERTEX
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-
-vertex::vertex( std::vector< dxfpair > info){
-    // Get the vertex information
-    
-    basic_entity( info );
-    static char string[10000];
-    for (int i = 0; i < info.size(); i++){
-        switch( info[i].group_code ){
-            case 42:
-                info[i].value_char(string);
-                bulge = atof(string);
-                break;
-        }
-    }    
-}
-
-double vertex::ret_bulge(){
-    return bulge;
-}
-
-void vertex::display(){
-    std::cout << "VERTEX\n";
-    std::cout << "\tx = " << x << "\ty = " << y << "\tz = " << z << "\tbulge = " << bulge << std::flush;
-}
-
-
-
-
-
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// POLYLINE
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-
-// The polyline is handled a little differently compared to the other entities because a POLYLINE is built from a bunch of VERTEX entities
-polyline::polyline( std::vector< std::vector< dxfpair > > sections ){
-    buldge = 0;
-    pline_flag = 0;
-    reset_extents();
-    // get the polyline information
-    basic_entity( sections[0] );
-    points.clear();
-    static char string[10000];
-    for (int i = 0; i < sections[0].size(); i++){
-        switch( sections[0][i].group_code ){
-            case 70:
-                sections[0][i].value_char(string);
-                pline_flag = atoi(string);
-                break;
-            case 40:
-                sections[0][i].value_char(string);
-                start_width = atoi(string);
-                break;
-            case 41:
-                sections[0][i].value_char(string);
-                end_width = atoi(string);
-                break;
-            case 75:
-                sections[0][i].value_char(string);
-                curves_flag = atoi(string);
-                break;
-        }
-    }
-    curves_flag = 0;
-    
-    // Now add the VERTEX entities to the POLYLINE
-    for (int i = 1; i < sections.size(); i++){
-        points.push_back( vertex( sections[i] ) );
-    }
-}
-
-
-std::vector< vertex > polyline::ret_points(){
-    return points;
-}
-
-double polyline::bulge(int point){
-    return points[point].ret_bulge();
-}
-
-double polyline::bulge_r(int point){
-    // Make sure we are not exceeding the bounds of the points vector
-    if (point >= (points.size()-1)) return 0;
-    
-    double dx = points[point+1].ret_x() - points[point].ret_x();
-    double dy = points[point+1].ret_y() - points[point].ret_y();
-    double bulge = points[point].ret_bulge();
-    double l = sqrt(dx*dx + dy*dy);
-    double r = fabs(l*(bulge*bulge+1)/bulge/4);
-    
-    return r;
-}
-
-double polyline::bulge_start_angle(int point){
-    // Make sure we are not exceeding the bounds of the points vector
-    if (point >= (points.size()-1))
-    {
-        return 0;
-    }
-    
-    double dx = points[point+1].ret_x() - points[point].ret_x();
-    double dy = points[point+1].ret_y() - points[point].ret_y();
-    double bulge = points[point].ret_bulge();
-    double l = sqrt(dx*dx + dy*dy);
-    double r = fabs(l*(bulge*bulge+1)/bulge/4);
-    
-    if (dx > 0)
-    {
-        sb *= -1; // Correct for different point ordering and bulge direction
-    }
-    
-    // Now calculate the angle 
-    double theta = asin(points[point].ret_x()/r);
-    if (dy < 0) theta = 6.2831853 - theta;  // The angle is greater than pi so fix this because max(asin) = pi
-    
-    return theta;    
-}
-
-double polyline::bulge_end_angle(int point){
-    // Make sure we are not exceeding the bounds of the points vector
-    if (point >= (points.size()-1))
-    {
-        return 0;
-    }
-    
-    double dx = points[point+1].ret_x() - points[point].ret_x();
-    double dy = points[point+1].ret_y() - points[point].ret_y();
-    double bulge = points[point].ret_bulge();
-    double l = sqrt(dx*dx + dy*dy);
-    double r = fabs(l*(bulge*bulge+1)/bulge/4);
-    
-    // Now calculate the angle 
-    double theta = asin(points[point+1].ret_x()/r);
-    if (dy < 0) theta = 6.2831853 - theta;  // The angle is greater than pi so fix this because max(asin) = pi
-    
-    return theta;    
-}
-
-bool polyline::is_closed(){
-    // pline-flag holds info about closed pline in the 1 bit.  The info is bit wise encoded so use bit wise operators
-    return bool(pline_flag&1);
-}
-
-void polyline::display(){
-    std::cout << "POLYLINE\n";
-    entity_display();
-    std::cout << std::endl;
-    for (int i = 0; i < points.size(); i++){
-        points[i].display();
-        std::cout << std::endl;
-    }
-    std::cout << std::endl;
-}
-
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// LWPOLYLINE
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-
-// The lwpolyline is different than the polyline because there are no vertex entities.  Use the same basic process as the polyline but parse it out differently
-lwpolyline::lwpolyline( std::vector< dxfpair > section ){
-    
-    // First break up the data into the same format that is used by the polyline entity
-    std::vector< std::vector< dxfpair > > sections;
-    std::vector< dxfpair > first;
-    std::vector< dxfpair > others;
-    
-    sections.clear();
-    first.clear();
-    others.clear();
-    
-    int gc;  // make a shorter name for group_code;
-    
-    int vertex_part;
-    int already_found = 0;
-    
-    for (int i = 0; i < section.size(); i++){
-        gc = section[i].group_code;
-        // Encode bitwise information to keep track of what has been found
-        vertex_part = 0;
-        if (gc == 10 ) vertex_part += 1;
-        if (gc == 20 ) vertex_part += 2;
-        if (gc == 30 ) vertex_part += 4;
-        if (gc == 40 ) vertex_part += 8;
-        if (gc == 41 ) vertex_part += 16;
-        if (gc == 42 ) vertex_part += 32;
-        //std::cout << "\n\nvertex_part = " << vertex_part << std::endl << "already_found = " << already_found << std::endl << "(vertex_part&already_found) = " << (vertex_part&already_found) << std::endl;
-        if ( vertex_part == 0 ){
-            // If header stuff has been found save it under first.
-            // I.E. in a polyline the first set of information is linetype and layer, all of what should be in here
-            first.push_back( section[i] );            
-        }
-        else if ( (vertex_part&already_found) == 0 ){
-            // Now work on what would be the vertex information
-            // New information is still being found so keep saving it
-            others.push_back( section[i] );    
-            //std::cout << "add to others" << std::endl;
-            already_found += vertex_part;  // Keep track of what has been found            
-        }
-        else{
-            sections.push_back( others );
-            //std::cout << "sections.size() = " << sections.size() << std::endl;
-            // Now clear the information out and start over
-            others.clear();
-            others.push_back( section[i] );
-            already_found = vertex_part;            
-        }
-    }
-    
-    // Now put on the last data that was found 
-    if (!others.empty()){
-        sections.push_back(others);
-    }
-    
-    reset_extents();
-    basic_entity( first );
-    points.clear();
-    static char string[10000];
-    buldge = 0;
-    pline_flag = 0;
-    curves_flag = 0;
-    for (int i = 0; i < first.size(); i++){
-        switch( sections[0][i].group_code ){
-            case 70:
-                first[i].value_char(string);
-                pline_flag = atoi(string);
-                break;
-            case 40:
-                first[i].value_char(string);
-                start_width = atoi(string);
-                break;
-            case 41:
-                first[i].value_char(string);
-                end_width = atoi(string);
-                break;
-            case 75:
-                first[i].value_char(string);
-                curves_flag = atoi(string);
-                break;
-        }
-    }
-    // Now add the VERTEX entities to the POLYLINE
-    for (int i = 0; i < sections.size(); i++){
-        points.push_back( vertex( sections[i] ) );
-    }
-}
-
-
-
-std::vector< vertex > lwpolyline::ret_points(){
-    return points;
-}
-
-
-double lwpolyline::bulge(int point){
-    return points[point].ret_bulge();
-}
-
-double lwpolyline::bulge_r(int point){
-    // Make sure we are not exceeding the bounds of the points vector
-    if (point >= (points.size()-1)) return 0;
-    
-    double dx = points[point+1].ret_x() - points[point].ret_x();
-    double dy = points[point+1].ret_y() - points[point].ret_y();
-    double bulge = points[point].ret_bulge();
-    double l = sqrt(dx*dx + dy*dy);
-    double r = fabs(l*(bulge*bulge+1)/bulge/4);
-    
-    return r;
-}
-
-double lwpolyline::bulge_start_angle(int point){
-    // Make sure we are not exceeding the bounds of the points vector
-    if (point >= (points.size()-1)) return 0;
-    
-    double dx = points[point+1].ret_x() - points[point].ret_x();
-    double dy = points[point+1].ret_y() - points[point].ret_y();
-    double bulge = points[point].ret_bulge();
-    double l = sqrt(dx*dx + dy*dy);
-    double r = fabs(l*(bulge*bulge+1)/bulge/4);
-    
-    // Now calculate the angle 
-    double theta = asin(points[point].ret_x()/r);
-    if (dy < 0) theta = 6.2831853 - theta;  // The angle is greater than pi so fix this because max(asin) = pi
-    
-    return theta;    
-}
-
-double lwpolyline::bulge_end_angle(int point){
-    // Make sure we are not exceeding the bounds of the points vector
-    if (point >= (points.size()-1)) return 0;
-    
-    double dx = points[point+1].ret_x() - points[point].ret_x();
-    double dy = points[point+1].ret_y() - points[point].ret_y();
-    double bulge = points[point].ret_bulge();
-    double l = sqrt(dx*dx + dy*dy);
-    double r = fabs(l*(bulge*bulge+1)/bulge/4);
-    
-    // Now calculate the angle 
-    double theta = asin(points[point+1].ret_x()/r);
-    if (dy < 0) theta = 6.2831853 - theta;  // The angle is greater than pi so fix this because max(asin) = pi
-    
-    return theta;    
-}
-
-bool lwpolyline::is_closed(){
-    // pline-flag holds info about closed pline in the 1 bit.  The info is bit wise encoded so use bit wise operators
-    return bool(pline_flag&1);
-}
-
-void lwpolyline::display(){
-    std::cout << "lwpolyline\n";
-    entity_display();
-    std::cout << std::endl;
-    for (int i = 0; i < points.size(); i++){
-        points[i].display();
-        std::cout << std::endl;
-    }
-    std::cout << std::endl;
-}
-
-
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// ARC
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-
-arc::arc( std::vector< dxfpair > info){
-    
-    reset_extents();
-    basic_entity( info );
-    static char string[10000];
-    for (int i = 0; i < info.size(); i++){
-        switch( info[i].group_code ){
-            case 40:
-                info[i].value_char(string);
-                radius = atof(string);
-                test_coord(x+radius,y+radius);
-                test_coord(x-radius,y-radius);
-                break;
-            case 50:
-                info[i].value_char(string);
-                start_angle = atof(string);
-                break;
-            case 51:
-                info[i].value_char(string);
-                end_angle = atof(string);
-                break;
-            default:
-                break;
-        }
-    }
-}
-
-double arc::ret_radius(){
-    return radius;
-}
-
-
-double arc::ret_srt_ang(){
-    return start_angle;
-}
-
-
-double arc::ret_end_ang(){
-    return end_angle;
-}
-
-
-void arc::display(){
-    std::cout << "ARC\n";
-    entity_display();
-    std::cout << "\n\tradius = " << radius << "\tstart_angle = " << start_angle << "end_angle = " << end_angle << std::flush;
-}
-
-
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// CIRCLE
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-
-circle::circle( std::vector< dxfpair > info){
-    
-    reset_extents();
-    basic_entity( info );
-    static char string[10000];
-    for (int i = 0; i < info.size(); i++){
-        switch( info[i].group_code ){
-            case 40:
-                info[i].value_char(string);
-                radius = atof(string);
-                test_coord(x+radius,y+radius);
-                test_coord(x-radius,y-radius);
-                break;
-        }
-    }
-}
-
-void circle::display(){
-    std::cout << "CIRCLE\n";
-    entity_display();
-    std::cout << "\n\tradius = " << radius << std::flush;
-}
-
-
-double circle::ret_radius(){
-    return radius;
-}
-
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// LINE
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-
-line::line( std::vector< dxfpair > info){
-    
-    reset_extents();
-    basic_entity( info );
-    static char string[10000];
-    for (int i = 0; i < info.size(); i++){
-        switch( info[i].group_code ){
-            case 11:
-                info[i].value_char(string);
-                xf = atof(string);
-                break;
-            case 21:
-                info[i].value_char(string);
-                yf = atof(string);
-                break;
-            case 31:
-                info[i].value_char(string);
-                zf = atof(string);
-                break;
-        }
-    }
-    test_coord(xf,yf);
-        
-}
-
-void line::display(){
-    std::cout << "LINE\n";
-    entity_display();
-    std::cout << "\n\txf = " << xf << "\tyf = " << yf << "\tzf = " << zf << std::flush;
-}
-
-
-double line::ret_xf(){
-    return xf;
-}
-
-double line::ret_yf(){
-    return yf;
-}
-
-double line::ret_zf(){
-    return zf;
-}
-
-
-
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// TEXT
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-text::text( std::vector< dxfpair > info){
-    
-    reset_extents();
-    basic_entity( info );
-    static char string[10000];
-    for (int i = 0; i < info.size(); i++){
-        switch( info[i].group_code ){
-            case 1:
-                info[i].value_char(dxf_text); // directly copy the text into a string
-                break;
-            case 40:
-                info[i].value_char(string);
-                text_height = atof(string);
-                break;
-            case 50:
-                info[i].value_char(string);
-                text_rotation = atof(string);
-                break;
-        }
-    }
-}
-
-char * text::ret_text(char *string){
-    return( strcpy(string,dxf_text) );
-}
-
-double text::ret_txt_ht(){
-    return text_height;
-}
-
-double text::ret_txt_rot(){
-    return text_rotation;
-}
-
-void text::display(){
-    char tmp[10000];
-    std::cout << "TEXT\n";
-    entity_display();
-    std::cout << "\ndxf_text = " << ret_text(tmp) << std::flush;
-}
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// INSERT
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-insert::insert( std::vector< dxfpair > info){
-    ret_x_sf = 0;
-    ret_y_sf = 0;
-    ret_z_sf = 0;
-    ret_rotation = 0;
-    
-    basic_entity( info );
-    static char string[10000];
-    for (int i = 0; i < info.size(); i++){
-        switch( info[i].group_code ){
-            case 2:
-                info[i].value_char(block_name); // directly copy the text into a string
-                break;
-            case 41:
-                info[i].value_char(string);
-                x_scale_factor = atof(string);
-                break;
-            case 42:
-                info[i].value_char(string);
-                y_scale_factor = atof(string);
-                break;
-            case 43:
-                info[i].value_char(string);
-                z_scale_factor = atof(string);
-                break;
-            case 50:
-                info[i].value_char(string);
-                rotation = atof(string);
-                break;
-        }
-    }
-}
-
-
-char * insert::name(char *string){
-    return( strcpy(string,block_name) );
-}
-
-
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// entities
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-    
-
-
-entities::entities(std::vector< std::vector< dxfpair > > sections){
-    // Read the main information about the entities section and then put it in the enetites class
-    int value;
-    char string[10000];
-    std::vector< dxfpair > single_line;
-    std::vector< std::vector< dxfpair > > pline;
-    pline.clear();
-    single_line.clear();
-    
-    for(int i = 0; i < sections.size(); i++){
-        sections[i][0].value_char(string);
-        value = detmine_entity(string);
-        switch( value ){
-            case 0:
-                // Get everything from the start of the polyline designation to an SEQEND value
-                pline.clear();  // First clear out the pline information
-                do{
-                    pline.push_back( sections[i] );
-                    sections[++i][0].value_char(string);
-                }while( strncmp(string,"SEQEND",6) != 0 );
-                ents_polyline.push_back( polyline( pline ) );
-                break;
-            
-            case 1:
-                // ARC
-                ents_arc.push_back( arc( sections[i] ) );
-                break;
-                
-            case 2:
-                // CIRCLE
-                ents_circle.push_back( circle( sections[i] ) );
-                break;
-                
-            case 3:
-                // LINE
-                ents_line.push_back( line( sections[i] ) );
-                break;
-            case 11:
-                // TEXT
-                ents_text.push_back( text( sections[i] ) );
-                break;
-            case 21:
-                // LWPOLYLINE
-                ents_lwpolyline.push_back( lwpolyline( sections[i] ) );
-            case 9:
-                // INSERT
-                ents_insert.push_back( insert( sections[i] ) );
-            
-            //default:
-                // Nothing here
-        }
-        
-    }
-    
-}
-
-
-// Maybe all of this could be turned into fewer function by using templates, but no time right now.  MBS
-
-std::vector< polyline > entities::ret_plines(){
-    std::vector< polyline > pls;
-    pls.clear();
-    for(int i = 0; i < ents_polyline.size();i++){
-        pls.push_back( ents_polyline[i] );
-    }
-    return pls;
-}
-
-std::vector< lwpolyline > entities::ret_lwplines(){
-    std::vector< lwpolyline > lwpls;
-    lwpls.clear();
-    for(int i = 0; i < ents_lwpolyline.size();i++){
-        lwpls.push_back( ents_lwpolyline[i] );
-    }
-    return lwpls;
-}
-
-
-std::vector< arc > entities::ret_arcs(){
-    std::vector< arc > a;
-    a.clear();
-    for(int i = 0; i < ents_arc.size();i++){
-        a.push_back( ents_arc[i] );
-    }
-    return a;
-}
-
-std::vector< circle > entities::ret_circles(){
-    std::vector< circle > circs;
-    circs.clear();
-    for(int i = 0; i < ents_circle.size();i++){
-        circs.push_back( ents_circle[i] );
-    }
-    return circs;
-}
-
-
-std::vector< line > entities::ret_lines(){
-    std::vector< line > lns;
-    lns.clear();
-    for(int i = 0; i < ents_line.size();i++){
-        lns.push_back( ents_line[i] );
-    }
-    return lns;
-}
-
-
-std::vector< text > entities::ret_texts(){
-    std::vector< text > txts;
-    txts.clear();
-    for(int i = 0; i < ents_text.size();i++){
-        txts.push_back( ents_text[i] );
-    }
-    return txts;
-}
-
-
-std::vector< insert > entities::ret_inserts(){
-    std::vector< insert > ins;
-    ins.clear();
-    for(int i = 0; i < ents_insert.size();i++){
-        ins.push_back( ents_insert[i] );
-    }
-    return ins;
-}
-
-
-
-// Overload the return function to depend on the layer
-std::vector< polyline > entities::ret_plines(char * layer){
-    char temp[10000];
-    std::vector< polyline > pls;
-    pls.clear();
-    
-    for(int i = 0; i < ents_polyline.size();i++){
-        if ( strcmp( layer,ents_polyline[i].ret_layer_name(temp) ) == 0 ){
-            pls.push_back( ents_polyline[i] );
-        }
-    }
-    return pls;
-}
-
-
-std::vector< lwpolyline > entities::ret_lwplines(char * layer){
-    char temp[10000];
-    std::vector< lwpolyline > lwpls;
-    lwpls.clear();
-    
-    for(int i = 0; i < ents_lwpolyline.size();i++){
-        if ( strcmp( layer,ents_lwpolyline[i].ret_layer_name(temp) ) == 0 ){
-            lwpls.push_back( ents_lwpolyline[i] );
-        }
-    }
-    return lwpls;
-}
-
-
-std::vector< circle > entities::ret_circles(char * layer){
-    char temp[10000];
-    std::vector< circle > circs;
-    circs.clear();
-    
-    for(int i = 0; i < ents_circle.size();i++){
-        if ( strcmp( layer,ents_circle[i].ret_layer_name(temp) ) == 0 ){
-            circs.push_back( ents_circle[i] );
-        }
-    }
-    return circs;
-}
-
-
-std::vector< line > entities::ret_lines(char * layer){
-    char temp[10000];
-    std::vector< line > lns;
-    lns.clear();
-    
-    for(int i = 0; i < ents_line.size();i++){
-        if ( strcmp( layer,ents_line[i].ret_layer_name(temp) ) == 0 ){
-            lns.push_back( ents_line[i] );
-        }
-    }
-    return lns;
-}
-
-
-std::vector< text > entities::ret_texts(char * layer){
-    char temp[10000];
-    std::vector< text > txts;
-    txts.clear();
-    
-    for(int i = 0; i < ents_text.size();i++){
-        if ( strcmp( layer,ents_text[i].ret_layer_name(temp) ) == 0 ){
-            txts.push_back( ents_text[i] );
-        }
-    }
-    return txts;
-}
-
-
-/*std::vector< ellipse > entities::ret_ellipses(char * layer){
-    char temp[10000];
-    std::vector< polyline > pls;
-    pls.clear();
-    
-    for(int i = 0; i < ents_polyline.size();i++){
-        if ( strcmp( layer,ents_polyline[i].ret_layer_name(temp) ) == 0 ){
-            pls.push_back( ents_polyline[i] );
-        }
-    }
-    return pls;
-}*/
-
-
-std::vector< arc > entities::ret_arcs(char * layer){
-    char temp[10000];
-    std::vector< arc > a;
-    a.clear();
-    
-    for(int i = 0; i < ents_arc.size();i++){
-        if ( strcmp( layer,ents_arc[i].ret_layer_name(temp) ) == 0 ){
-            a.push_back( ents_arc[i] );
-        }
-    }
-    return a;
-}
-
-
-std::vector< insert > entities::ret_inserts(char * layer){
-    char temp[10000];
-    std::vector< insert > ins;
-    ins.clear();
-    
-    for(int i = 0; i < ents_insert.size();i++){
-        if ( strcmp( layer,ents_insert[i].ret_layer_name(temp) ) == 0 ){
-            ins.push_back( ents_insert[i] );
-        }
-    }
-    return ins;
-}
-
-
-
-
-void entities::display_all(){
-    for (int i = 0; i < ents_polyline.size(); i++){
-        ents_polyline[i].display();
-    }
-    std::cout << std::endl;
-    for (int i = 0; i < ents_lwpolyline.size(); i++){
-        ents_lwpolyline[i].display();
-    }
-    std::cout << std::endl;
-    for (int i = 0; i < ents_circle.size(); i++){
-        ents_circle[i].display();
-    }
-    std::cout << std::endl;
-    for (int i = 0; i < ents_text.size(); i++){
-        ents_text[i].display();
-    }
-}
-
-
diff --git a/src/extension/dxf2svg/entities.h b/src/extension/dxf2svg/entities.h
deleted file mode 100644
index 3afd949b0..000000000
--- a/src/extension/dxf2svg/entities.h
+++ /dev/null
@@ -1,256 +0,0 @@
-/*  Class for interpereting the entities found in a DXF file
-Matt Squires
-Google SOC
-2 July 05
-*/
-
-#ifndef DXF_ENTITIES_H
-#define DXF_ENTITIES_H
-
-#include"read_dxf.h"
-#include<vector>
-
-
-
-
-class entity{
-    public:
-        void basic_entity( std::vector< dxfpair > info); // Extract all of the typical entity information (e.g. layer name, positions)
-        void entity_display();
-        double ret_x();
-        double ret_y();
-        double ret_z();
-        char* ret_layer_name(char* string);
-        char* ret_ltype_name(char* string);
-        double ret_min_x();
-        double ret_max_x();
-        double ret_min_y();
-        double ret_max_y();    
-        
-    
-    protected:
-        char layer[10000];
-        char linetype[10000];
-        double x;
-        double y;
-        double z;
-        double min_x;
-        double max_x;
-        double min_y;
-        double max_y;
-        void reset_extents();
-        void test_coord(double x, double y);
-};
-
-
-
-
-
-class vertex : public entity {
-    public:
-        vertex( std::vector< dxfpair > info);
-        void display();
-        double ret_bulge();
-    
-    private:
-        double bulge;
-};
-
-
-
-
-
-class polyline : public entity {
-    public:
-        polyline( std::vector< std::vector< dxfpair > > sections );
-        std::vector< vertex > ret_points();
-        double bulge(int point);
-        double bulge_r(int point);
-        double bulge_start_angle(int point);
-        double bulge_end_angle(int point);
-        bool is_closed();
-        void display();
-    
-    private:
-        double buldge;
-        int pline_flag; // 70
-        double start_width; // 40
-        double end_width; // 41
-        int curves_flag;
-        std::vector< vertex > points;
-};
-
-class lwpolyline : public entity {
-    public:
-        lwpolyline( std::vector< dxfpair > section );
-        std::vector< vertex > ret_points();
-        double bulge(int point);
-        double bulge_r(int point);
-        double bulge_start_angle(int point);
-        double bulge_end_angle(int point);
-        bool is_closed();
-        void display();
-    
-    private:
-        double buldge;
-        int pline_flag; // 70
-        double start_width; // 40
-        double end_width; // 41
-        int curves_flag;
-        std::vector< vertex > points;
-};
-
-class arc : public entity {
-    public:
-        arc( std::vector< dxfpair > info);
-        double ret_radius();
-        double ret_srt_ang();
-        double ret_end_ang();
-        void display();
-    
-    private:
-        double radius;
-        double start_angle;
-        double end_angle;
-};
-
-
-
-
-class circle : public entity {
-    public:
-        circle( std::vector< dxfpair > info);
-        void display();
-        double ret_radius();
-    
-    private:
-        double radius;
-};
-
-
-class line : public entity {
-    public:
-        line( std::vector< dxfpair > info);
-        void display();
-        double ret_xf();
-        double ret_yf();
-        double ret_zf();
-    
-    private:
-        double xf;
-        double yf;
-        double zf;
-};
-
-class ellipse : public entity {
-    public:
-        ellipse( std::vector< dxfpair > info);
-        void display();
-        double ret_x_ma;
-        double ret_y_ma;
-        double ret_z_ma;
-        double ret_ratio;
-        double ret_start_p;
-        double ret_end_p;
-        
-    
-    private:
-        double x_major_axis;
-        double y_major_axis;
-        double z_major_axis;
-        double ratio;
-        double start_param;
-        double end_param;
-};
-
-
-
-class text : public entity {
-    public:
-        text( std::vector< dxfpair > info);
-        void display();
-        char * ret_text(char *string);
-        double ret_txt_ht();
-        double ret_txt_rot();
-    
-    private:
-        char dxf_text[10000];
-        double text_height; // dxf 40
-        double text_rotation; //dxf 50
-};
-
-
-class insert : public entity {
-    public:
-        insert( std::vector< dxfpair > info);
-        void display();
-        char* name(char* string);
-        double ret_x_sf;
-        double ret_y_sf;
-        double ret_z_sf;
-        double ret_rotation;        
-    
-    private:
-        char block_name[10000];
-        double x_scale_factor;
-        double y_scale_factor;
-        double z_scale_factor;
-        double rotation;
-};
-
-
-
-
-
-
-class entities{
-    // Well I said that I would only use STL containers internally, but I would have to use a dynamically linked list, and I haven't done for a long time soo STL is my crutch.
-    // I also think that there are others in my same boat that prefer stl containers because they are much easier to use
-    public:
-        entities(std::vector< std::vector< dxfpair > > sections); // Put the various entities into their respective vectors
-        void display_all();
-        std::vector< polyline > ret_plines();
-        std::vector< circle > ret_circles();
-        std::vector< line > ret_lines();
-        std::vector< text > ret_texts();
-        std::vector< ellipse > ret_ellipses();
-        std::vector< arc > ret_arcs();
-        std::vector< lwpolyline > ret_lwplines();
-        std::vector< insert > ret_inserts();
-        // Overload the return function to depend on the layer
-        std::vector< polyline > ret_plines(char * layer);
-        std::vector< circle > ret_circles(char * layer);
-        std::vector< line > ret_lines(char * layer);
-        std::vector< text > ret_texts(char * layer);
-        std::vector< ellipse > ret_ellipses(char * layer);
-        std::vector< arc > ret_arcs(char * layer);
-        std::vector< lwpolyline > ret_lwplines(char * layer);
-        std::vector< insert > ret_inserts(char * layer);
-        
-        int plines_size();
-        int circles_size();
-        int lines_size();
-        int texts_size();
-        
-        
-        
-    private:
-        void add_polyline(polyline pline);
-        void add_circle(circle circ);
-        void add_line(line ln);
-        
-        std::vector< polyline > ents_polyline;
-        std::vector< arc > ents_arc;
-        std::vector< circle > ents_circle;
-        std::vector< line > ents_line;
-        std::vector< ellipse > ents_ellipse;
-        std::vector< text > ents_text;
-        std::vector< lwpolyline > ents_lwpolyline;
-        std::vector< insert > ents_insert;
-        
-        
-};
-
-
-
-#endif
diff --git a/src/extension/dxf2svg/entities2elements.cpp b/src/extension/dxf2svg/entities2elements.cpp
deleted file mode 100644
index 8a17a0d84..000000000
--- a/src/extension/dxf2svg/entities2elements.cpp
+++ /dev/null
@@ -1,678 +0,0 @@
-/*
- * Code for converting dxf entities to SVG elements
- * There are multiple ways for converting different items
- * If possible most DXF enetities will be converted to paths because that is the most flexable object
- *
- * Author:
- *   Matt Squires <squiresm@colorado.edu>
- *
- * Copyright (C) 2005 Matt Squires
- *
- * Released under GNU GPL and LGPL, read the file 'GPL.txt' and 'LGPL.txt' for details
- */
-
-
-
-/* 
-
-Matt Squires
-SoC 2005
-
-*/
-
-#include "entities2elements.h"
-#include "tables2svg_info.h"
-#include <iostream>
-#include <math.h>
-#include <string.h>
-#include <stdlib.h>
-// The names indicate the DXF entitiy first and the SVG element last
-
-// Common elements
-char* to_arc(double bulge, double r, double start_ang, double end_ang, int precision,char* delim, char * units, double scaling, char *out){
-	// This is used for arcs, polylines, and lwpolylines
-	char temp[50];
-	
-	// Assume that we are adding to the input and not starting over
-	strcat(out," A ");
-	// For arcs there is only one radius
-	strcat(out,gcvt(scaling*r,precision,temp) );
-	strcat(out,",");
-	strcat(out,gcvt(scaling*r,precision,temp) );
-	
-	strcat(out," 0"); // For arc assume no x-axis rotation.  That seems to apply to elipse elements only
-	// Determine if it is a large arc
-	if ( (end_ang > start_ang) && ( (end_ang - start_ang) > 180) ){
-		//strcat(out," 1,0 "); // Large arc flag...Always use a zero sweep flag
-		strcat(out," 1, "); // Large arc flag...Always use a zero sweep flag
-	}
-	else{
-		//strcat(out," 0,0 "); // Small arc flag...Always use a zero sweep flag
-		strcat(out," 0,");
-	}
-	// This may be easier if I allow r to be plus and minus, but for now this works
-	if (bulge > 0){
-		strcat(out,"0 ");
-	}
-	else{
-		strcat(out,"1 ");
-	}
-}
-
-// Build Coordinate
-void coord(entity *ent, int precision,char* delim, char * units, double scaling, char *out){
-	// Pairs of coords with units will be used so often build a function build a dedicated function for returning such
-	
-	char temp[20];
-	if (units != NULL) scaling = 1;  // If units have been defined then ignore the scaling parameter
-	strcat(out, gcvt(scaling*ent->ret_x(),precision,temp) );  // There must be a better function for double to ascii conversion that is defined in most libraries
-	if (units != NULL) strcat(out, units);
-	strcat(out, delim);
-	strcat(out, gcvt(-scaling*ent->ret_y(),precision,temp) ); // Because SVG has a the Y-axis pointed down multiply by -1
-	if (units != NULL) strcat(out, units);
-	strcat(out, " ");
-}
-
-// DXF Polyline -> SVG
-// General function for the conversion of a pline to a SVG element.  Very similar functions just make accomidations for parts that may not be supported
-void pline2svg(polyline pline, int type, int precision, char * units, double scaling, tables plot_info, char *out){
-	// 0 is pline2path
-	// 1 is pline2pline
-	// 2 is pline2polygon
-	
-	
-	char delim[2];
-	
-	std::vector< vertex >::iterator vver_iter;
-	std::vector< vertex > points = pline.ret_points();
-	
-	if (type < 1){
-		// Put the first Move To at the first, everything else will be a lineto
-		strcpy(delim," ");
-		strcat(out, "M ");
-		coord( &points[0], precision, delim, units, scaling, out ); 
-		double prev_mag_bulge = sqrt(pow(points[0].ret_bulge(),2));  // Because the bulge value can be positive or negative calculate the magnitude
-		if ( prev_mag_bulge > pow(0.1,precision) ){
-				to_arc(pline.bulge(0), pline.bulge_r(0), pline.bulge_start_angle(0), pline.bulge_end_angle(0), precision, delim, units, scaling, out);
-		}
-		for (int i = 1; i < points.size(); i++){
-			if ( prev_mag_bulge < pow(0.1,precision) ){
-				// If the previous point was a bulge then don't use a line to
-				strcat(out, "L ");
-			}
-			coord( &points[i], precision, delim, units, scaling, out ); 
-			// If bulge > some precsion then add bulge
-			double mag_bulge = sqrt(pow(points[i].ret_bulge(),2));
-			if ( (mag_bulge > pow(0.1,precision))  && (i < (points.size() - 1) )){
-				to_arc(pline.bulge(i), pline.bulge_r(i), pline.bulge_start_angle(i), pline.bulge_end_angle(i), precision, delim, units, scaling, out);
-			}
-			prev_mag_bulge = mag_bulge;
-		}
-		if ( pline.is_closed() ){
-			strcat(out,"z");
-		}
-		strcat(out,"\" ");
-	}
-	else{
-		strcpy(delim,",");		
-		for (int i = 0; i < points.size(); i++){
-			coord( &points[i], precision, delim, NULL, scaling, out ); 
-			// If bulge > some precsion then add bulge	
-		}
-		// if the element is a SVG::pline and the DXF::pline is closed then simulate by adding an extra point
-		if ( (type == 1) && pline.is_closed() ){
-			coord( &points[0], precision, delim, NULL, scaling, out ); 
-		}
-	}	
-		
-}
-
-char* pline2path(polyline pline, char * units, double scaling, tables plot_info){
-	// Convert a dxf polyline to a SVG path.  This is the closest conversion of the DXF polyline to an SVG element
-	char *out_ptr;
-	char out[10000] = "<path d=\"";
-	entity *ent_ptr = &pline;
-	char temp[20];
-	int precision = 6;
-	
-	pline2svg(pline, 0, precision, units, scaling, plot_info, out);
-	// Add some line information
-	strcat(out,"fill=\"none\" stroke=\"black\" stroke-width=\"1\" ");
-	pattern2dasharray(plot_info.ret_ltype( ent_ptr->ret_ltype_name(temp),ent_ptr->ret_layer_name(temp) ), precision, scaling, out);  // Add the linetype information
-	
-	strcat(out," />");
-	out_ptr = out;
-	return out_ptr;	
-}
-
-char* pline2pline(polyline pline, char * units, double scaling, tables plot_info){
-	// Convert a dxf polyline to a SVG polyline.  The conversion is not 1:1 because the SVG pline doesn't support closed objects or curves
-	entity *ent_ptr = &pline;
-	char temp[2000];
-	int precision = 6;
-	
-	char out[10000] = "<polyline fill=\"none\" stroke=\"black\" stroke-width=\"1\" ";
-	ltype linfo = plot_info.ret_ltype(ent_ptr->ret_ltype_name(temp), ent_ptr->ret_layer_name(temp));
-	pattern2dasharray(linfo, precision, scaling, out);  // Add the linetype information
-	//strcpy(temp," ");
-	
-	strcat(out,"points=\"");
-	
-	//strcat(out,"<polyline fill=\"none\" stroke=\"black\" stroke-width=\"1\" points=\"");
-	pline2svg(pline, 1, precision, units, scaling, plot_info, out);
-	// Add some line information
-	// if the DXF pline is closed then add an extra point
-	
-	strcat(out,"\"/>");
-	char *out_ptr = out;
-	return out_ptr;
-}
-char* pline2polygon(polyline pline, char * units, double scaling, tables plot_info){
-	// Convert a dxf polyline to a SVG polygon.  The conversion is not 1:1 because the SVG polygone assumes a closed path.  If the pline is not closed it will be forced closed
-	//return pline2svg(pline, 2, 6, units, double scaling,out);	
-}
-
-
-// DXF LWPolyline -> SVG
-
-
-// This could be a template with polyline and lwpolyline but right now it is not that important
-void lwpline2svg(lwpolyline pline, int type, int precision, char * units, double scaling, tables plot_info, char *out); // General function for the conversion of a pline to a SVG element.  Very similar functions just make accomidations for parts that may not be supported
-void lwpline2svg(lwpolyline pline, int type, int precision, char * units, double scaling, tables plot_info, char *out){
-	// 0 is pline2path
-	// 1 is pline2pline
-	// 2 is pline2polygon
-	
-	
-	char delim[2];
-	
-	std::vector< vertex >::iterator vver_iter;
-	std::vector< vertex > points = pline.ret_points();
-	
-	if (type < 1){
-		// Put the first Move To at the first, everything else will be a lineto
-		strcpy(delim," ");
-		strcat(out, "M ");
-		coord( &points[0], precision, delim, NULL, scaling, out );
-		double prev_mag_bulge = sqrt(pow(points[0].ret_bulge(),2));  // Because the bulge value can be positive or negative calculate the magnitude
-		if ( prev_mag_bulge > pow(0.1,precision) ){
-				to_arc(pline.bulge(0),pline.bulge_r(0), pline.bulge_start_angle(0), pline.bulge_end_angle(0), precision, delim, NULL, scaling, out);
-		}
-		
-		for (int i = 1; i < points.size(); i++){
-			if ( prev_mag_bulge < pow(0.1,precision) ){
-				// If the previous point was a bulge then don't use a line to
-				strcat(out, "L ");
-			}
-			coord( &points[i], precision, delim, NULL , scaling, out ); 
-			// If bulge > some precsion then add bulge
-			double mag_bulge = sqrt(pow(points[i].ret_bulge(),2));
-			if ( ( mag_bulge > pow(0.1,precision) ) && (i < (points.size() - 1) )){ // Make sure the final point doesn't add a bulge on accident
-				to_arc(pline.bulge(i), pline.bulge_r(i), pline.bulge_start_angle(i), pline.bulge_end_angle(i), precision, delim, units, scaling, out);
-			}
-			prev_mag_bulge = mag_bulge;	
-		}
-		if ( pline.is_closed() ){
-			strcat(out,"z");
-		}
-		strcat(out,"\" ");
-	}
-	else{
-		strcpy(delim,",");		
-		for (int i = 0; i < points.size(); i++){
-			coord( &points[i], precision, delim, units, scaling, out ); 
-			// If bulge > some precsion then add bulge	
-		}
-		// if the element is a SVG::pline and the DXF::pline is closed then simulate by adding an extra point
-		if ( (type == 1) && pline.is_closed() ){
-			coord( &points[0], precision, delim, units, scaling, out ); 
-		}
-	}	
-		
-}
-
-char* lwpline2path(lwpolyline pline, char * units, double scaling, tables plot_info){
-	// Convert a dxf polyline to a SVG path.  This is the closest conversion of the DXF polyline to an SVG element
-	char *out_ptr;
-	char out[10000] = "<path d=\"";
-	entity *ent_ptr = &pline;
-	char temp[20];
-	int precision = 6;
-	
-	lwpline2svg(pline, 0, precision, units, scaling, plot_info, out);
-	// Add some line information
-	strcat(out,"fill=\"none\" stroke=\"black\" stroke-width=\"1\" ");
-	pattern2dasharray(plot_info.ret_ltype( ent_ptr->ret_ltype_name(temp),ent_ptr->ret_layer_name(temp) ), precision, scaling, out);  // Add the linetype information
-	
-	strcat(out," />");
-	out_ptr = out;
-	return out_ptr;	
-}
-
-// DXF ARC -> SVG
-char* arc2path(arc a, int precision, char * units, double scaling, tables plot_info, char *out){
-	// So far this appears to be the only way to convert arcs into something recognized by SVG
-	char *out_ptr;
-	char temp[20];
-	entity *ent_ptr = &a;
-	
-	strcpy(out,"<path d=\"M");
-	// Calculate the starting point from the center and the start angle.  As far as I can tell the rotation is CCW in the dxf notation and it in degrees
-	strcat(out,gcvt(scaling*(ent_ptr->ret_x()+a.ret_radius()*cos( a.ret_srt_ang()*3.14159/180 )),precision,temp) );
-	strcat(out," ");
-	strcat(out,gcvt(-1*scaling*(ent_ptr->ret_y()+a.ret_radius()*sin( a.ret_srt_ang()*3.14159/180 )),precision,temp) );
-	strcat(out," A ");
-	// For arcs there is only one radius
-	strcat(out,gcvt(scaling*a.ret_radius(),precision,temp) );
-	strcat(out,",");
-	strcat(out,gcvt(scaling*a.ret_radius(),precision,temp) );
-	
-	strcat(out," 0"); // For arc assume no x-axis rotation.  That seems to apply to elipse elements only
-	// Determine if it is a large arc
-	if ( (a.ret_end_ang() > a.ret_srt_ang()) && ( (a.ret_end_ang() - a.ret_srt_ang()) > 180) ){
-		strcat(out," 1,0 "); // Large arc flag...Always use a zero sweep flag
-	}
-	else{
-		strcat(out," 0,0 "); // Small arc flag...Always use a zero sweep flag
-	}
-	
-	//The final point
-	strcat(out,gcvt(scaling*(ent_ptr->ret_x()+a.ret_radius()*cos( a.ret_end_ang()*3.14159/180 )),precision,temp) );
-	strcat(out,",");
-	strcat(out,gcvt(-1*scaling*(ent_ptr->ret_y()+a.ret_radius()*sin( a.ret_end_ang()*3.14159/180 )),precision,temp) );
-	strcat(out,"\" fill=\"none\" stroke=\"black\" stroke-width=\"1\" ");
-	ltype linfo = plot_info.ret_ltype(ent_ptr->ret_ltype_name(temp), ent_ptr->ret_layer_name(temp));
-	pattern2dasharray(linfo, precision, scaling, out);  // Add the linetype information
-	strcat(out, " />");
-	
-	
-	out_ptr = out;
-	return out_ptr;
-	
-}
-
-
-// DXF Circle -> SVG
-char* circle2circle(circle circ, int precision, char * units, double scaling, tables plot_info, char *out){
-	// Direct conversion of DXF circle to SVG circle
-	char *out_ptr;
-	char temp[1000]="\" cy=\"";
-	entity *ent_ptr = &circ;
-	strcpy(out,"<circle cx=\"");
-	coord(ent_ptr, precision,temp, units, scaling, out);
-	strcat(out,"\" r=\"");
-	strcat(out,gcvt(circ.ret_radius(),precision,temp) );
-	strcat(out,units);
-	strcat(out,"\" fill=\"none\" stroke=\"black\" stroke-width=\"1\" ");
-	ltype linfo = plot_info.ret_ltype(ent_ptr->ret_ltype_name(temp), ent_ptr->ret_layer_name(temp));
-	//plot_info.ret_ltype(ent_ptr->ret_ltype_name(temp), ent_ptr->ret_layer_name(temp));
-	pattern2dasharray(linfo, precision, scaling, out);  // Add the linetype information
-	//pattern2dasharray(plot_info.ret_ltype(ent_ptr->ret_ltype_name(temp), ent_ptr->ret_layer_name(temp)), precision, scaling, out);  // Add the linetype information
-	strcat(out, " />");
-	out_ptr = out;
-	return out_ptr;
-}
-
-char* circle2path(circle circ, int precision, char * units, double scaling, tables plot_info, char *out){
-	// Conversion of DXF circle to SVG circle assuming the path will represent the circle
-	
-	char *out_ptr;
-	char temp[20]=",";
-	entity *ent_ptr = &circ;	
-	
-	strcpy(out,"<path d=\"M");
-	// The starting point is x-r,y so subtract off the radius from the x coord
-	strcat(out,gcvt(ent_ptr->ret_x()-circ.ret_radius(),precision,temp) );
-	strcat(out," ");
-	strcat(out,gcvt(ent_ptr->ret_y(),precision,temp) );
-	
-	strcat(out," a");
-	strcat(out,gcvt(circ.ret_radius(),precision,temp) );
-	strcat(out,",");
-	strcat(out,gcvt(circ.ret_radius(),precision,temp) );
-	strcat(out,"0 0,0 0,0\"  fill=\"none\" stroke=\"black\" stroke-width=\"1\"");
-		
-	out_ptr = out;
-	return out_ptr;
-}
-
-
-// DXF Line -> SVG
-char* line2line(line ln, int precision, char * units, double scaling, tables plot_info, char *out){
-	// Directly convert DXF to SVG because it works
-	char *out_ptr;
-	char temp[20];
-	entity *ent_ptr = &ln;	
-	
-	strcpy(out,"<line x1=\"");
-	strcat(out,gcvt(ent_ptr->ret_x(),precision,temp) );
-	strcat(out,units);
-	strcat(out,"\" y1=\"");
-	strcat(out,gcvt(-1*ent_ptr->ret_y(),precision,temp) ); // Put in an extra minus because of the way SVG has defined the axis
-	strcat(out,units);
-	
-	strcat(out,"\" x2=\"");
-	strcat(out,gcvt(ln.ret_xf(),precision,temp) );
-	strcat(out,units);
-	strcat(out,"\" y2=\"");  
-	strcat(out,gcvt(-1*ln.ret_yf(),precision,temp) ); // Put in an extra minus because of the way SVG has defined the axis
-	strcat(out,units);
-	strcat(out,"\" stroke-width=\"1\" stroke=\"black\" ");
-	ltype linfo = plot_info.ret_ltype(ent_ptr->ret_ltype_name(temp), ent_ptr->ret_layer_name(temp));
-	pattern2dasharray(linfo, precision, scaling, out);  // Add the linetype information
-	strcat(out, " />");
-		
-	out_ptr = out;
-	return out_ptr;
-}
-
-
-char* line2path(line ln, int precision, char * units, double scaling, tables plot_info, char *out){
-	// Convert DXF line to SVG path
-	
-	char *out_ptr;
-	char temp[20];
-	entity *ent_ptr = &ln;	
-	
-	strcpy(out,"<path d=\"M");
-	strcat(out,gcvt(scaling*ent_ptr->ret_x(),precision,temp) );
-	strcat(out," ");
-	strcat(out,gcvt(scaling*ent_ptr->ret_y(),precision,temp) );
-	
-	strcat(out," L");
-	strcat(out,gcvt(scaling*ln.ret_xf(),precision,temp) );
-	strcat(out," ");
-	strcat(out,gcvt(scaling*ln.ret_yf(),precision,temp) );
-	strcat(out,"\" fill=\"none\" stroke=\"black\" stroke-width=\"1\" /");
-		
-	out_ptr = out;
-	return out_ptr;
-}
-
-// DXF Text -> SVG
-char* text2text(text txt, int precision, char * units, double scaling, tables plot_info, char *out){
-	// Directly convert DXF to SVG because it works
-	char *out_ptr;
-	char temp[10000];	
-	entity *ent_ptr = &txt;
-	
-	// If the text is rotated use the transform matrix
-
-	if ( txt.ret_txt_rot() > precision ){
-		double ca = cos(0.017453*txt.ret_txt_rot()); // ca = cosine(a)
-		double sa = sin(-0.017453*txt.ret_txt_rot()); // sa = sine(a)
-		double tx = ent_ptr->ret_x()*scaling;
-		double ty = -ent_ptr->ret_y()*scaling;
-		// Apply a translation to the orgin, then a rotation, then a translation back to the original position
-		double a = ca;
-		double b = sa;
-		double c = -sa;
-		double d = ca;
-		double e = -1*(tx*ca-ty*sa-tx);
-		double f = -1*(tx*sa+ty*ca-ty);
-		
-		strcpy(out, "<g transform=\"matrix(");
-		strcat(out,gcvt(a,precision,temp) );
-		strcat(out," ");
-		strcat(out,gcvt(b,precision,temp) );
-		strcat(out," ");
-		strcat(out,gcvt(c,precision,temp) );
-		strcat(out," ");
-		strcat(out,gcvt(d,precision,temp) );
-		strcat(out," ");
-		strcat(out,gcvt(e,precision,temp) );
-		strcat(out," ");
-		strcat(out,gcvt(f,precision,temp) );
-		strcat(out,")\" >\n<text x=\"");
-	}
-	else{
-		strcpy(out,"<text x=\"");
-	}
-	/*
-	strcat(out,gcvt(ent_ptr->ret_x(),precision,temp) );
-	strcat(out,units);
-	strcat(out,"\" y=\"-"); // Put in an extra minus because of the way SVG has defined the axis
-	strcat(out,gcvt(ent_ptr->ret_y(),precision,temp) );
-	strcat(out,units);
-	*/
-	strcat(out,gcvt(ent_ptr->ret_x()*scaling,precision,temp) );
-	//strcat(out,units);
-	strcat(out,"\" y=\"-"); // Put in an extra minus because of the way SVG has defined the axis
-	strcat(out,gcvt(ent_ptr->ret_y()*scaling,precision,temp) );
-	//strcat(out,units);
-	strcat(out,"\" font-family=\"Verdana\" font-size=\"");
-	strcat(out,gcvt(scaling*txt.ret_txt_ht(),precision,temp) );
-	strcat(out,"\" Fill=\"black\"");
-	
-	strcat(out," >");
-	//  Now put in the text
-	strcat(out,txt.ret_text(temp));
-	
-	// Now close the text element
-	strcat(out,"</text>");	
-	// If the text was rotated finish off the tranform group
-	if ( txt.ret_txt_rot() > precision ){
-		strcat(out,"</g>");
-	}
-	
-	out_ptr = out;
-	return out_ptr;
-}
-
-
-
-// DXF Insert -> SVG
-char* insert2group(insert in, int precision, char * units, double scaling, tables plot_info, blocks blks, char *out){
-	char *out_ptr;
-	char tmp_char[100000];
-	
-	//  get the block using the name from the insert information
-	block blk = blks.ret_block(in.name(tmp_char));
-	
-	entity *ent_ptr = &in;
-	entities *ents_ptr = &blk;
-	// For now just translations  MBS 22 Aug 05
-	strcpy(out, "<g transform=\"matrix(1,0,0,1,");
-	strcat(out,gcvt(scaling*ent_ptr->ret_x(),precision,tmp_char) );
-	strcat(out,",");
-	strcat(out,gcvt(-scaling*ent_ptr->ret_y(),precision,tmp_char) );
-	strcat(out,")\" >\n");
-	
-	
-	// Now convert the entities in the block
-	std::vector< polyline > plines = ents_ptr->ret_plines();
-	std::vector< lwpolyline > lwplines = ents_ptr->ret_lwplines();
-	std::vector< arc > arcs = ents_ptr->ret_arcs();
-	std::vector< circle > circs = ents_ptr->ret_circles();
-	std::vector< line > lns = ents_ptr->ret_lines();
-	std::vector< text > txts = ents_ptr->ret_texts();
-	
-		
-	
-	for(int i = 0; i < plines.size();i++){
-		strcat( out,pline2pline(plines[i], units, scaling, plot_info ) );
-		strcat( out, "\n" );
-	}
-	for(int i = 0; i < lwplines.size();i++){
-		strcat( out,lwpline2path(lwplines[i], units, scaling, plot_info ) );
-		strcat( out, "\n" );
-	}
-	for(int i = 0; i < arcs.size();i++){
-		strcat( out, arc2path(arcs[i], 6,units, scaling, plot_info, tmp_char ) );
-		strcat( out, "\n" );
-	}
-	for(int i = 0; i < circs.size();i++){
-		strcat( out, circle2circle(circs[i], 6, units, scaling, plot_info, tmp_char) );
-		strcat( out, "\n" );
-	}
-	for(int i = 0; i < lns.size();i++){
-		strcat( out, line2line(lns[i], 6, units, scaling, plot_info, tmp_char) );
-		strcat( out, "\n" );
-	}
-	for(int i = 0; i < txts.size();i++){
-		strcat( out, text2text(txts[i], 6, units, scaling, plot_info, tmp_char) );
-		strcat( out, "\n" );
-	}
-	// End the group
-	strcat(out,"</g>");
-	
-	out_ptr = out;
-	return out_ptr;	
-}
-
-
-
-char* write_by_layer(int output_type, entities &ents, tables &tbls, blocks &blks, double scaling, char * units, char * layer, char * out){
-	// output_type = 0 is to std:out
-	// output_type = 1 is to the input filename but with .dxf on the end
-	
-	// For now everything will go to stdout later may directed to other places
-	
-	// Get the various file informations as dependent on the layer type
-	std::vector< polyline > plines = ents.ret_plines(layer);
-	std::vector< lwpolyline > lwplines = ents.ret_lwplines(layer);
-	std::vector< arc > arcs = ents.ret_arcs(layer);
-	std::vector< circle > circs = ents.ret_circles(layer);
-	std::vector< line > lns = ents.ret_lines(layer);
-	std::vector< text > txts = ents.ret_texts(layer);
-	std::vector< insert > ins = ents.ret_inserts(layer);
-	
-	// It would be better to redirect stdout to different places.  That would make the code cleaner but I don't think it will work better
-	char tmp_char[100000];
-	for(int i = 0; i < plines.size();i++){
-		if (output_type == 0){
-			std::cout << "\t" << pline2path(plines[i], NULL, scaling, tbls ) << std::endl;
-		}
-		else if (output_type == 1){
-			std::cout << "\t" << pline2path(plines[i], NULL, scaling, tbls ) << std::endl;
-		}
-	}
-	for(int i = 0; i < lwplines.size();i++){
-		if (output_type == 0){
-			std::cout << "\t" << lwpline2path(lwplines[i], units, scaling, tbls ) << std::endl;
-		}
-		else if (output_type == 1){
-			std::cout << "\t" << lwpline2path(lwplines[i], units, scaling, tbls ) << std::endl;
-		}
-	}
-	for(int i = 0; i < arcs.size();i++){
-		if (output_type == 0){
-			std::cout << "\t" << arc2path(arcs[i], 6,units, scaling, tbls, tmp_char ) << std::endl;
-		}
-		else if (output_type == 1){
-			std::cout << "\t" << arc2path(arcs[i], 6,units, scaling, tbls, tmp_char ) << std::endl;
-		}
-	}
-	for(int i = 0; i < circs.size();i++){
-		if (output_type == 0){
-			std::cout << "\t" << circle2circle(circs[i], 6, units, scaling, tbls, tmp_char) << std::endl;
-		}
-		else if (output_type == 1){
-			std::cout << "\t" << circle2circle(circs[i], 6, units, scaling, tbls, tmp_char) << std::endl;
-		}
-	}
-	for(int i = 0; i < lns.size();i++){
-		if (output_type == 0){
-			std::cout << "\t" << line2line(lns[i], 6, units, scaling, tbls, tmp_char) << std::endl;
-		}
-		else if (output_type == 1){
-			std::cout << "\t" << line2line(lns[i], 6, units, scaling, tbls, tmp_char) << std::endl;
-		}
-	}
-	for(int i = 0; i < txts.size();i++){
-		if (output_type == 0){
-			std::cout << "\t" << text2text(txts[i], 6, units, scaling, tbls, tmp_char) << std::endl;
-		}
-		else if (output_type == 1){
-			std::cout << "\t" << text2text(txts[i], 6, units, scaling, tbls, tmp_char) << std::endl;
-		}
-	}
-	for(int i = 0; i < ins.size();i++){
-		if (output_type == 0){
-			std::cout << "\t" << insert2group(ins[i], 6, units, scaling, tbls, blks, tmp_char) << std::endl;
-		}
-		else if (output_type == 1){
-			std::cout << "\t" << insert2group(ins[i], 6, units, scaling, tbls, blks, tmp_char) << std::endl;
-		}
-	}
-}
-
-
-
-char* write_all(int output_type, entities &ents, tables &tbls, blocks &blks, double scaling, char * units, char * out){
-	// output_type = 0 is to std:out
-	// output_type = 1 is to the input filename but with .dxf on the end
-	
-	// For now everything will go to stdout later may directed to other places
-	
-	// Get the various file informations as dependent on the layer type
-	std::vector< polyline > plines = ents.ret_plines();
-	std::vector< lwpolyline > lwplines = ents.ret_lwplines();
-	std::vector< arc > arcs = ents.ret_arcs();
-	std::vector< circle > circs = ents.ret_circles();
-	std::vector< line > lns = ents.ret_lines();
-	std::vector< text > txts = ents.ret_texts();
-	std::vector< insert > ins = ents.ret_inserts();
-	
-	// It would be better to redirect stdout to different places.  That would make the code cleaner but I don't think it will work better
-	char tmp_char[100000];
-	for(int i = 0; i < plines.size();i++){
-		if (output_type == 0){
-			std::cout << "\t" << pline2path(plines[i], NULL, scaling, tbls ) << std::endl;
-		}
-		else if (output_type == 1){
-			std::cout << "\t" << pline2path(plines[i], NULL, scaling, tbls ) << std::endl;
-		}
-	}
-	for(int i = 0; i < lwplines.size();i++){
-		if (output_type == 0){
-			std::cout << "\t" << lwpline2path(lwplines[i], units, scaling, tbls ) << std::endl;
-		}
-		else if (output_type == 1){
-			std::cout << "\t" << lwpline2path(lwplines[i], units, scaling, tbls ) << std::endl;
-		}
-	}
-	for(int i = 0; i < arcs.size();i++){
-		if (output_type == 0){
-			std::cout << "\t" << arc2path(arcs[i], 6,units, scaling, tbls, tmp_char ) << std::endl;
-		}
-		else if (output_type == 1){
-			std::cout << "\t" << arc2path(arcs[i], 6,units, scaling, tbls, tmp_char ) << std::endl;
-		}
-	}
-	for(int i = 0; i < circs.size();i++){
-		if (output_type == 0){
-			std::cout << "\t" << circle2circle(circs[i], 6, units, scaling, tbls, tmp_char) << std::endl;
-		}
-		else if (output_type == 1){
-			std::cout << "\t" << circle2circle(circs[i], 6, units, scaling, tbls, tmp_char) << std::endl;
-		}
-	}
-	for(int i = 0; i < lns.size();i++){
-		if (output_type == 0){
-			std::cout << "\t" << line2line(lns[i], 6, units, scaling, tbls, tmp_char) << std::endl;
-		}
-		else if (output_type == 1){
-			std::cout << "\t" << line2line(lns[i], 6, units, scaling, tbls, tmp_char) << std::endl;
-		}
-	}
-	for(int i = 0; i < txts.size();i++){
-		if (output_type == 0){
-			std::cout << "\t" << text2text(txts[i], 6, units, scaling, tbls, tmp_char) << std::endl;
-		}
-		else if (output_type == 1){
-			std::cout << "\t" << text2text(txts[i], 6, units, scaling, tbls, tmp_char) << std::endl;
-		}
-	}
-	for(int i = 0; i < ins.size();i++){
-		if (output_type == 0){
-			std::cout << "\t" << insert2group(ins[i], 6, units, scaling, tbls, blks, tmp_char) << std::endl;
-		}
-		else if (output_type == 1){
-			std::cout << "\t" << insert2group(ins[i], 6, units, scaling, tbls, blks, tmp_char) << std::endl;
-		}
-	}
-}
-
-
-
diff --git a/src/extension/dxf2svg/entities2elements.h b/src/extension/dxf2svg/entities2elements.h
deleted file mode 100644
index cceefcf15..000000000
--- a/src/extension/dxf2svg/entities2elements.h
+++ /dev/null
@@ -1,53 +0,0 @@
-/* Method for converting dxf entities to SVG elements
-There are multiple ways for converting different items
-
-If possible most DXF enetities will be converted to paths because that is the most flexable object
-
-Matt Squires
-SoC 2005
-
-*/
-
-#include"entities.h"
-#include"tables.h"
-#include"blocks.h"
-
-// The names indicate the DXF entitiy first and the SVG element last
-
-// Common elements
-char* to_arc(double bulge, double r, double start_ang, double end_ang, int precision,char* delim, char * units, double scaling, char *out); // This is used for arcs, polylines, and lwpolylines
-
-// DXF Polyline -> SVG
-
-char* pline2path(polyline pline, char * units, double scaling, tables plot_info);  // Convert a dxf polyline to a SVG path.  This is the closest conversion of the DXF polyline to an SVG element
-char* pline2pline(polyline pline, char * units, double scaling, tables plot_info);  // Convert a dxf polyline to a SVG polyline.  The conversion is not 1:1 because the SVG pline doesn't support closed objects or curves
-char* pline2polygon(polyline pline, char * units, double scaling, tables plot_info);  // Convert a dxf polyline to a SVG polygon.  The conversion is not 1:1 because the SVG polygone assumes a closed path.  If the pline is not closed it will be forced closed
-
-// DXF LWPolyline -> SVG
-char* lwpline2path(lwpolyline pline, char * units, double scaling, tables plot_info);  // Convert a dxf polyline to a SVG path.  This is the closest conversion of the DXF polyline to an SVG element
-
-// DXF ARC -> SVG
-char* arc2path(arc a, int precision, char * units, double scaling, tables plot_info, char *out); // So far this appears to be the only way to convert arcs into something recognized by SVG
-
-
-// DXF Circle -> SVG
-char* circle2circle(circle circ, int precision, char * units, double scaling, tables plot_info, char *out); // Direct conversion of DXF circle to SVG circle
-char* circle2path(circle circ, int precision, char * units, double scaling, tables plot_info, char *out); // Conversion of DXF circle to SVG circle assuming the path will represent the circle
-
-
-// DXF Line -> SVG
-char* line2line(line ln, int precision, char * units, double scaling, tables plot_info, char *out);  // Directly convert DXF to SVG because it works
-char* line2path(line ln, int precision, char * units, double scaling, tables plot_info, char *out);  // Convert DXF line to SVG path
-
-// DXF Text -> SVG
-char* text2text(text txt, int precision, char * units, double scaling, tables plot_info, char *out); // Directly convert DXF to SVF assuming VERANDA font
-
-// DXF Insert -> SVG
-char* insert2group(insert in, int precision, char * units, double scaling, tables plot_info, blocks blks, char *out);
-
-// Write all of the possible enties with a variety of options
-
-char* write_by_layer(int output_type, entities &ents, tables &tbls, blocks &blks, double scaling, char * units, char * layer, char * out); // Write out the entities by layer designation
-char* write_all(int output_type, entities &ents, tables &tbls, blocks &blks, double scaling, char * units, char * out);
-
-
diff --git a/src/extension/dxf2svg/read_dxf.cpp b/src/extension/dxf2svg/read_dxf.cpp
deleted file mode 100644
index 1a4eefbc9..000000000
--- a/src/extension/dxf2svg/read_dxf.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-/*
- * For reading and slight parsing of dxf files
- *
- * Author:
- *   Matt Squires <squiresm@colorado.edu>
- *
- * Copyright (C) 2005 Matt Squires
- *
- * Released under GNU GPL and LGPL, read the file 'GPL.txt' and 'LGPL.txt' for details
- */
-
-
-
-#include <fstream>
-#include <string>
-#include "read_dxf.h"
-
-#include <iostream>
-#include <string.h>
-#include <stdlib.h>
-using namespace std;
-
-
-int MAX_STR_LN = 10000;
-
-int section(char* value){
-	if ( strncmp(value,"HEADER",6) == 0 ) return 0;
-	if ( strncmp(value,"CLASSES",7) == 0 ) return 1;
-	if ( strncmp(value,"TABLES",6) == 0 ) return 2;
-	if ( strncmp(value,"BLOCKS",6) == 0 ) return 3;
-	if ( strncmp(value,"ENTITIES",8) == 0 ) return 4;
-	if ( strncmp(value,"OBJECTS",7) == 0 ) return 5;
-	if ( strncmp(value,"THUMBNAILIMAGE",14) == 0 ) return 6;
-}
-
-
-dxfpair::dxfpair(int gcode, char val[10000]){
-		group_code = gcode;
-		// Dynamically save the strings, otherwise the memory uses is bad
-		
-		for (int i = 0; i < strlen(val); i++){
-			value.push_back(val[i]);
-		}		
-}
-
-
-dxfpair::~dxfpair(){
-	//delete [] value;
-}
-
-char * dxfpair::value_char(char *string){
-	int size = value.size();
-	while( ( size > 0 ) && int(value[size-1]) < 33){
-		// Strip off any control characters and spaces off the end of the string
-		size--;
-	}
-	for(int i = 0; i < size; i++){
-		string[i] = value[i];
-	}
-	string[size]=0;
-}
-
-std::vector< std::vector< dxfpair > > dxf_get_sections(char* filename){
-	// In the dxf format information is paired into group codes that indicate the information that follows on the next line.  The information on the next line is called the value
-	
-	int n =0;
-	
-	int group_code;
-	char value[MAX_STR_LN];
-	
-	int section_num;
-	
-	
-	
-	
-	std::vector< std::vector< dxfpair > > out;
-	
-	std::vector< dxfpair > header;
-	std::vector< dxfpair > classes;
-	std::vector< dxfpair > tables;
-	std::vector< dxfpair > blocks;
-	std::vector< dxfpair > entities;
-	std::vector< dxfpair > objects;
-	std::vector< dxfpair > thumbnailimage;
-	
-	header.clear();
-	classes.clear();
-	tables.clear();
-	blocks.clear();
-	entities.clear();
-	objects.clear();
-	thumbnailimage.clear();
-	
-	
-	// Open dxf file for reading
-	std::ifstream file(filename);
-	
-	if (!file.is_open()){
-		exit (1);  // Change this to an exception
-	}
-	
-	// Find the first SECTION header
-	
-	while ( (!file.eof()) ){ 
-		n++;
-		
-		// get the first group code and value
-		file.getline(value,MAX_STR_LN);
-		group_code = atoi(value);
-		file.getline(value,MAX_STR_LN);
-		
-		do{	
-				
-			// TO DO     set all the chars to be caps for later comparison
-		
-			// Find the SECTION codes
-			if ( (group_code == 0 ) && ( strncmp(value,"SECTION",7) == 0 ) ){
-				// Directly after a section value is the type of section ( e.g. HEADER, TABLES )
-				file.getline(value,MAX_STR_LN);
-				group_code = atoi(value);
-				file.getline(value,MAX_STR_LN);
-				section_num = section( value );
-				if ( group_code == 2 ){
-					// Make sure the the group code is 2 for the SECTION name
-					// This is a big block of mostly repetitive code, it will result in larger code, but would be faster than putting the switch in another while loop.  If I still live in a time when file size mattered alot I would change it
-					//std::cout << "section_num = " << section_num << std::endl;
-					switch ( section_num ){
-						case 0:
-							file.getline(value,MAX_STR_LN);
-							group_code = atoi(value);
-							file.getline(value,MAX_STR_LN);
-							do{
-								header.push_back( dxfpair( group_code, value ) );
-								file.getline(value,MAX_STR_LN);
-								group_code = atoi(value);
-								file.getline(value,MAX_STR_LN);
-							}while( ( (group_code != 0) || strncmp(value,"ENDSEC",6) != 0 ) && (!file.eof()) );  // I put in the (group_code != 0) in the hope that it will be a faster bool compare than the string compare.  Test this later
-							break;
-						case 1:
-							file.getline(value,MAX_STR_LN);
-							group_code = atoi(value);
-							file.getline(value,MAX_STR_LN);
-							if ( (group_code != 0) || (strncmp(value,"ENDSEC",6) != 0) ){
-								// Some dxf files have blank sections.  These are not handled by the do/while loop so break about if needed
-								do{
-									classes.push_back( dxfpair( group_code, value ) );
-									file.getline(value,MAX_STR_LN);
-									group_code = atoi(value);
-									file.getline(value,MAX_STR_LN);
-								}while( ( (group_code != 0) || strncmp(value,"ENDSEC",6) != 0 ) && (!file.eof()) );  // I put in the (group_code != 0) in the hope that it will be a faster bool compare than the string compare.  Test this later
-							}
-							break;
-						case 2:
-							file.getline(value,MAX_STR_LN);
-							group_code = atoi(value);
-							file.getline(value,MAX_STR_LN);
-							do{
-								tables.push_back( dxfpair( group_code, value ) );
-								file.getline(value,MAX_STR_LN);
-								group_code = atoi(value);
-								file.getline(value,MAX_STR_LN);
-							}while( ( (group_code != 0) || strncmp(value,"ENDSEC",6) != 0 ) && (!file.eof()) );
-							break;
-						case 3:
-							file.getline(value,MAX_STR_LN);
-							group_code = atoi(value);
-							file.getline(value,MAX_STR_LN);
-							do{
-								blocks.push_back( dxfpair( group_code, value ) );
-								file.getline(value,MAX_STR_LN);
-								group_code = atoi(value);
-								file.getline(value,MAX_STR_LN);
-							}while( ( (group_code != 0) || strncmp(value,"ENDSEC",6) != 0 ) && (!file.eof()) );  // I put in the (group_code != 0) in the hope that it will be a faster bool compare than the string compare.  Test this later
-							break;
-						case 4:
-							file.getline(value,MAX_STR_LN);
-							group_code = atoi(value);
-							file.getline(value,MAX_STR_LN);
-							do{
-								entities.push_back( dxfpair( group_code, value ) );
-								file.getline(value,MAX_STR_LN);
-								group_code = atoi(value);
-								file.getline(value,MAX_STR_LN);
-							}while( ( (group_code != 0) || strncmp(value,"ENDSEC",6) != 0 ) && (!file.eof()) );  // I put in the (group_code != 0) in the hope that it will be a faster bool compare than the string compare.  Test this later
-							break;
-						case 5:
-							file.getline(value,MAX_STR_LN);
-							group_code = atoi(value);
-							file.getline(value,MAX_STR_LN);
-							do{
-								objects.push_back( dxfpair( group_code, value ) );
-								file.getline(value,MAX_STR_LN);
-								group_code = atoi(value);
-								file.getline(value,MAX_STR_LN);
-							}while( ( (group_code != 0) || strncmp(value,"ENDSEC",6) != 0 ) && (!file.eof()) );  // I put in the (group_code != 0) in the hope that it will be a faster bool compare than the string compare.  Test this later
-							break;
-						case 6:
-							file.getline(value,MAX_STR_LN);
-							group_code = atoi(value);
-							file.getline(value,MAX_STR_LN);
-							do{
-								thumbnailimage.push_back( dxfpair( group_code, value ) );
-								file.getline(value,MAX_STR_LN);
-								group_code = atoi(value);
-								file.getline(value,MAX_STR_LN);
-							}while( ( (group_code != 0) || strncmp(value,"ENDSEC",6) != 0 ) && (!file.eof()) );  // I put in the (group_code != 0) in the hope that it will be a faster bool compare than the string compare.  Test this later
-							break;
-						default:
-							file.getline(value,MAX_STR_LN);
-							group_code = atoi(value);
-							file.getline(value,MAX_STR_LN);	
-					}
-				}
-			}	
-			file.getline(value,MAX_STR_LN);
-			group_code = atoi(value);
-			file.getline(value,MAX_STR_LN);
-			
-			n++;
-		}while( ( strncmp(value,"EOF",3) != 0 ) && (!file.eof()) ); 
-	}
-	
-	out.push_back(header);
-	out.push_back(classes);
-	out.push_back(tables);
-	out.push_back(blocks);
-	out.push_back(entities);
-	out.push_back(objects);
-	out.push_back(thumbnailimage);
-	
-	return out;
-}
-
-
-std::vector< std::vector< dxfpair > > separate_parts( std::vector< dxfpair > section){
-	//std::cout << "1" << std::endl;
-	//std::cout << "section.size() = " << section.size() << std::endl;
-	// Find where the major sections are and break into smaller parts
-	// Major section is defined as anything beween group_code 0 to 0
-	std::vector< dxfpair > inner;
-	std::vector< std::vector< dxfpair > > outer;
-	//std::cout << "2" << std::endl;
-	for (int i = 0; i < section.size(); i++){
-		//std::cout << "i = " << i << std::endl;
-		//std::cout << "section[i].value.size() = " << section[i].value.size() << std::endl;
-		
-		// Make sure no control codes like LF or CR are making it past this section
-		if ( (section[i].value.size() > 0) && int(section[i].value.back()) < 32 ){
-			 section[i].value.pop_back();
-		 }
-		//for(int j = 0;j < section[i].value.size();j++ ) std::cout << section[i].value[j];
-		//std::cout << std::endl;
-		
-		inner.push_back( section[i] );
-		
-		// If the next group code is 0 then push the previously found info on outer and start looking for data again
-		if (section[i+1].group_code == 0){
-			//std::cout << "inner.push_back" << std::endl;
-			outer.push_back( inner );
-			inner.clear();
-		}
-	}
-	// Because putting the data on outer depends on find a GC=0 the last bit of data may be left behind so it inner has data in it put it on outer
-	if (!inner.empty()){
-		outer.push_back( inner );
-		inner.clear();
-	}
-	//std::cout << "3" << std::endl;
-	if (section.back().group_code == 0){
-		//outer.push_back( inner ); // Put the last part on if there is information, but I don't think it needs to.
-	}
-	
-	return outer;
-}
-
diff --git a/src/extension/dxf2svg/read_dxf.h b/src/extension/dxf2svg/read_dxf.h
deleted file mode 100644
index 7e008b4e0..000000000
--- a/src/extension/dxf2svg/read_dxf.h
+++ /dev/null
@@ -1,32 +0,0 @@
-/* Header file for reading dxf information and basic parsing.  Interprting information is found in other files
-*/
-
-#ifndef READ_DXF_H
-#define READ_DXF_H
-
-#include<vector>
-
-
-
-class dxfpair{
-public:
-    dxfpair(int gcode, char val[10000]);
-    virtual ~dxfpair();
-
-    char * value_char(char *string);
-
-    // Leave this data public
-    int group_code;
-    std::vector< char > value;
-};
-
-
-
-
-int section(char* value);  // Convert the section titles into integers
-
-std::vector< std::vector< dxfpair > > dxf_get_sections(char* filename);
-
-std::vector< std::vector< dxfpair > > separate_parts( std::vector< dxfpair > section );  // Find where the major sections are and break into smaller parts
-
-#endif
diff --git a/src/extension/dxf2svg/tables.cpp b/src/extension/dxf2svg/tables.cpp
deleted file mode 100644
index fcaff33c0..000000000
--- a/src/extension/dxf2svg/tables.cpp
+++ /dev/null
@@ -1,211 +0,0 @@
-/*
- * Code for the conversion of DXF information in the TABLES section
- *
- * Author:
- *   Matt Squires <squiresm@colorado.edu>
- *
- * Copyright (C) 2005 Matt Squires
- *
- * Released under GNU GPL and LGPL, read the file 'GPL.txt' and 'LGPL.txt' for details
- */
-
-#include"tables.h"
-#include<iostream>
-
-
-
-
-int determine_table(char* value){
-	// Common Elements as far as I am concerend
-	if ( strncmp(value,"LAYER",5) == 0 ) return 0;	
-	if ( strncmp(value,"LTYPE",5) == 0 ) return 1;	
-	if ( strncmp(value,"STYLE",5) == 0 ) return 2;
-	if ( strncmp(value,"UCS",3) == 0 ) return 3;
-	if ( strncmp(value,"VIEW",4) == 0 ) return 4;
-	if ( strncmp(value,"VPORT",4) == 0 ) return 5;
-	if ( strncmp(value,"APPID",5) == 0 ) return 6;
-	if ( strncmp(value,"BLOCK_RECORD",12) == 0 ) return 7;
-	else return -1;
-}
-
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// TABLE
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-
-int table::ret_maxN(){
-	return max_number;
-}
-
-
-
-
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// LAYER
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-
-layer::layer( std::vector< dxfpair > info){
-	// Get the vertex information
-	
-	//basic_entity( info );
-	//static char string[10000];
-	char string[10000];
-	for (int i = 0; i < info.size(); i++){
-		switch( info[i].group_code ){
-			case 2:
-				info[i].value_char(layer_name);
-				break;
-			case 6:
-				info[i].value_char(ltype_name);
-				break;
-				
-			case 62:
-				info[i].value_char(string);
-				color_number = atoi(string);
-				//std::cout << "I found a color and its number = " << color_number << std::endl;
-				break;
-			case 290:
-				info[i].value_char(string);
-				plotting_flag = atoi(string);				
-				break;
-		}
-	}	
-}
-
-void layer::display(){
-	std::cout << "LAYER\n";
-	//std::cout << "\tx = " << x << "\ty = " << y << "\tz = " << z << "\tbulge = " << bulge << std::flush;
-}
-
-char* layer::name(char* string){
-	return( strcpy(string,layer_name) );
-}
-
-
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// LTYPE
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-
-ltype::ltype( std::vector< dxfpair > info){
-	// Get the linetype information
-	
-	//static char string[10000];
-	char string[10000];
-	for (int i = 0; i < info.size(); i++){
-		switch( info[i].group_code ){
-			case 2:
-				info[i].value_char(ltype_name);
-				break;
-			case 3:
-				info[i].value_char(descriptive_txt);
-				break;
-			case 73:
-				info[i].value_char(string);
-				num_elements = atoi(string);
-				break;
-			case 40:
-				info[i].value_char(string);
-				pattern_length = atof(string);				
-				break;
-			case 49:
-				info[i].value_char(string);
-				pattern.push_back( atof(string) );
-				break;
-		}
-	}	
-}
-
-
-
-char* ltype::name(char* string){
-	return( strcpy(string,ltype_name) );
-}
-
-
-std::vector< double > ltype::ret_pattern(){
-	return pattern;
-}
-
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// tables
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-	
-
-
-tables::tables(std::vector< std::vector< dxfpair > > sections){
-	// Read the main information about the entities section and then put it in the enetites class
-	int value;
-	char string[10000];
-	
-	for(int i = 0; i < sections.size(); i++){
-		//std::cout << "start" << std::endl;
-		sections[i][0].value_char(string);
-		value = determine_table(string);
-		//std::cout << "sections.size() = " << sections.size() << std::endl << "i = " << i << std::endl << "string = " << string << std::endl;
-		switch( value ){
-			case 0:
-				// LAYER
-				//std::cout << "tables start layer " << std::endl;
-				tables_layer.push_back( layer( sections[i] ) );
-				//std::cout << "tables end layer " << std::endl;
-				break;
-			
-			case 1:
-				// LTYPE
-				//std::cout << "tables start ltype " << std::endl;
-				tables_ltype.push_back( ltype( sections[i] ) );
-				//std::cout << "tables end ltype " << std::endl;
-				break;
-				
-			//case 3:
-			//	break;
-			
-			default:
-				break;
-				// Nothing here
-		}
-		
-	}
-	
-}
-
-
-
-		
-ltype tables::ret_ltype(char ltype_name[10000], char layer_name[10000]){
-	int string_len = 0;
-	char name[10000];
-	char temp[10000];
-	// The ltype information may be given in the entitity or in the layer information
-	// Assume that if there is a name defined in the linetype that it trumps any other layer information
-	if ( strlen(ltype_name) > 0 ) strcpy(name,ltype_name); 
-	else strcpy(name,layer_name);
-	for (int i = 0; i < tables_ltype.size();i++){
-		string_len = strlen(tables_ltype[i].name(temp));	
-		if (strncmp(tables_ltype[i].name(temp),name,string_len) == 0 ) return tables_ltype[i];	
-	}
-	return tables_ltype[0];
-}
-
-
-layer tables::ret_layer(char layer_name[10000]){
-	int string_len = 0;
-	char temp[10000];
-	
-	for (int i = 0; i < tables_layer.size();i++){
-		string_len = strlen(tables_layer[i].name(temp));	
-		if (strncmp(tables_layer[i].name(temp),layer_name,string_len) == 0 ) return tables_layer[i];	
-	}
-	return tables_layer[0];
-}
-
-
-std::vector< layer > tables::ret_layers(){
-	return tables_layer;
-}
diff --git a/src/extension/dxf2svg/tables.h b/src/extension/dxf2svg/tables.h
deleted file mode 100644
index f63122eaf..000000000
--- a/src/extension/dxf2svg/tables.h
+++ /dev/null
@@ -1,71 +0,0 @@
-/* Code for the conversion of DXF information in the TABLES section
-Matt Squires
-SoC
-2005*/
-
-#ifndef DXF_TABLES_H
-#define DXF_TABLES_H
-
-#include<vector>
-#include"read_dxf.h"
-
-class table{
-	public:
-		int ret_maxN();
-	private:
-		int max_number;
-};
-
-
-class layer : public table{
-	public:
-		layer( std::vector< dxfpair > info);
-		void display();
-		char* name(char* string);
-	private:
-		char layer_name[10000];
-		char ltype_name[10000]; // The layer may also hold the ltype infomation
-		int color_number;
-		int plotting_flag;
-	
-};
-
-
-class ltype : public table{
-	public:
-		ltype( std::vector< dxfpair > info);
-		char* name(char* string);
-		std::vector< double > ret_pattern();
-	private:
-		char ltype_name[10000];
-		char descriptive_txt[10000];
-		int num_elements;
-		double pattern_length;
-		std::vector< double > pattern;
-	
-};
-
-
-class tables{
-	// Well I said that I would only use STL containers internally, but I would have to use a dynamically linked list, and I haven't done for a long time soo STL is my crutch.
-	public:
-		tables(std::vector< std::vector< dxfpair > > sections); // Put the various entities into their respective vectors
-		void display_all();
-		
-		ltype ret_ltype(char ltype_name[10000], char layer_name[10000]);
-		layer ret_layer(char layer_name[10000]);
-		
-		std::vector< layer > ret_layers();
-		
-		
-	private:
-		//void add_dimstyle(polyline pline);
-		void add_layer(layer layr);
-		void add_ltype(ltype line_type);
-		
-		std::vector< layer > tables_layer;
-		std::vector< ltype > tables_ltype;
-};
-
-
-#endif
diff --git a/src/extension/dxf2svg/tables2svg_info.cpp b/src/extension/dxf2svg/tables2svg_info.cpp
deleted file mode 100644
index c59060306..000000000
--- a/src/extension/dxf2svg/tables2svg_info.cpp
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- * Convert DXF table information to a format that is recognized by SVG
- *
- * Author:
- *   Matt Squires <squiresm@colorado.edu>
- *
- * Copyright (C) 2005 Matt Squires
- *
- * Released under GNU GPL and LGPL, read the file 'GPL.txt' and 'LGPL.txt' for details
- */
-
-
-#include "tables2svg_info.h"
-#include <math.h>
-#include <iostream>
-#include <stdlib.h>
-#include <string.h>
-
-char* pattern2dasharray(ltype info, int precision, double scaling, char* out){
-	std::vector< double > pattern = info.ret_pattern();
-	char temp[50];
-	char *out_ptr;
-	
-	
-	if (!pattern.empty()){
-		strcat(out," stroke-dasharray=\"");	
-		for(int i = 0; i < pattern.size()-1;i++){
-			strcat(out,gcvt(scaling*sqrt(pow(pattern[i],2)),precision,temp) );
-			strcat(out,",");
-		}
-		strcat( out,gcvt(scaling*sqrt(pow(pattern[pattern.size()-1],2)),precision,temp) );
-		strcat(out,"\" ");
-	}
-	
-	out_ptr = out;
-	return out_ptr;
-}
diff --git a/src/extension/dxf2svg/tables2svg_info.h b/src/extension/dxf2svg/tables2svg_info.h
deleted file mode 100644
index 2c99f034e..000000000
--- a/src/extension/dxf2svg/tables2svg_info.h
+++ /dev/null
@@ -1,9 +0,0 @@
-/* Convert DXF table information to a format that is recognized by SVG
-Matt Squires
-SOC 2005
-*/
-
-
-#include"tables.h"
-
-char* pattern2dasharray(ltype info, int precision, double scaling, char* temp);
diff --git a/src/extension/dxf2svg/test_dxf.cpp b/src/extension/dxf2svg/test_dxf.cpp
deleted file mode 100644
index c3bbdc141..000000000
--- a/src/extension/dxf2svg/test_dxf.cpp
+++ /dev/null
@@ -1,99 +0,0 @@
-/* test read_dxf  */
-#include"read_dxf.h"
-#include"entities.h"
-#include"blocks.h"
-#include"tables.h"
-#include<iostream>
-#include"entities2elements.h"
-
-using namespace std;
-
-int main(){
-	std::vector< std::vector< dxfpair > >  output, entities_info, blocks_info, tables_info;
-	//output =  dxf_get_sections("circ_sqr.dxf");
-	//output =  dxf_get_sections("Labjack.dxf");
-	//output =  dxf_get_sections("mini_post.dxf");
-	//output =  dxf_get_sections("../8599-E0W.dxf");
-	//output =  dxf_get_sections("../bulged_lwpoly.dxf");
-	//output =  dxf_get_sections("../aspheric_lens.dxf");
-	output =  dxf_get_sections("../layers_colors.dxf");
-	/*std::vector< dxfpair > header;
-	std::vector< dxfpair > classes;
-	std::vector< dxfpair > tables;
-	std::vector< dxfpair > blocks;
-	std::vector< dxfpair > entities;
-	std::vector< dxfpair > objects;
-	std::vector< dxfpair > thumbnailimage;
-	*/
-	
-	
-	//dxf_get_sections("circ_sqr.dxf",header,classes,tables,blocks,entities,objects,thumbnailimage);
-	//dxf_get_sections("mini_post.dxf",header,classes,tables,blocks,entities,objects,thumbnailimage);
-	
-	//cout << entities.size() << endl;
-	for (int i=0;i<output.size();i++) cout << "output[i].size()" << i << " = " << output[i].size() << endl;
-	//cout << endl;
-	//for (int i=0;i<output[0].size();i++) cout << output[0][i].group_code << "\t"  << output[0][i].value << endl;
-	//cout << endl;
-	//for (int i=0;i<output[4].size();i++) cout << output[4][i].group_code << "\t" << output[4][i].value << endl;
-	
-	// Now display the different parts of the entities section
-	//cout << endl;
-	for (int i=0;i < output[4].size();i++){
-		//cout << output[4][i].group_code << "  " << output[4][i].value[0] << output[4][i].value[1] << endl;
-	}
-	cout << endl;
-	entities_info = separate_parts(output[4]);
-	cout << "entities_info.size() = " << entities_info.size() << endl;
-	
-	for (int i=0;i < entities_info.size();i++){
-		//for (int j=0;j < entities_info[i].size();j++) cout << entities_info[i][j].group_code << "  " << entities_info[i][j].value[0] << entities_info[i][j].value[1] << entities_info[i][j].value[2] << entities_info[i][j].value[3] << entities_info[i][j].value[4] << "\n";
-		//cout << endl << endl << endl;
-	}
-	
-	cout << "blocks separate parts" << endl;
-	blocks_info = separate_parts(output[3]); // Tables is the 4th part of a dxf file.
-	cout << "sort separated parts" << endl;
-	blocks blks(blocks_info);  // Sort the information in the tables
-	cout << "blocks_info.size() = " << blocks_info.size() << endl;
-	
-	for (int i=0;i < blocks_info.size();i++){
-		//for (int j=0;j < blocks_info[i].size();j++) cout << blocks_info[i][j].group_code << "  " << blocks_info[i][j].value[0] << blocks_info[i][j].value[1] << blocks_info[i][j].value[2] << blocks_info[i][j].value[3] << blocks_info[i][j].value[4] << "\n";
-		//cout << endl << endl << endl;
-	}
-	
-	
-	tables_info = separate_parts(output[2]); // Tables is the 3rd part of a dxf file.
-	cout << "tables_info.size() = " << tables_info.size() << endl;
-	for (int i=0;i < tables_info.size();i++){
-		//for (int j=0;j < tables_info[i].size();j++) cout << tables_info[i][j].group_code << "  " << tables_info[i][j].value[0] << tables_info[i][j].value[1] << tables_info[i][j].value[2] << tables_info[i][j].value[3] << tables_info[i][j].value[4] << "\n";
-		//cout << "i = " << i << endl << endl;
-	}
-	tables tbls(tables_info);  // Sort the information in the tables
-	
-	
-	
-	cout << "This should change \n";
-	
-	cout << "\n\nNow display all parsed info \n";
-	entities ents(entities_info);
-	ents.display_all();
-	
-	//char units[5] = "in";
-	// char units[5] = "";
-	
-	cout << "\nNow for the begining of the SVG...\n\n";
-	
-	cout << "Polyline conversion\n";
-	//std::vector< polyline > pl_tmp= ents.ret_plines();
-	//cout << "pline2pline\n" << pline2pline(pl_tmp[0], units ) << endl;
-	//cout << "pline2pline\n" << pline2pline(ents.ret_plines()[0], units ) << endl;
-	//cout << "pline2path\n" << pline2path(ents.ret_plines()[0], units );
-	
-	// char tmp_char[10000];
-	
-	cout << "\nCircle conversion\n";
-	//cout << "circle2circle\n" << circle2circle(ents.ret_circles()[0], 3, units, tmp_char) << endl;
-	
-	return 0;
-}