Login

Search Javascript Folder

/ root / Products / Root / AllJavascript / Desktop.js

Desktop.js
  

Get

1    
2   function slideDownTo(key){
3      var node = getNode(key);
4      dispatchOver(node);
5   } 
6    
7    function displaySlideNamed(aName){
8        pinned = null;
9        var node = getNode(aName);
10       dispatchOver(node);
11   
12    }
13    
14    function getNode(nodeName){
15         return view.graph.nodes(nodeName);
16    }
17   
18    function setRatio(node,score){
19        node.data.ratio = score;
20    }
21        
22    function getConferenceKey(slide){
23       return slide.conference.id;
24   }
25   
26    function getConference(slide){
27       return slide.conference;
28   }
29   
30   function localRebuild(){
31        return true;
32     }
33   
34   
35   
36   
37     function getConferenceName(node){
38         if (getClass(node)== 'Conference'){
39             return node.title;
40         }
41         return node.conference.title;
42     }
43     
44   function isRoot(node){
45       if (! ('parent' in node) ||
46          (node.parent === null)){
47           return true;
48       }
49       return false;
50   }
51   
52   
53   
54        
55     function getTitle(item){
56         return item.title;
57     }
58     
59     function getBranchSize(item){
60         return item.branchSize;
61     }
62     
63     
64      function getDescription(item){
65         return item.description;
66     }
67        function getUpVotes(item){
68         return item.upVotes;
69     }
70        function getDownVotes(item){
71         return item.downVotes;
72     }
73     
74     function getClass(slide){
75         return slide.class;
76     }
77     
78     
79    
80    function addChildArray (item,index){
81        item.children = [];
82    }
83    
84    function getKey(item,array){
85        return item.id;
86    }
87     function getClass(item,array){
88        return item.class;
89    }
90    
  

Move Commands For Destkopt

91    function moveUp(){
92               moveTo(homeNode.parent);
93   }
94   
95   function moveDown(childIndex){
96           moveTo (homeNode.children[childIndex]);
97   }
98   
99   function moveToLast(numberOfSiblings){
100           moveTo (homeNode.parent.children[numberOfSiblings -1]);
101   }
102   
103   function moveToFirst(){
104       moveTo (homeNode.preant.children[0]); 
105   }
106   
107   function moveRight(offset){
108           moveTo (homeNode.parent.children[offset+1]); 
109   }
110   
111   function moveLeft(offset){
112        moveTo (homeNode.parent.children[offset-1]);
113   }
  

addDescription

114     
115     /*
116     function addDescription (description){
117        $('#description').remove();
118        var result =' <span id = "description" style= "position:absolute; bottom:10px;'   +
119        'z-index: -1; left: 33%; padding: 20px; ">'+
120        description + 
121        '</span>';
122    
123        $('#graph-container').append(result);
124    }
125    */
  

addList

126     function renderList(node){
127         if (node.children.length ===0){
128             return '';
129         }
130         result = '<center>';
131         result +='<b>SubCategories:</b><br>';
132         for (var i = 0  i< node.children.length; i++){
133             result +=  node.children[i].title + "<br>";
134         }
135         result += '</center>';
136         return result;
137     }
138     
139       function renderList2(node){
140         result ='<ul>';
141         for (var i = 0  i< node.children.length; i++){
142             result += "<li>" + node.children[i].title + "</li>";
143         }
144         result += "</ul>";
145         return result;
146     }
147     /*
148     function deleteNodePlusChildren(){
149              $('#NodePlusChildren').remove();
150     }
151     function renderNodePlusChildren (node){
152        var result ='<div id = "NodePlusChildren" ' +
153        'style= "position:fixed;'+
154        'bottom:' + node.children.length + 'em;  '   +
155        'left: 30%; z-index: -1;">' +
156        "<p>" + node.title + "</p>"+ 
157         renderList(node)+
158        '</div>';
159        $('#graph-container').append(result);
160    }
161    */
  

camera

162    var baseX = 0;
163    var baseY = -($('#graph-container')[0].clientWidth)/4
164   ;
165     function cameraGoToOrigin(){
166    view.cameras[0].goTo({x:baseX, y: baseY, ratio:1, angle: 1.55});
167    }
168    
169    //NOT WORKING
170    function cameraGoToNode(node){
171         view.cameras[0].goTo({x:node.x , y: node.y ,  angle:node.angle});
172        
173    }
174   
  

childFunctions

175    
176   
177   function getChildIndex(node){
178      var childIndex = 0;    
179             if ('previousChildIndex' in node){
180                childIndex = node.previousChildIndex;
181              }
182      return childIndex;
183   }
184    
185        
  

first

