/lenasys/0.1

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/lenasys/0.1

« back to all changes in this revision

Viewing changes to js/dugga.js

  • Committer: Erik Wikström
  • Date: 2013-03-28 07:43:18 UTC
  • mto: This revision was merged to the branch mainline in revision 7.
  • Revision ID: wikxen@gmail.com-20130328074318-9v6krijkyap59nct
Removed trunk folder and moved its contents to the root

Show diffs side-by-side

added added

removed removed

Lines of Context:
js/dugga.js
1
 
/********************************************************************************
2
 
 
3
 
   Mouse coordinate and canvas globals
4
 
   
5
 
   Handles both Touch and Mouse/Keyboard input at the same time
6
 
   
7
 
*********************************************************************************/
8
 
 
9
 
                // Mouse coordinate globals
10
 
                var gridx,gridy;
11
 
                var clickstate=0;
12
 
 
13
 
                var acanvas;
14
 
                var context;
15
 
 
16
 
/********************************************************************************
17
 
 
18
 
   Canvas Setup and Click Handling Code
19
 
   
20
 
   Handles both Touch and Mouse/Keyboard input at the same time and executes 
21
 
   handler callbacks.
22
 
   Also declares canvas globals
23
 
 
24
 
*********************************************************************************/
25
 
 
26
 
                function setupcanvas()
27
 
                {
28
 
                                acanvas=document.getElementById('a');
29
 
                                context=acanvas.getContext("2d");               
30
 
                                
31
 
                                setTimeout("foo();",50);
32
 
                                
33
 
                                setupClickHandling();           
34
 
                }
35
 
                
36
 
                function setupClickHandling()
37
 
                {
38
 
                                // Mouse and Keyboard Events
39
 
                                acanvas.addEventListener('mousemove', ev_mousemove, false);
40
 
                                acanvas.addEventListener('mouseup', ev_mouseup, false);
41
 
                                acanvas.addEventListener('mousedown', ev_mousedown, false);
42
 
                                
43
 
                                // Touch Events
44
 
                                acanvas.addEventListener('touchstart', ev_touchstart, false);
45
 
                                acanvas.addEventListener('touchend', ev_touchend, false);
46
 
                                acanvas.addEventListener('touchmove', ev_touchmove, false);             
47
 
                }                                               
48
 
                                
49
 
                // Keyboard/Mouse Mouse Up Handler
50
 
                function ev_mouseup(ev)
51
 
                {
52
 
                                handler_mouseup();
53
 
                }
54
 
                
55
 
                // Keyboard/Mouse Mouse Down Handler
56
 
                function ev_mousedown(ev)
57
 
                {
58
 
                                handler_mousedown(ev);          
59
 
                }
60
 
 
61
 
                // Keyboard/Mouse Mouse Move Handler
62
 
                function ev_mousemove (ev) 
63
 
                {
64
 
                          var cx,cy=0;
65
 
                          if (ev.layerX||ev.layerX==0) { // Firefox
66
 
                                    cx=ev.layerX-acanvas.offsetLeft;
67
 
                                    cy=ev.layerY-acanvas.offsetTop;
68
 
                          } else if (ev.offsetX || ev.offsetX == 0) { // Opera
69
 
                                    cx=ev.offsetX-acanvas.offsetLeft;
70
 
                                    cy=ev.offsetY-acanvas.offsetTop;
71
 
                          }
72
 
 
73
 
                          coord=findPos(acanvas);
74
 
                                cx=cx-coord.x;
75
 
                                cy=cy-coord.y;
76
 
 
77
 
                                handler_mousemove(cx,cy);
78
 
                }               
79
 
 
80
 
                // Touch start event
81
 
                function ev_touchstart(event){  
82
 
                event.preventDefault();  
83
 
                var numtouch = event.touches.length;  
84
 
 
85
 
                                targetEvent =  event.touches.item(0);
86
 
 
87
 
                                var cx = targetEvent.pageX;
88
 
                                var cy = targetEvent.pageY;
89
 
                                
90
 
                                gridx=cx;
91
 
                                gridy=cy;
92
 
 
93
 
                                handler_mousedown();
94
 
 
95
 
                };  
