1. Create a new text document on your desktop (because of protected folders in Windows 8).

• Make sure you can see file extensions, so the file is not named Winapp2.ini.txt
• Choose yes to change the file extension.

3. Right mouse click on the file and choose Open With... then select Notepad.

4. Copy-paste in the following text where the yellow file location points to the correct file on your computer!

• Note that FileKey3 clears all the files and folders in the Local\Temp folder including those that are not related to Processing! However since these files are also leftovers, this is an added benefit.

1. [* Processing]
2.  
3. LangSecRef=3024
4.  
5. DetectFile=C:\Coding\processing-2.0.1-x64\processing.exe
6.  
7. Default=True
8.  
9. FileKey1=%userprofile%\AppData\Roaming\Processing\console|*.*
10. FileKey2=%userprofile%\AppData\Roaming\Processing\debug|*.*
11. FileKey3=%userprofile%\AppData\Local\Temp|*.*|RECURSE

• The default installation folder is: C:\Program Files\CCleaner

6. On Windows 8 these folders are protected, so - when asked - choose yes to move the file into the folder.

Testing if it works

1. Run CCleaner and choose Analyze.

2. If there are any files found for this rule, you should see an item: Utilities - *Processing

3. Double click the item to see the found files for this rule.

4. The first time there are probably some / many non-related files from the Temp folder.

5. If it's correct press Run Cleaner to remove all the crap files from your computer!