186     var view;
187     var homeNode;
188     var root;
189     var landingPage;
190     var lastHover = null;
191     isMobile = false;
192   
193   
194   
195   
196   
197   
198    var mySettings =  {
199          animationsTime: 500,
200        drawLabels: true,
201        drawEdgeLabels: true,
202         zoomMax : 4,
203         singleHover: false,
204       doubleClickEnabled: false,
205       enableNodeHovering: true,
206           labelSizeRatio: 0,
207       labelThreshold: 1,
208       minNodeSize: 1,
209       maxNodeSize: 4
210     };
211     
212    function myCallback(arg){
213        view  = arg;
214        var nodes = view.graph.nodes();
215        nodes.forEach(addChildArray);
216        nodes.forEach (setParent);
217        nodes.forEach(zeroPosition);
218        //nodes.forEach(setLabels);
219        //MUST BE AFTER SET PARENT
220        nodes.forEach(setConferences);
221      
222     
223    
224   
225        
226        
227        root = getNode(rootName);
228        root.x=0; 
229        root.y=0;
230        root.share = 2*Math.PI;
231        root.angle = 0;
232     
233   
234        var row = root.children;
235        var radius = 1;
236        
237        while (row.length > 0){
238            
239            calculateChildPositions(row,radius ); 
240            row = rowItems(row);
241            radius ++ 
242         }
243         cameraGoToOrigin();
244   view.bind('overNode', overNode);
245       view.bind('outNode', outNode);
246   view.bind('overNodes', overNodes);
247       view.bind('outNodes', outNodes);
248       view.bind('clickNode', clickNode);
249       
250        view.refresh();
251            
252           homeNode= getNode(homeNodeKey);
253          landingPage = homeNode;
254       dispatchOver(homeNode);
255            pinned = homeNode;
256   
257    } //END OF CALLBACK
258   
259   
260    sigma.parsers.json(deskTopJson, {
261     container: 'graph-container',
262     settings: mySettings
263   },
264     myCallback);
265    
266    
267   
  

hasChildren

268    function hasChildren(node){
269        if (node.children.length > 0){
270            return true;
271        }
272        return false;
273        
274    }
  

hover

275   var pinned = null;
276   
277   function deletePin(node){
278       delete pinned.data.pinned;
279       pinned = null;
280   }
281   
282      
283    function leavePinnedNode(){
284         var pin = pinned;
285            deletePin (pin);
286            outNodeCore(pin);
287            view.refresh();
288    }  
289    
290    function clickNode(e){
291         var node = e.data.node;
292         clickNodeCore(node);
293    }
294    function clickNodeCore (node){
295         //Clicking on Pinned Node
296        if (node == pinned){
297          deletePin(pinned);
298            node.label = node.title;
299           newHomeNode(e.node);
300            view.refresh();
301        }
302        // CLICKING ON A DIFFERENT NODE
303        else if (pinned){
304            leavePinnedNode();
305        }
306        else{
307            overNodeCore(node);
308            pinned = node;
309            node.data.pinned = true;
310            node.label = 'PINNED: '+ node.title;
311            view.refresh();
312        }
313        
314    }
315    
316    
317    
318    var hoverNodes= {};
319   
320    function overNode(e) {
321              if (pinned){
322               return;
323           }
324           var node = e.data.node;
325           overNodeCore(node);
326    }
327    
328   function overNodes(e){
329             if (pinned){
330               return;
331           }
332       for (var i = 0; i < e.data.nodes.length; i++){
333           var node = e.data.nodes [i];
334           overNodeCore(node);
335    }
336   }
337   
338   function deleteOldHovers(){
339            for (var key in hoverNodes){
340                var item = hoverNodes[key];
341                 hideLabel(item);
342                 if (item.conference){
343                     hideLabel(item.conference);
344                 }
345               delete hoverNodes[key];
346          }
347   }
348   var lastOverNode=null;
349   var lastOutNode = null;
350   var lastNodeEvent=null;
351   function  overNodeCore(node){
352     
353           showLabel (node);
354          if ((lastOverNode== node)&&
355              (lastNodeEvent =="overNode")){
356                  return;
357              }
358           //if (lastOverNode){
359           //hideLabel(lastOverNode);
360          //}
361           lastOverNode = node;
362           lastNodeEvent = "overNode";
363               deleteOldHovers();
364   
365           showLabel (node);
366           newHomeNode(node);
367           possiblyLoadContent(node);
368           hoverNodes [node.id]= node;
369   }
370    
371    function outNode(e){
372               if (pinned){
373               return;
374           }
375            var node = e.data.node;
376         outNodeCore(node);
377   }
378   
379   function outNodes(e){
380          if (pinned){
381               return;
382           }
383       for (var i = 0; i < e.data.nodes.length; i++){
384            var node = e.data.nodes [i];
385           outNodeCore (node);
386       }
387   }
388   
389   function outNodeCore(node){
390   
391              if ((lastOutNode== node)&&
392              (lastNodeEvent =="outNode")){
393                  return;
394              }
395              hideLabel(node);
396             view.refresh();
397           //deleteOldHovers();
398           if (node.conference){
399                     hideLabel(node.conference);
400                 }
401           lastOutNode = node;
402           lastNodeEvent = "outNode";
403      
404    }
405    
406    
  

