add XNODE and XATTR classes

common/CMakeLists.txt

@@ -53,6 +53,7 @@ set(COMMON_SRCS
     trigo.cpp
     worksheet.cpp
     wxwineda.cpp
+    xnode.cpp
     zoom.cpp
 )
 

common/xnode.cpp

+/*
+ * This program source code file is part of KICAD, a free EDA CAD application.
+ *
+ * Copyright (C) 2010 SoftPLC Corporation, Dick Hollenbeck <dick@softplc.com>
+ * Copyright (C) 1992-2010 Kicad Developers, see change_log.txt for contributors.
+ *
+ * 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, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+
+#include "xnode.h"
+
+void XNODE::Format( OUTPUTFORMATTER* out, int nestLevel ) throw( IOError )
+{
+    // output attributes first if they exist
+
+    // output children if they exist.
+
+    // output "contents" if it exists.  Use quote need checker to wrap contents if needed.
+
+    // A good XML element will not have both children AND contents, usually one or the other.
+    // children != attributes in the above statement.
+
+//    for( XNODE*...
+}
+
+
+void XNODE::FormatContents( OUTPUTFORMATTER* out, int nestLevel ) throw( IOError )
+{
+    // overridden in ELEM_HOLDER
+}
+
+
+void XATTR::Format( OUTPUTFORMATTER* out, int nestLevel ) throw( IOError )
+{
+    // output attributes first if they exist
+
+    // output children if they exist.
+
+    // output "contents" if it exists.  Use quote need checker to wrap contents if needed.
+
+    // A good XML element will not have both children AND contents, usually one or the other.
+    // children != attributes in the above statement.
+
+//    for( XNODE*...
+}
+
+
+void XATTR::FormatContents( OUTPUTFORMATTER* out, int nestLevel ) throw( IOError )
+{
+    // overridden in ELEM_HOLDER
+}
+
+
+// EOF

eeschema/netform.cpp

@@ -30,7 +30,6 @@
 
 #include "fctsys.h"
 
-#include <wx/xml/xml.h>
 
 #include "gr_basic.h"
 #include "common.h"
@@ -46,6 +45,8 @@
 #include "class_library.h"
 #include "class_pin.h"
 
+#include "xnode.h"      // also nests: <wx/xml/xml.h>
+
 #include "build_version.h"
 
 #include <set>
@@ -189,6 +190,21 @@ class EXPORT_HELP
      */
     void writeListOfNetsCADSTAR( FILE* f, NETLIST_OBJECT_LIST& aObjectsList );
 
+
+    /**
+     * Function makeGenericRoot
+     * builds the entire document tree for the generic export.  This is factored
+     * out here so we can write the tree in either S-expression file format
+     * or in XML if we put the tree built here into a wxXmlDocument.
+     */
+    wxXmlNode* makeGenericRoot();
+
+    /**
+     * Function makeGenericComponents
+     * returns a sub-tree holding all the schematic components.
+     */
+    wxXmlNode* makeGenericComponents();
+
     /**
      * Function makeGenericDesignHeader
      * fills out a project "design" header into an XML node.
@@ -219,11 +235,11 @@ class EXPORT_HELP
 public:
 
     /**
-     * Function Write_GENERIC_NetList
+     * Function WriteGENERICNetList
      * creates a generic netlist, now in XML.
      * @return bool - true if there were no errors, else false.
      */
