Changeset 1044 for trunk/modules


Ignore:
Timestamp:
10/02/08 17:07:26 (11 years ago)
Author:
douglas
Message:

FIXED Ticket #1176 Merging new dialogs branch back to trunk.

Location:
trunk/modules
Files:
9 added
1 deleted
8 edited

Legend:

Unmodified
Added
Removed
  • trunk/modules/ColorPicker/ColorPicker.js

    r1024 r1044  
    372372          this.table.style.position = 'fixed'; 
    373373        } 
    374         top+=e.offsetTop - e.scrollTop; 
    375         left+=e.offsetLeft - e.scrollLeft; 
     374        top += e.offsetTop - e.scrollTop; 
     375        left += e.offsetLeft - e.scrollLeft; 
    376376 
    377377        e = e.offsetParent; 
  • trunk/modules/CreateLink/link.js

    r1001 r1044  
    1  
    21  /*--------------------------------------:noTabs=true:tabSize=2:indentSize=2:-- 
    32    --  Xinha (is not htmlArea) - http://xinha.org 
     
    1615    --  which provides the functionality to insert a hyperlink in the editor. 
    1716    -- 
    18     --  he file is loaded as a special plugin by the Xinha Core when no alternative method (plugin) is loaded. 
     17    --  The file is loaded as a special plugin by the Xinha Core when no alternative method (plugin) is loaded. 
    1918    -- 
    2019    -- 
     
    2423    --  $LastChangedBy:ray $ 
    2524    --------------------------------------------------------------------------*/ 
     25 
     26function CreateLink(editor) { 
     27        this.editor = editor; 
     28        var cfg = editor.config; 
     29        var self = this; 
     30 
     31   editor.config.btnList.createlink[3] = function() { self.show(self._getSelectedAnchor()); } 
     32} 
     33 
    2634CreateLink._pluginInfo = { 
    2735  name          : "CreateLink", 
    2836  origin        : "Xinha Core", 
    29   version       : "$LastChangedRevision:990 $".replace(/^[^:]*:\s*(.*)\s*\$$/, '$1'), 
     37  version       : "$LastChangedRevision$".replace(/^[^:]*:\s*(.*)\s*\$$/, '$1'), 
    3038  developer     : "The Xinha Core Developer Team", 
    31   developer_url : "$HeadURL:http://svn.xinha.webfactional.com/trunk/modules/CreateLink/link.js $".replace(/^[^:]*:\s*(.*)\s*\$$/, '$1'), 
     39  developer_url : "$HeadURL$".replace(/^[^:]*:\s*(.*)\s*\$$/, '$1'), 
    3240  sponsor       : "", 
    3341  sponsor_url   : "", 
     
    3543}; 
    3644 
    37 function CreateLink(editor) { 
    38 }                                                        
     45CreateLink.prototype._lc = function(string) { 
     46        return Xinha._lc(string, 'Xinha'); 
     47}; 
    3948 
    40 Xinha.prototype._createLink = function(link) 
     49 
     50CreateLink.prototype.onGenerateOnce = function() 
    4151{ 
    42   var editor = this; 
    43   var outparam = null; 
    44   if ( typeof link == "undefined" ) 
    45   { 
    46     link = this.getParentElement(); 
    47     if ( link ) 
    48     { 
    49       while (link && !/^a$/i.test(link.tagName)) 
    50       { 
    51         link = link.parentNode; 
    52       } 
    53     } 
    54   } 
    55   if ( !link ) 
    56   { 
    57     var sel = editor.getSelection(); 
    58     var range = editor.createRange(sel); 
    59     var compare = 0; 
    60     if ( Xinha.is_ie ) 
    61     { 
    62       if ( sel.type == "Control" ) 
    63       { 
    64         compare = range.length; 
    65       } 
    66       else 
    67       { 
    68         compare = range.compareEndPoints("StartToEnd", range); 
    69       } 
    70     } 
    71     else 
    72     { 
    73       compare = range.compareBoundaryPoints(range.START_TO_END, range); 
    74     } 
    75     if ( compare === 0 ) 
    76     { 
    77       alert(Xinha._lc("You need to select some text before creating a link")); 
    78       return; 
    79     } 
    80     outparam = 
    81     { 
    82       f_href : '', 
    83       f_title : '', 
    84       f_target : '', 
    85       f_usetarget : editor.config.makeLinkShowsTarget 
    86     }; 
    87   } 
    88   else 
    89   { 
    90     outparam = 
    91     { 
    92       f_href   : Xinha.is_ie ? editor.stripBaseURL(link.href) : link.getAttribute("href"), 
    93       f_title  : link.title, 
    94       f_target : link.target, 
    95       f_usetarget : editor.config.makeLinkShowsTarget 
    96     }; 
    97   } 
    98   Dialog( 
    99     editor.config.URIs.link, 
    100     function(param) 
    101     { 
    102       if ( !param ) 
    103       { 
    104         return false; 
    105       } 
    106       var a = link; 
    107       if ( !a ) 
    108       { 
    109         try 
    110         { 
    111           var tmp = Xinha.uniq('http://www.example.com/Link'); 
    112           editor._doc.execCommand('createlink', false, tmp); 
     52  CreateLink.loadAssets(); 
     53}; 
    11354 
    114           // Fix them up 
    115           var anchors = editor._doc.getElementsByTagName('a'); 
    116           for(var i = 0; i < anchors.length; i++) 
    117           { 
    118             var anchor = anchors[i]; 
    119             if(anchor.href == tmp) 
    120             { 
    121               // Found one. 
    122               if (!a) a = anchor; 
    123               anchor.href =  param.f_href; 
    124               if (param.f_target) anchor.target =  param.f_target; 
    125               if (param.f_title)  anchor.title =  param.f_title; 
    126             } 
    127           } 
    128         } catch(ex) {} 
    129       } 
    130       else 
    131       { 
    132         var href = param.f_href.trim(); 
    133         editor.selectNodeContents(a); 
    134         if ( href === '' ) 
    135         { 
    136           editor._doc.execCommand("unlink", false, null); 
    137           editor.updateToolbar(); 
    138           return false; 
    139         } 
    140         else 
    141         { 
    142           a.href = href; 
    143         } 
    144       } 
    145       if ( ! ( a && a.tagName.toLowerCase() == 'a' ) ) 
    146       { 
    147         return false; 
    148       } 
    149       a.target = param.f_target.trim(); 
    150       a.title = param.f_title.trim(); 
    151       editor.selectNodeContents(a); 
    152       editor.updateToolbar(); 
    153     }, 
    154     outparam); 
     55CreateLink.loadAssets = function() 
     56{ 
     57        var self = CreateLink; 
     58        if (self.loading) return; 
     59        self.loading = true; 
     60        Xinha._getback(_editor_url + 'modules/CreateLink/dialog.html', function(getback) { self.html = getback; self.dialogReady = true; }); 
     61        Xinha._getback(_editor_url + 'modules/CreateLink/pluginMethods.js', function(getback) { eval(getback); self.methodsReady = true; }); 
     62} 
     63 
     64CreateLink.prototype.onUpdateToolbar = function() 
     65{  
     66        if (!(CreateLink.dialogReady && CreateLink.methodsReady)) 
     67        { 
     68                this.editor._toolbarObjects.createlink.state("enabled", false); 
     69        } 
     70        else this.onUpdateToolbar = null; 
    15571}; 
     72 
     73CreateLink.prototype.prepareDialog = function() 
     74{ 
     75        var self = this; 
     76        var editor = this.editor; 
     77 
     78        var dialog = this.dialog = new Xinha.Dialog(editor, CreateLink.html, 'Xinha',{width:400}) 
     79        // Connect the OK and Cancel buttons 
     80        dialog.getElementById('ok').onclick = function() {self.apply();} 
     81 
     82        dialog.getElementById('cancel').onclick = function() { self.dialog.hide()}; 
     83 
     84        if (!editor.config.makeLinkShowsTarget) 
     85        { 
     86                dialog.getElementById("f_target_label").style.visibility = "hidden"; 
     87                dialog.getElementById("f_target").style.visibility = "hidden"; 
     88                dialog.getElementById("f_other_target").style.visibility = "hidden"; 
     89        } 
     90 
     91        dialog.getElementById('f_target').onchange= function()  
     92        { 
     93                var f = dialog.getElementById("f_other_target"); 
     94                if (this.value == "_other") { 
     95                        f.style.visibility = "visible"; 
     96                        f.select(); 
     97                        f.focus(); 
     98                } else f.style.visibility = "hidden"; 
     99        }; 
     100 
     101         
     102        this.dialogReady = true; 
     103}; 
  • trunk/modules/Gecko/Gecko.js

    r1001 r1044  
    576576Xinha.prototype.restoreSelection = function(savedSelection) 
    577577{ 
     578  try  
     579  { 
    578580  var sel = this.getSelection(); 
    579581  sel.removeAllRanges(); 
    580582  sel.addRange(savedSelection); 
     583  } 
     584  catch (e) {} 
    581585} 
    582586/** 
     
    585589 * 
    586590 * @param node DomNode  
    587  * @param pos  Set to a numeric position inside the node to collapse the cursor here if possible.  
    588  */ 
    589   
    590 Xinha.prototype.selectNodeContents = function(node, pos) 
     591 * @param collapseToStart A boolean that, when supplied, says to collapse the selection. True collapses to the start, and false to the end. 
     592 */ 
     593  
     594Xinha.prototype.selectNodeContents = function(node, collapseToStart) 
    591595{ 
    592596  this.focusEditor(); 
    593597  this.forceRedraw(); 
    594598  var range; 
    595   var collapsed = typeof pos == "undefined" ? true : false; 
     599  var collapsed = typeof collapseToStart == "undefined" ? true : false; 
    596600  var sel = this.getSelection(); 
    597601  range = this._doc.createRange(); 
     
    609613  { 
    610614    range.selectNodeContents(node); 
    611     //(collapsed) && range.collapse(pos); 
    612615  } 
    613616  sel.removeAllRanges(); 
    614617  sel.addRange(range); 
     618  if (typeof collapseToStart != "undefined") 
     619  { 
     620    if (collapseToStart) 
     621    { 
     622      sel.collapse(range.startContainer, range.startOffset); 
     623    } else 
     624    { 
     625      sel.collapse(range.endContainer, range.endOffset); 
     626    } 
     627  } 
    615628}; 
    616629   
  • trunk/modules/InsertImage/insert_image.js

    r1001 r1044  
    1  
    21  /*--------------------------------------:noTabs=true:tabSize=2:indentSize=2:-- 
    32    --  Xinha (is not htmlArea) - http://xinha.org 
     
    87    --  Copyright (c) 2005-2008 Xinha Developer Team and contributors 
    98    -- 
    10     --  This is the standard implementation of the Xinha.prototype._insertImage method, 
    11     --  which provides the functionality to insert an image in the editor. 
     9    --  This is the Xinha standard implementation of an image insertion plugin 
    1210    -- 
    13     --  The file is loaded as a special plugin by the Xinha Core when no alternative method (plugin) is loaded. 
     11    --  he file is loaded as a special plugin by the Xinha Core when no alternative method (plugin) is loaded. 
    1412    -- 
    1513    -- 
    16     --  $HeadURL:http://svn.xinha.webfactional.com/trunk/modules/InsertImage/insert_image.js $ 
    17     --  $LastChangedDate:2008-04-12 23:02:13 +0200 (Sa, 12 Apr 2008) $ 
    18     --  $LastChangedRevision:992 $ 
    19     --  $LastChangedBy:ray $ 
     14    --  $HeadURL$ 
     15    --  $LastChangedDate$ 
     16    --  $LastChangedRevision$ 
     17    --  $LastChangedBy$ 
    2018    --------------------------------------------------------------------------*/ 
     19   
    2120InsertImage._pluginInfo = { 
    2221  name          : "InsertImage", 
    2322  origin        : "Xinha Core", 
    24   version       : "$LastChangedRevision:992 $".replace(/^[^:]*:\s*(.*)\s*\$$/, '$1'), 
     23  version       : "$LastChangedRevision$".replace(/^[^:]*:\s*(.*)\s*\$$/, '$1'), 
    2524  developer     : "The Xinha Core Developer Team", 
    26   developer_url : "$HeadURL:http://svn.xinha.webfactional.com/trunk/modules/InsertImage/insert_image.js $".replace(/^[^:]*:\s*(.*)\s*\$$/, '$1'), 
     25  developer_url : "$HeadURL$".replace(/^[^:]*:\s*(.*)\s*\$$/, '$1'), 
    2726  sponsor       : "", 
    2827  sponsor_url   : "", 
     
    3130 
    3231function InsertImage(editor) { 
    33 }                                       
     32        this.editor = editor; 
     33        var cfg = editor.config; 
     34        var self = this; 
    3435 
    35 // Called when the user clicks on "InsertImage" button.  If an image is already 
    36 // there, it will just modify it's properties. 
    37 Xinha.prototype._insertImage = function(image) 
    38 { 
    39   var editor = this;  // for nested functions 
    40   var outparam; 
    41   if ( typeof image == "undefined" ) 
    42   { 
    43     image = this.getParentElement(); 
    44     if ( image && image.tagName.toLowerCase() != 'img' ) 
    45     { 
    46       image = null; 
    47     } 
     36   editor.config.btnList.insertimage[3] = function() { self.show(); } 
    4837  } 
    4938   
    50   var base; 
    51   if ( typeof editor.config.baseHref != 'undefined' && editor.config.baseHref !== null ) { 
    52     base = editor.config.baseHref; 
     39InsertImage.prototype._lc = function(string) { 
     40        return Xinha._lc(string, 'Xinha'); 
     41}; 
     42 
     43InsertImage.prototype.onGenerateOnce = function() 
     44{ 
     45        InsertImage.loadAssets(); 
     46}; 
     47 
     48InsertImage.loadAssets = function() 
     49{ 
     50        var self = InsertImage; 
     51        if (self.loading) return; 
     52        self.loading = true; 
     53        Xinha._getback(_editor_url + 'modules/InsertImage/dialog.html', function(getback) { self.html = getback; self.dialogReady = true; }); 
     54        Xinha._getback(_editor_url + 'modules/InsertImage/pluginMethods.js', function(getback) { eval(getback); self.methodsReady = true; }); 
     55}; 
     56InsertImage.prototype.onUpdateToolbar = function() 
     57{  
     58  if (!(InsertImage.dialogReady && InsertImage.methodsReady)) 
     59        { 
     60          this.editor._toolbarObjects.insertimage.state("enabled", false); 
    5361  } 
    54   else { 
    55     var bdir = window.location.toString().split("/"); 
    56     bdir.pop(); 
    57     base = bdir.join("/"); 
    58   } 
     62  else this.onUpdateToolbar = null; 
     63}; 
    5964   
    60   if ( image ) 
     65InsertImage.prototype.prepareDialog = function() 
    6166  { 
    62     function getSpecifiedAttribute(element,attribute) 
    63     { 
    64       var a = element.attributes; 
    65       for (var i=0;i<a.length;i++) 
    66       { 
    67         if (a[i].nodeName == attribute && a[i].specified) 
    68         { 
    69           return a[i].value; 
    70         } 
    71       } 
    72       return ''; 
    73   } 
    74   /* if you want to understand why the above function is required, uncomment the two lines below and launch InsertImage in both Mozilla & IE with an image selected that hath neither value set and compare the results 
    75   alert(image.vspace +' '+ image.getAttribute('vspace') + ' ' + image.getAttribute('vspace',2) + ' ' + getSpecifiedAttribute(image,'vspace') ); 
    76     alert(image.hspace +' '+ image.getAttribute('hspace') + ' ' + image.getAttribute('hspace',2) + ' ' + getSpecifiedAttribute(image,'hspace') ); 
    77   */ 
    78   outparam = 
    79     { 
    80       f_base   : base, 
    81       f_url    : this.stripBaseURL(image.getAttribute('src',2)), // the second parameter makes IE return the value as it is set, as opposed to an "interpolated" (as MSDN calls it) value 
    82       f_alt    : image.alt, 
    83       f_border : image.border, 
    84       f_align  : image.align, 
    85       f_vert   : getSpecifiedAttribute(image,'vspace'), 
    86       f_horiz  : getSpecifiedAttribute(image,'hspace'), 
    87       f_width  : image.width, 
    88       f_height : image.height 
    89     }; 
    90   } 
    91   else{ 
    92     outparam = 
    93     { 
    94       f_base   : base, 
    95       f_url    : ""       
    96     }; 
    97   } 
     67        var self = this; 
     68        var editor = this.editor; 
    9869   
    99   Dialog( 
    100     editor.config.URIs.insert_image, 
    101     function(param) 
    102     { 
    103       // user must have pressed Cancel 
    104       if ( !param ) 
    105       { 
     70        var dialog = this.dialog = new Xinha.Dialog(editor, InsertImage.html, 'Xinha',{width:410}) 
     71        // Connect the OK and Cancel buttons 
     72        dialog.getElementById('ok').onclick = function() {self.apply();} 
     73 
     74        dialog.getElementById('cancel').onclick = function() { self.dialog.hide()}; 
     75 
     76        dialog.getElementById('preview').onclick = function() {  
     77          var f_url = dialog.getElementById("f_url"); 
     78          var url = f_url.value; 
     79          var base = dialog.getElementById("f_base").value; 
     80          if (!url) { 
     81            alert(dialog._lc("You must enter the URL")); 
     82            f_url.focus(); 
    10683        return false; 
    10784      } 
    108       var img = image; 
    109       if ( !img ) 
     85          dialog.getElementById('ipreview').src = Xinha._resolveRelativeUrl(base, url); 
     86          return false; 
     87        } 
     88        this.dialog.onresize = function () 
    11089      { 
    111         if ( Xinha.is_ie ) 
    112         { 
    113           var sel = editor.getSelection(); 
    114           var range = editor.createRange(sel); 
    115           editor._doc.execCommand("insertimage", false, param.f_url); 
    116           img = range.parentElement(); 
    117           // wonder if this works... 
    118           if ( img.tagName.toLowerCase() != "img" ) 
    119           { 
    120             img = img.previousSibling; 
     90                 
     91                 
     92                var newHeightForPreview =  
     93                parseInt(this.height,10)  
     94                - this.getElementById('h1').offsetHeight  
     95                - this.getElementById('buttons').offsetHeight 
     96                - this.getElementById('inputs').offsetHeight  
     97                - parseInt(this.rootElem.style.paddingBottom,10); // we have a padding at the bottom, gotta take this into acount 
     98                 
     99                 
     100                this.getElementById("ipreview").style.height = ((newHeightForPreview > 0) ? newHeightForPreview : 0) + "px"; // no-go beyond 0 
     101                 
     102                this.getElementById("ipreview").style.width = this.width - 2   + 'px'; // and the width 
     103 
    121104          } 
    122         } 
    123         else 
    124         { 
    125           img = document.createElement('img'); 
    126           img.src = param.f_url; 
    127           editor.insertNodeAtSelection(img); 
    128           if ( !img.tagName ) 
    129           { 
    130             // if the cursor is at the beginning of the document 
    131             img = range.startContainer.firstChild; 
    132           } 
    133         } 
    134       } 
    135       else 
    136       { 
    137         img.src = param.f_url; 
    138       } 
    139  
    140       for ( var field in param ) 
    141       { 
    142         var value = param[field]; 
    143         switch (field) 
    144         { 
    145           case "f_alt": 
    146             if (value) 
    147               img.alt = value; 
    148             else 
    149               img.removeAttribute("alt"); 
    150             break; 
    151           case "f_border": 
    152             if (value) 
    153               img.border = parseInt(value || "0"); 
    154             else 
    155               img.removeAttribute("border"); 
    156             break; 
    157           case "f_align": 
    158             if (value) 
    159               img.align = value; 
    160             else 
    161               img.removeAttribute("align"); 
    162             break; 
    163           case "f_vert": 
    164             if (value != "") 
    165               img.vspace = parseInt(value || "0"); 
    166             else 
    167               img.removeAttribute("vspace"); 
    168             break; 
    169           case "f_horiz": 
    170             if (value != "") 
    171               img.hspace = parseInt(value || "0"); 
    172             else 
    173               img.removeAttribute("hspace"); 
    174             break; 
    175           case "f_width": 
    176             if (value) 
    177               img.width = parseInt(value || "0"); 
    178             else 
    179               img.removeAttribute("width"); 
    180             break; 
    181           case "f_height": 
    182             if (value) 
    183               img.height = parseInt(value || "0"); 
    184             else 
    185               img.removeAttribute("height"); 
    186             break; 
    187         } 
    188       } 
    189     }, 
    190     outparam); 
     105        this.dialogReady = true; 
    191106}; 
  • trunk/modules/InsertTable/insert_table.js

    r1001 r1044  
    1313    --      This copyright notice MUST stay intact for use. 
    1414    -- 
    15     --  This is the standard implementation of the Xinha.prototype._insertTable method, 
    16     --  which provides the functionality to insert an image in the editor. 
     15    --  This is the Xinha standard implementation of a table insertion plugin 
    1716    -- 
    18     --  he file is loaded as a special plugin by the Xinha Core when no alternative method (plugin) is loaded. 
     17    --  The file is loaded by the Xinha Core when no alternative method (plugin) is loaded. 
    1918    -- 
    2019    -- 
     
    3635 
    3736function InsertTable(editor) { 
    38 }                                       
     37        this.editor = editor; 
     38        var cfg = editor.config; 
     39        var self = this; 
    3940 
    40 Xinha.prototype._insertTable = function() 
     41        editor.config.btnList.inserttable[3] = function() { self.show(); } 
     42      } 
     43 
     44InsertTable.prototype._lc = function(string) { 
     45        return Xinha._lc(string, 'Xinha'); 
     46}; 
     47 
     48 
     49InsertTable.prototype.onGenerateOnce = function() 
    4150{ 
    42   var sel = this.getSelection(); 
    43   var range = this.createRange(sel); 
    44   var editor = this;    // for nested functions 
    45   Dialog( 
    46     editor.config.URIs.insert_table, 
    47     function(param) 
    48     { 
    49       // user must have pressed Cancel 
    50       if ( !param ) 
    51       { 
    52         return false; 
    53       } 
    54       var doc = editor._doc; 
    55       // create the table element 
    56       var table = doc.createElement("table"); 
    57       // assign the given arguments 
     51        InsertTable.loadAssets(); 
     52}; 
     53InsertTable.loadAssets = function() 
     54{ 
     55        var self = InsertTable; 
     56        if (self.loading) return; 
     57        self.loading = true; 
     58        Xinha._getback(_editor_url + 'modules/InsertTable/dialog.html', function(getback) { self.html = getback; self.dialogReady = true; }); 
     59        Xinha._getback(_editor_url + 'modules/InsertTable/pluginMethods.js', function(getback) { eval(getback); self.methodsReady = true; }); 
     60}; 
    5861 
    59       for ( var field in param ) 
    60       { 
    61         var value = param[field]; 
    62         if ( !value ) 
    63         { 
    64           continue; 
    65         } 
    66         switch (field) 
    67         { 
    68           case "f_width": 
    69             table.style.width = value + param.f_unit; 
    70           break; 
    71           case "f_align": 
    72             table.align = value; 
    73           break; 
    74           case "f_border": 
    75             table.border = parseInt(value, 10); 
    76           break; 
    77           case "f_spacing": 
    78             table.cellSpacing = parseInt(value, 10); 
    79           break; 
    80           case "f_padding": 
    81             table.cellPadding = parseInt(value, 10); 
    82           break; 
    83         } 
    84       } 
    85       var cellwidth = 0; 
    86       if ( param.f_fixed ) 
    87       { 
    88         cellwidth = Math.floor(100 / parseInt(param.f_cols, 10)); 
    89       } 
    90       var tbody = doc.createElement("tbody"); 
    91       table.appendChild(tbody); 
    92       for ( var i = 0; i < param.f_rows; ++i ) 
    93       { 
    94         var tr = doc.createElement("tr"); 
    95         tbody.appendChild(tr); 
    96         for ( var j = 0; j < param.f_cols; ++j ) 
    97         { 
    98           var td = doc.createElement("td"); 
    99           // @todo : check if this line doesnt stop us to use pixel width in cells 
    100           if (cellwidth) 
    101           { 
    102             td.style.width = cellwidth + "%"; 
    103           } 
    104           tr.appendChild(td); 
    105           // Browsers like to see something inside the cell (&nbsp;). 
    106           td.appendChild(doc.createTextNode('\u00a0')); 
    107         } 
    108       } 
    109       if ( Xinha.is_ie ) 
    110       { 
    111         range.pasteHTML(table.outerHTML); 
    112       } 
    113       else 
    114       { 
    115         // insert the table 
    116         editor.insertNodeAtSelection(table); 
    117       } 
    118       return true; 
    119     }, 
    120     null 
    121   ); 
     62InsertTable.prototype.onUpdateToolbar = function() 
     63{  
     64  if (!(InsertTable.dialogReady && InsertTable.methodsReady)) 
     65        { 
     66          this.editor._toolbarObjects.inserttable.state("enabled", false); 
     67        } 
     68        else this.onUpdateToolbar = null; 
    12269}; 
     70 
     71InsertTable.prototype.prepareDialog = function() 
     72{ 
     73        var self = this; 
     74        var editor = this.editor; 
     75 
     76        var dialog = this.dialog = new Xinha.Dialog(editor, InsertTable.html, 'Xinha',{width:400}) 
     77        // Connect the OK and Cancel buttons 
     78        dialog.getElementById('ok').onclick = function() {self.apply();} 
     79        dialog.getElementById('cancel').onclick = function() { self.dialog.hide()}; 
     80   
     81        this.borderColorPicker = new Xinha.colorPicker.InputBinding(dialog.getElementById('border_color')); 
     82 
     83        this.dialog.onresize = function () 
     84        { 
     85                this.getElementById("layout_fieldset").style.width =(this.width / 2) + 50 + 'px'; 
     86    this.getElementById("spacing_fieldset").style.width =(this.width / 2) - 120 + 'px';  
     87        } 
     88 
     89        this.dialogReady = true; 
     90}; 
  • trunk/modules/InternetExplorer/InternetExplorer.js

    r1001 r1044  
    147147   html = html.replace(/(<script|<!--)/i,"&nbsp;$1"); 
    148148    
     149   // We've got a workaround for certain issues with saving and restoring 
     150   // selections that may cause us to fill in junk span tags.  We'll clean 
     151   // those here 
     152   html = html.replace(/<span[^>]+id="__InsertSpan_Workaround_[a-z]+".*?>([\s\S]*?)<\/span>/i,"$1"); 
     153    
    149154   return html; 
    150155} 
     
    154159   // remove space added before first script on the page 
    155160   html = html.replace(/&nbsp;(\s*)(<script|<!--)/i,"$1$2"); 
     161 
     162   // We've got a workaround for certain issues with saving and restoring 
     163   // selections that may cause us to fill in junk span tags.  We'll clean 
     164   // those here 
     165   html = html.replace(/<span[^>]+id="__InsertSpan_Workaround_[a-z]+".*?>([\s\S]*?)<\/span>/i,"$1"); 
    156166    
    157167   return html; 
     
    441451Xinha.prototype.restoreSelection = function(savedSelection) 
    442452{ 
     453  // In order to prevent triggering the IE bug mentioned below, we will try to 
     454  // optimize by not restoring the selection if it happens to match the current 
     455  // selection. 
     456  var range = this.createRange(this.getSelection()); 
     457 
     458  // We can't compare two selections that come from different documents, so we 
     459  // must make sure they're from the same document. 
     460  var findDoc = function(el) 
     461  { 
     462    for (var root=el; root; root=root.parentNode) 
     463    { 
     464      if (root.tagName.toLowerCase() == 'html') 
     465      { 
     466        return root.parentNode; 
     467      } 
     468    } 
     469    return null; 
     470  } 
     471 
     472  if (findDoc(savedSelection.parentElement()) == findDoc(range.parentElement())) 
     473  { 
     474    if ((0 == range.compareEndPoints('StartToStart',savedSelection)) && 
     475        (0 == range.compareEndPoints('EndToEnd',savedSelection))) 
     476    { 
     477      // The selection hasn't moved, no need to restore. 
     478      return; 
     479    } 
     480  } 
     481 
    443482  try { savedSelection.select() } catch (e) {}; 
     483  range = this.createRange(this.getSelection()); 
     484  if (range.parentElement() != savedSelection.parentElement()) 
     485  { 
     486    // IE has a problem with selections at the end of text nodes that 
     487    // immediately precede block nodes. Example markup: 
     488    // <div>Text Node<p>Text in Block</p></div> 
     489    //               ^ 
     490    // The problem occurs when the cursor is after the 'e' in Node. 
     491 
     492    var solution = editor.config.selectWorkaround || 'InsertSpan'; 
     493    switch (solution) 
     494    { 
     495      case 'SimulateClick': 
     496        // Try to get the bounding box of the selection and then simulate a 
     497        // mouse click in the upper right corner to return the cursor to the 
     498        // correct location. 
     499 
     500        // No code yet, fall through to InsertSpan 
     501      case 'InsertSpan': 
     502        // This workaround inserts an empty span element so that we are no 
     503        // longer trying to select a text node, 
     504        var parentDoc = findDoc(savedSelection.parentElement()); 
     505 
     506        // A function used to generate a unique ID for our temporary span. 
     507        var randLetters = function(count) 
     508        { 
     509          // Build a list of 26 letters. 
     510          var Letters = ''; 
     511          for (var index = 0; index<26; ++index) 
     512          { 
     513            Letters += String.fromCharCode('a'.charCodeAt(0) + index); 
     514          } 
     515 
     516          var result = ''; 
     517          for (var index=0; index<count; ++index) 
     518          { 
     519            result += Letters.substr(Math.floor(Math.random()*Letters.length + 1), 1); 
     520          } 
     521          return result; 
     522        } 
     523 
     524        // We'll try to find a unique ID to use for finding our element. 
     525        var keyLength = 1; 
     526        var tempId = '__InsertSpan_Workaround_' + randLetters(keyLength); 
     527        while (parentDoc.getElementById(tempId)) 
     528        { 
     529          // Each time there's a collision, we'll increase our key length by 
     530          // one, making the chances of a collision exponentially more rare. 
     531          keyLength += 1; 
     532          tempId = '__InsertSpan_Workaround_' + randLetters(keyLength); 
     533        } 
     534 
     535        // Now that we have a uniquely identifiable element, we'll stick it and 
     536        // and use it to orient our selection. 
     537        savedSelection.pasteHTML('<span id="' + tempId + '"></span>'); 
     538        var tempSpan = parentDoc.getElementById(tempId); 
     539        savedSelection.moveToElementText(tempSpan); 
     540        savedSelection.select(); 
     541        break; 
     542      case 'JustificationHack': 
     543        // Setting the justification on an element causes IE to alter the 
     544        // markup so that the selection we want to make is possible. 
     545        // Unfortunately, this can force block elements to be kicked out of 
     546        // their containing element, so it is not recommended. 
     547 
     548        // Set a non-valid character and use it to anchor our selection. 
     549        var magicString = String.fromCharCode(1); 
     550        savedSelection.pasteHTML(magicString); 
     551        savedSelection.findText(magicString,-1); 
     552        savedSelection.select(); 
     553 
     554        // I don't know how to find out if there's an existing justification on 
     555        // this element.  Hopefully, you're doing all of your styling outside, 
     556        // so I'll just clear.  I already told you this was a hack. 
     557        savedSelection.execCommand('JustifyNone'); 
     558        savedSelection.pasteHTML(''); 
     559        break; 
     560      case 'VisiblePrompt': 
     561      default: 
     562        // This method will insert a little box character to hold our selection 
     563        // in the desired spot.  We're depending on the user to see this ugly 
     564        // box and delete it themselves. 
     565        var magicString = String.fromCharCode(1); 
     566        savedSelection.pasteHTML(magicString); 
     567        savedSelection.findText(magicString,-1); 
     568        savedSelection.select(); 
     569    } 
     570  } 
    444571} 
    445572 
     
    449576 * 
    450577 * @param node DomNode  
    451  * @param pos  Set to a numeric position inside the node to collapse the cursor here if possible.  
    452  */ 
    453   
    454 Xinha.prototype.selectNodeContents = function(node, pos) 
     578 * @param collapseToStart A boolean that, when supplied, says to collapse the selection. True collapses to the start, and false to the end. 
     579 */ 
     580  
     581Xinha.prototype.selectNodeContents = function(node, collapseToStart) 
    455582{ 
    456583  this.focusEditor(); 
    457584  this.forceRedraw(); 
    458585  var range; 
    459   var collapsed = typeof pos == "undefined" ? true : false; 
     586  var collapsed = typeof collapseToStart == "undefined" ? true : false; 
    460587  // Tables and Images get selected as "objects" rather than the text contents 
    461588  if ( collapsed && node.tagName && node.tagName.toLowerCase().match(/table|img|input|select|textarea/) ) 
     
    467594  { 
    468595    range = this._doc.body.createTextRange(); 
     596    if (3 == node.nodeType) 
     597    { 
     598      // Special handling for text nodes, since moveToElementText fails when 
     599      // attempting to select a text node 
     600 
     601      // Since the TextRange has a quite limited API, our strategy here is to 
     602      // select (where possible) neighboring nodes, and then move our ranges 
     603      // endpoints to be just inside of neighboring selections. 
     604      if (node.parentNode) 
     605      { 
     606        range.moveToElementText(node.parentNode); 
     607      } else 
     608      { 
     609        range.moveToElementText(this._doc.body); 
     610      } 
     611      var trimmingRange = this._doc.body.createTextRange(); 
     612 
     613      // In rare situations (mostly html that's been monkeyed about with by 
     614      // javascript, but that's what we're doing) there can be two adjacent 
     615      // text nodes.  Since we won't be able to handle these, we'll have to 
     616      // hack an offset by 'move'ing the number of characters they contain. 
     617      var texthackOffset = 0; 
     618      var borderElement=node.previousSibling; 
     619      for (; borderElement && (1 != borderElement.nodeType); borderElement = borderElement.previousSibling) 
     620      { 
     621        if (3 == borderElement.nodeType) 
     622        { 
     623          // IE doesn't count '\r' as a character, so we have to adjust the offset. 
     624          texthackOffset += borderElement.nodeValue.length-borderElement.nodeValue.split('\r').length-1; 
     625        } 
     626      } 
     627      if (borderElement && (1 == borderElement.nodeType)) 
     628      { 
     629        trimmingRange.moveToElementText(borderElement); 
     630        range.setEndPoint('StartToEnd', trimmingRange); 
     631      } 
     632      if (texthackOffset) 
     633      { 
     634        // We now need to move the selection forward the number of characters 
     635        // in all text nodes in between our text node and our ranges starting 
     636        // border. 
     637        range.moveStart('character',texthackOffset); 
     638      } 
     639 
     640      // Youpi!  Now we get to repeat this trimming on the right side. 
     641      texthackOffset = 0; 
     642      borderElement=node.nextSibling; 
     643      for (; borderElement && (1 != borderElement.nodeType); borderElement = borderElement.nextSibling) 
     644      { 
     645        if (3 == borderElement.nodeType) 
     646        { 
     647          // IE doesn't count '\r' as a character, so we have to adjust the offset. 
     648          texthackOffset += borderElement.nodeValue.length-borderElement.nodeValue.split('\r').length-1; 
     649          if (!borderElement.nextSibling) 
     650          { 
     651            // When a text node is the last child, IE adds an extra selection 
     652            // "placeholder" for the newline character.  We need to adjust for 
     653            // this character as well. 
     654            texthackOffset += 1; 
     655          } 
     656        } 
     657      } 
     658      if (borderElement && (1 == borderElement.nodeType)) 
     659      { 
     660        trimmingRange.moveToElementText(borderElement); 
     661        range.setEndPoint('EndToStart', trimmingRange); 
     662      } 
     663      if (texthackOffset) 
     664      { 
     665        // We now need to move the selection backward the number of characters 
     666        // in all text nodes in between our text node and our ranges ending 
     667        // border. 
     668        range.moveEnd('character',-texthackOffset); 
     669      } 
     670      if (!node.nextSibling) 
     671      { 
     672        // Above we performed a slight adjustment to the offset if the text 
     673        // node contains a selectable "newline".  We need to do the same if the 
     674        // node we are trying to select contains a newline. 
     675        range.moveEnd('character',-1); 
     676      } 
     677    } 
     678    else 
     679    { 
    469680    range.moveToElementText(node); 
    470     //(collapsed) && range.collapse(pos); 
     681    } 
     682  } 
     683  if (typeof collapseToStart != "undefined") 
     684  { 
     685    range.collapse(collapseToStart); 
     686    if (!collapseToStart) 
     687    { 
     688      range.moveStart('character',-1); 
     689      range.moveEnd('character',-1); 
     690    } 
    471691  } 
    472692  range.select(); 
  • trunk/modules/Opera/Opera.js

    r1001 r1044  
    576576 * 
    577577 * @param node DomNode  
    578  * @param pos  Set to a numeric position inside the node to collapse the cursor here if possible.  
    579  */ 
    580   
    581 Xinha.prototype.selectNodeContents = function(node, pos) 
     578 * @param collapseToStart A boolean that, when supplied, says to collapse the selection. True collapses to the start, and false to the end. 
     579 */ 
     580  
     581Xinha.prototype.selectNodeContents = function(node, collapseToStart) 
    582582{ 
    583583  this.focusEditor(); 
    584584  this.forceRedraw(); 
    585585  var range; 
    586   var collapsed = typeof pos == "undefined" ? true : false; 
     586  var collapsed = typeof collapseToStart == "undefined" ? true : false; 
    587587  var sel = this.getSelection(); 
    588588  range = this._doc.createRange(); 
     
    595595  { 
    596596    range.selectNodeContents(node); 
    597     //(collapsed) && range.collapse(pos); 
    598597  } 
    599598  sel.removeAllRanges(); 
    600599  sel.addRange(range); 
     600  if (typeof collapseToStart != "undefined") 
     601  { 
     602    if (collapseToStart) 
     603    { 
     604      sel.collapse(range.startContainer, range.startOffset); 
     605    } else 
     606    { 
     607      sel.collapse(range.endContainer, range.endOffset); 
     608    } 
     609  } 
    601610}; 
    602611   
  • trunk/modules/WebKit/WebKit.js

    r1001 r1044  
    574574 * 
    575575 * @param node DomNode  
    576  * @param pos  Set to a numeric position inside the node to collapse the cursor here if possible.  
    577  */ 
    578   
    579 Xinha.prototype.selectNodeContents = function(node, pos) 
     576 * @param collapseToStart A boolean that, when supplied, says to collapse the selection. True collapses to the start, and false to the end. 
     577 */ 
     578  
     579Xinha.prototype.selectNodeContents = function(node, collapseToStart) 
    580580{ 
    581581  this.focusEditor(); 
    582582  this.forceRedraw(); 
    583583  var range; 
    584   var collapsed = typeof pos == "undefined" ? true : false; 
     584  var collapsed = typeof collapseToStart == "undefined" ? true : false; 
    585585  var sel = this.getSelection(); 
    586586  range = this._doc.createRange(); 
     
    593593  { 
    594594    range.selectNodeContents(node); 
    595     //(collapsed) && range.collapse(pos); 
    596595  } 
    597596  sel.removeAllRanges(); 
    598597  sel.addRange(range); 
     598  if (typeof collapseToStart != "undefined") 
     599  { 
     600    if (collapseToStart) 
     601    { 
     602      sel.collapse(range.startContainer, range.startOffset); 
     603    } else 
     604    { 
     605      sel.collapse(range.endContainer, range.endOffset); 
     606    } 
     607  } 
    599608}; 
    600609   
     
    685694Xinha.prototype.isKeyEvent = function(event) 
    686695{ 
    687   return event.type == "keypress"; 
     696  return event.type == "keydown"; 
    688697} 
    689698 
Note: See TracChangeset for help on using the changeset viewer.