I would like to be able to provide cross-version libraries rather than having to main two sets of parallel libraries, and I would normally do this by implementing a factory design pattern with an interface to the cross-platform common functionality. My problem though is that I need to be able to detect at runtime which version of the processing core is being used with the library so the factory can create the appropriate implementation. As far as I can see there is no obvious 'version' constant or method available for such detection. I note that there is a 'Base' class available in the IDE application that has a version, but this is no good for libraries that just use the core classes.

So what is the best way to detect the difference between 2.x and 1.x from the processing core at runtime (hacky solutions OK, but ideally something that would survive future changes in the core library)?

In Processing 2.x, you can use the two-parameter createGraphics(w,h) which will use the same renderer as that created in the main sketch through the size() command. However, Processing 1.x requires a three-parameter version createGraphics(w,h,iRenderer) where iRenderer is an explicit string such as P2D, P3D etc, that indicates the renderer to use.

My question is, what is the best way to use createGraphics() that works with both Processing 1.x and 2.x? As far as I can see, there is nothing exposed in PApplet that allows programmatic detection of the renderer type. If there was, I could simply set the createGraphics renderer type to that of the main sketch. Since this is for a library, I have no control over the renderer that a user of the library may have selected with size(), so I need to be able to set the appropriate createGraphics renderer at runtime.

Any thoughts?

PGraphicsPDF pdf = (PGraphicsPDF)createGraphics(pWidth, Math.round(pWidth*1.41f), PDF, "report.pdf");

In order to maintain a decent resolution for my raster images (ie greater than 72 dpi), I have to set fairly large pWidth (e.g. 2000 pixels). This will produce the desired level of detail in the PDF, but the document itself is then way bigger than the A4 I need for output.

I realise I can scale down the PDF when printing so that it fits on an A4 page, but my question is, is there any way of creating a PDF with a resolution of greater than 72 dpi that is A4 size by default?

The code to do this might be something like this:

1. String message = "This is a simple line of text";
2. float visualTextSize = 6;
3. 
   
4. void setup()
5. {
6.   size(400,120);
7.   smooth();
8.   textAlign(CENTER,CENTER);
9.   rectMode(CENTER);
10.   textFont(createFont("Arial",6),6);
11. }
12. 
    
13. void draw()
14. {
15.   background(255,220,230);
16.   noFill();
17.   textSize(visualTextSize);
18.   rect(width/2,height/2,textWidth(message),visualTextSize);
19.   fill(255,0,0);
20.   text(message,width/2,height/2);
21. }

If in the sketch, you wished to enlarge the text/rectangle (for example in response to interactive zooming), applying a simple scaling results in blurred text as we might expect because a 6pt font is being displayed at a much larger size:

I would assume that the way to overcome the blurring would be to create a larger font before it is displayed:

1. String message = "This is a simple line of text";
2. float visualTextSize = 6;
3. 
   
4. void setup()
5. {
6.   size(400,120);
7.   smooth();
8.   textAlign(CENTER,CENTER);
9.   rectMode(CENTER);
10.   
11.   textFont(createFont("Arial",30),30);
12. }
13. 
    
14. void draw()
15. {
16.   background(255,220,230);
17.   noFill();
18.   textSize(visualTextSize);
19.   
20.   translate(width/2,height/2);
21.   scale(5);
22.   translate(-width/2, -height/2);
23.    
24.   rect(width/2,height/2,textWidth(message),visualTextSize);
25.   fill(255,0,0);
26.   text(message,width/2,height/2);
27. }

Unfortunately, when text is enlarged through scale(), even if it is stored at a high resolution, some rounding occurs in text placement (this is a  known bug  that I reported a couple of years ago):

This has been bugging me for a while now as I create lots of sketches with text that can be interactively zoomed.

Because I am not sufficiently familiar with the workings of the Processing source code to deal with the problem at source, I think I have a workaround. Whenever some scaled text needs to be displayed, temporarily reset the transformation matrix and display the text at a scale closer to its natural resolution. This is all done in the text2() method:

1. String message = "This is a simple line of text";
2. float visualTextSize = 6;
3. 
   
4. void setup()
5. {
6.   size(400,120);
7.   smooth();
8.   textAlign(CENTER,CENTER);
9.   rectMode(CENTER);
10.   textFont(createFont("Arial",30),30);
11. }
12. 
    
13. void draw()
14. {
15.   background(255,220,230);
16.   noFill();
17.   textSize(visualTextSize);
18.   
19.   translate(width/2,height/2);
20.   scale(5);
21.   translate(-width/2, -height/2);
22.    
23.   rect(width/2,height/2,textWidth(message),visualTextSize);
24.   fill(255,0,0);
25.   text2(message,width/2,height/2);
26. }
27. 
    
28. void text2(String textToDisplay, float xPos, float yPos)
29. {
30.    pushMatrix();
31.    float matrixScale = g.getMatrix().get(null)[0];
32.    PVector newTextPos = new PVector(0,0);
33.    g.getMatrix().mult(new PVector(xPos,yPos),newTextPos);
34.    resetMatrix();
35.    
36.    float origTextSize = g.textSize;
37.    textSize(matrixScale*origTextSize);
38.    text(textToDisplay,newTextPos.x,newTextPos.y);
39.    textSize(origTextSize);
40.    
41.    popMatrix();
42. }

It appears to give much better results and is about 3 times faster as a downscale-upscale transformation is avoided:

I don't like messing about with the 'g' object and this solution feels a bit hacky to me although it does appear to work. Are there any better ways of dealing with the text rounding problem?

Thanks,

Jo.

Ideally I would like a normal static image embedded in the web page that when clicked starts the processing applet within the same bounds as the image. That way, the static image would appear to 'come alive' when clicked. Perhaps something like the way  sketches appear and can be closed at openprocessing.org, but instead of automatically appearing when the page is first visited, only when an image is clicked.  Solutions that involve running the applets on page load but keeping them invisible until activated won't really work without draining resources.

I am no expert in Javascript, but I would hope that some fairly simple modifications of calls to one or more of the methods in  deployJava.js should do the job, but can't get anything working. Does anyone have a solution to this?