-    bool Write_GENERIC_NetList( WinEDA_SchematicFrame* frame, const wxString& aOutFileName );
+    bool WriteGENERICNetList( WinEDA_SchematicFrame* frame, const wxString& aOutFileName );
 
     /**
      * Function WriteNetListPCBNEW
@@ -337,7 +353,7 @@ bool WinEDA_SchematicFrame::WriteNetListFile( int aFormat, const wxString& aFull
             wxFileName  tmpFile = aFullFileName;
             tmpFile.SetExt( wxT( "tmp" ) );
 
-            ret = helper.Write_GENERIC_NetList( this, tmpFile.GetFullPath() );
+            ret = helper.WriteGENERICNetList( this, tmpFile.GetFullPath() );
             if( !ret )
                 break;
 
@@ -795,57 +811,63 @@ wxXmlNode* EXPORT_HELP::makeGenericListOfNets()
 }
 
 
-bool EXPORT_HELP::Write_GENERIC_NetList( WinEDA_SchematicFrame* frame, const wxString& aOutFileName )
+wxXmlNode* EXPORT_HELP::makeGenericRoot()
 {
-#if 1
-    // output the XML format netlist.
-    wxXmlDocument   xdoc;
+    wxXmlNode*  xroot = node( wxT( "export" ) );
 
-                                // tree markers or walkers
-    wxXmlNode*      xroot;      // root node
-    wxXmlNode*      xcomps;     // start of components
+    xroot->AddProperty( wxT( "version" ), wxT( "D" ) );
+
+    // add the "design" header
+    xroot->AddChild( makeGenericDesignHeader() );
+
+    xroot->AddChild( makeGenericComponents() );
+
+    xroot->AddChild( makeGenericLibParts() );
+
+    // must follow makeGenericLibParts()
+    xroot->AddChild( makeGenericLibraries() );
+
+    xroot->AddChild( makeGenericListOfNets() );
+
+    return xroot;
+}
+
+
+wxXmlNode* EXPORT_HELP::makeGenericComponents()
+{
+    wxXmlNode*      xcomps = node( wxT( "components" ) );
+
+    wxString        timeStamp;
 
     // some strings we need many times, but don't want to construct more
     // than once for performance.  These are used within loops so the
     // enclosing wxString constructor would fire on each loop iteration if
     // they were in a nested scope.
 
-    wxString        timeStamp;
-    wxString        logicalLibName;
-
-
     // these are actually constructor invocations, not assignments as it appears:
-    const wxString  sFields     = wxT( "fields" );
-    const wxString  sField      = wxT( "field" );
-    const wxString  sComponent  = wxT( "comp" );          // use "part" ?
-    const wxString  sName       = wxT( "name" );
-    const wxString  sRef        = wxT( "ref" );
-    const wxString  sPins       = wxT( "pins" );
-    const wxString  sPin        = wxT( "pin" );
-    const wxString  sValue      = wxT( "value" );
-    const wxString  sSheetPath  = wxT( "sheetpath" );
-    const wxString  sFootprint  = wxT( "footprint" );
-    const wxString  sDatasheet  = wxT( "datasheet" );
-    const wxString  sTStamp     = wxT( "tstamp" );
-    const wxString  sTStamps    = wxT( "tstamps" );
-    const wxString  sTSFmt      = wxT( "%8.8lX" );        // comp->m_TimeStamp
-    const wxString  sLibSource  = wxT( "libsource" );
-    const wxString  sLibPart    = wxT( "libpart" );
-    const wxString  sLib        = wxT( "lib" );
-    const wxString  sPart       = wxT( "part" );
-    const wxString  sNames      = wxT( "names" );
+    wxString  sFields     = wxT( "fields" );
+    wxString  sField      = wxT( "field" );
+    wxString  sComponent  = wxT( "comp" );          // use "part" ?
+    wxString  sName       = wxT( "name" );
+    wxString  sRef        = wxT( "ref" );
+    wxString  sPins       = wxT( "pins" );
+    wxString  sPin        = wxT( "pin" );
+    wxString  sValue      = wxT( "value" );
+    wxString  sSheetPath  = wxT( "sheetpath" );
+    wxString  sFootprint  = wxT( "footprint" );
+    wxString  sDatasheet  = wxT( "datasheet" );
+    wxString  sTStamp     = wxT( "tstamp" );
+    wxString  sTStamps    = wxT( "tstamps" );
+    wxString  sTSFmt      = wxT( "%8.8lX" );        // comp->m_TimeStamp
+    wxString  sLibSource  = wxT( "libsource" );
+    wxString  sLibPart    = wxT( "libpart" );
+    wxString  sLib        = wxT( "lib" );
+    wxString  sPart       = wxT( "part" );
+    wxString  sNames      = wxT( "names" );
 
 
     m_ReferencesAlreadyFound.Clear();
 
-    xdoc.SetRoot( xroot = node( wxT( "export" ) ) );
-    xroot->AddProperty( wxT( "version" ), wxT( "D" ) );
-
-    // add the "design" header
-    xroot->AddChild( makeGenericDesignHeader() );
-
-    xroot->AddChild( xcomps = node( wxT( "components" ) ) );
-
     SCH_SHEET_LIST sheetList;
 
     // Output is xml, so there is no reason to remove spaces from the field values.
@@ -922,12 +944,17 @@ bool EXPORT_HELP::Write_GENERIC_NetList( WinEDA_SchematicFrame* frame, const wxS
         }
     }
 
-    xroot->AddChild( makeGenericLibParts() );
+    return xcomps;
+}
 
-    // must follow makeGenericLibParts()
-    xroot->AddChild( makeGenericLibraries() );
 
-    xroot->AddChild( makeGenericListOfNets() );
+bool EXPORT_HELP::WriteGENERICNetList( WinEDA_SchematicFrame* frame, const wxString& aOutFileName )
+{
+#if 1
+    // output the XML format netlist.
+    wxXmlDocument   xdoc;
+
+    xdoc.SetRoot( makeGenericRoot() );
 
     return xdoc.Save( aOutFileName, 2 /* indent bug, today was ignored by wxXml lib */ );
 