96
 
 
97
 
                // Touch end event
98
 
                function ev_touchend(event){  
99
 
                event.preventDefault();  
100
 
                var numtouch = event.touches.length;  
101
 
 
102
 
                                handler_mouseup();
103
 
                };  
104
 
                
105
 
                // Touch move event
106
 
                function ev_touchmove(event){  
107
 
                event.preventDefault();  
108
 
                var numtouch = event.touches.length;  
109
 
 
110
 
                                targetEvent =  event.touches.item(0);
111
 
 
112
 
                                var cx = targetEvent.pageX;
113
 
                                var cy = targetEvent.pageY;
114
 
                                
115
 
                                handler_mousemove(cx,cy);                               
116
 
                };  
117
 
 
118
 
                // Fix scrolling on touch devices
119
 
                var ScrollFix = function(elem) {
120
 
                    // Variables to track inputs
121
 
                    var startY, startTopScroll;
122
 
                
123
 
                    elem = elem || document.querySelector(elem);
124
 
                
125
 
                    // If there is no element, then do nothing  
126
 
                    if(!elem)
127
 
                        return;
128
 
                
129
 
                    // Handle the start of interactions
130
 
                    elem.addEventListener('touchstart', function(event){
131
 
                        startY = event.touches[0].pageY;
132
 
                        startTopScroll = elem.scrollTop;
133
 
                
134
 
                        if(startTopScroll <= 0)
135
 
                            elem.scrollTop = 1;
136
 
                
137
 
                        if(startTopScroll + elem.offsetHeight >= elem.scrollHeight)
138
 
                            elem.scrollTop = elem.scrollHeight - elem.offsetHeight - 1;
139
 
                    }, false);
140
 
                };
141
 
 
142
 
/********************************************************************************
143
 
 
144
 
   Canvas Diagram Drawing Code
145
 
 
146
 
*********************************************************************************/
147
 
 
148
 
                // Draws a stroked rectangle of certain thicknes and color
149
 
 
150
 
                function drawrect(x1,y1,x2,y2,color)
151
 
                {
152
 
                                context.lineWidth   = 1.5;
153
 
                                context.strokeStyle = color;
154
 
                                context.strokeRect(x1,y1,x2-x1,y2-y1);
155
 
                }
156
 
 
157
 
                
158
 
 
159
 
                // Draws a perfect round circle
160
 
                
161
 
                function drawcircle(radius,color)
162
 
                {
163
 
                                context.lineWidth   = 1.5;
164
 
                                context.strokeStyle = color;
165
 
                                context.arc(0, 0, radius, 0 , 2 * Math.PI, false);
166
 
                }
167
 
 
168
 
                // Draws 90 degree arc
169
 
                
170
 
                function drawellipse(x1,y1,x2,y2)
171
 
                {
172
 
 
173
 
                                        var rx=(x2-x1)*0.5;
174
 
                                        var ry=(y2-y1)*0.5;
175
 
 
176
 
                                        context.beginPath();                                    
177
 
 
178
 
                                        context.moveTo(x1,y1+ry);
179
 
                                        context.quadraticCurveTo(x1,y1,x1+rx,y1);
180
 
                                        context.quadraticCurveTo(x2,y1,x2,y1+ry);
181
 
                                        context.quadraticCurveTo(x2,y2,x2-rx,y2);
182
 
                                        context.quadraticCurveTo(x1,y2,x1,y1+ry);
183
 
 
184
 
                                        context.stroke();
185
 
                }       
186
 
                
187
 
                // Draw a point         
188
 
                
189
 
                function point(x,y,col)
190
 
                {
191
 
                                context.strokeStyle="#000";
192
 
                                context.lineWidth = 1;
193
 
                        
194
 
                                context.fillStyle=col;
195
 
                                context.fillRect(x-4,y-4,8,8);          
196
 
                                context.strokeRect(x-4,y-4,8,8);                                                
197
 
                }
198
 
                
199
 
                // Draw a box around a point to indicate highlight