initialize

407      
408    function setParent(item,index){
409        item.data= {};
410        var parent = item.parent;
411        if (item.id == rootName){
412            item.parent = null;
413            return;
414        }
415        parent = getNode (item.parent);
416        item.parent = parent;
417        item.parent.children.push (item);
418       view.graph.addEdge({source:parent.id, 
419                      target:item.id,
420                      label:"Hello",
421                 id:(item.id + parent.id), size: 1});
422       if (item.class == 'Conference'){
423           item.data.talks = [];
424       }
425    }
426    function setConferences(node,index){
427        if (getClass(node) == 'Video'){
428           node.conference = getNode(node.conference);
429           node.conference.data.talks.push(node);
430           /*
431           if (node.parent != node.conference){
432               view.graph.addEdge({source:node.id, 
433                         target:node.conference.id, 
434                         id:(node.id + node.conference.id), 
435                         size: 1,
436                         hidden:true
437           });
438          
439           }
440           */
441   
442       }
443   }    
444    function setLabels(item,index){
445      //  item.label = item.title;
446    }
447    
  

loadContent

448   function possiblyLoadContent(node){
449            lastHover = node;
450      setTimeout (maybeLoadContent,400,node);
451   }
452   
453   function maybeLoadContent(node){
454        if (lastHover == node){
455           addLinks(node);
456          loadRemoteContent(node);
457           return;
458       }
459   }
460   
461   var oldVideoNode=null;
462   var oldConferenceNode = null;
463   function addLinks(node){
464       //if ('talks' in node){
465       //    addConferenceLinks(node);
466       //}
467       if ('conference' in node){
468          addVideoLink (node);                    
469       }
470       view.refresh();
471   }
472    
473   function addConferenceLinks(node){
474           dropConferenceLinks (oldVideoNode);
475           oldConferenceNode = node;
476           node.data.hasConferenceLink = true;
477   
478           for (var i = 0  i < node.talks.length; i++){
479               var talk = node.talks[i];
480               var name = node.id + talk.id;
481               if (!view.graph.edges(name)){
482                  view.graph.addEdge({source:node.id, 
483                               target:talk.id, 
484                              id:name, 
485                              size: 1});
486           } 
487           }
488   } 
489   
490   function addVideoLink(node){
491           dropVideoLink (oldVideoNode);
492           oldVideoNode = node;
493           var name = node.id + node.conference.id;
494           if (!view.graph.edges(name)){
495              node.data.hasVideoLink = true;
496              //showLabel(node.conference);
497              view.graph.addEdge({source:node.id, 
498                               target:node.conference.id, 
499                              id:name, size: 1});
500           }      
501   } 
502   
503   function dropConferenceLink(conference){
504       if (! conference){
505           return;
506       }
507       if (conference.data.hasConferenceLink){
508           node.data.hasConferenceLink = false;  
509           for (var i=0; i<conference.talks.length; i++ ){
510              var name = conference.id + conference.talks[i];
511              view.graph.dropEdge(name);
512           }
513           view.refresh();
514   
515       }
516   }
517   
518   
519   function dropVideoLink(node){
520   
521       if (! node){
522           return;
523       }
524       if (node.data.hasVideoLink){
525           node.data.hasVideoLink = false;   
526           var name = node.id + node.conference.id;
527           view.graph.dropEdge(name);
528           view.refresh();
529   
530       }
531   }
532   
533   function newHomeNode (node){
534          homeNode = node;
535          showLabel(node);
536       saveCurrentURL();
537      // $("#arrows").html(arrows(node));
538       $("#text").html(renderSlide(node));
539       //postRender();
540   
541   }
542        
543            
544   
545    function errorF( jqXHR, textStatus, errorThrown ){
546       console.log ("AJAX ERROR", jqXHR, textStatus, errorThrown );
547   }
548   
549   //after slide load
550   function loadRemoteContent(node){
551       var url = "/" + getKey(node) + "/content";
552       divName = "#" + getKey(node) + "-content";
553         $.ajax({url: url, cache: false, 
554         error: errorF,
555         success: function(result){
556           $(divName).html(result);
557           resizeVideos(0,0,"#text");
558       }
559         });
560       
561   }
562    
563   
564      
  

