Thats solved that problem nicely - in fact, I'd forgotten I had:

xmlIO = new XMLInOut(this);

In my code, so "xmlIO.saveElement(elementhere, filehere);" appears to be working. Except, on ls -la of the directory, no "mbp_toc.xml"

In the output window, I get the directory of where the file is being saved, ergo: /home/boris/Sketchbook/data but no error messages, nothing really. I don't know if the fact the directory being printed there is significant - possibly its saying "can't write file"?

And yes, ok, is there a way to move this to the Contributed Libraries section? I thought this was just an out and out programming question. My apoligies.

Being moderator of the forum, I already moved it...
And I tend to move any question involving a library to the appropriate section, because often it needs knowledge of the said library, and in the case of contributed ones, needs the library itself to run given code (if complete). That's why I often say to isolate (when you can!) code from "fluff" (libraries not necessary to the question itself).

Your question is, somehow, in between: programming (Java) question, but related to a library you used, which can be misleading (I had to guess the origin of the issue, not looking at the API itself).
But to answer your issue (no file), one has to know the library itself.
BTW, why did you move away from Jsoup?

As the British would say: "Jolly good show, old son...!"

Possibly I should write an actual test program involving only the proXML libraries, and try to cobble it together first, you're thinking? This is what I did for the loop that we were having problems with - wrote it out as logically as I could, and got it working. For "haspreface" (the eventual checkbox) I used a value of "0" or "1" and that worked good.

Ok - the docos on the library are a bit sparse, and examples are few and far between. This is unfortunate, as I'm sure its a great library and is featured on the Processing site under third party libraries, which is where I originally found it. I think it was you who suggested JSoup for the HTML, yes...? It works great now...!

Moving away from JSoup, I was unaware it would do XML. Is this the case? Or could I use it to (potentially) construct an XML file? You see, the application calls for the HTML files to be parsed, as we discussed, then an XML file generated... I don't question why, I'm sure I could do it better, along with every other programmer out there, but I didn't design the eventual device that the code will be used on. Almost like saying "Well Accessory Mode on Android is a hack, and I don't like it, and it isn't an official USB spec and..." but someone else designed it, and you need to make your code work with it.

By the way, I'm loving this development so much, I might even use Processing, along with the Android libraries, to make a program for my active RFID, which is the next project in the shop...

Anyway, I'll let you get back to me on the XML processing abilities of JSoup... thinking about it, i couldn't see why not, but I'm just going to throw up "structured XML vs code soup HTML" as a thought.

Thanks again!

