Ignore:
Timestamp:
05/07/05 21:19:31 (15 years ago)
Author:
yermol
Message:

htmlarea.js

. more debugging messages added.
. added HTMLArea.Config.linkReplacementMode which can be either

fullyqualified (the old default behavior) or absolute.


When set to fullyqualified all absolute links (e.g. /somepath) will be changed to fullyqualified URLS (e.g. http://yoursite/somepth).


When set to absolute, all fullyqualified urls back to the current site
will be changed to absolute (e.g. httpyoursite/somepath to /somepath)
making the Xinha generated content portable between sites.


( see HTMLArea.prototype.outwardHtml() )


. bugfix - if plugin .js file has a parse error htmlarea will only try to load

it a configurable number of times before popping up an error message.


backends/backend.php

. initial unified backend created. Requests to this backend are routed

to the corresponding plugin specific backend.php file.


backends/backend_conf.php

. a central server side configuration file has been created for the use

of plugin serverside code.

. all backends hooked into this scheme must include the central config file.

ImageManager?

. modified the config to allow overriding default values.
. default image directory is now xinha/examples/images
. added debugging trace messages which are tagged with the ImageManager? name.
. now uses unified backend.

Linker

. includes central config.
. default directory is now the xinha/examples directory (to avoid scan.php security

problem)

. added debugging trace messages which are tagged with the Linker name.
. links selected from the tree are now displayed in absolute instead of fully qualified

fashion.

. on edit the link that was previously selected is highlighted.
. on edit the selected link is scrolled to if it's outside the viewable area.
. if scan.php returns some kind of error or invalid javascript Linker now pops up

a nice descriptive error message.


. bugfix - same pattern as in loading plugins. If there is some error in loading the directory listing Linker will only attempt it a few times before giving up and

displaying a nice error.


dTree.js

. added clear_s() method to clear the selection
. added getNodeElement() method to return the <a ..> element for a given node.

Location:
branches/unified_backend/plugins/Linker
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • branches/unified_backend/plugins/Linker/dTree/dtree.js

    r20 r121  
    1 /*--------------------------------------------------| 
    2  
    3 | dTree 2.05 | www.destroydrop.com/javascript/tree/ | 
    4  
    5 |---------------------------------------------------| 
    6  
    7 | Copyright (c) 2002-2003 Geir Landr?               | 
    8  
    9 |                                                   | 
    10  
    11 | This script can be used freely as long as all     | 
    12  
    13 | copyright messages are intact.                    | 
    14  
    15 |                                                   | 
    16  
    17 | Updated: 17.04.2003                               | 
    18  
    19 |--------------------------------------------------*/ 
    20  
    21  
    22  
    23 // Node object 
    24  
    25 function Node(id, pid, name, url, title, target, icon, iconOpen, open) { 
    26  
     1/** 
     2* @fileoverview dTree 2.05 | www.destroydrop.com/javascript/tree/  
     3* 
     4* @copyright 2002-2003 Geir Landr?                
     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* Modification by Yermo Lamers http://www.formvista.com/contact.html 
     12* 
     13* . added clear_s() to clear selection. 
     14* . set useCookies to false. 
     15* . added JSDoc headers. 
     16*/ 
     17 
     18/** 
     19* Node object 
     20* 
     21*/ 
     22 
     23function Node(id, pid, name, url, title, target, icon, iconOpen, open)  
     24        { 
    2725  this.id = id; 
    28  
    2926  this.pid = pid; 
    30  
    3127  this.name = name; 
    32  
    3328  this.url = url; 
    34  
    3529  this.title = title; 
    36  
    3730  this.target = target; 
    38  
    3931  this.icon = icon; 
    40  
    4132  this.iconOpen = iconOpen; 
    42  
    4333  this._io = open || false; 
    44  
    4534  this._is = false; 
    46  
    4735  this._ls = false; 
    48  
    4936  this._hc = false; 
    50  
    5137  this._ai = 0; 
    52  
    5338  this._p; 
    54  
    55 }; 
    56  
    57  
    58  
    59 // Tree object 
    60  
    61 function dTree(objName, baseDir) { 
    62  
    63   this.config = { 
    64  
     39        }; 
     40 
     41/** 
     42* Tree object 
     43*/ 
     44 
     45function dTree(objName, baseDir)  
     46        { 
     47  this.config =  
     48                { 
    6549    target                                      : null, 
    66  
    6750    folderLinks                 : true, 
    68  
    6951    useSelection                : true, 
    70  
    71     useCookies                  : true, 
    72  
     52    useCookies                  : false, 
    7353    useLines                            : true, 
    74  
    7554    useIcons                            : true, 
    76  
    7755    useStatusText               : false, 
    78  
    7956    closeSameLevel      : false, 
    80  
    8157    inOrder                                     : false 
    82  
    83   } 
    84  
    85   this.icon = { 
    86  
     58          } 
     59 
     60  this.icon =  
     61                { 
    8762    root                                : baseDir + 'img/base.gif', 
    88  
    8963    folder                      : baseDir + 'img/folder.gif', 
    90  
    9164    folderOpen  : baseDir + 'img/folderopen.gif', 
    92  
    9365    node                                : baseDir + 'img/page.gif', 
    94  
    9566    empty                               : baseDir + 'img/empty.gif', 
    96  
    9767    line                                : baseDir + 'img/line.gif', 
    98  
    9968    join                                : baseDir + 'img/join.gif', 
    100  
    10169    joinBottom  : baseDir + 'img/joinbottom.gif', 
    102  
    10370    plus                                : baseDir + 'img/plus.gif', 
    104  
    10571    plusBottom  : baseDir + 'img/plusbottom.gif', 
    106  
    10772    minus                               : baseDir + 'img/minus.gif', 
    108  
    10973    minusBottom : baseDir + 'img/minusbottom.gif', 
    110  
    11174    nlPlus                      : baseDir + 'img/nolines_plus.gif', 
    112  
    11375    nlMinus                     : baseDir + 'img/nolines_minus.gif' 
    114  
    115   }; 
     76          }; 
    11677 
    11778  this.obj = objName; 
     
    12990  this.completed = false; 
    13091 
    131 }; 
    132  
    133  
    134  
    135 // Adds a new node to the node array 
    136  
    137 dTree.prototype.add = function(id, pid, name, url, title, target, icon, iconOpen, open) { 
    138  
     92        }; 
     93 
     94/** 
     95* Adds a new node to the node array 
     96*/ 
     97 
     98dTree.prototype.add = function(id, pid, name, url, title, target, icon, iconOpen, open)  
     99        { 
    139100  this.aNodes[this.aNodes.length] = new Node(id, pid, name, url, title, target, icon, iconOpen, open); 
    140  
    141 }; 
    142  
    143  
    144  
    145 // Open/close all nodes 
    146  
    147 dTree.prototype.openAll = function() { 
    148  
     101        }; 
     102 
     103/** 
     104* Open all nodes 
     105*/ 
     106 
     107dTree.prototype.openAll = function()  
     108        { 
    149109  this.oAll(true); 
    150  
    151 }; 
    152  
    153 dTree.prototype.closeAll = function() { 
    154  
     110        }; 
     111 
     112/** 
     113* close all nodes 
     114*/ 
     115 
     116dTree.prototype.closeAll = function()  
     117        { 
    155118  this.oAll(false); 
    156  
    157 }; 
    158  
    159  
    160  
    161 // Outputs the tree to the page 
    162  
    163 dTree.prototype.toString = function() { 
     119        }; 
     120 
     121/** 
     122* returns HTML string representation of tree 
     123*/ 
     124 
     125dTree.prototype.toString = function()  
     126        { 
    164127  this.setCS_All(); 
     128 
    165129  var str = '<div class="dtree">\n'; 
    166130 
    167   if (document.getElementById) { 
    168  
    169     if (this.config.useCookies) this.selectedNode = this.getSelected(); 
     131  if (document.getElementById)  
     132                { 
     133    if (this.config.useCookies)  
     134                        this.selectedNode = this.getSelected(); 
    170135 
    171136    str += this.addNode(this.root); 
    172137 
    173   } else str += 'Browser not supported.'; 
     138          }  
     139        else  
     140                { 
     141                str += 'Browser not supported.'; 
     142                } 
    174143 
    175144  str += '</div>'; 
    176145 
    177   if (!this.selectedFound) this.selectedNode = null; 
     146  if (!this.selectedFound)  
     147                this.selectedNode = null; 
    178148 
    179149  this.completed = true; 
     
    181151  return str; 
    182152 
    183 }; 
    184  
    185  
    186  
    187 // Creates the tree structure 
    188  
    189 dTree.prototype.addNode = function(pNode) { 
     153        };      // end of toString() 
     154 
     155/** 
     156* Creates the HTML tree structure in a string. 
     157* 
     158* @todo the name of this method is confusing. 
     159*/ 
     160 
     161dTree.prototype.addNode = function(pNode)  
     162        { 
    190163 
    191164  var str = ''; 
     
    195168  if (this.config.inOrder) n = pNode._ai; 
    196169 
    197   for (n; n<this.aNodes.length; n++) { 
    198  
    199     if (this.aNodes[n].pid == pNode.id) { 
     170  for (n; n<this.aNodes.length; n++)  
     171                { 
     172 
     173    if (this.aNodes[n].pid == pNode.id)  
     174                        { 
    200175 
    201176      var cn = this.aNodes[n]; 
    202  
    203177      cn._p = pNode; 
    204  
    205178      cn._ai = n; 
    206179 
    207180      // this.setCS(cn); 
    208181 
    209       if (!cn.target && this.config.target) cn.target = this.config.target; 
    210  
    211       if (cn._hc && !cn._io && this.config.useCookies) cn._io = this.isOpen(cn.id); 
    212  
    213       if (!this.config.folderLinks && cn._hc) cn.url = null; 
    214  
    215       if (this.config.useSelection && cn.id == this.selectedNode && !this.selectedFound) { 
    216  
    217           cn._is = true; 
    218  
    219           this.selectedNode = n; 
    220  
    221           this.selectedFound = true; 
    222  
    223       } 
     182      if (!cn.target && this.config.target)  
     183                                cn.target = this.config.target; 
     184 
     185      if (cn._hc && !cn._io && this.config.useCookies)  
     186                                cn._io = this.isOpen(cn.id); 
     187 
     188      if (!this.config.folderLinks && cn._hc)  
     189                                cn.url = null; 
     190 
     191      if (this.config.useSelection && cn.id == this.selectedNode && !this.selectedFound)  
     192                                { 
     193        cn._is = true; 
     194        this.selectedNode = n; 
     195        this.selectedFound = true; 
     196              } 
    224197 
    225198      str += this.node(cn, n); 
     
    227200      if (cn._ls) break; 
    228201 
    229     } 
    230  
    231   } 
     202            } 
     203 
     204        } 
     205 
     206        return str; 
     207 
     208        }; 
     209 
     210/** 
     211* Creates the node icon, url and text and returns the HTML string. 
     212*/ 
     213 
     214dTree.prototype.node = function(node, nodeId)  
     215        { 
     216 
     217  var str = '<div class="dTreeNode">' + this.indent(node, nodeId); 
     218 
     219  if (this.config.useIcons)  
     220                { 
     221 
     222    if (!node.icon)  
     223                        node.icon = (this.root.id == node.pid) ? this.icon.root : ((node._hc) ? this.icon.folder : this.icon.node); 
     224 
     225    if (!node.iconOpen)  
     226                        node.iconOpen = (node._hc) ? this.icon.folderOpen : this.icon.node; 
     227 
     228    if (this.root.id == node.pid)  
     229                        { 
     230      node.icon = this.icon.root; 
     231      node.iconOpen = this.icon.root; 
     232            } 
     233 
     234    str += '<img id="i' + this.obj + nodeId + '" src="' + ((node._io) ? node.iconOpen : node.icon) + '" alt="" />'; 
     235 
     236          } 
     237 
     238  if (node.url)  
     239                { 
     240 
     241    str += '<a id="s' + this.obj + nodeId + '" class="' + ((this.config.useSelection) ? ((node._is ? 'nodeSel' : 'node')) : 'node') + '" href="' + node.url + '"'; 
     242 
     243    if (node.title)  
     244                        str += ' title="' + node.title + '"'; 
     245 
     246    if (node.target)  
     247                        str += ' target="' + node.target + '"'; 
     248 
     249    if (this.config.useStatusText)  
     250                        str += ' onmouseover="window.status=\'' + node.name + '\';return true;" onmouseout="window.status=\'\';return true;" '; 
     251 
     252    if (this.config.useSelection && ((node._hc && this.config.folderLinks) || !node._hc)) 
     253                        { 
     254      str += ' onclick="javascript: ' + this.obj + '.s(' + nodeId + ');"'; 
     255                        } 
     256 
     257    str += '>'; 
     258 
     259          } 
     260  else if ((!this.config.folderLinks || !node.url) && node._hc && node.pid != this.root.id) 
     261                { 
     262    str += '<a href="javascript: ' + this.obj + '.o(' + nodeId + ');" class="node">'; 
     263                } 
     264 
     265  str += node.name; 
     266 
     267  if (node.url || ((!this.config.folderLinks || !node.url) && node._hc)) str += '</a>'; 
     268 
     269  str += '</div>'; 
     270 
     271  if (node._hc)  
     272                { 
     273    str += '<div id="d' + this.obj + nodeId + '" class="clip" style="display:' + ((this.root.id == node.pid || node._io) ? 'block' : 'none') + ';">'; 
     274    str += this.addNode(node); 
     275    str += '</div>'; 
     276          } 
     277 
     278  this.aIndent.pop(); 
    232279 
    233280  return str; 
    234281 
    235 }; 
    236  
    237  
    238  
    239 // Creates the node icon, url and text 
    240  
    241 dTree.prototype.node = function(node, nodeId) { 
    242  
    243   var str = '<div class="dTreeNode">' + this.indent(node, nodeId); 
    244  
    245   if (this.config.useIcons) { 
    246  
    247     if (!node.icon) node.icon = (this.root.id == node.pid) ? this.icon.root : ((node._hc) ? this.icon.folder : this.icon.node); 
    248  
    249     if (!node.iconOpen) node.iconOpen = (node._hc) ? this.icon.folderOpen : this.icon.node; 
    250  
    251     if (this.root.id == node.pid) { 
    252  
    253       node.icon = this.icon.root; 
    254  
    255       node.iconOpen = this.icon.root; 
    256  
    257     } 
    258  
    259     str += '<img id="i' + this.obj + nodeId + '" src="' + ((node._io) ? node.iconOpen : node.icon) + '" alt="" />'; 
    260  
    261   } 
    262  
    263   if (node.url) { 
    264  
    265     str += '<a id="s' + this.obj + nodeId + '" class="' + ((this.config.useSelection) ? ((node._is ? 'nodeSel' : 'node')) : 'node') + '" href="' + node.url + '"'; 
    266  
    267     if (node.title) str += ' title="' + node.title + '"'; 
    268  
    269     if (node.target) str += ' target="' + node.target + '"'; 
    270  
    271     if (this.config.useStatusText) str += ' onmouseover="window.status=\'' + node.name + '\';return true;" onmouseout="window.status=\'\';return true;" '; 
    272  
    273     if (this.config.useSelection && ((node._hc && this.config.folderLinks) || !node._hc)) 
    274  
    275       str += ' onclick="javascript: ' + this.obj + '.s(' + nodeId + ');"'; 
    276  
    277     str += '>'; 
    278  
    279   } 
    280  
    281   else if ((!this.config.folderLinks || !node.url) && node._hc && node.pid != this.root.id) 
    282  
    283     str += '<a href="javascript: ' + this.obj + '.o(' + nodeId + ');" class="node">'; 
    284  
    285   str += node.name; 
    286  
    287   if (node.url || ((!this.config.folderLinks || !node.url) && node._hc)) str += '</a>'; 
    288  
    289   str += '</div>'; 
    290  
    291   if (node._hc) { 
    292  
    293     str += '<div id="d' + this.obj + nodeId + '" class="clip" style="display:' + ((this.root.id == node.pid || node._io) ? 'block' : 'none') + ';">'; 
    294  
    295     str += this.addNode(node); 
    296  
    297     str += '</div>'; 
    298  
    299   } 
    300  
    301   this.aIndent.pop(); 
     282        };      // end of node() 
     283 
     284/** 
     285* Adds the empty and line icons and returns HTML string 
     286*/ 
     287 
     288dTree.prototype.indent = function(node, nodeId)  
     289        { 
     290 
     291  var str = ''; 
     292 
     293  if (this.root.id != node.pid)  
     294                { 
     295 
     296    for (var n=0; n<this.aIndent.length; n++) 
     297                        { 
     298      str += '<img src="' + ( (this.aIndent[n] == 1 && this.config.useLines) ? this.icon.line : this.icon.empty ) + '" alt="" />'; 
     299                        } 
     300 
     301    (node._ls) ? this.aIndent.push(0) : this.aIndent.push(1); 
     302 
     303    if (node._hc)  
     304                        { 
     305 
     306      str += '<a href="javascript: ' + this.obj + '.o(' + nodeId + ');"><img id="j' + this.obj + nodeId + '" src="'; 
     307 
     308      if (!this.config.useLines)  
     309                                str += (node._io) ? this.icon.nlMinus : this.icon.nlPlus; 
     310      else  
     311                                str += ( (node._io) ? ((node._ls && this.config.useLines) ? this.icon.minusBottom : this.icon.minus) : ((node._ls && this.config.useLines) ? this.icon.plusBottom : this.icon.plus ) ); 
     312 
     313      str += '" alt="" /></a>'; 
     314 
     315            }  
     316                else  
     317                        { 
     318                        str += '<img src="' + ( (this.config.useLines) ? ((node._ls) ? this.icon.joinBottom : this.icon.join ) : this.icon.empty) + '" alt="" />'; 
     319                        } 
     320 
     321          } 
    302322 
    303323  return str; 
    304324 
    305 }; 
    306  
    307  
    308  
    309 // Adds the empty and line icons 
    310  
    311 dTree.prototype.indent = function(node, nodeId) { 
    312  
    313   var str = ''; 
    314  
    315   if (this.root.id != node.pid) { 
    316  
    317     for (var n=0; n<this.aIndent.length; n++) 
    318  
    319       str += '<img src="' + ( (this.aIndent[n] == 1 && this.config.useLines) ? this.icon.line : this.icon.empty ) + '" alt="" />'; 
    320  
    321     (node._ls) ? this.aIndent.push(0) : this.aIndent.push(1); 
    322  
    323     if (node._hc) { 
    324  
    325       str += '<a href="javascript: ' + this.obj + '.o(' + nodeId + ');"><img id="j' + this.obj + nodeId + '" src="'; 
    326  
    327       if (!this.config.useLines) str += (node._io) ? this.icon.nlMinus : this.icon.nlPlus; 
    328  
    329       else str += ( (node._io) ? ((node._ls && this.config.useLines) ? this.icon.minusBottom : this.icon.minus) : ((node._ls && this.config.useLines) ? this.icon.plusBottom : this.icon.plus ) ); 
    330  
    331       str += '" alt="" /></a>'; 
    332  
    333     } else str += '<img src="' + ( (this.config.useLines) ? ((node._ls) ? this.icon.joinBottom : this.icon.join ) : this.icon.empty) + '" alt="" />'; 
    334  
    335   } 
    336  
    337   return str; 
    338  
    339 }; 
    340  
    341  
    342  
    343 // Checks if a node has any children and if it is the last sibling 
    344  
    345 dTree.prototype.setCS = function(node) { 
     325        };      // end of indent() 
     326 
     327/** 
     328* Checks if a node has any children and if it is the last sibling 
     329*/ 
     330 
     331dTree.prototype.setCS = function(node)  
     332        { 
    346333 
    347334  var lastId; 
    348335 
    349   for (var n=0; n<this.aNodes.length; n++) { 
    350  
    351     if (this.aNodes[n].pid == node.id) node._hc = true; 
    352  
    353     if (this.aNodes[n].pid == node.pid) lastId = this.aNodes[n].id; 
    354  
    355   } 
    356  
    357   if (lastId==node.id) node._ls = true; 
    358  
    359 }; 
     336  for (var n=0; n<this.aNodes.length; n++)  
     337                { 
     338 
     339    if (this.aNodes[n].pid == node.id)  
     340                        node._hc = true; 
     341 
     342    if (this.aNodes[n].pid == node.pid)  
     343                        lastId = this.aNodes[n].id; 
     344 
     345          } 
     346 
     347  if (lastId==node.id)  
     348                node._ls = true; 
     349 
     350        }; 
     351 
     352/** 
     353* setCS_All() 
     354*/ 
    360355 
    361356dTree.prototype.setCS_All = function() 
    362 { 
     357        { 
    363358  var ids = { }; // ID => { _hc: haschildren, _ls_is: lastsibling} 
    364359 
    365360  for(var n = 0; n < this.aNodes.length; n++) 
    366   { 
     361        { 
    367362    var node = this.aNodes[n]; 
    368363    if(!ids[node.pid]) 
    369     { 
     364        { 
    370365      ids[node.pid] = { _hc: true, _ls_is: node.id }; 
    371     } 
     366            } 
    372367    else 
    373     { 
     368          { 
    374369      ids[node.pid]._hc    = true; 
    375370      ids[node.pid]._ls_is = node.id; 
    376     } 
     371        } 
    377372 
    378373    if(!ids[node.id]) 
    379     { 
     374            { 
    380375      ids[node.id] = { _hc: false, _ls_is: null } 
    381     } 
    382   } 
     376          } 
     377          } 
    383378 
    384379  for(var n = 0; n < this.aNodes.length; n++) 
    385   { 
     380        { 
    386381    var node = this.aNodes[n]; 
    387382    node._ls = ids[node.pid]._ls_is == node.id ? true : false; 
    388383    node._hc = ids[node.id]._hc; 
    389   } 
    390 } 
    391  
    392 // Returns the selected node 
    393  
    394 dTree.prototype.getSelected = function() { 
     384          } 
     385 
     386        }       // end of setCS_All() 
     387 
     388/** 
     389* Returns the selected node 
     390*/ 
     391 
     392dTree.prototype.getSelected = function()  
     393        { 
    395394 
    396395  var sn = this.getCookie('cs' + this.obj); 
    397  
    398396  return (sn) ? sn : null; 
    399397 
    400 }; 
    401  
    402  
    403  
    404 // Highlights the selected node 
    405  
    406 dTree.prototype.s = function(id) { 
    407  
    408   if (!this.config.useSelection) return; 
     398        }; 
     399 
     400/** 
     401* Clears selection. 
     402*/ 
     403 
     404dTree.prototype.clear_s = function()  
     405  { 
     406 
     407  var n=0; 
     408 
     409  for (n; n<this.aNodes.length; n++)  
     410    { 
     411 
     412    eOld = document.getElementById("s" + this.obj + n); 
     413 
     414    if ( eOld ) 
     415                        { 
     416                eOld.className = "node"; 
     417                  } 
     418                } 
     419 
     420  this.selectedNode = null; 
     421 
     422  }     // end of clear_s() 
     423 
     424/** 
     425* Highlights the selected node 
     426*/ 
     427 
     428dTree.prototype.s = function(id)  
     429        { 
     430 
     431  if (!this.config.useSelection)  
     432                return; 
    409433 
    410434  var cn = this.aNodes[id]; 
    411435 
    412   if (cn._hc && !this.config.folderLinks) return; 
    413  
    414   if (this.selectedNode != id) { 
    415  
    416     if (this.selectedNode || this.selectedNode==0) { 
    417  
     436  if (cn._hc && !this.config.folderLinks)  
     437                return; 
     438 
     439  if (this.selectedNode != id)  
     440                { 
     441 
     442    if (this.selectedNode || this.selectedNode==0)  
     443                        { 
    418444      eOld = document.getElementById("s" + this.obj + this.selectedNode); 
    419  
    420445      eOld.className = "node"; 
    421  
    422     } 
     446            } 
    423447 
    424448    eNew = document.getElementById("s" + this.obj + id); 
     
    428452    this.selectedNode = id; 
    429453 
    430     if (this.config.useCookies) this.setCookie('cs' + this.obj, cn.id); 
    431  
    432   } 
    433  
    434 }; 
    435  
    436  
    437  
    438 // Toggle Open or close 
    439  
    440 dTree.prototype.o = function(id) { 
     454    if (this.config.useCookies)  
     455                        this.setCookie('cs' + this.obj, cn.id); 
     456 
     457          } 
     458 
     459        }; // end of s() 
     460 
     461/** 
     462* Toggle Open or close 
     463*/ 
     464 
     465dTree.prototype.o = function(id)  
     466        { 
    441467 
    442468  var cn = this.aNodes[id]; 
     
    450476  if (this.config.useCookies) this.updateCookie(); 
    451477 
    452 }; 
    453  
    454  
    455  
    456 // Open or close all nodes 
    457  
    458 dTree.prototype.oAll = function(status) { 
    459  
    460   for (var n=0; n<this.aNodes.length; n++) { 
    461  
    462     if (this.aNodes[n]._hc && this.aNodes[n].pid != this.root.id) { 
    463  
     478        }; 
     479 
     480/** 
     481* Open or close all nodes 
     482*/ 
     483 
     484dTree.prototype.oAll = function(status)  
     485        { 
     486 
     487  for (var n=0; n<this.aNodes.length; n++)  
     488                { 
     489 
     490    if (this.aNodes[n]._hc && this.aNodes[n].pid != this.root.id)  
     491                        { 
    464492      this.nodeStatus(status, n, this.aNodes[n]._ls) 
    465  
    466493      this.aNodes[n]._io = status; 
    467  
    468     } 
    469  
    470   } 
    471  
    472   if (this.config.useCookies) this.updateCookie(); 
    473  
    474 }; 
    475  
    476  
    477  
    478 // Opens the tree to a specific node 
    479  
    480 dTree.prototype.openTo = function(nId, bSelect, bFirst) { 
    481  
    482   if (!bFirst) { 
    483  
    484     for (var n=0; n<this.aNodes.length; n++) { 
    485  
    486       if (this.aNodes[n].id == nId) { 
    487  
     494            } 
     495        } 
     496 
     497  if (this.config.useCookies)  
     498                this.updateCookie(); 
     499 
     500        }; 
     501 
     502/** 
     503* Opens the tree to a specific node 
     504*/ 
     505 
     506dTree.prototype.openTo = function(nId, bSelect, bFirst)  
     507        { 
     508 
     509  if (!bFirst)  
     510                { 
     511 
     512    for (var n=0; n<this.aNodes.length; n++)  
     513                        { 
     514 
     515      if (this.aNodes[n].id == nId)  
     516                                { 
    488517        nId=n; 
    489  
    490518        break; 
    491  
    492       } 
    493  
    494     } 
    495  
    496   } 
     519              } 
     520          } 
     521          } 
    497522 
    498523  var cn=this.aNodes[nId]; 
    499524 
    500   if (cn.pid==this.root.id || !cn._p) return; 
     525  if (cn.pid==this.root.id || !cn._p)  
     526                return; 
    501527 
    502528  cn._io = true; 
    503  
    504529  cn._is = bSelect; 
    505530 
    506   if (this.completed && cn._hc) this.nodeStatus(true, cn._ai, cn._ls); 
    507  
    508   if (this.completed && bSelect) this.s(cn._ai); 
    509  
    510   else if (bSelect) this._sn=cn._ai; 
     531  if (this.completed && cn._hc)  
     532                this.nodeStatus(true, cn._ai, cn._ls); 
     533 
     534  if (this.completed && bSelect)  
     535                this.s(cn._ai); 
     536  else if (bSelect)  
     537                this._sn=cn._ai; 
    511538 
    512539  this.openTo(cn._p._ai, false, true); 
    513540 
    514 }; 
    515  
    516  
    517  
    518 // Closes all nodes on the same level as certain node 
    519  
    520 dTree.prototype.closeLevel = function(node) { 
    521  
    522   for (var n=0; n<this.aNodes.length; n++) { 
    523  
    524     if (this.aNodes[n].pid == node.pid && this.aNodes[n].id != node.id && this.aNodes[n]._hc) { 
    525  
     541        };      // end of openTo() 
     542 
     543/** 
     544* Closes all nodes on the same level as certain node 
     545*/ 
     546 
     547dTree.prototype.closeLevel = function(node)  
     548        { 
     549 
     550  for (var n=0; n<this.aNodes.length; n++)  
     551                { 
     552 
     553    if (this.aNodes[n].pid == node.pid && this.aNodes[n].id != node.id && this.aNodes[n]._hc)  
     554                        { 
    526555      this.nodeStatus(false, n, this.aNodes[n]._ls); 
    527  
    528556      this.aNodes[n]._io = false; 
    529  
    530557      this.closeAllChildren(this.aNodes[n]); 
    531558 
    532     } 
    533  
    534   } 
    535  
    536 } 
    537  
    538  
    539  
    540 // Closes all children of a node 
    541  
    542 dTree.prototype.closeAllChildren = function(node) { 
    543  
    544   for (var n=0; n<this.aNodes.length; n++) { 
    545  
    546     if (this.aNodes[n].pid == node.id && this.aNodes[n]._hc) { 
    547  
    548       if (this.aNodes[n]._io) this.nodeStatus(false, n, this.aNodes[n]._ls); 
     559            } 
     560 
     561        } 
     562 
     563        }       // end of closeLevel() 
     564 
     565/** 
     566* Closes all children of a node 
     567*/ 
     568 
     569dTree.prototype.closeAllChildren = function(node)  
     570        { 
     571 
     572  for (var n=0; n<this.aNodes.length; n++)  
     573                { 
     574 
     575    if (this.aNodes[n].pid == node.id && this.aNodes[n]._hc)  
     576                        { 
     577 
     578      if (this.aNodes[n]._io)  
     579                                this.nodeStatus(false, n, this.aNodes[n]._ls); 
    549580 
    550581      this.aNodes[n]._io = false; 
     
    552583      this.closeAllChildren(this.aNodes[n]); 
    553584 
    554     } 
    555  
    556   } 
    557  
    558 } 
    559  
    560  
    561  
    562 // Change the status of a node(open or closed) 
    563  
    564 dTree.prototype.nodeStatus = function(status, id, bottom) { 
     585            } 
     586 
     587        } 
     588 
     589        }       // end of closeAllChildren() 
     590 
     591/** 
     592* Change the status of a node(open or closed) 
     593*/ 
     594 
     595dTree.prototype.nodeStatus = function(status, id, bottom)  
     596        { 
    565597 
    566598  eDiv  = document.getElementById('d' + this.obj + id); 
    567  
    568599  eJoin = document.getElementById('j' + this.obj + id); 
    569600 
    570   if (this.config.useIcons) { 
    571  
     601  if (this.config.useIcons)  
     602                { 
    572603    eIcon       = document.getElementById('i' + this.obj + id); 
    573  
    574604    eIcon.src = (status) ? this.aNodes[id].iconOpen : this.aNodes[id].icon; 
    575  
    576   } 
     605          } 
    577606 
    578607  eJoin.src = (this.config.useLines)? 
     
    584613  eDiv.style.display = (status) ? 'block': 'none'; 
    585614 
    586 }; 
    587  
    588  
    589  
    590  
    591  
    592 // [Cookie] Clears a cookie 
    593  
    594 dTree.prototype.clearCookie = function() { 
     615        }; 
     616 
     617/** 
     618* retrieves the element for a node 
     619*/ 
     620 
     621dTree.prototype.getNodeElement = function( n ) 
     622        { 
     623        return document.getElementById("s" + this.obj + n); 
     624        } 
     625 
     626/** 
     627* [Cookie] Clears a cookie 
     628*/ 
     629 
     630dTree.prototype.clearCookie = function()  
     631        { 
    595632 
    596633  var now = new Date(); 
    597  
    598634  var yesterday = new Date(now.getTime() - 1000 * 60 * 60 * 24); 
    599  
    600635  this.setCookie('co'+this.obj, 'cookieValue', yesterday); 
    601  
    602636  this.setCookie('cs'+this.obj, 'cookieValue', yesterday); 
    603637 
    604 }; 
    605  
    606  
    607  
    608 // [Cookie] Sets value in a cookie 
    609  
    610 dTree.prototype.setCookie = function(cookieName, cookieValue, expires, path, domain, secure) { 
     638        }; 
     639 
     640/** 
     641* [Cookie] Sets value in a cookie 
     642*/ 
     643 
     644dTree.prototype.setCookie = function(cookieName, cookieValue, expires, path, domain, secure)  
     645        { 
    611646 
    612647  document.cookie = 
    613  
    614648    escape(cookieName) + '=' + escape(cookieValue) 
    615  
    616649    + (expires ? '; expires=' + expires.toGMTString() : '') 
    617  
    618650    + (path ? '; path=' + path : '') 
    619  
    620651    + (domain ? '; domain=' + domain : '') 
    621  
    622652    + (secure ? '; secure' : ''); 
    623  
    624 }; 
    625  
    626  
    627  
    628 // [Cookie] Gets a value from a cookie 
    629  
    630 dTree.prototype.getCookie = function(cookieName) { 
     653        }; 
     654 
     655/** 
     656* [Cookie] Gets a value from a cookie 
     657*/ 
     658 
     659dTree.prototype.getCookie = function(cookieName)  
     660        { 
    631661 
    632662  var cookieValue = ''; 
    633  
    634663  var posName = document.cookie.indexOf(escape(cookieName) + '='); 
    635664 
    636   if (posName != -1) { 
     665  if (posName != -1)  
     666                { 
    637667 
    638668    var posValue = posName + (escape(cookieName) + '=').length; 
    639  
    640669    var endPos = document.cookie.indexOf(';', posValue); 
    641  
    642     if (endPos != -1) cookieValue = unescape(document.cookie.substring(posValue, endPos)); 
    643  
    644     else cookieValue = unescape(document.cookie.substring(posValue)); 
    645  
    646   } 
     670    if (endPos != -1)  
     671                        cookieValue = unescape(document.cookie.substring(posValue, endPos)); 
     672    else  
     673                        cookieValue = unescape(document.cookie.substring(posValue)); 
     674          } 
    647675 
    648676  return (cookieValue); 
    649677 
    650 }; 
    651  
    652  
    653  
    654 // [Cookie] Returns ids of open nodes as a string 
    655  
    656 dTree.prototype.updateCookie = function() { 
    657  
     678        }; 
     679 
     680/** 
     681* [Cookie] Returns ids of open nodes as a string 
     682*/ 
     683 
     684dTree.prototype.updateCookie = function()  
     685        { 
    658686  var str = ''; 
    659  
    660   for (var n=0; n<this.aNodes.length; n++) { 
    661  
    662     if (this.aNodes[n]._io && this.aNodes[n].pid != this.root.id) { 
    663  
    664       if (str) str += '.'; 
    665  
     687  for (var n=0; n<this.aNodes.length; n++)  
     688                { 
     689    if (this.aNodes[n]._io && this.aNodes[n].pid != this.root.id)  
     690                        { 
     691      if (str)  
     692                                str += '.'; 
    666693      str += this.aNodes[n].id; 
    667  
    668     } 
    669  
    670   } 
    671  
     694            } 
     695 
     696          } 
    672697  this.setCookie('co' + this.obj, str); 
    673698 
    674 }; 
    675  
    676  
    677  
    678 // [Cookie] Checks if a node id is in a cookie 
    679  
    680 dTree.prototype.isOpen = function(id) { 
     699        }; 
     700 
     701/** 
     702* [Cookie] Checks if a node id is in a cookie 
     703*/ 
     704 
     705dTree.prototype.isOpen = function(id)  
     706        { 
    681707 
    682708  var aOpen = this.getCookie('co' + this.obj).split('.'); 
    683709 
    684710  for (var n=0; n<aOpen.length; n++) 
    685  
    686     if (aOpen[n] == id) return true; 
     711                { 
     712    if (aOpen[n] == id)  
     713                        return true; 
     714                } 
    687715 
    688716  return false; 
    689717 
    690 }; 
    691  
    692  
    693  
    694 // If Push and pop is not implemented by the browser 
    695  
    696 if (!Array.prototype.push) { 
    697  
    698   Array.prototype.push = function array_push() { 
    699  
     718        }; 
     719 
     720/** 
     721* If Push and pop is not implemented by the browser 
     722*/ 
     723 
     724if (!Array.prototype.push)  
     725        { 
     726 
     727  Array.prototype.push = function array_push()  
     728                { 
    700729    for(var i=0;i<arguments.length;i++) 
    701  
     730                        { 
    702731      this[this.length]=arguments[i]; 
     732                        } 
    703733 
    704734    return this.length; 
    705735 
    706   } 
    707  
    708 }; 
    709  
    710 if (!Array.prototype.pop) { 
    711  
    712   Array.prototype.pop = function array_pop() { 
    713  
     736          } 
     737 
     738        }; 
     739 
     740if (!Array.prototype.pop)  
     741        { 
     742 
     743  Array.prototype.pop = function array_pop()  
     744                { 
    714745    lastElement = this[this.length-1]; 
    715  
    716746    this.length = Math.max(this.length-1,0); 
    717  
    718747    return lastElement; 
    719748 
    720   } 
    721  
    722 }; 
    723  
     749          } 
     750 
     751        }; 
     752 
     753// END 
  • branches/unified_backend/plugins/Linker/linker.js

    r57 r121  
    11/** htmlArea - James' Fork - Linker Plugin **/ 
     2 
     3// tabs: 3 
     4 
     5/** 
     6* @fileoverview  The Linker plugin 
     7* 
     8* This plugin implements a client side tree view of server side filesystem. 
     9* 
     10* @package Xinha 
     11* @subpackage linker 
     12* @author James Sleeman 
     13* @author Yermo Lamers http://www.formvista.com/contact.html (unified backend modifications) 
     14*/ 
     15 
     16/** 
     17* linker plugin info for about box. 
     18*/ 
     19 
    220Linker._pluginInfo = 
    321{ 
     
    1230}; 
    1331 
     32/** 
     33* dtree style sheet 
     34*/ 
     35 
    1436HTMLArea.loadStyle('dTree/dtree.css', 'Linker'); 
     37 
     38/** 
     39* linker configuration 
     40*/ 
    1541 
    1642HTMLArea.Config.prototype.Linker = 
    1743{ 
    18   'backend' : _editor_url + 'plugins/Linker/scan.php', 
     44        'backend' : _editor_backend + ( _editor_backend.match(/.*\?.*/) ? "&" : "?" ) + '__plugin=Linker&', 
    1945  'files' : null 
    2046} 
    2147 
     48// ------------------------------------------------------------------------ 
     49 
     50/** 
     51* Inline Dialog for Linker 
     52*/ 
     53 
     54Linker.Dialog_dTrees = [ ]; 
     55 
     56// ------------------------------------------------------------------------ 
     57 
     58/** 
     59* @class Linker 
     60* 
     61* Linker constructor  
     62*/ 
    2263 
    2364function Linker(editor, args) 
    24 { 
     65        { 
     66 
    2567  this.editor  = editor; 
    2668  this.lConfig = editor.config.Linker; 
    2769 
     70        // [STRIP 
     71        // create a ddt debug trace object. There may be multiple editors on  
     72        // the page each with a Linker .. to distinguish which instance 
     73        // is generating the message we tack on the name of the textarea. 
     74 
     75        this.ddt = new DDT( editor._textArea + ":Linker Plugin" ); 
     76 
     77        // uncomment to turn on debugging messages. 
     78  
     79        this.ddt._ddtOn(); 
     80 
     81        this.ddt._ddt( "linker.js","81", "Linker(): constructor" ); 
     82 
     83        // STRIP] 
     84 
    2885  var linker = this; 
    29   if(editor.config.btnList.createlink) 
    30   { 
     86 
     87        // if there is already a createLink button override it's definition. 
     88 
     89  if (editor.config.btnList.createlink) 
     90          { 
    3191    editor.config.btnList.createlink[3] 
    32       =  function(e, objname, obj) { linker._createLink(linker._getSelectedAnchor()); }; 
    33   } 
     92      =  function(e, objname, obj)  
     93                                                {  
     94                                                linker._createLink(linker._getSelectedAnchor());  
     95                                                }; 
     96        } 
    3497  else 
    35   { 
     98          { 
    3699    editor.config.registerButton( 
    37100                                 'createlink', 'Insert/Modify Hyperlink', [_editor_url + "images/ed_buttons_main.gif",6,1], false, 
    38101                                 function(e, objname, obj) { linker._createLink(linker._getSelectedAnchor()); } 
    39102                                 ); 
    40   } 
     103        } 
    41104 
    42105  // See if we can find 'createlink' 
    43106  var t = editor.config.toolbar; 
    44107  var done = false; 
     108 
    45109  for(var i = 0; i < t.length && !done; i++) 
    46   { 
     110          { 
    47111    for(var x = 0; x < t[i].length && !done; x++) 
    48     { 
     112          { 
    49113      if(t[i][x] == 'createlink') 
    50       { 
     114          { 
    51115        done = true; 
    52       } 
    53     } 
    54   } 
    55  
    56   if(!done) 
    57   { 
     116        } 
     117            } 
     118          } 
     119 
     120  if ( !done ) 
     121        { 
    58122    t[t.length-1].push('createlink'); 
    59   } 
    60 } 
     123          } 
     124 
     125        }       // end of Linker Constructor. 
     126 
     127// ------------------------------------------------------------------------ 
     128 
     129/** 
     130* localization 
     131*/ 
    61132 
    62133Linker.prototype._lc = function(string) 
    63 { 
     134        { 
     135 
     136        this.ddt._ddt( "linker.js","136", "_lc(): top with string '" + string + "'" ); 
     137 
    64138  return HTMLArea._lc(string, 'Linker'); 
    65 } 
     139        } 
     140 
     141// ------------------------------------------------------------------------ 
     142 
     143/** 
     144* _createLink() 
     145*/ 
    66146 
    67147Linker.prototype._createLink = function(a) 
    68 { 
     148        { 
     149 
    69150  if(!a && this.editor._selectionEmpty(this.editor._getSelection())) 
    70   {        
     151          {        
    71152    alert(this._lc("You must select some text before making a new link.")); 
    72153    return false; 
    73   } 
     154          } 
     155 
     156        this.ddt._ddt( "linker.js","156", "_createLink(): top" ); 
     157 
     158        // for use in populating the dialog pane. 
    74159 
    75160  var inputs = 
    76   { 
     161          { 
    77162    type:     'url', 
    78163    href:     'http://www.example.com/', 
     
    84169    subject:  '', 
    85170    body:     '' 
    86   } 
    87  
    88   if(a && a.tagName.toLowerCase() == 'a') 
    89   { 
     171          } 
     172 
     173  if (a && a.tagName.toLowerCase() == 'a') 
     174        { 
     175 
     176                // m is an array of matches here. Email address followed by ? 
     177 
    90178    var m = a.href.match(/^mailto:(.*@[^?&]*)(\?(.*))?$/); 
    91     if(m) 
    92     { 
    93       // Mailto 
     179 
     180    if (m) 
     181        { 
     182      // it's a Mailto link 
     183 
    94184      inputs.type = 'mailto'; 
     185 
    95186      inputs.to = m[1]; 
    96       if(m[3]) 
    97       { 
     187 
     188                        this.ddt._ddt( "linker.js","188", "_createLink(): m[1] is '" + m[1] + "' m[3] is '" + m[3] + "'" ); 
     189 
     190      if (m[3]) 
     191              { 
    98192        var args  = m[3].split('&'); 
    99193        for(var x = 0; x<args.length; x++) 
    100         { 
     194              { 
    101195          var j = args[x].match(/(subject|body)=(.*)/); 
    102196          if(j) 
    103           { 
     197              { 
    104198            inputs[j[1]] = decodeURIComponent(j[2]); 
    105           } 
    106         } 
    107       } 
    108     } 
     199            } 
     200                } 
     201              } 
     202          } 
    109203    else 
    110     { 
    111  
    112  
    113       if(a.getAttribute('onclick')) 
    114       { 
     204        { 
     205 
     206      if (a.getAttribute('onclick')) 
     207              { 
     208 
     209                                this.ddt._ddt( "linker.js","209", "_createLink(): link is a popup window style link" ); 
     210 
    115211        var m = a.getAttribute('onclick').match(/window\.open\(\s*this\.href\s*,\s*'([a-z0-9_]*)'\s*,\s*'([a-z0-9_=,]*)'\s*\)/i); 
    116212 
    117213        // Popup Window 
     214 
    118215        inputs.href   = a.href ? a.href : ''; 
    119216        inputs.target = 'popup'; 
     
    121218        inputs.p_options = [ ]; 
    122219 
    123  
    124220        var args = m[2].split(','); 
     221 
     222                                this.ddt._ddt( "linker.js","222", "_createLink(): m[1] is '" + m[1] + "' m[2] is '" + m[2] + "'" ); 
     223 
    125224        for(var x = 0; x < args.length; x++) 
    126         { 
    127           var i = args[x].match(/(width|height)=([0-9]+)/); 
     225              { 
     226                var i = args[x].match(/(width|height)=([0-9]+)/); 
    128227          if(i) 
    129           { 
    130             inputs['p_' + i[1]] = parseInt(i[2]); 
    131           } 
     228                  { 
     229              inputs['p_' + i[1]] = parseInt(i[2]); 
     230            } 
    132231          else 
    133           { 
     232                { 
    134233            inputs.p_options.push(args[x]); 
    135           } 
    136         } 
    137       } 
     234                } 
     235                } 
     236        } 
    138237      else 
    139       { 
    140         // Normal 
    141         inputs.href   = a.href; 
     238        { 
     239        // Normal link 
     240 
     241                                this.ddt._ddt( "linker.js","241", "_createLink(): it's a normal link" ); 
     242 
     243                                // we're loading a link back into the dialog. There's a good chance, if it's 
     244                                // a local link that it contains a fully qualified URL (including http://host/) 
     245                                // 
     246                                // For display in the dialog, remove the host and protocol heading.  
     247                                // 
     248                                // If a user views the source (in FireFox) they will see the fully qualified 
     249                                // links, however there get rewritten before submit. 
     250 
     251                                if ( a.hostname == this.editor._doc.location.hostname ) 
     252                                        { 
     253                                        var someString = new String( a.href ); 
     254                                        inputs.href = someString.replace(/.*?\/\/.*?(\/.*)$/, "$1"); 
     255 
     256                                        this.ddt._ddt( "linker.js","256", "_createLink(): local link modified to '" + inputs.href + "'" ); 
     257                                        } 
     258                                else 
     259                                        { 
     260 
     261                                        // fix MSIE adding http://null/ ... 
     262 
     263                                        var someString = new String( a.href ); 
     264                inputs.href   = someString.replace(/https?:\/\/null\//g, "/"); 
     265 
     266                                        this.ddt._ddt( "linker.js","266", "_createLink(): MSIE hack link modified to '" + inputs.href + "'" ); 
     267 
     268                                        } 
     269 
    142270        inputs.target = a.target; 
    143       } 
    144     } 
    145   } 
     271 
     272        } 
     273        } 
     274 
     275        }       // end of if a was an "a href" object 
     276 
     277        // kludge to pass ourselves into the closure below. 
    146278 
    147279  var linker = this; 
     
    151283  // complete.  I guess because we are defocusing the iframe when we click stuff in the 
    152284  // linker dialog. 
     285        // 
     286        // NOTE that this.a = a means that linker.a == a.  
    153287 
    154288  this.a = a; // Why doesn't a get into the closure below, but if I set it as a property then it's fine? 
    155289 
     290        // this function gets invoked when the ok button is clicked in the panel. 
     291        // Note that in-line function definitions like this are called "closures" that 
     292        // freeze the state of all variables that were around when the function is defined. 
     293        // This is why the function below, which will be called much later, will have 
     294        // the linker variable defined above ...  
     295 
    156296  var doOK = function() 
    157   { 
     297          { 
     298 
     299                linker.ddt._ddt( "linker.js","299", "doOK(): top with link '" + ( linker.a ? linker.a : "none" ) + "'" ); 
     300 
    158301    //if(linker.a) alert(linker.a.tagName); 
     302 
    159303    var a = linker.a; 
    160304 
    161305    var values = linker._dialog.hide(); 
     306 
     307                linker.ddt._ddt( "linker.js","307", "doOK(): values.type is '" + values.type + "'" ); 
     308 
    162309    var atr = 
    163     { 
     310        { 
    164311      href: '', 
    165312      target:'', 
    166313      title:'', 
    167314      onclick:'' 
    168     } 
    169  
    170     if(values.type == 'url') 
    171     { 
    172      if(values.href) 
    173      { 
    174        atr.href = values.href; 
    175        atr.target = values.target; 
    176        if(values.target == 'popup') 
    177        { 
    178  
    179          if(values.p_width) 
    180          { 
    181            values.p_options.push('width=' + values.p_width); 
    182          } 
    183          if(values.p_height) 
    184          { 
    185            values.p_options.push('height=' + values.p_height); 
    186          } 
    187          atr.onclick = 'try{if(document.designMode && document.designMode == \'on\') return false;}catch(e){} window.open(this.href, \'' + (values.p_name.replace(/[^a-z0-9_]/i, '_')) + '\', \'' + values.p_options.join(',') + '\');return false;'; 
    188        } 
    189      } 
    190     } 
    191     else 
    192     { 
    193       if(values.to) 
    194       { 
     315            } 
     316 
     317                if (values.type == 'url') 
     318                { 
     319 
     320                        linker.ddt._ddt( "linker.js","320", "doOK(): type is a url" ); 
     321 
     322                        if(values.href) 
     323                { 
     324 
     325                                linker.ddt._ddt( "linker.js","325", "doOK(): values.href is '" + values.href + "'" ); 
     326 
     327                                atr.href = values.href; 
     328                                atr.target = values.target; 
     329 
     330                                if (values.target == 'popup') 
     331                                        { 
     332 
     333                                        linker.ddt._ddt( "linker.js","333", "doOK(): target is a popup" ); 
     334 
     335                                        if (values.p_width) 
     336                                                { 
     337                                                values.p_options.push('width=' + values.p_width); 
     338                                                } 
     339 
     340                                        if(values.p_height) 
     341                                                { 
     342              values.p_options.push('height=' + values.p_height); 
     343                                                } 
     344 
     345                                        atr.onclick = 'try{if(document.designMode && document.designMode == \'on\') return false;}catch(e){} window.open(this.href, \'' + (values.p_name.replace(/[^a-z0-9_]/i, '_')) + '\', \'' + values.p_options.join(',') + '\');return false;'; 
     346         
     347                                        } 
     348 
     349                                }       // end of if values.href. 
     350                        } 
     351    else        // it's not a url. 
     352            { 
     353 
     354      if (values.to) 
     355            { 
     356 
     357                                linker.ddt._ddt( "linker.js","357", "doOK(): it's a mailto with '" + values.to + "'" ); 
     358 
    195359        atr.href = 'mailto:' + values.to + '?'; 
    196         if(values.subject) atr.href += 'subject=' + encodeURIComponent(values.subject); 
    197         if(values.body)    atr.href += (values.subject ? '&' : '') + 'body=' + encodeURIComponent(values.body); 
    198       } 
    199     } 
    200  
    201     if(a && a.tagName.toLowerCase() == 'a') 
    202     { 
     360        if (values.subject) atr.href += 'subject=' + encodeURIComponent(values.subject); 
     361        if (values.body)    atr.href += (values.subject ? '&' : '') + 'body=' + encodeURIComponent(values.body); 
     362          } 
     363            } 
     364 
     365    if (a && a.tagName.toLowerCase() == 'a') 
     366            { 
     367 
    203368      if(!atr.href) 
    204       { 
     369        { 
    205370        if(confirm(linker._dialog._lc('Are you sure you wish to remove this link?'))) 
    206         { 
     371                { 
    207372          var p = a.parentNode; 
    208373          while(a.hasChildNodes()) 
    209           { 
     374                { 
    210375            p.insertBefore(a.removeChild(a.childNodes[0]), a); 
    211           } 
     376                  } 
    212377          p.removeChild(a); 
    213         } 
    214       } 
     378              } 
     379          } 
     380 
    215381      // Update the link 
     382 
    216383      for(var i in atr) 
    217       { 
     384              { 
     385                                linker.ddt._ddt( "linker.js","385", "doOK(): attribute '" + i + "' == '" + atr[i] + "'" ); 
    218386        a.setAttribute(i, atr[i]); 
    219       } 
    220     } 
     387            } 
     388            } 
    221389    else 
    222     { 
     390          { 
    223391      if(!atr.href) return true; 
    224392 
    225393      // Insert a link, we let the browser do this, we figure it knows best 
     394                        // 
     395                        // YmL: Not sure why but we're inserting a unique link (generated) then  
     396                        // we search for the link below and update it's parameters. Not sure why the 
     397                        // original author didn't just insert the link directly. 
     398 
    226399      var tmp = HTMLArea.uniq('http://www.example.com/Link'); 
    227       linker.editor._doc.execCommand('createlink', false, tmp); 
     400 
     401                        linker.ddt._ddt( "linker.js","401", "doOK(): else case with tmp '" + tmp + "'" ); 
     402 
     403                        linker.editor._doc.execCommand('createlink', false, tmp); 
    228404 
    229405      // Fix them up 
     406 
    230407      var anchors = linker.editor._doc.getElementsByTagName('a'); 
    231408      for(var i = 0; i < anchors.length; i++) 
    232       { 
     409        { 
    233410        var a = anchors[i]; 
     411 
     412                                // have we found the temporary link we made above? 
     413 
    234414        if(a.href == tmp) 
    235         { 
    236           // Found one. 
     415                { 
     416 
     417                                        // copy over the attributes 
     418 
     419                                        linker.ddt._ddt( "linker.js","419", "doOK(): found a '" + a + "'" ); 
     420 
    237421          for(var i in atr) 
    238           { 
     422                { 
    239423            a.setAttribute(i, atr[i]); 
    240           } 
    241         } 
    242       } 
    243     } 
    244   } 
     424                                                linker.ddt._ddt( "linker.js","424", "doOK(): attribute '" + i + "' == '" + atr[i] + "' on a '" + a + "'" ); 
     425                  } 
     426 
     427                                        // at one point we tried fixing up the links in FireFox to turn them into 
     428                                        // absolute URLs right here (instead of fully qualified ) but on view source 
     429                                        // they would get changed back to fully qualified. This is because 
     430                                        // HTMLArea.fixRelativeLinks() gets called at that point. 
     431                                        // 
     432                                        // We chop off the protocol and host before we put the link into the dialog.   
     433                                        // (see upper section of _createLink()) 
     434                                        // 
     435                                        // Also the links get modified onSubmit to remove the absolute pathnames. 
     436                                        // (see htmlarea.js) 
     437 
     438              }  // end of if a href == tmp 
     439 
     440          }  // end of for loop 
     441 
     442            }  // end of else 
     443 
     444                linker.ddt._ddt( "linker.js","444", "doOK(): bottom" ); 
     445 
     446                }       // end of function doOK(); 
     447 
     448        this.ddt._ddt( "linker.js","448", "_createLink(): before calling _dialog.show()" ); 
    245449 
    246450  this._dialog.show(inputs, doOK); 
    247451 
    248 } 
     452        }       // end of _createLink() 
     453 
     454// --------------------------------------------------------------- 
     455 
     456/** 
     457* _getSelectedAnchor() 
     458*/ 
    249459 
    250460Linker.prototype._getSelectedAnchor = function() 
    251 { 
     461        { 
     462 
     463        this.ddt._ddt( "linker.js","463", "_getSelectedAnchor(): top" ); 
     464 
    252465  var sel  = this.editor._getSelection(); 
    253466  var rng  = this.editor._createRange(sel); 
    254467  var a    = this.editor._activeElement(sel); 
     468 
    255469  if(a != null && a.tagName.toLowerCase() == 'a') 
    256   { 
     470          { 
     471                this.ddt._ddt( "linker.js","471", "_getSelectedAnchor(): returning link '" + a + "'" ); 
    257472    return a; 
    258   } 
     473          } 
    259474  else 
    260   { 
     475        { 
    261476    a = this.editor._getFirstAncestor(sel, 'a'); 
    262477    if(a != null) 
    263     { 
     478        { 
     479                        this.ddt._ddt( "linker.js","479", "_getSelectedAnchor(): returning first ancestor '" + a + "'" ); 
    264480      return a; 
    265     } 
    266   } 
     481            } 
     482        } 
     483 
     484        this.ddt._ddt( "linker.js","484", "_getSelectedAnchor(): bottom returning null" ); 
     485 
    267486  return null; 
    268 } 
     487 
     488        }       // end of _getSelectedAnchor() 
     489 
     490// ---------------------------------------------------------------------------- 
     491 
     492/** 
     493* onGenerate(): top 
     494*/ 
    269495 
    270496Linker.prototype.onGenerate = function() 
    271 { 
     497        { 
     498        this.ddt._ddt( "linker.js","498", "onGenerate(): top" ); 
     499 
    272500  this._dialog = new Linker.Dialog(this); 
    273 } 
    274 // Inline Dialog for Linker 
    275  
    276 Linker.Dialog_dTrees = [ ]; 
    277  
     501        } 
     502 
     503// ------------------------------------------------------------------------ 
     504 
     505/** 
     506* Dialog() - constructor 
     507*/ 
    278508 
    279509Linker.Dialog = function (linker) 
    280 { 
     510        { 
     511 
     512        linker.ddt._ddt( "linker.js","512", "Dialog(): top" ); 
     513 
    281514  var  lDialog = this; 
    282515  this.Dialog_nxtid = 0; 
     
    290523 
    291524  // load the dTree script 
     525 
     526        linker.ddt._ddt( "linker.js","526", "Dialog(): calling _prepareDialog()" ); 
     527 
    292528  this._prepareDialog(); 
    293  
    294 } 
     529        } 
     530 
     531// ------------------------------------------------------------------- 
     532 
     533/** 
     534* _prepareDialog() 
     535*/ 
    295536 
    296537Linker.Dialog.prototype._prepareDialog = function() 
    297 { 
     538        { 
     539 
    298540  var lDialog = this; 
    299541  var linker = this.linker; 
    300542 
    301   // We load some stuff up int he background, recalling this function 
     543        linker.ddt._ddt( "linker.js","543", "_prepareDialog(): top" ); 
     544 
     545  // We load some stuff up in the background, recalling this function 
    302546  // when they have loaded.  This is to keep the editor responsive while 
    303547  // we prepare the dialog. 
     548 
    304549  if(typeof dTree == 'undefined') 
    305   { 
    306     HTMLArea._loadback(_editor_url + 'plugins/Linker/dTree/dtree.js', 
    307                        function() {lDialog._prepareDialog(); } 
     550        { 
     551 
     552                linker.ddt._ddt( "linker.js","552", "_prepareDialog(): dtree not loaded. Calling _loadback()" ); 
     553 
     554    HTMLArea._loadback( _editor_url + 'plugins/Linker/dTree/dtree.js', 
     555                       function()  
     556                                                                                                { 
     557 
     558                                                                                                lDialog.linker.ddt._ddt( "linker.js","558",  "_loadback(): calling _prepareDialog"  ); 
     559 
     560                                                                                                lDialog._prepareDialog();  
     561                                                                                                } 
    308562                      ); 
    309563    return; 
    310   } 
    311  
    312   if(this.files == false) 
    313   { 
     564          }     // end of if the dTree was not loaded. 
     565 
     566  if( this.files == false) 
     567          { 
     568 
     569                linker.ddt._ddt( "linker.js","569", "_prepareDialog(): file list not loaded from backend" ); 
     570 
    314571    if(linker.lConfig.backend) 
    315     { 
    316         //get files from backend 
    317         HTMLArea._getback(linker.lConfig.backend, 
    318                           function(txt) { 
    319                             try { 
    320                                 eval('lDialog.files = '+txt); 
    321                             } catch(Error) { 
    322                                 lDialog.files = [ {url:'',title:Error.toString()} ]; 
    323                             } 
    324                             lDialog._prepareDialog(); }); 
    325     } 
     572            { 
     573 
     574                        linker.ddt._ddt( "linker.js","574", "_prepareDialog(): backend defined. loading files using _getback()" ); 
     575 
     576                        //get files from backend 
     577                        HTMLArea._getback( linker.lConfig.backend + "__function=scan", 
     578                                                function(txt)  
     579                                                        { 
     580 
     581                                                        linker.ddt._ddt( "linker.js","581",  "linker.js", "_getback(): got back txt '" + txt + "'"  ); 
     582 
     583                                                        try  
     584                                                                { 
     585                                                                eval('lDialog.files = ' + txt); 
     586                                                                }  
     587                                                        catch(Error)  
     588                                                                { 
     589                                                                lDialog.files = [ {url:'',title:Error.toString()} ]; 
     590 
     591                                                                alert( "ERROR in file list return '" + txt + "'" ); 
     592 
     593                                                                } 
     594 
     595                                                        lDialog._prepareDialog();  
     596 
     597                                                        });     // end of _getback() call 
     598            } 
    326599    else if(linker.lConfig.files != null) 
    327     { 
    328         //get files from plugin-config 
    329         lDialog.files = linker.lConfig.files; 
    330         lDialog._prepareDialog(); 
    331     } 
     600            { 
     601 
     602                        linker.ddt._ddt( "linker.js","602", "_prepareDialog(): pulling files from plugin-config" ); 
     603 
     604                        //get files from plugin-config 
     605                        lDialog.files = linker.lConfig.files; 
     606                        lDialog._prepareDialog(); 
     607                        } 
     608 
    332609    return; 
    333   } 
     610 
     611          } // end of if files hadn't been loaded. 
     612 
    334613  var files = this.files; 
    335614 
    336615  if(this.html == false) 
    337   { 
    338     HTMLArea._getback(_editor_url + 'plugins/Linker/dialog.html', function(txt) { lDialog.html = txt; lDialog._prepareDialog(); }); 
     616          { 
     617 
     618                linker.ddt._ddt( "linker.js","618", "_prepareDialog(): dialog html file not yet loaded" ); 
     619 
     620    HTMLArea._getback( linker.lConfig.backend + '&__function=dialog',  
     621                                function(txt)  
     622                                        {  
     623                                        lDialog.html = txt;  
     624                                        lDialog._prepareDialog();  
     625                                        }); 
     626 
    339627    return; 
    340   } 
     628          } 
     629 
    341630  var html = this.html; 
    342631 
    343632  // Now we have everything we need, so we can build the dialog. 
     633 
     634        linker.ddt._ddt( "linker.js","634", "_prepareDialog(): creating Dialog object" ); 
     635 
    344636  var dialog = this.dialog = new HTMLArea.Dialog(linker.editor, this.html, 'Linker'); 
    345637  var dTreeName = HTMLArea.uniq('dTree_'); 
    346638 
     639        linker.ddt._ddt( "linker.js","639", "_prepareDialog(): building dTree" ); 
     640 
    347641  this.dTree = new dTree(dTreeName, _editor_url + 'plugins/Linker/dTree/'); 
    348642  eval(dTreeName + ' = this.dTree'); 
    349643 
     644        // add the root node of the tree holding the name of the site. 
     645 
    350646  this.dTree.add(this.Dialog_nxtid++, -1, document.location.host, null, document.location.host); 
    351647  this.makeNodes(files, 0); 
     
    353649  // Put it in 
    354650  var ddTree = this.dialog.getElementById('dTree'); 
     651 
    355652  //ddTree.innerHTML = this.dTree.toString(); 
     653 
    356654  ddTree.innerHTML = ''; 
    357655  ddTree.style.position = 'absolute'; 
     
    362660  this.dTree._linker_premade = this.dTree.toString(); 
    363661 
     662        // to see the HTML of the generated tree uncomment the following. 
     663        //       
     664        // linker.ddt._ddt( "linker.js","664", "_prepareDialog(): dTree string is '" + this.dTree.toString().replace( /[<]/g, '&lt;' ).replace( /[>]/g, '&gt;' ) + "'" ); 
     665 
    364666  var options = this.dialog.getElementById('options'); 
    365667  options.style.position = 'absolute'; 
     
    372674  this.dialog.onresize = function() 
    373675    { 
    374       options.style.height = ddTree.style.height = (dialog.height - dialog.getElementById('h1').offsetHeight) + 'px'; 
    375       ddTree.style.width  = (dialog.width  - 322 ) + 'px'; 
     676                options.style.height = ddTree.style.height = (dialog.height - dialog.getElementById('h1').offsetHeight) + 'px'; 
     677                ddTree.style.width  = (dialog.width  - 322 ) + 'px'; 
    376678    } 
    377679 
    378680  this.ready = true; 
    379 } 
     681 
     682        }       // end of _prepareDialog() 
     683 
     684// ----------------------------------------------------------------------------- 
     685 
     686/** 
     687* makeNodes() 
     688*/ 
    380689 
    381690Linker.Dialog.prototype.makeNodes = function(files, parent) 
    382 { 
     691        { 
     692 
     693  var linker = this.linker; 
     694 
     695        linker.ddt._ddt( "linker.js","695", "makeNodes(): top" ); 
     696 
    383697  for(var i = 0; i < files.length; i++) 
    384   { 
     698          { 
     699 
     700                // either it's a leaf node (file) or an array (subdirectory) 
     701 
    385702    if(typeof files[i] == 'string') 
    386     { 
     703        { 
     704 
     705                        linker.ddt._ddt( "linker.js","705", "makeNodes(): adding node for file '" + files[i] + "'" ); 
     706 
    387707      this.dTree.add(Linker.nxtid++, parent, 
    388708                     files[i].replace(/^.*\//, ''), 
    389709                     'javascript:document.getElementsByName(\'' + this.dialog.id.href + '\')[0].value=decodeURIComponent(\'' + encodeURIComponent(files[i]) + '\');document.getElementsByName(\'' + this.dialog.id.type + '\')[0].click();document.getElementsByName(\'' + this.dialog.id.href + '\')[0].focus();void(0);', 
    390710                     files[i]); 
    391     } 
     711 
     712 
     713 
     714            } 
    392715    else if(files[i].length) 
    393     { 
     716          { 
     717 
     718                        linker.ddt._ddt( "linker.js","718", "makeNodes(): adding node for file '" + files[i][0] + "'" ); 
     719 
    394720      var id = this.Dialog_nxtid++; 
    395721      this.dTree.add(id, parent, files[i][0].replace(/^.*\//, ''), null, files[i][0]); 
    396722      this.makeNodes(files[i][1], id); 
    397     } 
     723        } 
    398724    else if(typeof files[i] == 'object') 
    399     { 
    400       if(files[i].children) { 
     725                        { 
     726 
     727                        // this section handles the title: and url: style of scan.php output. 
     728 
     729      if(files[i].children)  
     730                                { 
    401731        var id = this.Dialog_nxtid++; 
    402       } else { 
     732        }  
     733                        else  
     734                                { 
    403735        var id = Linker.nxtid++; 
    404       } 
    405  
    406       if(files[i].title) var title = files[i].title; 
     736        } 
     737 
     738                        var name = files[i].url; 
     739 
     740      if ( files[i].title) var title = files[i].title; 
    407741      else if(files[i].url) var title = files[i].url.replace(/^.*\//, ''); 
    408742      else var title = "no title defined"; 
    409743      if(files[i].url) var link = 'javascript:document.getElementsByName(\'' + this.dialog.id.href + '\')[0].value=decodeURIComponent(\'' + encodeURIComponent(files[i].url) + '\');document.getElementsByName(\'' + this.dialog.id.type + '\')[0].click();document.getElementsByName(\'' + this.dialog.id.href + '\')[0].focus();void(0);'; 
    410744      else var link = ''; 
     745 
     746                        linker.ddt._ddt( "linker.js","746", "makeNodes(): adding node id '" + id + "' parent '" + parent + "' title '" + title + "' link '" + link + "' name '" + name + "'" ); 
    411747       
    412       this.dTree.add(id, parent, title, link, title); 
    413       if(files[i].children) { 
     748      this.dTree.add(id, parent, title, link, name); 
     749      if(files[i].children)  
     750                                { 
    414751        this.makeNodes(files[i].children, id); 
    415       } 
    416     } 
    417   } 
    418 } 
     752        } 
     753        } 
     754        } 
     755 
     756        linker.ddt._ddt( "linker.js","756", "makeNodes(): bottom" ); 
     757 
     758        }       // end of makeNodes() 
     759 
     760// -------------------------------------------------------------------- 
     761 
     762/** 
     763* copy of linker lc  
     764*/ 
    419765 
    420766Linker.Dialog.prototype._lc = Linker.prototype._lc; 
    421767 
     768// -------------------------------------------------------------------- 
     769 
     770/** 
     771* show() 
     772*/ 
     773 
    422774Linker.Dialog.prototype.show = function(inputs, ok, cancel) 
    423 { 
    424   if(!this.ready) 
    425   { 
     775        { 
     776 
     777        var linker = this.linker; 
     778 
     779        linker.ddt._ddt( "linker.js","779", "show(): top" ); 
     780 
     781        // if we are not ready pause a bit and come back. This can be confusing for 
     782        // the end user if it takes a really long time to build the linker list.  
     783        // 
     784        // FIXME: put in some kind of "please wait - building list" message. 
     785        // 
     786        // To avoid an endless loop situation, limit the number of times we wait. 
     787 
     788        if ( typeof this.wait_count == 'undefined' ) 
     789                { 
     790                this.wait_count = 1; 
     791                } 
     792        else 
     793                { 
     794                this.wait_count++; 
     795                } 
     796 
     797        if ( this.wait_count > 100 ) 
     798                { 
     799                alert( "Linker plugin has waited too long for the directory listing. Please check your javascript console for possible errors" ); 
     800                return false; 
     801                } 
     802 
     803        // this.ready gets set in _prepareDialog() when it's finished doing it's thing. 
     804        // Unfortunately it can take a very long time depending on the size of the 
     805        // directory structure. 
     806 
     807  if (!this.ready) 
     808        { 
     809 
     810                linker.ddt._ddt( "linker.js","810", "show(): we are not ready. setting a 100 timeout wait count is '" + this.wait_count + "'" ); 
     811 
    426812    var lDialog = this; 
    427     window.setTimeout(function() {lDialog.show(inputs,ok,cancel);},100); 
     813    window.setTimeout( 
     814                                function()  
     815                                        { 
     816                                        lDialog.show(inputs,ok,cancel); 
     817                                        },100); 
     818 
    428819    return; 
    429   } 
     820          } 
    430821 
    431822  if(this.ddTree.innerHTML == '') 
    432   { 
     823          { 
    433824    this.ddTree.innerHTML = this.dTree._linker_premade; 
    434   } 
     825          } 
    435826 
    436827  if(inputs.type=='url') 
    437   { 
     828          { 
    438829    this.dialog.getElementById('urltable').style.display = ''; 
    439830    this.dialog.getElementById('mailtable').style.display = 'none'; 
    440   } 
     831        } 
    441832  else 
    442   { 
     833          { 
    443834    this.dialog.getElementById('urltable').style.display = 'none'; 
    444835    this.dialog.getElementById('mailtable').style.display = ''; 
    445   } 
     836        } 
    446837 
    447838  if(inputs.target=='popup') 
    448   { 
     839          { 
    449840    this.dialog.getElementById('popuptable').style.display = ''; 
    450   } 
     841        } 
    451842  else 
    452   { 
     843          { 
    453844    this.dialog.getElementById('popuptable').style.display = 'none'; 
    454   } 
     845        } 
    455846 
    456847  // Connect the OK and Cancel buttons 
     848 
    457849  var dialog = this.dialog; 
    458850  var lDialog = this; 
    459   if(ok) 
    460   { 
     851  if (ok) 
     852        { 
    461853    this.dialog.getElementById('ok').onclick = ok; 
    462   } 
     854          } 
    463855  else 
    464   { 
     856        { 
    465857    this.dialog.getElementById('ok').onclick = function() {lDialog.hide();}; 
    466   } 
     858          } 
    467859 
    468860  if(cancel) 
    469   { 
     861        { 
    470862    this.dialog.getElementById('cancel').onclick = cancel; 
    471   } 
     863          } 
    472864  else 
    473   { 
     865        { 
    474866    this.dialog.getElementById('cancel').onclick = function() { lDialog.hide()}; 
    475   } 
     867          } 
     868 
     869  // highlight the currently selected item, if one has been selected. 
     870  // unfortunately this means we have to loop through the dTree looking 
     871  // for a match on the target url. 
     872 
     873  var n=0; 
     874 
     875        linker.ddt._ddt( "linker.js","875", "show(): clearing selection" ); 
     876 
     877  this.dTree.clear_s(); 
     878 
     879  for (n; n<this.dTree.aNodes.length; n++)  
     880    { 
     881 
     882                linker.ddt._ddt( "linker.js","882", "show(): checking tree node '" + this.dTree.aNodes[n].title + "' against '" + inputs.href + "'" ); 
     883 
     884                if (this.dTree.aNodes[n].title == inputs.href)  
     885                        { 
     886                        linker.ddt._ddt( "linker.js","886", "show(): found selection at node '" + n + "'. selecting" ); 
     887 
     888                        this.dTree.s( n ); 
     889 
     890                        // it's possible that the sected link is in a collapsed subdirectory so open 
     891                        // the tree to the selected node. 
     892 
     893                        this.dTree.openTo( n, true, true ); 
     894 
     895                        // we would like to be able to scroll to the currently selected 
     896                        // node because it may be well below the visible portion of the  
     897                        // div. (see the id="[dTree]" in dialog.html to see where the tree 
     898                        // is displayed in the dialog. 
     899                        // 
     900                        // I've add a getNodeElement() method to dTree.js to return the <a>  
     901                        // element of the given node. Gecko and MSIE support a scrollIntoView() 
     902                        // method that should, in theory, scroll to make the given item visible. 
     903                        // 
     904                        // However, this has to be done after the dialog is displayed so we keep  
     905                        // the selectednode and call scrollIntoView() after the resizing. 
     906 
     907                        var selectedNode = this.dTree.getNodeElement(n); 
     908 
     909                        linker.ddt._ddt( "linker.js","909", "show(): select Node tagName is '" + selectedNode.tagName + "'" ); 
     910 
     911                        } 
     912                } 
    476913 
    477914  // Show the dialog 
     915 
    478916  this.linker.editor.disableToolbar(['fullscreen','linker']); 
    479917 
     
    481919 
    482920  // Init the sizes 
     921 
    483922  this.dialog.onresize(); 
    484 } 
     923 
     924        // scrollIntoView() is supported by MSIE 4+ and Gecko. It is not, according to the 
     925        // documentation I have, part of the DOM spec. 
     926 
     927        if ( selectedNode ) 
     928                selectedNode.scrollIntoView(); 
     929                 
     930        linker.ddt._ddt( "linker.js","930", "show(): bottom" ); 
     931 
     932        }       // end of show() 
     933 
     934// ------------------------------------------------------------------- 
     935 
     936/** 
     937* hide() 
     938*/ 
    485939 
    486940Linker.Dialog.prototype.hide = function() 
    487 { 
     941        { 
     942 
     943        var linker = this.linker; 
     944 
     945        linker.ddt._ddt( "linker.js","945", "hide(): top" ); 
     946 
    488947  this.linker.editor.enableToolbar(); 
    489948  return this.dialog.hide(); 
    490 } 
    491  
     949 
     950        }       // end of hide() 
     951 
     952// ----------------------------------------------------------- 
     953 
     954/** 
     955* scrollToElement() 
     956* 
     957* @todo THIS DOES NOT WORK. IT'S RIPPED OFF FROM htmlarea.js AND IS SETUP FOR A WINDOW 
     958*  
     959* this.ddtTree is a div that contains a tree. How to scroll to the right position in the 
     960* tree since the <div> tag doesn't seem to have an analog to the 'scrollTo()' method?? 
     961*/ 
     962 
     963Linker.Dialog.prototype.scrollToElement = function(e) 
     964  { 
     965 
     966        var linker = this.linker; 
     967 
     968  linker.ddt._ddt( "linker.js","968", "scrollToElement(): top" ); 
     969 
     970  if(HTMLArea.is_gecko) 
     971    { 
     972    var top  = 0; 
     973    var left = 0; 
     974 
     975    while(e) 
     976      { 
     977      top  += e.offsetTop; 
     978      left += e.offsetLeft; 
     979      if(e.offsetParent && e.offsetParent.tagName.toLowerCase() != 'body') 
     980        { 
     981        e = e.offsetParent; 
     982        } 
     983      else 
     984        { 
     985        e = null; 
     986        } 
     987      } 
     988 
     989    // this._iframe.contentWindow.scrollTo(left, top); 
     990 
     991          //linker.ddt._ddtDumpObject( "linker.js","6740", "scrollToElement(): before calling scrollTo top '" + top + "' left '" + left + "'", this.ddTree ); 
     992 
     993    linker.ddt._ddt( "linker.js","993", "Type of ddtTree is '" + this.ddTree.tagName + "'" ); 
     994 
     995    } 
     996  } // end of scrollToElement() 
     997 
     998// END 
     999 
  • branches/unified_backend/plugins/Linker/scan.php

    r57 r121  
    11<?php 
    22 
    3     // /home/username/foo/public_html/ 
    4     $dir          = $_SERVER['DOCUMENT_ROOT']; 
    5     $include      = '/\.(php|shtml|html|htm|shtm|cgi|txt|doc|pdf|rtf|xls|csv)$/'; 
    6     $exclude      = ''; 
    7     $dirinclude   = ''; 
    8     $direxclude   = '/(^|\/)[._]|htmlarea/'; // Exclude the htmlarea tree by default 
    9  
    10     $hash = ''; 
    11     foreach(explode(',', 'dir,include,exclude,dirinclude,direxclude') as $k) 
    12     { 
    13       if(isset($_REQUEST[$k])) 
    14       { 
    15         if(get_magic_quotes_gpc()) 
    16         { 
    17           $_REQUEST[$k] = stripslashes($_REQUEST[$k]); 
    18         } 
    19         $hash .= $k . '=' . $_REQUEST[$k]; 
    20         $$k = $_REQUEST[$k]; 
     3/** 
     4* scan.php Linker backend 
     5* 
     6* @author James Sleeman 
     7* @author Yermo Lamers http://www.formvista.com/contact.html unified backend modifications. 
     8* @copyright Gogo Code http://code.gogo.co.nz 
     9*/ 
     10 
     11/** 
     12* Xinha PHP backend master config file 
     13* 
     14* we assume the current working directory is plugins/Linker 
     15*/ 
     16 
     17require_once( "../../backends/backend_conf.php" ); 
     18 
     19/** 
     20* debugging library 
     21*/ 
     22 
     23require_once( "../../ddt/ddt.php" ); 
     24 
     25// by default we'll point linker at the examples document directory  
     26 
     27$dir          = XINHA_INSTALL_ROOT . "/examples";  
     28 
     29$include      = '/\.(php|shtml|html|htm|shtm|cgi|txt|doc|pdf|rtf|xls|csv)$/'; 
     30$exclude      = ''; 
     31$dirinclude   = ''; 
     32$direxclude   = '/(^|\/)[._]|htmlarea/'; // Exclude the htmlarea tree by default 
     33 
     34// ------------------------------------------------------------------------------- 
     35 
     36_ddt( __FILE__, __LINE__, "scan.php: top" ); 
     37 
     38$hash = ''; 
     39foreach(explode(',', 'dir,include,exclude,dirinclude,direxclude') as $k) 
     40        { 
     41        if (isset($_REQUEST[$k])) 
     42                { 
     43 
     44                if (get_magic_quotes_gpc()) 
     45                        { 
     46                        $_REQUEST[$k] = stripslashes($_REQUEST[$k]); 
     47                        } 
     48 
     49                $hash .= $k . '=' . $_REQUEST[$k]; 
     50                $$k = $_REQUEST[$k]; 
     51                } 
     52        } 
     53 
     54if ($hash) 
     55        { 
     56        session_start(); 
     57        if (!isset($_SESSION[sha1($hash)])) 
     58                { 
     59                ?> 
     60                [ ]; 
     61                <?php 
     62                exit; 
    2163      } 
    2264    } 
    2365 
    24     if($hash) 
    25     { 
    26       session_start(); 
    27       if(!isset($_SESSION[sha1($hash)])) 
    28       { 
    29         ?> 
    30         [ ]; 
    31         <?php 
    32         exit; 
    33       } 
    34     } 
    35  
    36     function scan($dir, $durl = '') 
    37     { 
    38       global $include, $exclude, $dirinclude, $direxclude; 
    39       static $seen = array(); 
    40  
    41       $files = array(); 
    42  
    43       $dir = realpath($dir); 
    44       if(isset($seen[$dir])) 
    45       { 
    46         return $files; 
    47       } 
    48       $seen[$dir] = TRUE; 
    49       $dh = @opendir($dir); 
    50  
    51  
    52       while($dh && ($file = readdir($dh))) 
    53       { 
    54         if($file !== '.' && $file !== '..') 
    55         { 
    56           $path = realpath($dir . '/' . $file); 
    57           $url  = $durl . '/' . $file; 
    58  
    59           if(($dirinclude && !preg_match($dirinclude, $url)) || ($direxclude && preg_match($direxclude, $url))) continue; 
    60           if(is_dir($path)) 
    61           { 
    62             if($subdir = scan($path, $url)) 
    63             { 
    64               $files[] = array('url'=>$url, 'children'=>$subdir); 
    65             } 
    66           } 
    67           elseif(is_file($path)) 
    68           { 
    69             if(($include && !preg_match($include, $url)) || ($exclude && preg_match($exclude, $url))) continue; 
    70             $files[] = array('url'=>$url); 
    71           } 
    72  
    73         } 
    74       } 
    75       @closedir($dh); 
    76       return dirsort($files); 
    77     } 
    78  
    79     function dirsort($files) 
    80     { 
    81       usort($files, 'dircomp'); 
    82       return $files; 
    83     } 
    84  
    85     function dircomp($a, $b) 
    86     { 
    87       if(is_array($a)) $a = $a[0]; 
    88       if(is_array($b)) $b = $b[0]; 
    89       return strcmp(strtolower($a), strtolower($b)); 
    90     } 
    91  
    92     function to_js($var, $tabs = 0) 
    93     { 
    94       if(is_numeric($var)) 
    95       { 
    96         return $var; 
    97       } 
    98  
    99       if(is_string($var)) 
    100       { 
    101         return "'" . js_encode($var) . "'"; 
    102       } 
    103  
    104       if(is_array($var)) 
    105       { 
    106         $useObject = false; 
    107         foreach(array_keys($var) as $k) { 
    108             if(!is_numeric($k)) $useObject = true; 
    109         } 
    110         $js = array(); 
    111         foreach($var as $k => $v) 
    112         { 
    113           $i = ""; 
    114           if($useObject) { 
    115             if(preg_match('#[a-zA-Z]+[a-zA-Z0-9]*#', $k)) { 
    116               $i .= "$k: "; 
    117             } else { 
    118               $i .= "'$k': "; 
    119             } 
    120           } 
    121           $i .= to_js($v, $tabs + 1); 
    122           $js[] = $i; 
    123         } 
    124         if($useObject) { 
    125             $ret = "{\n" . tabify(implode(",\n", $js), $tabs) . "\n}"; 
    126         } else { 
    127             $ret = "[\n" . tabify(implode(",\n", $js), $tabs) . "\n]"; 
    128         } 
    129         return $ret; 
    130       } 
    131  
    132       return 'null'; 
    133     } 
    134  
    135     function tabify($text, $tabs) 
    136     { 
    137       if($text) 
    138       { 
    139         return str_repeat("  ", $tabs) . preg_replace('/\n(.)/', "\n" . str_repeat("  ", $tabs) . "\$1", $text); 
    140       } 
    141     } 
    142  
    143     function js_encode($string) 
    144     { 
    145       static $strings = "\\,\",',%,&,<,>,{,},@,\n,\r"; 
    146  
    147       if(!is_array($strings)) 
    148       { 
    149         $tr = array(); 
    150         foreach(explode(',', $strings) as $chr) 
    151         { 
    152           $tr[$chr] = sprintf('\x%02X', ord($chr)); 
    153         } 
    154         $strings = $tr; 
    155       } 
    156  
    157       return strtr($string, $strings); 
    158     } 
    159  
    160  
    161     echo to_js(scan($dir)); 
     66// -------------------------------------------------------------- 
     67 
     68/** 
     69* scan a directory 
     70*/ 
     71 
     72function scan($dir, $durl = '') 
     73        { 
     74        global $include, $exclude, $dirinclude, $direxclude; 
     75        static $seen = array(); 
     76 
     77        _ddt( __FILE__, __LINE__, "scan(): to with dir '" . $dir . "' and durl '" . $durl . "'" ); 
     78 
     79        $files = array(); 
     80 
     81        $dir = realpath($dir); 
     82 
     83        if(isset($seen[$dir])) 
     84                { 
     85                return $files; 
     86                } 
     87 
     88        $seen[$dir] = TRUE; 
     89        $dh = @opendir($dir); 
     90 
     91        while($dh && ($file = readdir($dh))) 
     92                { 
     93                if($file !== '.' && $file !== '..') 
     94                        { 
     95                        $path = realpath($dir . '/' . $file); 
     96                        $url  = $durl . '/' . $file; 
     97 
     98                        if(($dirinclude && !preg_match($dirinclude, $url)) || ($direxclude && preg_match($direxclude, $url))) continue; 
     99                        if(is_dir($path)) 
     100                                { 
     101                                if($subdir = scan($path, $url)) 
     102                                        { 
     103                                        $files[] = array('url'=>$url, 'children'=>$subdir); 
     104                                        } 
     105                                } 
     106                        elseif(is_file($path)) 
     107                                { 
     108                                if(($include && !preg_match($include, $url)) || ($exclude && preg_match($exclude, $url))) continue; 
     109                                $files[] = array('url'=>$url); 
     110                                } 
     111 
     112                        } 
     113                } 
     114 
     115        @closedir($dh); 
     116 
     117        return dirsort($files); 
     118 
     119        }       // end of scan() 
     120 
     121// ---------------------------------------------------------------------- 
     122 
     123/** 
     124* sort a directory 
     125*/ 
     126 
     127function dirsort($files) 
     128        { 
     129        usort($files, 'dircomp'); 
     130        return $files; 
     131        } 
     132 
     133// ----------------------------------------------------------------------- 
     134 
     135/** 
     136* compare directory entries 
     137*/ 
     138 
     139function dircomp($a, $b) 
     140        { 
     141 
     142        _ddt( __FILE__, __LINE__, "dircomp(): top" ); 
     143 
     144        if(is_array($a))  
     145                { 
     146                _ddt( __FILE__, __LINE__, "dircomp(): a is a directory" ); 
     147 
     148                foreach ( $a as $name => $value ) 
     149                        _ddt( __FILE__, __LINE__, "dircomp(): $name => $value" ); 
     150 
     151                $a = $a["url"]; 
     152                } 
     153 
     154        if(is_array($b))  
     155                { 
     156                _ddt( __FILE__, __LINE__, "dircomp(): b is a directory" ); 
     157 
     158                $b = $b["url"]; 
     159                } 
     160 
     161        _ddt( __FILE__, __LINE__, "dircomp(): comparing '$a' with '$b'" ); 
     162 
     163        return strcmp(strtolower($a), strtolower($b)); 
     164 
     165        }       // end of dircomp() 
     166 
     167// ---------------------------------------------------------------------- 
     168 
     169/** 
     170* generate javascript array 
     171*/ 
     172 
     173function to_js( $var, $tabs = 0) 
     174        { 
     175 
     176        _ddt( __FILE__, __LINE__, "to_js(): top with var '$var'" ); 
     177 
     178        if(is_numeric($var)) 
     179                { 
     180                return $var; 
     181                } 
     182 
     183        if(is_string($var)) 
     184                { 
     185                return "'" . js_encode($var) . "'"; 
     186                } 
     187 
     188        if(is_array($var)) 
     189                { 
     190                $useObject = false; 
     191                foreach(array_keys($var) as $k)  
     192                        { 
     193                        if(!is_numeric($k)) $useObject = true; 
     194                        } 
     195 
     196                $js = array(); 
     197 
     198                foreach($var as $k => $v) 
     199                        { 
     200                        $i = ""; 
     201 
     202                        if($useObject)  
     203                                { 
     204                                if(preg_match('#[a-zA-Z]+[a-zA-Z0-9]*#', $k))  
     205                                        { 
     206                                        $i .= "$k: "; 
     207                                        }  
     208                                else  
     209                                        { 
     210                                        $i .= "'$k': "; 
     211                                        } 
     212                                } 
     213                         
     214                        $i .= to_js($v, $tabs + 1); 
     215                        $js[] = $i; 
     216                        } 
     217 
     218        if ($useObject)  
     219                        { 
     220                        $ret = "{\n" . tabify(implode(",\n", $js), $tabs) . "\n}"; 
     221                        }  
     222                else  
     223                        { 
     224                        $ret = "[\n" . tabify(implode(",\n", $js), $tabs) . "\n]"; 
     225                        } 
     226                return $ret; 
     227 
     228                } 
     229 
     230        return 'null'; 
     231         
     232        }       // end of to_js() 
     233 
     234// ------------------------------------------------------------------------ 
     235 
     236/** 
     237* tabify() 
     238*/ 
     239 
     240function tabify($text, $tabs) 
     241        { 
     242        if($text) 
     243                { 
     244                return str_repeat("  ", $tabs) . preg_replace('/\n(.)/', "\n" . str_repeat("  ", $tabs) . "\$1", $text); 
     245                } 
     246        } 
     247 
     248// --------------------------------------------------------------------- 
     249 
     250/** 
     251* js_encode() 
     252*/ 
     253 
     254function js_encode($string) 
     255        { 
     256        static $strings = "\\,\",',%,&,<,>,{,},@,\n,\r"; 
     257 
     258        if(!is_array($strings)) 
     259                { 
     260                $tr = array(); 
     261                foreach(explode(',', $strings) as $chr) 
     262                        { 
     263                        $tr[$chr] = sprintf('\x%02X', ord($chr)); 
     264                        } 
     265                $strings = $tr; 
     266                } 
     267 
     268        return strtr($string, $strings); 
     269        } 
     270 
     271/** 
     272* send out the resulting javascript array. 
     273*/ 
     274 
     275$javascript_array = to_js(scan($dir)); 
     276 
     277// if you want to see what's communicated back to the browser uncomment this. You will 
     278// get the output in an error popup. 
     279// 
     280// _ddtOn(); 
     281 
     282_ddt( __FILE__, __LINE__, "scan.php: Resulting array is '" + $javascript_array + "'" ); 
     283 
     284echo $javascript_array; 
     285 
     286// END 
    162287?> 
Note: See TracChangeset for help on using the changeset viewer.