200
 
                
201
 
                function highlight(px,py)
202
 
                {
203
 
                                context.strokeStyle="#aaa";
204
 
                                context.lineWidth = 1;
205
 
                        
206
 
                                context.strokeRect(px-8,py-8,16,16);                                            
207
 
                                
208
 
                }
209
 
                
210
 
                // Draw a line using current context
211
 
                
212
 
                function drawline(x1,y1,x2,y2,strokestyle,linewidth)
213
 
                {
214
 
                                                context.strokeStyle = strokestyle;
215
 
                                                context.lineWidth   = linewidth;
216
 
                                                context.beginPath();
217
 
                                                context.moveTo(x1,y1);
218
 
                                                context.lineTo(x2,y2);
219
 
                                                context.stroke();                                                       
220
 
                }
221
 
                
222
 
                function fourpoints(x1,y1,x2,y2,x3,y3,x4,y4,col)
223
 
                {
224
 
                                point(x1,y1,col);
225
 
                                point(x2,y2,col);
226
 
                                point(x3,y3,col);
227
 
                                point(x4,y4,col);                               
228
 
                }
229
 
                
230
 
                function drawdiamond(x1,y1,x2,y2)
231
 
                {
232
 
                                var rx=(x2-x1)*0.5;
233
 
                                var ry=(y2-y1)*0.5;
234
 
 
235
 
                                context.beginPath();                                    
236
 
                                context.moveTo(x1,y1+ry);
237
 
                                context.lineTo(x1+rx,y2);
238
 
                                context.lineTo(x2,y1+ry);
239
 
                                context.lineTo(x1+rx,y1);
240
 
                                context.lineTo(x1,y1+ry);                       
241
 
                                context.stroke();                                                                                       
242
 
                }
243
 
                
244
 
                // Dashed Line in Segments of given size
245
 
                
246
 
                function dashedline(sx,sy,ex,ey,dashlen,linewidth,col)
247
 
                {
248
 
                                                
249
 
                        var dx=ex-sx;
250
 
                        var dy=ey-sy;
251
 
                                                        
252
 
                        len=Math.sqrt((dx*dx)+(dy*dy));
253
 
                        notimes=Math.round(len/dashlen);
254
 
                        
255
 
                        dx=dx/notimes;
256
 
                        dy=dy/notimes;
257
 
                        
258
 
                        context.lineWidth = linewidth;
259
 
                        context.strokeStyle=col;
260
 
 
261
 
                        context.beginPath();
262
 
 
263
 
                        var xk,yk;
264
 
                        xk=sx;
265
 
                        yk=sy;
266
 
                        xh=dx/2.0;
267
 
                        yh=dy/2.0;
268
 
                        for(var i=0;i<notimes;i++){
269
 
 
270
 
                                        context.moveTo(xk,yk);                          
271
 
                                        context.lineTo(xk+xh,yk+yh);
272
 
                                
273
 
                                        xk+=dx;
274
 
                                        yk+=dy;
275
 
                        }
276
 
                                                        
277
 
                        context.stroke();
278
 
                                
279
 
                }
280
 
                                                                
281
 
                // Arcto only works if both x1 and y2 are on circle border
282
 
                
283
 
                function arcto(x0,y0,x1,y1,x2,y2)
284
 
                {
285
 
 
286
 
                                var r = Math.sqrt((x1-x0)*(x1-x0) + (y1-y0)*(y1-y0));
287
 
                                var x = x0-r;
288
 
                                var y = y0-r;
289
 
                                var startAngle = (180/Math.PI*Math.atan2(y1-y0, x1-x0));
290
 
                                var endAngle = (180/Math.PI*Math.atan2(y2-y0, x2-x0));
291
 
                                
292
 
                                context.arc(x0, y0, r, 0, Math.PI*2.0, 1.0);
293
 
 
294
 
                }
295
 
 
296
 
                // Draws 90 degree arc
297
 
                
298
 
                function arcdeg(x1,y1,x2,y2,x3,y3)