1. /*
2.   Line 2 TriangleMesh algorithm by Paul Houx (May 09, 2012)
3.   * Description: https://forum.libcinder.org/#Topic/23286000001268015
4.   * Source Code: https://github.com/paulhoux/Cinder/commit/2d467c4ae9145c03bbaf014c0bceb7f806754cc8
5.   Ported to Processing 1.5.1 + Toxiclibs 0021 by Amnon Owed (May 26, 2012)
6. */
7.  
8. import toxi.geom.*;
9. import toxi.processing.*;
10. ToxiclibsSupport gfx;
11.  
12. float mRadius = 5;
13. float mThickness = 50;
14. float dotStepSize = 10;
15. ArrayList <Vec2D> mPoints = new ArrayList <Vec2D> ();
16. boolean bDrawOutlines = true;
17. boolean bDrawConstruction = false;
18.  
19. void setup() {
20.   size(1280, 720);
21.   gfx = new ToxiclibsSupport(this);
22.   smooth();
23. }
24.  
25. void draw() {
26.   background(255);
27.  
28.   for (int i=0; i<mPoints.size(); i++) {
29.     int a = ((i-1) < 0) ? 0 : (i-1);
30.     int b = i;
31.     int c = ((i+1) >= mPoints.size()) ? mPoints.size()-1 : (i+1);
32.     int d = ((i+2) >= mPoints.size()) ? mPoints.size()-1 : (i+2);
33.     drawSegment( mPoints.get(a), mPoints.get(b), mPoints.get(c), mPoints.get(d) );
34.   }
35.  
36.   noStroke();
37.   fill(255, 0, 0);
38.   for (Vec2D p : mPoints) {
39.     ellipse(p.x, p.y, mRadius*2, mRadius*2);
40.   }
41. }
42.  
43. void mousePressed() {
44.   Vec2D m = new Vec2D(mouseX, mouseY);
45.   mPoints.add(m);
46. }
47.  
48. void keyPressed() {
49.   if (key == ' ') { mPoints.clear(); }
50.   if (key == 'o') { bDrawOutlines = !bDrawOutlines; }
51.   if (key == 'c') { bDrawConstruction = !bDrawConstruction; }
52.   if (key == ',') { if (mThickness > 1) mThickness--; }
53.   if (key == '.') { if (mThickness < 100) mThickness++; }
54. }
55.  
56. void drawSegment(Vec2D p0, Vec2D p1, Vec2D p2, Vec2D p3) {
57.  
58.   // skip if zero length
59.   if (p1.equals(p2)) return;
60.  
61.   // 1) define the line between the two points
62.   Vec2D line = p2.sub(p1).normalize();
63.  
64.   // 2) find the normal vector of this line
65.   Vec2D normal = new Vec2D(-line.y, line.x).normalize();
66.  
67.   // 3) find the tangent vector at both the end points:
68.   //    - if there are no segments before or after this one, use the line itself
69.   //    - otherwise, add the two normalized lines and average them by normalizing again
70.   Vec2D tangent1, tangent2;
71.   if (p0.equals(p1)) { tangent1 = line.copy(); } else { tangent1 = p1.sub(p0).normalize().add(line).normalize(); }
72.   if (p2.equals(p3)) { tangent2 = line.copy(); } else { tangent2 = p3.sub(p2).normalize().add(line).normalize(); }
73.  
74.   // 4) find the miter line, which is the normal of the tangent
75.   Vec2D miter1 = new Vec2D(-tangent1.y, tangent1.x);
76.   Vec2D miter2 = new Vec2D(-tangent2.y, tangent2.x);
77.  
78.   // find length of miter by projecting the miter onto the normal,
79.   // take the length of the projection, invert it and scaleSelfiply it by the thickness:
80.   // length = thickness * ( 1 / |normal|.|miter| )
81.   float length1 = mThickness / normal.dot(miter1);
82.   float length2 = mThickness / normal.dot(miter2);
83.  
84.   // calculate miter end points
85.   Vec2D p1ms = p1.sub(miter1.scale(length1));
86.   Vec2D p1ma = p1.add(miter1.scale(length1));
87.   Vec2D p2ms = p2.sub(miter2.scale(length2));
88.   Vec2D p2ma = p2.add(miter2.scale(length2));
89.  
90.   if (bDrawConstruction) {
91.     // set line width to 2
92.     strokeWeight(2);
93.    
94.     // draw black line between p1 and p2
95.     stroke(0);
96.     drawLine(p1, p2);
97.    
98.     Vec2D n = normal.scale(mThickness);
99.    
100.     // draw normals in stippled red
101.     stroke(255, 0, 0);
102.     drawDottedLine(p1.sub(n), p1.add(n));
103.     drawDottedLine(p2.sub(n), p2.add(n));
104.    
105.     // draw line segment in stippled gray
106.     stroke(128);
107.     drawDottedLine(p1.sub(n), p2.sub(n));
108.     drawDottedLine(p1.add(n), p2.add(n));
109.    
110.     // draw tangents in gray
111.     if (!p0.equals(p1)) { drawLine(p1.sub(tangent1.scale(mThickness)), p1.add(tangent1.scale(mThickness))); }
112.     if (!p2.equals(p3)) { drawLine(p2.sub(tangent2.scale(mThickness)), p2.add(tangent2.scale(mThickness))); }
113.    
114.     // draw miter (normal of tangents) in stippled black
115.     stroke(0);
116.     if (!p0.equals(p1)) { drawDottedLine(p1.sub(miter1.scale(length1)), p1.add(miter1.scale(length1))); }
117.     if (!p2.equals(p3)) { drawDottedLine(p2.sub(miter2.scale(length2)), p2.add(miter2.scale(length2))); }
118.    
119.     // draw black circles on miter   
120.     fill(0);
121.     ellipse(p1ms.x, p1ms.y, mRadius, mRadius);
122.     ellipse(p1ma.x, p1ma.y, mRadius, mRadius);
123.     ellipse(p2ms.x, p2ms.y, mRadius, mRadius);
124.     ellipse(p2ma.x, p2ma.y, mRadius, mRadius);
125.   }
126.  
127.   if (bDrawOutlines) {
128.     // finally, draw segment in thick black
129.     strokeWeight(3);
130.     stroke(0);
131.     drawLine(p1ms, p2ms);
132.     drawLine(p1ma, p2ma);
133.    
134.     // stipple triangles
135.     drawDottedLine(p1ms, p1ma);
136.     drawDottedLine(p1ms, p2ma);
137.     drawDottedLine(p2ms, p2ma);
138.   }
139. }
140.  
141. void drawLine(Vec2D s, Vec2D e) {
142.   gfx.line(s, e);
143. }
144.  
145. void drawDottedLine(Vec2D s, Vec2D e) {
146.   Line2D l = new Line2D(s, e);
147.   gfx.points2D(l.splitIntoSegments(null, dotStepSize, true));
148. }