I want to run my processing sketch into another sketch.I used NApplet for that.But when I pasted my code in the NApplet following exception occured :

java.lang.RuntimeException: Too many calls to pushMatrix().
    at processing.core.PGraphics2D.pushMatrix(Unknown Source)
    at processing.core.PApplet.pushMatrix(Unknown Source)
    at napplet.NAppletManager.draw(Unknown Source)
    at sun.reflect.GeneratedMethodAccessor4.invoke(Unknown Source)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
    at java.lang.reflect.Method.invoke(Method.java:597)
    at processing.core.PApplet$RegisteredMethods.handle(Unknown Source)
    at processing.core.PApplet$RegisteredMethods.handle(Unknown Source)
    at processing.core.PApplet.handleDraw(Unknown Source)
    at processing.core.PApplet.run(Unknown Source)
    at java.lang.Thread.run(Thread.java:619)

and the code is :

1. import napplet.*;
2. NAppletManager nappletManager;
3. int App_status;
4. String sketch;
5. void setup()
6. {
7.   size(500, 500,P2D);
8.   App_status =1;
9.   sketch = "MouseFollow";
10.   nappletManager = new NAppletManager(this);
11. }
12. void draw()
13. {
14.   background(50);
15.   stroke(255);
16.   fill(255);
17.   if(App_status ==1)
18.     sketch = "MouseFollow";
19.   else
20.     sketch = "try_app";
21.  
22.   
23. }
24. void mousePressed()
25. {
26.   if(App_status ==1)
27.       App_status =2;
28.   else
29.       App_status =1;
30.       nappletManager.createNApplet(sketch, 25, 200);
31. }
32. public class MouseFollow extends NApplet
33. {
34.   import TUIO.*;
35. int num = 200; //no of worms..
36. float r;
37. TuioProcessing tuioClient;
38. worm[] worms = new worm[num];
39. float X1,Y1 ;
40. PImage bg;
41. boolean touchDown=false,touchRemove=false,init=true,flag;
42. PImage img;
43. int q =1000;
44. void setup()
45. {
46.   size(screen.width,screen.height);
47.   smooth();
48.   img = loadImage("6.jpg");
49.   img.resize(width,height);
50.  
51.   frameRate(60);
52.   background(img); 
53.   for(int i=0;i<worms.length;i++)
54.   {
55.     worms[i] = new worm(new PVector(random(0,width),random(0,height)),color(random(0,255),random(0,255),random(0,255)));
56.   }
57.   tuioClient = new TuioProcessing(this);
58.   frameRate(60);
59. }
60. void draw()
61. {
62.   noStroke();
63.   background(img); 
64.  
65.   Vector tuioCurList = tuioClient.getTuioCursors();
66.   float X=0,Y=0;
67.   if(tuioCurList.size() ==0)
68.   {
69.     touchDown =false;
70.     for(int j=0 ; j<worms.length ; j++)
71.     {
72.       worms[j].forces(1,1,true);
73.       worms[j].display();
74.     }
75.   }
76.   else
77.   {
78.     for(int j=0 ; j<worms.length ; j++)
79.     {
80.       worms[j].processed = false;
81.       for(int i=0 ; i<tuioCurList.size() ;i++)
82.       {
83.         touchDown = true;
84.         TuioCursor tcur = (TuioCursor)tuioCurList.elementAt(i);
85.         X = tcur.getScreenX(width);
86.         Y = tcur.getScreenY(height);
87.         boolean done =false;
88.         float mdist = dist(X, Y, worms[j].loc.x, worms[j].loc.y);
89.         if (mdist < 100)
90.         {
91.           worms[j].forces(X,Y,true);
92.           worms[j].processed = true;
93.           break;
94.         }
95.      }
96.   }
97.     for(int j=0 ; j<worms.length ; j++)
98.     {
99.       if(worms[j].processed == false)
100.         worms[j].forces(X,Y,false);
101.       worms[j].display();
102.     }
103.   }
104.  
105. }
106. class worm
107. {
108.   PVector loc;
109.   PVector preLoc,vec;
110.   PVector acc,vel;
111.   int wcol;
112.   int velocityLim =15;
113.   float angle,tv;
114.   float speed =.6;
115.   boolean processed =false;
116.   int walpha ;
117.    int wsize;
118.   
119.   worm(PVector _loc,int _col )
120.   {
121.     loc = _loc.get();
122.     preLoc = new PVector(loc.x-6,loc.y-6);
123.     vel = new PVector(0,0);
124.     acc = new PVector(0,0);
125.     int j = (int)random(0,4);
126.     if(j ==1)
127.         _col = color(5,26,85);
128.    else if(j ==2)
129.        _col = color(211,55,131);
130.     else
131.        _col = color(241,250,13);
132.     wcol = _col;
133.    
134.     walpha = 255;//(int)random(150,255);
135.     wsize = (int) random(5,7);
136.     angle = random(0,2*PI);
137.   }
138.   void display()
139.   {
140.     stroke(255);
141.     PVector pre=new PVector();
142.     pre.x = preLoc.x;
143.     pre.y = preLoc.y;
144.     PVector curr = new PVector(loc.x,loc.y);
145.     float slope = atan2((loc.y-preLoc.y),(loc.x-preLoc.x));
146.     for (int i = 1; i < wsize; i++)
147.     {
148.       strokeWeight(sq(wsize - i) / (wsize-2));
149.      
150.       stroke(wcol,walpha);
151.       line(curr.x,curr.y,pre.x,pre.y);
152.       curr.x = pre.x;
153.       curr.y = pre.y;
154.       slope -=radians(tv+1);
155.       pre.x = pre.x -5* cos(slope);
156.       pre.y = pre.y -5* sin(slope);
157.     }
158.   }
159.   void bounds()
160.   {
161.     if(loc.y>height || loc.y<0)
162.       r = random(-3,-1);
163.     if(loc.x>width || loc.x<0)
164.       r = random(-3,-1);
165.   }
166.   void forces(float tx,float ty,boolean attract)
167.   {
168.     flag =false;
169.     float theta = atan2((loc.y-ty),(loc.x-tx));
170.     preLoc.x = loc.x;
171.     preLoc.y = loc.y;
172.     if(touchDown)
173.     {
174.       if(attract ==true)
175.       {
176.         flag=true;
177.         loc.x = loc.x-10*cos(theta);           
178.         loc.y = loc.y-10*sin(theta);
179.       }
180.     }
181.     if(flag == false)
182.     {
183.       if(tv >=1.5)
184.         tv=0;
185.       tv += 0.3 * (random(10) - random(10)) / 10.0;
186.       // tv += 0.5*random(2);
187.       angle += tv;
188.       loc.x+=speed;
189.       loc.y+=speed;
190.       loc.x += 10*cos(radians(angle));
191.       loc.y += 10*sin(radians(angle));
192.       //boundory check...
193.       if(loc.x<0 )
194.       {
195.         loc.x = width-20;
196.         preLoc.x = width-16;
197.       } 
198.       else if(loc.x >width)
199.       {
200.         loc.x =20;
201.         preLoc.x = 16;
202.       }
203.       else if(loc.y<0)
204.       {
205.         loc.y = height-20;
206.         preLoc.y =height-16;
207.       }
208.       else if(loc.y >width)
209.       {
210.         loc.y =20;
211.         preLoc.y = 16;
212.       }
213.     }
214.   }
215. }
216. // called when an object is added to the scene
217. void addTuioObject(TuioObject tobj)
218. {
219. }
220. // called when an object is removed from the scene
221. void removeTuioObject(TuioObject tobj)
222. {
223. }
224. // called when an object is moved
225. void updateTuioObject (TuioObject tobj)
226. {
227. }
228. // called when a cursor is added to the scene
229. void addTuioCursor(TuioCursor tcur)
230. {                
231.   println("X,Y:"+tcur.getScreenX(width)+ "    "+tcur.getScreenY(height));
232.   touchDown=true;
233.   touchRemove=false;
234.   init = false;
235.   X1 = tcur.getScreenX(width);
236.   Y1 = tcur.getScreenY(height);
237. }
238. // called when a cursor is moved
239. void updateTuioCursor (TuioCursor tcur)
240. {
241. }
242. // called when a cursor is removed from the scene
243. void removeTuioCursor(TuioCursor tcur)
244. {
245.   touchRemove =true;
246.   Vector tuioCurList = tuioClient.getTuioCursors();
247.   if(tuioCurList.size() ==0)
248.     touchDown=false;
249. }
250. // called after each message bundle
251. // representing the end of an image frame
252. void refresh(TuioTime bundleTime) {
253.   redraw();
254. }
255. }
256. public class try_app extends NApplet
257. {
258.  
259.   int x, y;
260.  
261.   void setup() {
262.     size(200, 200);
263.     x = width/2;
264.     y = height/2;
265.   }
266.  
267.   void draw()
268.   {
269.     println("Mouse2");
270.     background(255,0,0);
271.     fill(0,255,0);
272.     ellipse(mouseX,mouseY,10,10);
273.   }
274. }