include/xnode.h

+#ifndef _XATTR_H_
+#define _XATTR_H_
+
+/*
+ * This program source code file is part of KICAD, a free EDA CAD application.
+ *
+ * Copyright (C) 2010 SoftPLC Corporation, Dick Hollenbeck <dick@softplc.com>
+ * Copyright (C) 1992-2010 Kicad Developers, see change_log.txt for contributors.
+ *
+ * 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, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+
+#include "richio.h"
+
+#include <wx/xml/xml.h>
+
+// These are classes for eXporting document trees, and thus have names
+// starting with X.  They can export either in XML or S-expression format.
+
+
+/**
+ * Class XATTR
+ * holds an XML or S-expression attribute/child value.  It is used for eXporting
+ * a document tree in EITHER XML or S-expression.
+ */
+class XATTR : public wxXmlProperty      // use wxXmlAttribute for wx >= 2.9
+{
+public:
+    XATTR() :
+        wxXmlProperty()
+    {
+    }
+
+    XATTR( const wxString& aName, const wxString& aValue ) :
+        wxXmlProperty( aName, aValue )
+    {
+    }
+
+
+    /**
+     * Function Format
+     * writes this object as UTF8 out to an OUTPUTFORMATTER as an S-expression
+     * @param out The formatter to write to.
+     * @param nestLevel A multiple of the number of spaces to preceed the output with.
+     * @throw IOError if a system error writing the output, such as a full disk.
+     */
+    virtual void Format( OUTPUTFORMATTER* out, int nestLevel ) throw( IOError );
+
+
+    /**
+     * Function FormatContents
+     * writes the contents of object as UTF8 out to an OUTPUTFORMATTER as an S-expression
+     * This is the same as Format() except that the outer wrapper is not included.
+     * @param out The formatter to write to.
+     * @param nestLevel A multiple of the number of spaces to preceed the output with.
+     * @throw IOError if a system error writing the output, such as a full disk.
+     */
+    virtual void FormatContents( OUTPUTFORMATTER* out, int nestLevel ) throw( IOError );
+};
+
+
+/**
+ * Class XNODE
+ * holds an XML or S-expression element.  It is used for eXporting
+ * a document tree in EITHER XML or S-expression.
+ */
+class XNODE : public wxXmlNode
+{
+public:
+    XNODE() :
+        wxXmlNode()
+    {
+    }
+
+
+    XNODE( wxXmlNodeType aType, const wxString& aName, const wxString& aContent = wxEmptyString ) :
+        wxXmlNode( NULL, aType, aName, aContent )
+    {
+    }
+
+
+    /**
+     * Function Format
+     * writes this object as UTF8 out to an OUTPUTFORMATTER as an S-expression
+     * @param out The formatter to write to.
+     * @param nestLevel A multiple of the number of spaces to preceed the output with.
+     * @throw IOError if a system error writing the output, such as a full disk.
+     */
+    virtual void Format( OUTPUTFORMATTER* out, int nestLevel ) throw( IOError );
+
+
+    /**
+     * Function FormatContents
+     * writes the contents of object as UTF8 out to an OUTPUTFORMATTER as an S-expression
+     * This is the same as Format() except that the outer wrapper is not included.
+     * @param out The formatter to write to.
+     * @param nestLevel A multiple of the number of spaces to preceed the output with.
+     * @throw IOError if a system error writing the output, such as a full disk.
+     */
+    virtual void FormatContents( OUTPUTFORMATTER* out, int nestLevel ) throw( IOError );
+};
+
+#endif  // _XATTR_H_