299
 
                {
300
 
                                        
301
 
 
302
 
                                        // First quadrant positive positive                     
303
 
                                        dashedline(x1,y1,x2,y2,8,1.0,"#999");
304
 
                                        dashedline(x3,y3,x2,y2,8,1.0,"#999");                                   
305
 
 
306
 
                                        point(x1,y1,"#ff5");
307
 
                                        point(x2,y2,"#f55");
308
 
                                        point(x3,y3,"#f55");
309
 
                                                                                                
310
 
                                        k=(y3-y1)/(x3-x1);                                      
311
 
                                                                                
312
 
                                        yk=y1+((x2-x1)*k);
313
 
                                        
314
 
                                        rx=x3-x1;
315
 
                                        ry=y3-y1;
316
 
 
317
 
                                        point(x2,yk,"#f5f");
318
 
 
319
 
                                        context.strokeStyle = '#49f';
320
 
                                        context.lineWidth   = 1.0;                                      
321
 
                                        context.beginPath();                                    
322
 
                                        context.moveTo(x1,y1);
323
 
                                        for(i=0;i<48;i++){
324
 
                                                        if(y3>=y1){
325
 
                                                                        if(yk>=y2){
326
 
                                                                                        context.lineTo(x1+(Math.sin(((Math.PI/96.0)*-i)+(Math.PI*1.0))*rx),y3+(Math.cos(((Math.PI/96.0)*-i)+(Math.PI*1.0))*ry));
327
 
                                                                        }else{
328
 
                                                                                        context.lineTo(x3+(Math.sin(((Math.PI/96.0)*i)+(Math.PI*1.5))*rx),y1+(Math.cos(((Math.PI/96.0)*i)+(Math.PI*1.5))*ry));
329
 
                                                                        }
330
 
                                                        }else{
331
 
                                                                        if(yk<=y2){
332
 
                                                                                        context.lineTo(x1+(Math.sin(((Math.PI/96.0)*-i)+(Math.PI*1.0))*rx),y3+(Math.cos(((Math.PI/96.0)*-i)+(Math.PI*1.0))*ry));
333
 
                                                                        }else{
334
 
                                                                                        context.lineTo(x3+(Math.sin(((Math.PI/96.0)*i)+(Math.PI*1.5))*rx),y1+(Math.cos(((Math.PI/96.0)*i)+(Math.PI*1.5))*ry));
335
 
                                                                        }                                                       
336
 
                                                        }
337
 
                                        }
338
 
                                        context.stroke();
339
 
 
340
 
                }               
341
 
        
342
 
                // function that draws one part of the sun      
343
 
                
344
 
                function sundial(radius,angle,scale)
345
 
                {
346
 
                                
347
 
                                        cosv=Math.cos(angle);
348
 
                                        sinv=Math.sin(angle);
349
 
                                                                                
350
 
                                        yaddx=scale*cosv;
351
 
                                        yaddy=scale*sinv;
352
 
                                        
353
 
                                        xaddx=-scale*sinv;
354
 
                                        xaddy=scale*cosv;
355
 
 
356
 
                                        xk=cosv*radius;
357
 
                                        yk=sinv*radius;
358
 
 
359
 
                                        context.bezierCurveTo((-1.5*xaddx)+(yaddx*1.5)+xk,(-1.5*xaddy)+(yaddy*1.5)+yk,xaddx+(yaddx*2.0)+xk,xaddy+(yaddy*2.0)+yk,xaddx+(yaddx*3.0)+xk,xaddy+(yaddy*3.0)+yk);
360
 
                                        context.bezierCurveTo(xaddx+yaddx+xk,xaddy+yaddy+yk,(1.5*xaddx)+yaddx+xk,(1.5*xaddy)+yaddy+yk,(3.0*xaddx)+xk,(3.0*xaddy)+yk);
361
 
                }
362
 
 
363
 
                // function that daws the sun
364
 
                
365
 
                function drawsun()