moveTo

565    var currentNode=null;
566   function moveTo(node){
567       pinned = null;
568      
569       if (currentNode){
570               dispatchOut (currentNode);
571       }
572       dispatchOver(node);
573   }
574   
575   function hideLabel(node){
576            node.label = "";
577   }
578   function dispatchOut(node){
579           var data = {};
580           data.node = currentNode;
581          view.renderers[0].dispatchEvent('outNode',data);
582   }
583   function showLabel(node){
584           node.label=node.title;
585   }
586   function dispatchOver(node){
587          view.renderers[0].dispatchEvent('overNode',{node});
588   }
  

positions

589     
590    function nextItem(array,index){
591        if (index == array.length -1){
592            return array[0];
593        }
594        return array[index+1];
595    }
596    function previousItem(array,index){
597        if (index === 0){
598            return array [array.length -1];
599        }
600        return array [index-1];
601   }
602   
603   function average (angle1, angle2,radius){
604           if ((angle1 - angle2) > Math.PI){
605            
606              angle2=angle2 + 2*Math.PI;
607              //return angle1;
608              return average (angle1, angle2, radius);
609           } 
610           
611           if ((angle1 - angle2) > 1){
612              return angle1 - (0.333/radius);
613           }  
614           
615           if ((angle2 - angle1) > Math.PI){
616              
617                angle2= angle2 - 2*Math.PI;
618                return average (angle1, angle2, radius);      
619           }
620           if ((angle2 - angle1) > 1){
621              return angle1 + (0.3333/radius);
622       }
623       return (angle1 + angle2 ) /2.0;
624   }
625   
626    function calculateChildPositions (row,radius){
627        var i, item, arent, siblings, length, offset, share;
628        var angle, parentAngle,itemIndex,  delta;
629        var first, last, previous, previousAngle, next, nextAngle;
630        var j, ratio;
631        var rowLength= row.length;
632        var maxDelta = 0;
633        var minDelta = 0;
634        for (i = 0  i<rowLength;i ++ ){
635             item = row [i]; 
636             parentAngle= item.parent.angle;
637             siblings = item.parent.children;
638             length = siblings.length;
639             offset = length /2;
640             share =  item.parent.share/length;
641             item.share = share;
642             itemIndex = siblings.indexOf(item);
643             delta = (itemIndex -offset) * share 
644             angle = parentAngle + delta;
645             onePosition(item, angle, radius);
646            }
647             
648            if (radius < 2) {
649              return;
650          }
651          
652         for (i = 0  i<rowLength;i ++ ){
653                 item = row [i]; 
654                 siblings = item.parent.children;
655                 length= siblings.length;
656                 itemIndex = siblings.indexOf(item);  
657   
658                 if (itemIndex === 0){
659                     previous = previousItem (row,i);
660                     previousAngle = previous.angle;
661                     first = average (item.angle, previousAngle,radius);
662   
663                 }
664                 if (itemIndex == siblings.length -1 ){
665                     next = nextItem(row,i);
666                     nextAngle = next.angle;
667                     last = average (item.angle, nextAngle,radius); 
668                 
669   
670                     for (j=0 j< length; j++){
671                         item = siblings [j];
672                         delta = last - first;
673                         offset = length /2;
674                         ratio = (j) /length;
675                         if (length ==1){
676                             ratio = 0.5;
677                         }
678                         angle = first + (delta * ratio);
679                       onePosition(item, angle, radius);
680                     }
681                 }
682   
683         }
684   
685             
686   }
687   
688     function onePosition( item,angle,radius) {
689        item.angle = angle;
690       item.x=radius * Math.cos(angle);
691       item.y=  radius * Math.sin(angle);
692    } 
693    
694    
695    function randomPosition(item, index) {
696       item.x=Math.random () +1;
697       item.y=Math.random () +1;
698    }
699    function zeroPosition(item, index) {
700       item.x=0;
701       item.y=0;
702    }
  

renderSearchButton

703    function renderSearchOption(node){
704             if (! isMobile){
705             return "" +
706               lili('<a href="https://PythonLinks.info/search">Search</a>');
707             }
708             else{ 
709                 return lili('<a onclick ="showSearch()">Search</a>');
710           
711              }
712              
713    }
714    
  

showsearch

715     function showSearch(){}
  

traverse

716   
717    
718    function rowItems(rowArray){
719        var result = [];
720        for (var i=0  i<rowArray.length;i++){
721            result = result.concat(rowArray[i].children);
722        }
723        return result;
724    }