Chuck,
I still think an XML approach would be more easy to write and easier to
maintain. You normally already have the XML parser on your computer and
don't have to parse the file by your self.
Assume you have a XML file looking like below which is specifying the Sub's
you want to call and the parameters:
<?xml version="1.0" encoding="UTF-8"?>
<ChuckScript>
<Commands>
<Command>
<Name>MyOpenDoc</Name>
<Parameters>C:\temp\mydoc.doc</Parameters>
</Command>
<Command>
<Name>MyPrintDoc</Name>
<Parameters/>
</Command>
<Command>
<Name>MyCloseDoc</Name>
<Parameters/>
</Command>
</Commands>
</ChuckScript>
This XML file specifies three 'Command' and a parameter for only the first
Command. Then it would be very easy to add/remove Command tags depending on
your needs. One Command tag for each Sub you want to call.
Then your macros could look like this:
Sub XMLScript()
Dim sXMLFile As String
Dim oXML As Object
Dim oDocNode As Object
Dim oCommand As Object
Dim oCommandNode As Object
Dim oSub As Object
Dim oParam As Object
Dim oError As Object
sXMLFile = "c:\temp\chucktest.xml"
'**** This code is to get the XML Parser up and trunning with the XML file
' Create an instance of the Parser with the version independent
interface
' Sometimes you should use MSXML2.DOMDocument
Set oXML = CreateObject("MSXML.DOMDocument")
oXML.validateOnParse = False
oXML.async = False
oXML.Load sXMLFile ' Load the XML file
Set oError = oXML.parseError
' Check if there was any error open/parsing the XML file
If oError.errorCode <> 0 Then
MsgBox "Error parsing " & sXMLFile & vbCrLf & _
"Error: " & oError.reason
Exit Sub
End If
'**** If we get here we are ready to go
' Get the document tag (ChuckScript)
Set oDocNode = oXML.documentElement
' Get the whole node tree for the Commands node
Set oCommandNode = oDocNode.selectSingleNode("Commands")
'**** This is the logic for calling the Sub routines
' Loop through all Command nodes in the Commands node
For Each oCommand In oCommandNode.childNodes
' Get the Name and Parameters nodes in the Command node
Set oSub = oCommand.selectSingleNode("Name")
Set oParam = oCommand.selectSingleNode("Parameters")
' Call the sub defined in the Name node and the parameter string
Application.Run oSub.Text, oParam.Text
Next
'**** That's all
' Be polite and clean up after you
Set oXML = Nothing
Set oDocNode = Nothing
Set oCommand = Nothing
Set oCommandNode = Nothing
Set oSub = Nothing
Set oParam = Nothing
Set oError = Nothing
End Sub
'-------------------------------------
Sub MyOpenDoc(sParams As String)
MsgBox "MyOpenDoc was called with this parameter:" & vbCrLf & sParams
End Sub
'------------------------------------
Sub MyPrintDoc(sParams As String)
MsgBox "MyPrintDoc was called with this parameter:" & vbCrLf & sParams
End Sub
'------------------------------------
Sub MyCloseDoc(sParams As String)
MsgBox "MyCloseDoc was called with this parameter:" & vbCrLf & sParams
End Sub
'------------------------------------
If you try this code with the XML file I think you will get the whole idea.
As you can see you don't have to bother about opening, reading, parsing a
text file if you take the XML approach. The XML Parser does it all for you.
We actually used a similar solution in a large system. It was a system for
power suppliers that was reading the power meters remotely. Each power
supplier (with self respect) has their own billing system that expects data
in a specific format. We craeted a small application where the users could
specify which methods to use to collect the data (like calling Sub's above),
which data to output, the output format of the binary file and very detailed
formatting of the data. All the settings were written to an XML file and the
system used this XML file when generating the output for the different
billing systems. This solution turned out to be very flexibel and very easy
to maintain. When output formats changes we do not have to tuch the system
as all definitions are stored outside the system in XML.
One other good thing about working with XML is that there are many tools
available. I prefer XMLSpy. XML is also becomming the standard for data
exchange between different systems.
Regards,
Lars-Eric
