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

initialize

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

loadContent

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

moveTo

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

positions

591     
592    function nextItem(array,index){
593        if (index == array.length -1){
594            return array[0];
595        }
596        return array[index+1];
597    }
598    function previousItem(array,index){
599        if (index === 0){
600            return array [array.length -1];
601        }
602        return array [index-1];
603   }
604   
605   function average (angle1, angle2,radius){
606           if ((angle1 - angle2) > Math.PI){
607            
608              angle2=angle2 + 2*Math.PI;
609              //return angle1;
610              return average (angle1, angle2, radius);
611           } 
612           
613           if ((angle1 - angle2) > 1){
614              return angle1 - (0.333/radius);
615           }  
616           
617           if ((angle2 - angle1) > Math.PI){
618              
619                angle2= angle2 - 2*Math.PI;
620                return average (angle1, angle2, radius);      
621           }
622           if ((angle2 - angle1) > 1){
623              return angle1 + (0.3333/radius);
624       }
625       return (angle1 + angle2 ) /2.0;
626   }
627   
628   
629   //Furst we sgikd uteratue iver tge cgukdreb, 
630   //tgeb iver tge oarebt arrat,  
631   // So there should be two functions called from the calling function. 
632   //But not that big a priority. 
633    function calculateChildPositions (row,radius){
634        var i, item, arent, siblings, length, offset, share;
635        var angle, parentAngle,itemIndex,  delta;
636        var first, last, previous, previousAngle, next, nextAngle;
637        var j, ratio;
638        var rowLength= row.length;
639        var maxDelta = 0;
640        var minDelta = 0;
641        for (i = 0  i<rowLength;i ++ ){
642             item = row [i]; 
643             parentAngle= item.parent.angle;
644             siblings = item.parent.children;
645             length = siblings.length;
646             offset = length /2;
647             share =  item.parent.share/length;
648             item.share = share;
649             itemIndex = siblings.indexOf(item);
650             delta = (itemIndex -offset) * share 
651             angle = parentAngle + delta;
652             onePosition(item, angle, radius);
653            }
654             
655            if (radius < 2) {
656              return;
657          }
658          
659         for (i = 0  i<rowLength;i ++ ){
660                 item = row [i]; 
661                 siblings = item.parent.children;
662                 length= siblings.length;
663                 itemIndex = siblings.indexOf(item);  
664   
665                 //IF there is nothing on the other side, 
666                 //this grabs an item from this side of the circle
667                 //so the angle is reversed. 
668                 //we need to check that the first item is before the 
669                 //current item. 
670                 //we need to check that the last item, is after the current 
671                 //item.  
672                 if (itemIndex === 0){
673                     previous = previousItem (row,i);
674                     previousAngle = previous.angle;
675                     first = average (item.angle, previousAngle,radius);
676   
677                 }
678                 if (itemIndex == siblings.length -1 ){
679                     next = nextItem(row,i);
680                     nextAngle = next.angle;
681                     last = average (item.angle, nextAngle,radius); 
682                 
683   
684                     for (j=0 j< length; j++){
685                         item = siblings [j];
686                         delta = last - first;
687                         offset = length /2;
688                         ratio = (j) /length;
689                         if (length ==1){
690                             ratio = 0.5;
691                         }
692                         angle = first + (delta * ratio);
693                       onePosition(item, angle, radius);
694                     }
695                 }
696   
697         }
698   
699             
700   }
701   
702     function onePosition( item,angle,radius) {
703        item.angle = angle;
704       item.x=radius * Math.cos(angle);
705       item.y=  radius * Math.sin(angle);
706    } 
707    
708    
709    function randomPosition(item, index) {
710       item.x=Math.random () +1;
711       item.y=Math.random () +1;
712    }
713    function zeroPosition(item, index) {
714       item.x=0;
715       item.y=0;
716    }
  

renderSearchButton

717    function renderSearchOption(node){
718             if (! isMobile){
719             return "" +
720               lili('<a href="https://PythonLinks.info/search">Search</a>');
721             }
722             else{ 
723                 return lili('<a onclick ="showSearch()">Search</a>');
724           
725              }
726              
727    }
728    
  

showsearch

729     function showSearch(){}
  

traverse

730   
731    
732    function rowItems(rowArray){
733        var result = [];
734        for (var i=0  i<rowArray.length;i++){
735            result = result.concat(rowArray[i].children);
736        }
737        return result;
738    }