/lenasys/trunk

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

« back to all changes in this revision

Viewing changes to codeigniter/js/dugga.js

  • Committer: Gustav Hatvigsson
  • Date: 2013-05-30 12:02:31 UTC
  • mfrom: (85.1.28 lenasys)
  • Revision ID: gustav.hartvigsson@gmail.com-20130530120231-ttqgqjqw2w8enn7g
Merged Ohlsons changes:
added function to get ssn and name for the registrationspages in the user model.
added the registrationpage for students.
edited the registration page for instructors
edited the css for both the registrationpages
minor fix to registration css

Show diffs side-by-side

added added

removed removed

Lines of Context:
codeigniter/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'