366
 
                {
367
 
                                context.fillStyle = "#fe9";
368
 
                                context.strokeStyle = "#d82";
369
 
                                context.lineWidth   = 1.5;
370
 
                                                                 
371
 
                                context.beginPath();
372
 
                                context.moveTo(30,0);
373
 
                                for(i=0.0;i<360.0;i+=22.5){
374
 
                                                angle=(i/360.0)*2*Math.PI;
375
 
                                                sundial(30,angle,3);
376
 
                                }
377
 
                                context.stroke();
378
 
                                context.fill();                                                                                                                 
379
 
                }
380
 
                
381
 
                // Draws the ball (used in various examples)
382
 
                
383
 
                function drawball(cx,cy,radie,innerradie,ballradie,col1,inangle,inangleadd)
384
 
                {
385
 
                                        
386
 
                                        angleadd=(inangleadd/360.0)*2*Math.PI;
387
 
                                                                        
388
 
                                        context.fillStyle = col1;                                       
389
 
                                        
390
 
                                        for(i=0;i<360;i+=inangle){
391
 
                                                                                                                
392
 
                                                        angle=(i/360.0)*2*Math.PI;
393
 
                                                        angle2=angle+angleadd;
394
 
                                                        angle3=angle+(angleadd*2.0);
395
 
                                                        angle4=angle-angleadd;
396
 
 
397
 
                                                        cosv=Math.cos(angle);
398
 
                                                        sinv=Math.sin(angle);
399
 
 
400
 
                                                        cosv2=Math.cos(angle2);
401
 
                                                        sinv2=Math.sin(angle2);
402
 
 
403
 
                                                        cosv4=Math.cos(angle4);
404
 
                                                        sinv4=Math.sin(angle4);
405
 
                                                        
406
 
                                                        context.beginPath();
407
 
 
408
 
                                                        context.moveTo(cx,cy);
409
 
                                                        context.quadraticCurveTo(cx+(cosv*innerradie),cy+(sinv*innerradie),cx+(cosv2*radie),cy+(sinv2*radie));                                                  
410
 
                                                        context.arc(cx,cy,radie,angle2,angle,1.0);
411
 
                                                        context.quadraticCurveTo(cx+(cosv4*innerradie),cy+(sinv4*innerradie),cx,cy);                                                    
412
 
                                                                                                                
413
 
                                                        context.fill();                                                                                                                 
414
 
                                                        
415
 
                                        }       
416
 
                                                                                                        
417
 
                                        context.beginPath();
418
 
                                        context.arc(cx,cy,radie,0,Math.PI*2.0,1.0);                                                                                             
419
 
                                        context.stroke();                                                                                                                       
420
 
                
421
 
                }
422
 
                
423
 
                // Draws underlined/dashed underlined text clipped inside a rectangle, a quadratic curve ellipsis or a diamond
424
 
                
425
 
                function cliptext(x1,y1,x2,y2,tex,font,align,edgeoffs,baseline,color,clipkind,underlinekind)
