miteruzo
/
mr-legend_wiki
1
0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1 Commit
1 Branch
13 MiB
 
 
 
 
 
Branch: main
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'main'
${ noResults }
mr-legend_wiki/lib/plugins/indexmenu/scripts/indexmenu.js

1010 lines
32 KiB
Raw Permalink Blame History 

  1. /*--------------------------------------------------------|

  2.  | dTree 2.05 | www.destroydrop.com/javascript/tree/      |

  3.  |--------------------------------------------------------|

  4.  | Copyright (c) 2002-2003 Geir Landro                    |

  5.  |                                                        |

  6.  | This script can be used freely as long as all          |

  7.  | copyright messages are intact.                         |

  8.  |                                                        |

  9.  | Updated: 17.04.2003                                    |

  10.  |--------------------------------------------------------|

  11.  | Modified for Dokuwiki by                               |

  12.  | Samuele Tognini <samuele@samuele.netsons.org>          |

  13.  | under GPL 2 license                                    |

  14.  | (http://www.gnu.org/licenses/gpl.html)                 |

  15.  | Updated: 29.08.2009                                    |

  16.  |--------------------------------------------------------|

  17.  | Modified for Dokuwiki by                               |

  18.  | Rene Hadler <rene.hadler@iteas.at>                     |

  19.  | under GPL 2 license                                    |

  20.  | (http://www.gnu.org/licenses/gpl.html)                 |

  21.  | Updated: 07.08.2012                                    |

  22.  |--------------------------------------------------------|

  23.  | jQuery update - 27 02 2012                             |

  24.  | Gerrit Uitslag <klapinklapin@gmail.com                 |

  25.  |--------------------------------------------------------|

  26.  | indexmenu  | https://www.dokuwiki.org/plugin:indexmenu |

  27.  |-------------------------------------------------------*/

  28. /* global DOKU_COOKIE_PARAM */

  29. /* global DOKU_BASE */

  30. 

  31. /*

  32.  * ids used in the dTree:

  33.  *  - div#cdtree_<id indexmenu>  div top level

  34.  *      - div#dtree_<id indexmenu> div contains all nodes

  35.  *          - div#toc_<id indexmenu> ??

  36.  *          - div.dtreeNode

  37.  *              - img#i<id indexmenu><nodenr?>   icon

  38.  *              - a#s<id indexmenu><nodenr?>     url to page/namespace with title

  39.  *              - div#t<id indexmenu><nodenr?>   button for opening ToC, included if hovered

  40.  *          - div.d<id indexmenu><nodenr?>

  41.  *  repeats:    - div.dtreeNode (with img#i, a#s and div#t)

  42.  *  repeats:    - div.d<id indexmenu><nodenr?>

  43.  *      - z<id indexmenu>  scroll rightward arrows

  44.  *      - left_<id indexmenu> scroll leftward arrows

  45.  *

  46.  * at the end of body:

  47.  *  - picker_<id indexmenu> popup with ToC

  48.  *  - r<id indexmenu>  rightmouse button menu

  49.  */

  50. 

  51. /**

  52.  * dTreeNode object

  53.  *

  54.  * @param {string}        dokuid page id of node

  55.  * @param {number}        id     node id

  56.  * @param {number}        pid    parent node id

  57.  * @param {string}        name   Page Title

  58.  * @param {number|string} hns    page id of headpage of namespace

  59.  * @param {number}        isdir  is directory?

  60.  * @param {number}        ajax   load subnodes by ajax

  61.  * @constructor

  62.  */

  63. function dTreeNode(dokuid, id, pid, name, hns, isdir, ajax) {

  64.     /** @type {string} */

  65.     this.dokuid = dokuid; // page id of node

  66.     /** @type {number} */

  67.     this.id = id;         // id number of node

  68.     /** @type {number} */

  69.     this.pid = pid;       // id number of parent node

  70.     /** @type {string} */

  71.     this.name = name;     // ns/page title

  72.     /** @type {number|string} */

  73.     this.hns = hns;       // headpage of namespace or zero

  74.     /** @type {boolean} */

  75.     this.isdir = Boolean(isdir); // is directory

  76.     /** @type {boolean} */

  77.     this.ajax = Boolean(ajax);   // load its nodes by ajax

  78.     /** @type {boolean} */

  79.     this._io = false;     // is node open

  80.     /** @type {boolean} */

  81.     this._is = false;     // is selected

  82.     /** @type {boolean} */

  83.     this._ls = false;     // is last sibling

  84.     /** @type {boolean} */

  85.     this._hc = Boolean(ajax); // has children

  86.     /** @type {number} */

  87.     this._ai = 0;         // id number of first child....

  88.     /** @type {dTreeNode} */

  89.     this._p = undefined;  // parent dTreeNode

  90.     /** @type {number} */

  91.     this._lvl = 0;        // level

  92.     /** @type {boolean} */

  93.     this._ok = false;     // all children are loaded

  94.     /** @type {boolean} */

  95.     this._cp = false;     // current page

  96.     /** @type {string} */

  97.     this.icon = '';       // icon of closed node

  98.     /** @type {string} */

  99.     this.iconOpen = '';   // icon of opened node

  100. }

  101. 

  102. /**

  103.  * Tree object

  104.  *

  105.  * @param {string} treeName id of the indexmenu, has form 'indexmenu_<identifier>'

  106.  * @param {string} theme   name of theme dir

  107.  * @constructor

  108.  */

  109. function dTree(treeName, theme) {

  110.     let imgExt = IndexmenuUtils.determineExtension(theme);

  111.     this.config = {

  112.         urlbase: DOKU_BASE + 'doku.php?id=',           // base of dokuwiki (set in page)

  113.         plugbase: DOKU_BASE + 'lib/plugins/indexmenu', // base of plugin folder

  114.         useCookies: true,                              // use cookies (set in page) e.g. disabled for context option

  115.         scroll: true,                                  // enable scrolling of tree in too small columns (set in page)

  116.         toc: true,                                     // enable ToC popups in tree (set in page)

  117.         maxjs: 1,                                      // number set by maxjs option (set in page)

  118.         jsajax: '',                                    //  &max=#&sort=(t|d)&msort=(indexmenu_n|<metakey>)&rsort=1&nsort=1&hsort=1&nopg=1&skipns=+=/.../&skipfile=+=/.../(set in page)

  119.         sepchar: ':',                                  // value ':', ';' or '/'  (set in page)

  120.         theme: theme                                   // dir name of theme folder

  121.     };

  122.     let imagePath = this.config.plugbase + '/images/' + theme + '/';

  123.     this.icon = {

  124.         root: imagePath + 'base.' + imgExt,

  125.         folder: imagePath + 'folder.' + imgExt,

  126.         folderH: imagePath + 'folderh.' + imgExt,

  127.         folderOpen: imagePath + 'folderopen.' + imgExt,

  128.         folderHOpen: imagePath + 'folderhopen.' + imgExt,

  129.         node: imagePath + 'page.' + imgExt,

  130.         empty: imagePath + 'empty.' + imgExt,

  131.         line: imagePath + 'line.' + imgExt,

  132.         join: imagePath + 'join.' + imgExt,

  133.         joinBottom: imagePath + 'joinbottom.' + imgExt,

  134.         plus: imagePath + 'plus.' + imgExt,

  135.         plusBottom: imagePath + 'plusbottom.' + imgExt,

  136.         minus: imagePath + 'minus.' + imgExt,

  137.         minusBottom: imagePath + 'minusbottom.' + imgExt,

  138.         nlPlus: imagePath + 'nolines_plus.' + imgExt,

  139.         nlMinus: imagePath + 'nolines_minus.' + imgExt

  140.     };

  141.     /** @type {string} */

  142.     this.treeName = treeName; // (unique) name of this indexmenu

  143.     /** @type {dTreeNode[]} */

  144.     this.aNodes = [];   // array of nodes

  145.     /** @type {number[]} */

  146.     this.aIndent = [];  // array stores the indents of the tree (contains values 0 or 1)

  147.     /** @type {dTreeNode} */

  148.     this.root = new dTreeNode(false, -1);

  149.     /** @type {number} */

  150.     this.selectedNode = undefined;      // node id

  151.     /** @type {boolean} */

  152.     this.selectedFound = false;    // set to true when found

  153.     /** @type {boolean} */

  154.     this.completed = false;        // succesfull written js tree to the page

  155.     /** @type {number} */

  156.     this.scrllTmr = 0;             // store timer id for horizontal scrolling the page

  157.     /** @type {string} */

  158.     this.pageid = JSINFO.id || ''; // current page

  159. 

  160.     this.fajax = false;            // if retrieve next level of opened nodes

  161. }

  162. /**

  163.  * CSS classes:

  164.  *

  165.  * a.nodeFdUrl	Namespace with url link (headpage)

  166.  * a.node 	    Namespace without url link

  167.  * a.nodeUrl	Page

  168.  * a.nodeSel 	Last visited page

  169.  * a.navSel 	Current page

  170.  */

  171. 

  172. 

  173. /**

  174.  * Adds a new node to the node array

  175.  *

  176.  * @param {string}        dokuid page id of node

  177.  * @param {number}        id     node id

  178.  * @param {number}        pid    parent node id

  179.  * @param {string}        name   Page Title

  180.  * @param {number|string} hns    page id of headpage of namespace

  181.  * @param {number}        isdir  is directory?

  182.  * @param {number}        ajax   load subnodes by ajax

  183.  */

  184. dTree.prototype.add = function (dokuid, id, pid, name, hns, isdir, ajax) {

  185.     this.aNodes[this.aNodes.length] = new dTreeNode(dokuid, id, pid, name, hns, isdir, ajax);

  186. };

  187. 

  188. /**

  189.  * Open all nodes, if no node status was stored in cookie

  190.  */

  191. dTree.prototype.openAll = function () {

  192.     if (!this.getCookie('co' + this.treeName)) {

  193.         this.oAll(true);

  194.     }

  195. };

  196. 

  197. /**

  198.  * Outputs the tree to the page. Called by document.write after adding the nodes to the tree.

  199.  *

  200.  * @returns {string} html of whole tree

  201.  */

  202. dTree.prototype.toString = function () {

  203.     let str = '';

  204.     this.pageid = this.pageid.replace(/:/g,this.config.sepchar);

  205.     if (this.config.scroll) {

  206.         str += '<div id="cdtree_' + this.treeName + '" class="dtree" style="position:relative;overflow:hidden;width:100%;">';

  207.     }

  208.     str += '<div id="dtree_' + this.treeName + '" class="dtree ' + this.config.theme + '" style="overflow:';

  209.     if (this.config.scroll) {

  210.         str += 'visible;position:relative;width:100%"';

  211.     } else {

  212.         str += 'hidden;"';

  213.     }

  214.     str += '>';

  215. 	if (jQuery('#dtree_' + this.treeName)[0]) {

  216.         str += '<div class="error">Indexmenu id conflict</div>';

  217.     }

  218.     if (this.config.toc) {

  219.         str += '<div id="t' + this.treeName + '" class="indexmenu_tocbullet ' + this.config.theme + '" style="display:none;" title="Table of contents"></div>';

  220.         str += '<div id="toc_' + this.treeName + '" style="display:none;"></div>';

  221.     }

  222.     if (this.config.useCookies) {

  223.         this.selectedNode = this.getSelected();

  224.     }

  225.     str += this.addNode(this.root) + '</div>';

  226.     if (this.config.scroll) {

  227.         str += '<div id="z' + this.treeName + '" class="indexmenu_rarrow"></div>';

  228.         str += '<div id="left_' + this.treeName + '" class="indexmenu_larrow" style="display:none;" title="Click to scroll back" onmousedown="' + this.treeName + '.scroll(\'r\',1)" onmouseup="' + this.treeName + '.stopscroll()"></div>';

  229.         str += '</div>';

  230.     }

  231.     this.completed = true;

  232.     //hide the fallback nojs indexmenu

  233.     jQuery('#nojs_' + this.treeName).css("display", "none"); //using  .hide(); let's  crash opera

  234.     return str;

  235. };

  236. 

  237. /**

  238.  * Creates the tree structure

  239.  *

  240.  * @param {dTreeNode} pNode

  241.  * @returns {string} html of node (inclusive children)

  242.  */

  243. dTree.prototype.addNode = function (pNode) {

  244.     let str = '', cn, n = pNode._ai, l = pNode._lvl + 1;

  245.     for (n; n < this.aNodes.length; n++) {

  246.         if (this.aNodes[n].pid === pNode.id) {

  247.             cn = this.aNodes[n];

  248.             cn._p = pNode;

  249.             cn._ai = n;

  250.             cn._lvl = l;

  251.             this.setCS(cn);

  252.             if (cn._hc && !cn._io && this.config.useCookies) {

  253.                 cn._io = this.isOpen(cn.id);

  254.             }

  255.             if (this.pageid === (!cn.hns && cn.dokuid || cn.hns)) {

  256.                 cn._cp = true;

  257.             } else if (cn.id === this.selectedNode && !this.selectedFound) {

  258.                 cn._is = true;

  259.                 this.selectedNode = n;

  260.                 this.selectedFound = true;

  261.             }

  262.             if (!cn._hc && cn.isdir && !cn.ajax && !cn.hns) {

  263.                 if (cn._ls) {

  264.                     str += this.noderr(cn, n);

  265.                 }

  266.             } else {

  267.                 str += this.node(cn, n);

  268.             }

  269.             if (cn._ls) {

  270.                 break;

  271.             }

  272.         }

  273.     }

  274.     return str;

  275. };

  276. 

  277. /**

  278.  * Create empty node

  279.  *

  280.  * @param {dTreeNode} node

  281.  * @param {int} nodeId

  282.  * @returns {string} html of empty node

  283.  */

  284. dTree.prototype.noderr = function (node, nodeId) {

  285.     let str = '<div class="dTreeNode">' + this.indent(node, nodeId);

  286.     str += '<div class="emptynode" title="Empty"></div></div>';

  287.     return str;

  288. };

  289. 

  290. /**

  291.  * Creates the node icon, url and text

  292.  *

  293.  * @param {dTreeNode} node

  294.  * @param {int} nodeId

  295.  * @returns {string} html of node (inclusive children)

  296.  */

  297. dTree.prototype.node = function (node, nodeId) {

  298.     let h = 1, jsfnc, str;

  299.     jsfnc = 'onmouseover="' + this.treeName + '.show_feat(\'' + nodeId + '\');" onmousedown="return IndexmenuContextmenu.checkcontextm(\'' + nodeId + '\',' + this.treeName + ',event);" oncontextmenu="return IndexmenuContextmenu.stopevt(event)"';

  300.     if (node._lvl > this.config.maxjs) {

  301.         h = 0;

  302.     } else {

  303.         node._ok = true;

  304.     }

  305.     str = '<div class="dTreeNode">' + this.indent(node, nodeId);

  306.     node.icon = (this.root.id === node.pid) ? this.icon.root : ((node.hns) ? this.icon.folderH : ((node._hc) ? this.icon.folder : this.icon.node));

  307.     node.iconOpen = (node._hc) ? ((node.hns) ? this.icon.folderHOpen : this.icon.folderOpen) : this.icon.node;

  308.     if (this.root.id === node.pid) {

  309.         node.icon = this.icon.root;

  310.         node.iconOpen = this.icon.root;

  311.     }

  312.     str += '<img id="i' + this.treeName + nodeId + '" src="' + ((node._io) ? node.iconOpen : node.icon) + '" alt="" />';

  313.     if (!node._hc || node.hns) {

  314.         str += '<a id="s' + this.treeName + nodeId + '" class="' + ((node._cp) ? 'navSel' : ((node._is) ? 'nodeSel' : (node._hc) ? 'nodeFdUrl' : 'nodeUrl'));

  315.         str += '" href="' + this.config.urlbase;

  316.         (node.hns) ? str += node.hns : str += node.dokuid;

  317.         str += '"' + ' title="' + node.name + '"' + jsfnc;

  318.         str += ' onclick="javascript: ' + this.treeName + '.s(' + nodeId + ');"';

  319.         str += ' data-wiki-id="' + node.dokuid + '"';

  320.         str += '>' + node.name + '</a>';

  321.     }

  322.     else if (node.pid !== this.root.id) {

  323.         str += '<a id="s' + this.treeName + nodeId + '" href="javascript: ' + this.treeName + '.o(' + nodeId + '); " data-wiki-id="' + node.dokuid + '" class="node"' + jsfnc + '>' + node.name + '</a>';

  324.     } else {

  325.         str += node.name;

  326.     }

  327.     str += '</div>';

  328.     if (node._hc) {

  329.         str += '<div id="d' + this.treeName + nodeId + '" class="clip" style="display:' + ((this.root.id === node.pid || node._io) ? 'block' : 'none') + ';">';

  330.         if (h) {

  331.             str += this.addNode(node);

  332.         }

  333.         str += '</div>';

  334.     }

  335.     this.aIndent.pop();

  336.     return str;

  337. };

  338. 

  339. /**

  340.  * Adds the empty and line icons which indent the node

  341.  *

  342.  * @param {dTreeNode} node

  343.  * @param {int} nodeId

  344.  * @returns {string} html of indent icons

  345.  */

  346. dTree.prototype.indent = function (node, nodeId) {

  347.     let n, str = '';

  348.     if (this.root.id !== node.pid) {

  349.         for (n = 0; n < this.aIndent.length; n++) {

  350.             str += '<img src="' + ( (this.aIndent[n] === 1) ? this.icon.line : this.icon.empty ) + '" alt="" />';

  351.         }

  352.         if (node._ls) {

  353.             this.aIndent.push(0);

  354.         } else {

  355.             this.aIndent.push(1);

  356.         }

  357.         if (node._hc) {

  358.             str += '<a href="javascript: ' + this.treeName + '.o(' + nodeId + ');">' +

  359.                    '<img id="j' + this.treeName + nodeId + '" src="' +

  360.                    ( (node._io) ? ((node._ls) ? this.icon.minusBottom : this.icon.minus) : ((node._ls) ? this.icon.plusBottom : this.icon.plus ) ) +

  361.                    '" alt="" /></a>';

  362.         } else {

  363.             str += '<img src="' + ((node._ls) ? this.icon.joinBottom : this.icon.join) + '" alt="" />';

  364.         }

  365.     }

  366.     return str;

  367. };

  368. 

  369. /**

  370.  * Checks if a node has any children and if it is the last sibling

  371.  *

  372.  * @param {dTreeNode} node

  373.  */

  374. dTree.prototype.setCS = function (node) {

  375.     let lastId, n;

  376.     for (n = 0; n < this.aNodes.length; n++) {

  377.         if (this.aNodes[n].pid === node.id) {

  378.             node._hc = true;

  379.         }

  380.         if (this.aNodes[n].pid === node.pid) {

  381.             lastId = this.aNodes[n].id;

  382.         }

  383.     }

  384.     if (lastId === node.id) {

  385.         node._ls = true;

  386.     }

  387. };

  388. 

  389. /**

  390.  * Returns the selected node as stored in cookie

  391.  *

  392.  * @returns {int} node id

  393.  */

  394. dTree.prototype.getSelected = function () {

  395.     let sn = this.getCookie('cs' + this.treeName);

  396.     return (sn) ? parseInt(sn, 10) : null;

  397. };

  398. 

  399. /**

  400.  * Highlights the selected node

  401.  *

  402.  * @param {int} id node id

  403.  */

  404. dTree.prototype.s = function (id) {

  405.     let eOld, eNew, cn = this.aNodes[id];

  406.     if (this.selectedNode !== id) {

  407.         eNew = jQuery("#s" + this.treeName + id)[0];

  408.         if (!eNew) {

  409.             return;

  410.         }

  411.         if (this.selectedNode || this.selectedNode === 0) {

  412.             eOld = jQuery("#s" + this.treeName + this.selectedNode)[0];

  413.             eOld.className = "node";

  414.         }

  415.         eNew.className = "nodeSel";

  416.         this.selectedNode = id;

  417.         if (this.config.useCookies) {

  418.             this.setCookie('cs' + this.treeName, cn.id);

  419.         }

  420.     }

  421. };

  422. 

  423. /**

  424.  * Toggle Open or close

  425.  *

  426.  * @param {int} id node id

  427.  */

  428. dTree.prototype.o = function (id) {

  429.     let cn = this.aNodes[id];

  430.     this.nodeStatus(!cn._io, id, cn._ls);

  431.     cn._io = !cn._io;

  432.     if (this.config.useCookies) {

  433.         this.updateCookie();

  434.     }

  435.     // scroll

  436.     this.divdisplay('z', false);

  437.     this.resizescroll("block");

  438. };

  439. 

  440. /**

  441.  * Open or close all nodes

  442.  *

  443.  * @param {boolean} status if true open

  444.  */

  445. dTree.prototype.oAll = function (status) {

  446.     for (let n = 0; n < this.aNodes.length; n++) {

  447.         if (this.aNodes[n]._hc && this.aNodes[n].pid !== this.root.id) {

  448.             this.nodeStatus(status, n, this.aNodes[n]._ls);

  449.             this.aNodes[n]._io = status;

  450.         }

  451.     }

  452.     if (this.config.useCookies) {

  453.         this.updateCookie();

  454.     }

  455. };

  456. 

  457. /**

  458.  * Opens the tree to a specific node

  459.  *

  460.  * @param {number} nId node id

  461.  * @param {boolean} bSelect

  462.  * @param {boolean} bFirst

  463.  */

  464. dTree.prototype.openTo = function (nId, bSelect, bFirst) {

  465.     let n, cn;

  466.     if (!bFirst) {

  467.         for (n = 0; n < this.aNodes.length; n++) {

  468.             if (this.aNodes[n].id === nId) {

  469.                 nId = n;

  470.                 break;

  471.             }

  472.         }

  473.     }

  474.     this.fill(this.aNodes[nId].pid);

  475.     cn = this.aNodes[nId];

  476.     if (cn.pid === this.root.id || !cn._p) {

  477.         return;

  478.     }

  479.     cn._io = 1;

  480.     if (this.completed && cn._hc) {

  481.         this.nodeStatus(true, cn._ai, cn._ls);

  482.     }

  483.     if (cn._is) {

  484.         (this.completed) ? this.s(cn._ai) : this._sn = cn._ai;

  485.     }

  486.     this.openTo(cn._p._ai, false, true);

  487. };

  488. 

  489. /**

  490.  * Open the given nodes, if no node status is already stored

  491.  *

  492.  * @param {Array|string} nodes array of nodes to open or empty string to open all nodes

  493.  */

  494. dTree.prototype.getOpenTo = function (nodes) {

  495.     if (nodes === '') {

  496.         this.openAll();

  497.     } else if (!this.config.useCookies || !this.getCookie('co' + this.treeName)) {

  498.         for (let n = 0; n < nodes.length; n++) {

  499.             this.openTo(nodes[n], false, true);

  500.         }

  501.     }

  502. };

  503. 

  504. /**

  505.  * Change the status of a node(open or closed)

  506.  *

  507.  * @param {boolean} status true if open

  508.  * @param {int}     id     node id

  509.  * @param {boolean} bottom true if bottom node

  510.  */

  511. dTree.prototype.nodeStatus = function (status, id, bottom) {

  512.     if (status && !this.fill(id)) {

  513.         return;

  514.     }

  515.     let eJoin, eIcon;

  516. 	eJoin = jQuery('#j' + this.treeName + id)[0];

  517. 	eIcon = jQuery('#i' + this.treeName + id)[0];

  518.     eIcon.src = (status) ? this.aNodes[id].iconOpen : this.aNodes[id].icon;

  519.     eJoin.src = ((status) ? ((bottom) ? this.icon.minusBottom : this.icon.minus) : ((bottom) ? this.icon.plusBottom : this.icon.plus));

  520.     jQuery('#d' + this.treeName + id)[0].style.display = (status) ? 'block' : 'none';

  521. };

  522. 

  523. /**

  524.  * [Cookie] Clears a cookie

  525.  */

  526. dTree.prototype.clearCookie = function () {

  527.     let now, yday;

  528.     now = new Date();

  529.     yday = new Date(now.getTime() - 1000 * 60 * 60 * 24);

  530.     this.setCookie('co' + this.treeName, 'cookieValue', yday);

  531.     this.setCookie('cs' + this.treeName, 'cookieValue', yday);

  532. };

  533. 

  534. /**

  535.  * [Cookie] Sets value in a cookie

  536.  *

  537.  * @param {string}  cookieName

  538.  * @param {string}  cookieValue

  539.  * @param {boolean|Date} expires

  540.  */

  541. dTree.prototype.setCookie = function (cookieName, cookieValue, expires = false) {

  542.     document.cookie =

  543.         encodeURIComponent(cookieName) + '=' + encodeURIComponent(cookieValue) +

  544.             (expires ? '; expires=' + expires.toUTCString() : '') +

  545.             '; path=' + DOKU_COOKIE_PARAM.path +

  546.             '; secure=' + DOKU_COOKIE_PARAM.secure;

  547. };

  548. 

  549. /**

  550.  * [Cookie] Gets a value from a cookie

  551.  *

  552.  * @param cookieName

  553.  * @returns {string}

  554.  */

  555. dTree.prototype.getCookie = function (cookieName) {

  556.     let cookieValue = '', pN, posValue, endPos;

  557.     pN = document.cookie.indexOf(encodeURIComponent(cookieName) + '=');

  558.     if (pN !== -1) {

  559.         posValue = pN + (encodeURIComponent(cookieName) + '=').length;

  560.         endPos = document.cookie.indexOf(';', posValue);

  561.         if (endPos !== -1) {

  562.             cookieValue = decodeURIComponent(document.cookie.substring(posValue, endPos));

  563.         }

  564.         else {

  565.             cookieValue = decodeURIComponent(document.cookie.substring(posValue));

  566.         }

  567.     }

  568.     return (cookieValue);

  569. };

  570. 

  571. /**

  572.  * [Cookie] Stores ids of open nodes as a string in cookie

  573.  */

  574. dTree.prototype.updateCookie = function () {

  575.     let str = '', n;

  576.     for (n = 0; n < this.aNodes.length; n++) {

  577.         if (this.aNodes[n]._io && this.aNodes[n].pid !== this.root.id) {

  578.             if (str) {

  579.                 str += '.';

  580.             }

  581.             str += this.aNodes[n].id;

  582.         }

  583.     }

  584.     this.setCookie('co' + this.treeName, str);

  585. };

  586. 

  587. /**

  588.  * [Cookie] Checks if a node id is in the cookie

  589.  *

  590.  * @param {int} id node id

  591.  * @return {Boolean} if open true

  592.  */

  593. dTree.prototype.isOpen = function (id) {

  594.     let n, aOpen = this.getCookie('co' + this.treeName).split('.');

  595.     for (n = 0; n < aOpen.length; n++) {

  596.         if (parseInt(aOpen[n],10) === id) {

  597.             return true;

  598.         }

  599.     }

  600.     return false;

  601. };

  602. 

  603. /**

  604.  * Open the node of the current namespace

  605.  *

  606.  * @param {int} max

  607.  */

  608. dTree.prototype.openCurNS = function (max) {

  609.     let r, cn, match, t, i, n, cnsa, cna;

  610.     let cns = this.pageid;

  611.     r = new RegExp("\\b" + this.config.sepchar + "\\b", "g");

  612.     match = cns.match(r) || -1;

  613.     if (max > 0 && match.length >= max) {

  614.         t = cns.split(this.config.sepchar);

  615.         n = (this.aNodes[0].dokuid === '') ? 0 : this.aNodes[0].dokuid.split(this.config.sepchar).length;

  616.         t.splice(max + n, t.length);

  617.         cnsa = t.join(this.config.sepchar);

  618.     }

  619.     for (i = 0; i < this.aNodes.length; i++) {

  620.         cn = this.aNodes[i];

  621.         if (cns === cn.dokuid || cns === cn.hns) {

  622.             this.openTo(cn.id, false, true);

  623.             this.fajax = false;

  624.             if (cn.pid >= 0) {

  625. 				jQuery(this.scroll("l", 4, cn.pid, 1));

  626.             }

  627.             break;

  628.         }

  629.         if (cnsa === cn.dokuid || cnsa === cn.hns) {

  630.             cna = cn;

  631.             this.fajax = true;

  632.         }

  633.     }

  634.     if (cna) {

  635.         this.openTo(cna.id, false, true);

  636.     }

  637. };

  638. 

  639. /**

  640.  * Load children when not available

  641.  *

  642.  * @param {int} id node id

  643.  * @returns {boolean}

  644.  */

  645. dTree.prototype.fill = function (id) {

  646.     if (id === -1 || this.aNodes[id]._ok) {

  647.         return true;

  648.     }

  649.     let n = id, $eLoad, a, rd, ln, eDiv;

  650.     if (this.aNodes[n].ajax) {

  651.         //temporary load indicator

  652.         $eLoad = jQuery('#l' + this.treeName);

  653.         if (!$eLoad.length) {

  654.             $eLoad = IndexmenuUtils.createPicker('l' + this.treeName, 'picker');

  655.         }

  656.         jQuery('#s' + this.treeName + n).parent().append($eLoad);

  657.         $eLoad

  658.             .html('Loading ...')

  659.             .css({width: 'auto'})

  660.             .show();

  661. 

  662.         //retrieves children

  663.         this.getAjax(n);

  664.         return true;

  665.     }

  666.     rd = [];

  667.     while (!this.aNodes[n]._ok) {

  668.         rd[rd.length] = n;

  669.         n = this.aNodes[n].pid;

  670.     }

  671.     for (ln = rd.length - 1; ln >= 0; ln--) {

  672.         id = rd[ln];

  673.         a = this.aNodes[id];

  674. 		eDiv = jQuery('#d' + this.treeName + id)[0];

  675.         if (!eDiv) {

  676.             return false;

  677.         }

  678.         this.aIndent = [];

  679.         n = a;

  680.         while (n.pid >= 0) {

  681.             if (n._ls) {

  682.                 this.aIndent.unshift(0);

  683.             } else {

  684.                 this.aIndent.unshift(1);

  685.             }

  686.             n = n._p;

  687.         }

  688.         eDiv.innerHTML = this.addNode(a);

  689.         a._ok = true;

  690.     }

  691.     return true;

  692. };

  693. 

  694. /**

  695.  * Open the nodes stored in cookie

  696.  */

  697. dTree.prototype.openCookies = function () {

  698.     let n, cn, aOpen = this.getCookie('co' + this.treeName).split('.');

  699.     for (n = 0; n < aOpen.length; n++) {

  700.         if (aOpen[n] === "") {

  701.             break;

  702.         }

  703.         cn = this.aNodes[aOpen[n]];

  704.         if (!cn._ok) {

  705.             this.nodeStatus(true, aOpen[n], cn._ls);

  706.             cn._io = true;

  707.         }

  708.     }

  709. };

  710. 

  711. /**

  712.  * Scrolls the index

  713.  *

  714.  * @param {string} where to move to

  715.  * @param {int}    s     start

  716.  * @param {int}    n     parent node id

  717.  * @param {int}    i

  718.  */

  719. dTree.prototype.scroll = function (where, s, n, i) {

  720.     if (!this.config.scroll) {

  721.         return false;

  722.     }

  723.     let w, dtree, dtreel, nodeId;

  724.     dtree = jQuery('#dtree_' + this.treeName)[0];

  725.     dtreel = parseInt(dtree.offsetLeft);

  726.     if (where === "r") {

  727.         jQuery('#left_' + this.treeName)[0].style.border = "thin inset";

  728.         this.scrollRight(dtreel, s);

  729.     } else {

  730.         nodeId = jQuery('#s' + this.treeName + n)[0];

  731.         if (nodeId == null) {

  732.             return false;

  733.         }

  734.         w = parseInt(dtree.parentNode.offsetWidth - nodeId.offsetWidth - nodeId.offsetLeft);

  735.         if (this.config.toc) {

  736.             w = w - 11;

  737.         }

  738.         if (dtreel <= w) {

  739.             return;

  740.         }

  741.         this.resizescroll("none");

  742.         this.stopscroll();

  743.         this.scrollLeft(dtreel, s, w - 3, i);

  744.     }

  745. };

  746. 

  747. /**

  748.  * Scroll index to the left

  749.  *

  750.  * @param {int} lft current position

  751.  * @param {int} s start

  752.  * @param {int} w width

  753.  * @param {int} i

  754.  */

  755. dTree.prototype.scrollLeft = function (lft, s, w, i) {

  756.     if (lft < w - i - 10) {

  757.         this.divdisplay('z', false);

  758.         this.scrllTmr = 0;

  759.         return;

  760.     }

  761.     var self = this;

  762.     jQuery('#dtree_' + self.treeName)[0].style.left = lft + "px";

  763.     this.scrllTmr = setTimeout(function () {

  764.         self.scrollLeft(lft - s, s + i, w, i);

  765.     }, 20);

  766. };

  767. 

  768. /**

  769.  * Scroll Index back to the right

  770.  *

  771.  * @param {int} lft current position

  772.  * @param {int} s   start

  773.  */

  774. dTree.prototype.scrollRight = function (lft, s) {

  775.     if (lft >= s) {

  776.         this.divdisplay('left_', false);

  777.         this.stopscroll();

  778.         return;

  779.     }

  780.     var self = this;

  781.     jQuery('#dtree_' + self.treeName)[0].style.left = lft + "px";

  782.     if (lft > -15) {

  783.         s = 1;

  784.     }

  785.     this.scrllTmr = setTimeout(function () {

  786.         self.scrollRight(lft + s, s + 1);

  787.     }, 20);

  788. };

  789. 

  790. /**

  791.  * Stop scroll movement

  792.  */

  793. dTree.prototype.stopscroll = function () {

  794.     jQuery('#left_' + this.treeName)[0].style.border = "none";

  795.     clearTimeout(this.scrllTmr);

  796.     this.scrllTmr = 0;

  797. };

  798. 

  799. /**

  800.  * Show features and add event handlers for ToC and scroll

  801.  *

  802.  * @param {int} n node id

  803.  */

  804. dTree.prototype.show_feat = function (n) {

  805. 	var w, div, id, dtree, dtreel, self, node = jQuery('#s' + this.treeName + n)[0];

  806.     self = this;

  807.     if (this.config.toc && node.className !== "node") {

  808. 		div = jQuery('#t' + this.treeName)[0];

  809.         id = (this.aNodes[n].hns) ? this.aNodes[n].hns : this.aNodes[n].dokuid;

  810.         div.onmousedown = function () {

  811.             IndexmenuContextmenu.createTocMenu('call=indexmenu&req=toc&id=' + decodeURIComponent(id), 'picker_' + self.treeName, 't' + self.treeName);

  812.         };

  813.         node.parentNode.appendChild(div);

  814.         if (div.style.display === "none") {

  815.             div.style.display = "inline";

  816.         }

  817.     }

  818.     if (this.config.scroll) {

  819. 		div = jQuery('#z' + this.treeName)[0];

  820.         div.onmouseover = function () {

  821.             div.style.border = "none";

  822.             self.scroll("l", 1, n, 0);

  823.         };

  824.         div.onmousedown = function () {

  825.             div.style.border = "thin inset";

  826.             self.scroll("l", 4, n, 1);

  827.         };

  828.         div.onmouseout = function () {

  829.             div.style.border = "none";

  830.             self.stopscroll();

  831.         };

  832.         div.onmouseup = div.onmouseover;

  833. 		dtree = jQuery('#dtree_' + this.treeName)[0];

  834.         dtreel = parseInt(dtree.offsetLeft);

  835.         w = parseInt(dtree.parentNode.offsetWidth - node.offsetWidth - node.offsetLeft + 1);

  836.         if (dtreel > w) {

  837.             div.style.display = "none";

  838.             div.style.top = node.offsetTop + "px";

  839.             div.style.left = parseInt(node.offsetLeft + node.offsetWidth + w - 12) + "px";

  840.             div.style.display = "block";

  841.         }

  842.     }

  843. };

  844. 

  845. /**

  846.  * Show and resize the scroll-back button relatively to size of tree

  847.  *

  848.  * @param {string} status 'block' or 'none'

  849.  */

  850. dTree.prototype.resizescroll = function (status) {

  851. 	let dtree, w, h, left = jQuery('#left_' + this.treeName)[0];

  852.     if (!left) {

  853.         return;

  854.     }

  855.     if (left.style.display === status) {

  856.         dtree = jQuery('#dtree_' + this.treeName)[0];

  857.         w = Math.trunc(dtree.offsetHeight / 3);

  858.         h = Math.trunc(w / 50) * 50;

  859.         if (h < 50) {

  860.             h = 50;

  861.         }

  862.         left.style.height = h + "px";

  863.         left.style.top = w + "px";

  864.         if (status === "none") {

  865.             left.style.display = "block";

  866.         }

  867.     }

  868. };

  869. 

  870. /**

  871.  * Toggle Open or close

  872.  *

  873.  * @param {int} n node id

  874.  */

  875. dTree.prototype.getAjax = function (n) {

  876.     var node, selft = this;

  877.     let req, curns;

  878.     node = selft.aNodes[n];

  879. 

  880.     req = 'req=index&idx=' + node.dokuid + decodeURIComponent(this.config.jsajax);

  881. 

  882.     curns = this.pageid.substring(0, this.pageid.lastIndexOf(this.config.sepchar));

  883.     if (this.fajax) {

  884.         req += '&nss=' + curns + '&max=1';

  885.     }

  886. 

  887.     var onCompletion = function (data) {

  888.         var i, ajxnodes, ajxnode, plus;

  889.         plus = selft.aNodes.length - 1;

  890.         eval(data);

  891.         if (!ajxnodes instanceof Array || ajxnodes.length < 1) {

  892.             ajxnodes = [

  893.                 ['', 1, 0, '', 0, 1, 0]

  894.             ];

  895.         }

  896.         node.ajax = false;

  897.         for (i = 0; i < ajxnodes.length; i++) {

  898.             ajxnode = ajxnodes[i];

  899.             ajxnode[2] = (ajxnode[2] == 0) ? node.id : ajxnode[2] + plus;

  900.             ajxnode[1] += plus;

  901.             selft.add(ajxnode[0], ajxnode[1], ajxnode[2], ajxnode[3], ajxnode[4], ajxnode[5], ajxnode[6]);

  902.         }

  903.         if (selft.fajax) {

  904.             selft.fajax = false;

  905.             selft.openCurNS(0);

  906.         } else {

  907.             selft.openTo(node.id, false, true);

  908.         }

  909.         jQuery('#l' + selft.treeName).hide();

  910.     };

  911. 

  912.     jQuery.post(

  913.         DOKU_BASE + 'lib/exe/ajax.php',

  914.         'call=indexmenu&'+req,

  915.         onCompletion,

  916.         'html'

  917.     );

  918. };

  919. 

  920. /**

  921.  * Load custom css for theme

  922.  */

  923. dTree.prototype.loadCss = function () {

  924.     let oLink = document.createElement("link");

  925.     oLink.href = this.config.plugbase + '/images/' + this.config.theme + '/style.css';

  926.     oLink.rel = "stylesheet";

  927.     oLink.type = "text/css";

  928.     document.getElementsByTagName('head')[0].appendChild(oLink);

  929. };

  930. 

  931. /**

  932.  * Show the contextmenu

  933.  *

  934.  * @param {int}   n node id

  935.  * @param {Event} e event

  936.  * @returns {boolean}

  937.  */

  938. dTree.prototype.contextmenu = function (n, e) {

  939.     let type, node, cdtree, $rmenu;

  940.     cdtree = jQuery("#cdtree_" + this.treeName)[0];

  941. 	$rmenu = jQuery('#r' + this.treeName)[0];

  942.     if (!$rmenu) {

  943.         return true;

  944.     }

  945.     IndexmenuContextmenu.mouseposition($rmenu, e);

  946.     let cmenu = window.indexmenu_contextmenu;

  947.     node = this.aNodes[n];

  948.     $rmenu.innerHTML = '<div class="indexmenu_rmenuhead" title="' + node.name + '">' + node.name + "</div>";

  949.     $rmenu.appendChild(document.createElement('ul'));

  950.     type = (node.isdir || node._hc) ? 'ns' : 'pg';

  951.     IndexmenuContextmenu.arrconcat(cmenu['all'][type], this, n);

  952.     if (node.hns) {

  953.         IndexmenuContextmenu.arrconcat(cmenu[type], this, n);

  954.         type = 'pg';

  955.         IndexmenuContextmenu.arrconcat(cmenu['all'][type], this, n);

  956.     }

  957.     IndexmenuContextmenu.arrconcat(cmenu[type], this, n);

  958.     $rmenu.style.display = 'inline';

  959.     return false;

  960. };

  961. 

  962. /**

  963.  * Show/hide object with given id of current indexmenu

  964.  *

  965.  * @param {string}  objName name of object, which is combined with the unique id of the indexmenu

  966.  * @param {boolean} visible true: visible, false: hide.

  967.  */

  968. dTree.prototype.divdisplay = function (objName, visible) {

  969. 	let o = jQuery('#' + objName + this.treeName)[0];

  970.     if (!o) {

  971.         return;

  972.     }

  973.     (visible) ? o.style.display = 'inline' : o.style.display = 'none';

  974. };

  975. 

  976. /**

  977.  * Initialise the dTree index

  978.  *

  979.  * @param {int}    hasstyle  has an additional css style sheet

  980.  * @param {int}    nocookies use no cookies

  981.  * @param {string} opennodes string of initial opened nodes

  982.  * @param {int}    nav       is navbar option set

  983.  * @param {int}    max       max level of available nodes (deeper levels are included with js)

  984.  * @param {int}    nomenu    show no menu

  985.  */

  986. dTree.prototype.init = function (hasstyle, nocookies, opennodes, nav, max, nomenu) {

  987.     if (hasstyle) {

  988.         this.loadCss();

  989.     }

  990.     if (!nocookies) {

  991.         this.openCookies();

  992.     }

  993.     //open given nodes

  994.     if (opennodes) {

  995.         this.getOpenTo(opennodes.split(" "));

  996.     }

  997.     if (nav) {

  998.         this.openCurNS(max);

  999.     }

  1000.     //create contextmenu

  1001.     if (!nomenu) {

  1002.         var self = this;

  1003.         IndexmenuUtils.createPicker('r' + this.treeName, 'indexmenu_rmenu ' + this.config.theme);

  1004.         jQuery('#r' + this.treeName)[0].oncontextmenu = IndexmenuContextmenu.stopevt;

  1005. 		jQuery(document).on("click",function() {

  1006.             self.divdisplay('r', false);

  1007.         });

  1008.     }

  1009. };