I am not sure why kind of XML you need, but the file I saved with Jsoup has an HTML 3.2 header but it wrote effectively XHTML code (eg. with <hr />, self-closing tags).
I have nothing against proXML (which I haven't really used) but today, with Java 6, I would just go at the native XML support from Java. Not necessarily easy to learn/master, but powerful and handling all XML you can throw at it. I believe that Processing 2.0 will switch to it for its XML library.

Yeah, essentially I need a nice header (hate them), and then something like:

<docTitle><text>Fringe of Telecommunications</text></docTitle>

Kind of code. Self closing? Unsure if they'd work with what I'm programming for - I'm guessing "no."

And yea, I can imagine the advances with the XML handling, but I'm using todays apps, not tomorrows... If I were to rewrite this sketch in Processing 2.0, I'd be open to suggestions, for sure. But unfortunately, that doesn't help me with todays tools.

Just an idea of code to generate a header and then the code as expounded upon would be lovely. Otherwise this whole thing is dead in the water. And here I was thinking the XML would be easy (before I found out about JSoup) because there was a library...!

Ok, made the decision to stick with JSoup, as you had recommended. I think the biggest motivating factor is the fact my XML file must follow a "traditional" tag format, ie, no self closing tags.

That example I gave you:

<docTitle><text>Fringe of Telecommunications</text></docTitle>

Would be easily handled by a "wrap" call - perhaps "doctitle.wrap("<docTitle><text></text></docTitle>"

So, the next question - how would I go about making the XML file from scratch?

You see, before we had the HTML files, and were able to "doc.select("h1");" for example. Thats actually working really well now. But how would I have a tag inserted, from scratch?

I have some code, doesn't do anything yet:

  System.out.println("XML file begins");
 
  Document xmlFringe = null;
 
  xmlFringe = new Document("/home/boris/Sketchbook/data/fringe.xml"); 
 
  header.html("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
 
  String[] ncxcode = {
    ncx.toString()
  };
  saveStrings("/home/boris/Sketchbook/data/fringe.xml", ncxcode);

So, in that example, everything works except for the "header.html..." - where I need a push in the right direction to start writing the tags. Creation and saving of the file works perfectly. All those methods we discussed in the JSoup questions would be put to good use... just need that little nudge.

Ah, I misunderstood, I thought you wanted to make XHTML. But you want to do real XML.
Now, it is not the future, you can use the existing Java API for that.

Here is a test I did in Java, transcribed almost literally for Processing:

1. import javax.xml.parsers.*;
2. import javax.xml.transform.*;
3. import javax.xml.transform.dom.DOMSource;
4. import javax.xml.transform.stream.StreamResult;
5.  
6. import org.w3c.dom.*;
7.  
8. void setup()
9. {
10.   createXMLFile(sketchPath("Test.xml"), false);
11.   println("Done");
12.   exit();
13. }
14.  
15. void createXMLFile(String fileName, boolean validating)
16. {
17.   try
18.   {
19.     DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
20.     factory.setNamespaceAware(true);
21.     DocumentBuilder builder = factory.newDocumentBuilder();
22.     Document document = builder.newDocument();
23.  
24.     Element root = document.createElementNS("http://example.com", "root");
25.     document.appendChild(root);
26.     Attr rootAttribute = document.createAttributeNS("http://example.com", "attribute");
27.     rootAttribute.setValue("value");
28.     root.setAttributeNodeNS(rootAttribute);
29.  
30.     Element child1 = document.createElement("one-child");
31.     child1.setTextContent("Content of one child");
32.     root.appendChild(child1);
33.  
34.     // Don't re-use Element!
35.     Element child2 = document.createElement("one-child");
36.     child2.setTextContent("Another content\nof one child");
37.     Attr childAttr = document.createAttribute("a");
38.     childAttr.setValue("Fooo");
39.     child2.setAttributeNode(childAttr);
40.     root.appendChild(child2);
41.  
42.     Element child3 = document.createElement("other-child");
43.     Attr childParam1 = document.createAttribute("param");
44.     childParam1.setValue("Empty tag");
45.     child3.setAttributeNode(childParam1);
46.     root.appendChild(child3);
47.  
48.     Element child4 = document.createElement("other-child");
49.     child4.setTextContent("Content of the other child");
50.     Attr childParam2 = document.createAttribute("param");
51.     childParam2.setValue("Some value");
52.     child4.setAttributeNode(childParam2);
53.     root.appendChild(child4);
54.  
55.     DOMSource source = new DOMSource(document);
56.     PrintStream ps = new PrintStream(fileName);
57.     StreamResult res = new StreamResult(ps);
58.  
59.     TransformerFactory tf = TransformerFactory.newInstance();
60.     Transformer transf = tf.newTransformer();
61.  
62.     // Output the generated XML
63.     transf.transform(source, res);
64.   }
65.   catch (ParserConfigurationException e)
66.   {
67.     println("Error: " + e);
68.   }
69.   catch (TransformerConfigurationException e)
70.   {
71.     println("Error: " + e);
72.   }
73.   catch (TransformerException e)
74.   {
75.     println("Error: " + e);
76.   }
77.   catch (IOException e)
78.   {
79.     println("Cannot write file " + fileName);
80.   }
81. }

If you understand how it works, you should be able to adapt to your needs, I think.
Note: there is no built-in way to format it nicely... (to my knowledge)

Yeah, I could imagine about the formatting - a little obtuse.

I understand, just by reading it, what it should do... but, and this will sound a little silly, I have a problem with the libraries:

No library found for org.w3c.dom

I tried a Google search for a quick download, and that proved fruitless.

Ah, I wrote a comment about it, but I forgot to paste it in the page! Silly me. Mmm, lost it.
Anyway, Processing detects an import not starting with java or javax, so it looks for a library, and doesn't find it. It doesn't matter because the library is actually shipped with the JDK/JRE, and it works despite the warning. The exotic name is because the W3C published the Dom API of XML, so the namespace belongs to them.

I found back a nicer way, more structured like the document to write, using the StAX library (still built in Java):

1. import javax.xml.stream.*;
2.  
3. void createXMLFile2(String fileName)
4. {
5.   XMLOutputFactory xof =  XMLOutputFactory.newInstance();
6.   XMLStreamWriter xtw = null;
7.   try
8.   {
9.     xtw = xof.createXMLStreamWriter(new FileOutputStream(fileName), "UTF-8");
10.     xtw.writeStartDocument("UTF-8", "1.0");
11.     xtw.writeStartElement("root");
12.     xtw.writeComment("This is an attempt to create an XML file with StAX");
13.  
14.     xtw.writeStartElement("foo");
15.     xtw.writeAttribute("order", "1");
16.       xtw.writeStartElement("meuh");
17.       xtw.writeAttribute("active", "true");
18.         xtw.writeCharacters("The cows are flying high this Spring");
19.       xtw.writeEndElement();
20.     xtw.writeEndElement();
21.  
22.     xtw.writeEmptyElement("separator");
23.  
24.     xtw.writeStartElement("bar");
25.     xtw.writeAttribute("order", "2");
26.       xtw.writeStartElement("tcho");
27.       xtw.writeAttribute("kola", "K");
28.         xtw.writeCharacters("Content of tcho tag");
29.       xtw.writeEndElement();
30.     xtw.writeEndElement();
31.  
32.     xtw.writeEndElement();
33.     xtw.writeEndDocument();
34.   }
35.   catch (XMLStreamException e)
36.   {
37.     e.printStackTrace();
38.   }
39.   catch (IOException ie)
40.   {
41.     ie.printStackTrace();
42.   }
43.   finally
44.   {
45.     if (xtw != null)
46.     {
47.       try
48.       {
49.         xtw.close();
50.       }
51.       catch (XMLStreamException e)
52.       {
53.         e.printStackTrace();
54.       }
55.     }
56.   }
57. }

I have also some code watching this print process and inserting additional chars (newlines, spaces or tabs) at strategical places to indent the output. I don't know if I ever made it to work, but it can be a good opportunity to work again on it.

It is a different approach. Here, you write the doc. as you build it, while in the first approach, you build the Dom first, then you output it. It allows additional manipulations of the Dom before output.

G'day again,

I'm going to use the first example, because I understand it much more readily. I know it doesn't output "clean" code, but I think I can live with that. I'm setting to work on the document that needs to be generated, but was wondering if you could give me a pointer - I need to write something similar to this in the header of the XML file:

<!DOCTYPE xml PUBLIC "-//NISO//DTD xml 2005-1//EN"
"http://www.daisy.org/a-link">
< xml xmlns= "http://www.daisy.org/b-link"
version="2005-1" xml:lang="en-US">

While I have played around a bit with the "header" in your code, I am unable to replicate this effort. So I'm going to concentrate on the rest of the document - not losing sight of the bigger picture, so to speak.

Thanks again!

Additionally, I tried this:

  createXMLFile("/home/boris/Sketckbook/data/mbp_toc.xml", false);

And got an error. Obviously, in your example, you put the file in with the sketch (sketchpath("foo.xml")), eventually mine will work off a variable in the GUI (using a File Chooser Dialog). However, for the time being, I'm just hard wiring the files, as you can see. If you could give me an idea of what I'm doing wrong there too, that'd be great.

Ah yes - good point. Re-examining the code, I'd realised I'd somehow made the "creatXMLFile" function declaration ("void...") into a simple call from my program. Ouch.

In its place, I put this:

void setup() {
  size(640, 480);
  noLoop();
  int haspreface = 1; //ControlP5 code?!
 
  generate("/home/boris/Sketchbook/data/paper1.html", "/home/boris/Sketchbook/data/mbp_toc.html", "/home/boris/Sketchbook/data/mbp_toc.xml");

}

void generate (String bookfile, String tocfile, String xmlfile) {

  System.out.println("Parsing begins...");
  ...

}

Hoping I could refer to those variables both within the setup() and generate(). It appears I can.

  Document doc = null;

Says "The type Document is ambiguous" - this was working, could it be because of my XML includes, and needing to name  JSoup.Document for example? That line there deals with the HTML files in the JSoup library, whereas I have more lines later in the program (eg "document.appendChild(root);") that deal with the XML file.

It is a mess now... trying to get the whole overall thing working now, so to speak. I call it "kludging" - others may call it "screen scraping" or a "simple, plain mess." =)

Ok, from the first part of the program (the JSoup part):

  Document doc = null;
  Document toc = null;

And from the second part of the program (the XML part):

  Document document = builder.newDocument();

Could it be an idea to make two seperate routines that are called from the pushing of the Generate button (say "HTXGenerate" and "XMLGenerate")?

Nope, that didn't work. Hmmm, if I'm able to explicitly name the type of Document I'm referring to, I would remove the ambiguity. I imagine the Element calls in one of the routines would need to be explicitly named as well.

Had a thought - why not make the HTXGenerate and XMLGenerate seperate files from the GUI? Then I can call the libraries necessary from each file without having that ambiguity.

So how would I go about calling different files from the main program? I can't seem to find any example code on the net...

Good line of thoughts...
Since you do pure Java programming anyway, if you prefer to remain in the PDE, you can put the Jsoup specific code in a .java file (eg. HTXGenerate.java) and the XML specific code in another (XMLGenerate.java) in addition to the base .pde file (all at the same level). The .java files will be loaded in separate threads, and can have independent imports. You can qualify the classes to distinguish them, but it is somehow impractical.

Note that separate .pde files are actually merged into the same class, so it wouldn't solve your problem.
Note also that in a .java file, you have no direct access to convenient functions like printn() or sketchPath().

Ok, yea, I wasn't using anything like "sketchPath()" although I noted one of your examples had it.

So I save them as .java files - how would I go about calling them from the main .pde? This is new territory for me, as I've noted, all coding I've done before was a single file.

Ok! Another step futher on this saga...

import javax.swing.JFileChooser;

public int tocitems;

HTXGenerate htx;
XMLGenerate xml;
 
void setup()
{
  size(640, 480);
  noLoop();
 
  int haspreface = 1; //ControlP5 code?!

  htx = new HTXGenerate(haspreface);
  xml = new XMLGenerate(haspreface);
 
  htx();
  ncx();

  println("Done");
  exit();
}

I know that isn't the right code, but hopefully you get an idea of what I'm trying to accomplish. Simply said, the variable "haspreface" needs to be passed to the .java files for additional processing. That detirmines whether the algorithm takes one choice or the other. That code is solid - might need some minor tweaks.

class HTXGenerate
{
  System.out.println("Parsing begins...");

is the code inside the .java file. I imagine I'll need to put something in there about "haspreface" too?

Eventually I want to pass "tocitems" to the two files, and use that in the algorithm to detirmine how many chapters there are. But we'll get "haspreface" working first, mmm?

By the way, the error i'm getting at the moment is:

The constructor HTXGenerate(int) is undefined

I suggest to take a look at an OOP tutorial like Objects.
Fast answer: should be like:

1. class HTXGenerate
2. {
3.   HTXGenerate(int hasprefact)
4.   {
5.     // Do some stuff
6.   }
7. }

Excellent!

Now a curly one - I want to return a value from the first class file, and put it into the second class file. Psudeocode like this:

void setup () {
      HTXGenerate;

class HTXGenerate {
      do some stuff;
      have a value, say tocitems.size();
      return tocitems.size;
}

      XMLGenerate;

class XMLGenerate {
      do some stuff;
      use the returned tocitems.size;
      do some more stuff;
}

exit();

I know in C you can return a value, and use that for telling whether the program worked or not (return 0 for sucess, -1 for a fail), but am I able to do this in Processing, and handle it the way I said?

Thanks!

Once you have a class, you populate it with methods (functions) that you can call, and that can return values. You better use booleans for success/fail condition...

Excellent - so its almost like a library, ergo:

htx.doSomething();
htx.doSomethingElse();

For example? Ok, that I understand.

What I now need is the nuts and bolts, in terms of the code, to implement the psudeocode that I expounded above. I'm going to need more than just a simple success/ fail, I need to know how many chapters are in the HTML file as I go from htx.doSomething to xml.doSomething.

That'll eliminate the ambiguity problem that we were tackling before by compartmentalising all the code with its own specific libraries.

Not almost like, exactly like... Libraries are based on classes...
And well, you can return anything, boolean, but also integers, or even objects. You can also store the result in the class, and get it with a method, eg. getChapterNb().

Hello again,

Ok - got all that. But some example code would be great...! =) I'd learn better with the code, and examining it, getting it to work for me, if you know what I mean.

I'm thinking now, it might be better to just return one of the numbers left over after the "mbp_toc_*" generation in the JSoup portion. That'll tell the XML portion how many "mbp_toc_*" items it needs.

* So, main file:

htx.doSomething();

returned value? how to handle?

xml.doSomethingElse(returned value)

* htxGenerate file:

...
return chaptercount;
...

* xmlgenerate file:

...
xml.doSomethingElse(int returned value) {
}

As you can see, the missing part is, how do I handle the returned value in the main file? Code for that is what I'm requiring at this point.

Thanks!

Have you read the tutorial on objects? It shows the base syntax of classes. Methods in classes are like functions (with context of the object), you get the returned value identically than you will do with a function.
To be more concrete:

1. HTXGenerate htx = new HTXGenerate(stuff);
2. XMLGenerate xml = new XMLGenerate (otherStuff);
3. int val = htx.doSomething(someParam);
4. xml.doSometingElse(val);
5. 
   
6. class HTXGenerate
7. {
8.   int someData;
9. 
   
10.   HTXGenerate(String stuff)
11.   {
12.     someData = int(stuff); // For example!
13.   }
14. 
    
15.   int doSomething(int someParam)
16.   {
17.     int nb = 0;
18.      // Manipulating data, setting nb, can call secondary, etc.
19.      return nb;
20.   }
21. 
    
22.   private secondary(Element e) { /* stuff */ }
23. }

Idem for XMLGenerate.

Ok, I believe I have it working now. I put in a "println("Count is: ");" for when it comes time to diagnose.

In the meantime, still using your first XML generation example, I've ecountered an error:

Cannot find a class or type named "Printstream"

Now, it was worklng, I generated an initial XML file with it, to test that portion of the code.

Any ideas?

Thanks!

PrintStream, not Printstream...
But indeed, in .java files, you have to do all the imports Processing does for you in the .pde files. So that's:
import java.io.*;

Ah yup, that makes sense. So, strictly speaking, nothing is really imported for you in a .java file, whereas a .pde file has most of the basic imports done.

Next problem...!

"The package "org.jsoup" does not exist. You may be missing a library."

It then goes on to say that the library must be in a certain folder - thats been done:

boris@fratus ~/sketchbook/libraries $ ls -la
total 20
drwxr-xr-x  5 boris boris 4096 2011-10-14 09:10 .
drwxr-xr-x 12 boris boris 4096 2011-10-14 09:10 ..
drwxr-xr-x  6 boris boris 4096 2011-10-14 09:04 controlP5
drwxr-xr-x  3 boris boris 4096 2011-10-14 09:04 jsoup
drwxr-xr-x  8 boris boris 4096 2011-10-14 09:10 proxml
boris@fratus ~/sketchbook/libraries $

I've also set the sketchbook path. No avail.

Any thoughts?

Ok, as a quick fix, I pasted the HTXGenerate code into the .pde file, but now I've somehow broken the code that parses and places the links into the HTML files. Sure, the algorithms work, debug tells me so, no obvious, glaring errors that halt the program... but also no links in the HTML files.

Oh, and the XML code works great now, I've just got to write out the rest of the file, and if you could make up the code for that "DOCTYPE" thing I pasted a while back, that would be good too... even just a suggestion for it.

EDIT: When I had cut and pasted the code, I had omitted the "Savestrings" part of the code. Issue fixed. Now I need that DOCTYPE =)