426
 
                {
427
 
 
428
 
                                var rx=(x2-x1)*0.5;
429
 
                                var ry=(y2-y1)*0.5;
430
 
                                                
431
 
                var tx=x1;              
432
 
 
433
 
                                if(clipkind!=0){
434
 
                        context.save();
435
 
                        context.beginPath();                            
436
 
                                }
437
 
                                
438
 
                                // Make Rectangle / Ellipse / Diamond Clipping Paths
439
 
                                if(clipkind==1){
440
 
                        context.moveTo(x1,y1);
441
 
                        context.lineTo(x1,y2);
442
 
                        context.lineTo(x2-edgeoffs,y2);
443
 
                        context.lineTo(x2-edgeoffs,y1);
444
 
                        context.lineTo(x1,y1);
445
 
                                }else if(clipkind==2){
446
 
                                                context.moveTo(x1,y1+ry);
447
 
                                                context.quadraticCurveTo(x1+edgeoffs,y1+edgeoffs,x1+edgeoffs+rx,y1+edgeoffs);
448
 
                                                context.quadraticCurveTo(x2-edgeoffs,y1+edgeoffs,x2-edgeoffs,y1+ry+edgeoffs);
449
 
                                                context.quadraticCurveTo(x2-edgeoffs,y2-edgeoffs,x2-rx-edgeoffs,y2-edgeoffs);
450
 
                                                context.quadraticCurveTo(x1+edgeoffs,y2-edgeoffs,x1+edgeoffs,y1+ry+edgeoffs);
451
 
                                }else if(clipkind==3){
452
 
                                                context.moveTo(x1,y1+ry);
453
 
                                                context.lineTo(x1+rx,y2);
454
 
                                                context.lineTo(x2,y1+ry);
455
 
                                                context.lineTo(x1+rx,y1);
456
 
                                                context.lineTo(x1,y1+ry);                       
457
 
                                }
458
 
 
459
 
                                if(clipkind!=0){
460
 
                        context.clip();                         
461
 
                                }
462
 
 
463
 
                                context.font = font;
464
 
                context.textAlign = "left";
465
 
                context.fillStyle = color;
466
 
 
467
 
        var metrics = context.measureText(tex);
468
 
        var hwidth = metrics.width*0.5;
469
 
                
470
 
                // Compute left-justified centered coordinate                   
471
 
                if((rx-hwidth-edgeoffs)<0){
472
 
                                tx=x1+edgeoffs;
473
 
                }else{
474
 
                                tx=x1+rx-hwidth;
475
 
                }
476
 
                
477
 
                context.fillText(tex, tx, y2-ry+baseline);
478
 
 
479
 
                                // Draw underlining - can handle dashed underline!
480
 
                                if(underlinekind==1){
481
 
                                                drawline(tx,y2-ry+baseline+5.0,tx+(hwidth*2),y2-ry+baseline+5.0,"#000",2.0);                                                                            
482
 
                                }
483
 
                                                                
484
 
                                if(clipkind!=0) context.restore(); 
485
 
 
486
 
                }
487
 
                
488
 
                // Draws cardinality at a certain offset from a coordinate
489
 
                function drawcardinality(x,y,side,tex,xoffs,yoffs,font,baseline,sign,color)
490
 
                {
491
 
                                // Xoffs is along line
492
 
                                xoffs=0;
493
 
                                // Yoffs is distance from line
494
 
                                yoffs=10;
495
 
                                
496
 
        var metrics = context.measureText(tex);
497
 
        var twidth = metrics.width;
498
 
        var theight = 12;
499
 
 
500
 
                                point(x,y,"#f8f");
501
 
 
502
 
                                context.font = font;
503
 
                context.textAlign = "left";
504
 
                context.fillStyle = color;
505
 
 
506
 
                                if(side==1&&sign==1){
507
 
                        context.fillText(tex, x-twidth-xoffs, y-yoffs);
508
 
                        drawrect(x-twidth-xoffs, y-yoffs,x-xoffs, y-yoffs-theight);
509
 
                                }else if(side==2&&sign==1){
510
 
                        context.fillText(tex, x+yoffs, y+xoffs+theight);                                        
511
 
                        drawrect(x+yoffs, y+xoffs+theight,x+yoffs+twidth, y+xoffs);
512
 
                                }else if(side==3&&sign==1){
513
 
                        context.fillText(tex, x+xoffs, y-yoffs);
514
 
                                }else if(side==4&&sign==1){
515
 
                        context.fillText(tex, x+yoffs, y-xoffs);                                        
516
 
                                }else if(side==1&&sign==2){
517
 
                        context.fillText(tex, x-twidth-xoffs, y+theight+yoffs);                                 
518
 
                        drawrect(x-twidth-xoffs, y+yoffs,x-xoffs, y+theight+yoffs);
519
 
                                }else if(side==2&&sign==2){
520
 
                        context.fillText(tex, x-yoffs-twidth, y+xoffs+theight);                                 
521
 
                        drawrect(x-yoffs-twidth, y+xoffs,x-yoffs, y+xoffs+theight);
522
 
                                }else if(side==3&&sign==2){
523
 
                        context.fillText(tex, x+xoffs, y+theight+yoffs);
524
 
                                }else if(side==4&&sign==2){
525
 
                        context.fillText(tex, x-yoffs-twidth, y-xoffs);                                 
526
 
                                }
527
 
 
528
 
                }
529
 
 
530
 
                
531
 
/********************************************************************************
532
 
 
533
 
   Canvas and Diagram Measuring Functions
534
 
   
535
 
        These functions allow us to measure pixels in diagram and other apps
536
 
 
537
 
*********************************************************************************/
538
 
                
539
 
                
540
 
                // Recursive Pos of div in document - should work in most browsers
541
 
                
542
 
                function findPos(obj) {
543
 
                        var curleft = curtop = 0;
544
 
                        if (obj.offsetParent) {
545
 
                                curleft = obj.offsetLeft
546
 
                                curtop = obj.offsetTop
547
 
                                while (obj = obj.offsetParent) {
548
 
                                        curleft += obj.offsetLeft
549
 
                                        curtop += obj.offsetTop
550
 
                                }
551
 
                        }
552
 
                        return {
553
 
                                                x:curleft,
554
 
                                                y:curtop
555
 
                                }
556
 
                }
557
 
                
558
 
                // Make side coordinates for drawing Model
559
 
 
560
 
                function makeside(side,x1,y1,x2,y2,perc){
561
 
        
562
 
                                var xk=0;
563
 
                                var yk=0;
564
 
        
565
 
                                if(side==1){
566
 
                                                xk=x1;
567
 
                                                yk=y1+((y2-y1)*perc);
568
 
                                }else if(side==2){
569
 
                                                xk=x1+((x2-x1)*perc);
570
 
                                                yk=y2;
571
 
                                }else if(side==3){
572
 
                                                xk=x2;
573
 
                                                yk=y1+((y2-y1)*perc);                                           
574
 
                                }else if(side==4){
575
 
                                                xk=x1+((x2-x1)*perc)
576
 
                                                yk=y1;
577
 
                                }
578
 
                                
579
 
                                return {
580
 
                                                        x:xk,
581
 
                                                        y:yk
582
 
                                        }
583
 
                
584
 
                }               
585
 
                
586
 
                // Computes side identifier for a mouse coordinate and object coordinates
587
 
                
588
 
                function computeside(x,y,x1,y1,x2,y2,sidetol){
589
 
        
590
 
                                var obj_sidentifier="None";
591
 
                                var obj_sideperc=0;
592
 
                                var obj_centerdist=0;
593
 
        
594
 
                                // Left Side
595
 
                                if(x>x1-sidetol&&x<x1+sidetol&&y>y1-sidetol&&y<y2+sidetol){
596
 
                                                obj_sidentifier=1;
597
 
                                                obj_sideperc=makesideperc(y,y1,y2);
598
 
                                                obj_centerdist=centerdist(y,y1,y2);
599
 
                                }
600
 
 
601
 
                                // Bottom Not Including Left Side or Right Side
602
 
                                if(x>x1+sidetol&&x<x2-sidetol&&y>y2-sidetol&&y<y2+sidetol){
603
 
                                                obj_sidentifier=2;
604
 
                                                obj_sideperc=makesideperc(x,x1,x2);
605
 
                                                obj_centerdist=centerdist(x,x1,x2);
606
 
                                }
607
 
 
608
 
                                // Right Side
609
 
                                if(x>x2-sidetol&&x<x2+sidetol&&y>y1-sidetol&&y<y2+sidetol){
610
 
                                                obj_sidentifier=3;
611
 
                                                obj_sideperc=makesideperc(y,y1,y2);
612
 
                                                obj_centerdist=centerdist(y,y1,y2);
613
 
                                }
614
 
                                
615
 
                                // Top Not Including Left Side or Right Side
616
 
                                if(x>x1+sidetol&&x<x2-sidetol&&y>y1-sidetol&&y<y1+sidetol){
617
 
                                                obj_sidentifier=4;
618
 
                                                obj_sideperc=makesideperc(x,x1,x2);
619
 
                                                obj_centerdist=centerdist(x,x1,x2);
620
 
                                }
621
 
                                
622
 
                                return {
623
 
                                                        side:obj_sidentifier,
624
 
                                                        perc:obj_sideperc,
625
 
                                                        dist:obj_centerdist
626
 
                                        }
627
 
                
628
 
                }               
629
 
                                                
630
 
                // Make side perc for ER model
631
 
                
632
 
                function makesideperc(x,x1,x2){
633
 
                                r=x2-x1;
634
 
                                perc=(x-x1)/r;
635
 
 
636
 
                                if(perc>1.0) perc=1.0;
637
 
                                if(perc<0.0) perc=0.0;
638
 
 
639
 
                                return perc;
640
 
                }
641
 
                
642
 
                function centerdist(x,x1,x2){
643
 
                                r=x1+((x2-x1)*0.5);
644
 
                                
645
 
                                return (x-r);
646
 
                }
647
 
                
648
 
                // Euclidian distance - Yo!
649
 
                
650
 
                function distance(x1,y1,x2,y2){
651
 
                                
652
 
                                var dist=Math.sqrt(((y2-y1)*(y2-y1))+((x2-x1)*(x2-x1)));
653
 
                                
654
 
                                return dist;
655
 
                }
656
 
 
657
 
                // Are we over a line or not.
658
 
 
659
 
                function overline(x,y,x1,y1,x2,y2,tolerance)
660
 
                {
661
 
                                var distance=10000;
662
 
                                
663
 
                                
664
 
                                dx=x2-x1;
665
 
                                dy=y2-y1;
666
 
                                
667
 
                                straighttolerance=2.0;
668
 
                                
669
 
                                var box1,boy1,box2,boy2;
670
 
                                
671
 
                                if(x1>x2){
672
 
                                                box1=x2;
673
 
                                                box2=x1;
674
 
                                }else{
675
 
                                                box1=x1;
676
 
                                                box2=x2;                                
677
 
                                }
678
 
 
679
 
                                if(y1>y2){
680
 
                                                boy1=y2;
681
 
                                                boy2=y1;
682
 
                                }else{
683
 
                                                boy1=y1;
684
 
                                                boy2=y2;                                
685
 
                                }
686
 
                                
687
 
//                              drawrect(box1-tolerance,boy1-tolerance,box2+tolerance,boy2+tolerance,"#aaa");
688
 
                                                                
689
 
                                if((x>(box1-tolerance))&&(x<(box2+tolerance))&&(y>(boy1-tolerance))&&(y<(boy2+tolerance))){
690
 
                                                // Straight X, Straight Y or Positive or Negative Incline
691
 
                                                if(Math.abs(dx)<straighttolerance){
692
 
                                                                if(y1<y2){
693
 
                                                                                if(y>y1-tolerance&&y<y2+tolerance){
694
 
                                                                                                distance=Math.abs(x1-x);
695
 
                                                                                }
696
 
                                                                }else{
697
 
                                                                                if(y>y2-tolerance&&y<y1+tolerance){
698
 
                                                                                                distance=Math.abs(x1-x);
699
 
                                                                                }                                               
700
 
                                                                }
701
 
                                                }else if(Math.abs(dy)<straighttolerance){
702
 
                                                                if(x1<x2){
703
 
                                                                                if(x>x1-tolerance&&x<x2+tolerance){
704
 
                                                                                                distance=Math.abs(y1-y);
705
 
                                                                                }
706
 
                                                                }else{
707
 
                                                                                if(x>x2-tolerance&&x<x1+tolerance){
708
 
                                                                                                distance=Math.abs(y1-y);
709
 
                                                                                }
710
 
                                                                }
711
 
                                                }else if(Math.abs(dx)>=Math.abs(dy)){
712
 
                                                                k=dy/dx;                                                                
713
 
                                                                yk=y1+((x-x1)*k);
714
 
                                                                distance=Math.abs(yk-y);
715
 
                                                }else{
716
 
                                                                k=dx/dy;
717
 
                                                                xk=x1+((y-y1)*k);
718
 
                                                                distance=Math.abs(xk-x);                                                
719
 
                                                }
720
 
                                }
721
 
                                                                                                
722
 
                                return distance;
723
 
                                                
724
 
                }
 
 
b'\\ No newline at end of file'