Changeset 11586

Show
Ignore:
Timestamp:
28.08.2008 23:29:43 (3 months ago)
Author:
sys
Message:

textPrim : navigation avec les tableaux

Location:
trunk/Wsp_Modeling/spaces/gen/modelBuilder/bs.doss/sm_textPrim/xedUi
Files:
2 modified

Legend:

Unmodified
Added
Removed

  • trunk/Wsp_Modeling/spaces/gen/modelBuilder/bs.doss/sm_textPrim/xedUi/static/textBase.xbl.xml

    r11584 r11586  
    7373                                                        return (vClasses[pNode.nodeName].type==1) ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP; 
    7474                                                }, false); 
    75                                 this.fHTMLEditor.selectionController.setSelectionFlags(1); //Ne sélectionne que le texte. 
     75                                //this.fHTMLEditor.selectionController.setSelectionFlags(1); //Ne sélectionne que le texte : impossible plus de navigation inter-lignes ! 
    7676                                try { 
    7777                                        if(! this.isTagHidden) this.fHTMLEditor.QueryInterface(Components.interfaces.nsIEditorStyleSheets).addOverrideStyleSheet(this.fUrlCssShowTag); 
    … …  
    13381338                                        } 
    13391339                                        this.fHTMLEditor.selection.collapse(vNode, 0); 
     1340                                ]]></body> 
     1341                        </method> 
     1342                        <!--  
     1343                        Gère l'entrée du caret d'un noeud par la gauche (pFromStart=true) ou par la droite (en mode LTR, l'inverse en RTL).  
     1344                        --> 
     1345                        <method name="moveCaretIn"> 
     1346                                <parameter name="pNode"/> 
     1347                                <parameter name="pFromStart"/> 
     1348                                <body><![CDATA[ 
     1349                                        switch(this.fClasses[pNode.nodeName].type) { 
     1350                                        case 10 : //text 
     1351                                                this.fHTMLEditor.selection.collapse(pNode, pFromStart ? 0 : pNode.data.length); 
     1352                                                break; 
     1353                                        case 1 : //objectLeaf 
     1354                                        case 9 : //BR 
     1355                                        case 8 : //externalBlock 
     1356                                                this.moveCaretOut(pNode, ! pFromStart); 
     1357                                                break; 
     1358                                        case 2 : //textLeaf 
     1359                                        case 3 : //style 
     1360                                        case 4 : //inlineContainer 
     1361                                                var vCh = pFromStart ? pNode.firstChild : pNode.lastChild; 
     1362                                                if(vCh && vCh.nodeType==3) this.moveCaretIn(vCh, pFromStart); 
     1363                                                else { 
     1364                                                        //On impose un noeud texte au début et à la fin d'un bloc éditable inline. 
     1365                                                        var vText = pNode.insertBefore(this.fHTMLEditor.document.createTextNode(""), pFromStart ? pNode.firstChild : null); 
     1366                                                        this.fHTMLEditor.selection.collapse(vText, 0); 
     1367                                                } 
     1368                                                break; 
     1369                                        case 5 : //paraBlock 
     1370                                        case 7 : //textBlock 
     1371                                                if(pFromStart) { 
     1372                                                        var vCh = pNode.firstChild; 
     1373                                                        if(vCh && vCh.nodeType==3) this.moveCaretIn(vCh, pFromStart); 
     1374                                                        else { 
     1375                                                                //On impose un noeud texte au début d'un para. 
     1376                                                                var vText = pNode.insertBefore(this.fHTMLEditor.document.createTextNode(""), pNode.firstChild); 
     1377                                                                this.fHTMLEditor.selection.collapse(vText, 0); 
     1378                                                        } 
     1379                                                } else { 
     1380                                                        var vBr = pNode.lastChild; 
     1381                                                        if(!vBr || vBr.nodeName != "BR") { 
     1382                                                                vBr = pNode.appendChild(this.fHTMLEditor.document.createElement("BR")); 
     1383                                                        } 
     1384                                                        this.moveCaretOut(vBr, true); 
     1385                                                } 
     1386                                                break; 
     1387                                        case 6 : //structure 
     1388                                                //On controle qu'il esxiste au moins un para si c'est un container de para. 
     1389                                                if(this.fClasses[pNode.nodeName].isParaParent) { 
     1390                                                        var vCh = pNode.firstChild; 
     1391                                                        while(vCh) { 
     1392                                                                var vChType = this.fClasses[vCh.nodeName].type; 
     1393                                                                if(vChType < 5 || vChType > 8) { 
     1394                                                                        //crasse, on néttoie (BR de moz, text...) 
     1395                                                                        pNode.removeChild(vCh); 
     1396                                                                        vCh = pNode.firstChild; 
     1397                                                                } else  break; 
     1398                                                        } 
     1399                                                        if( ! vCh) this.insertParaBlock(pNode, 0); 
     1400                                                } 
     1401                                                //on enchaine comme le case 0, donc pas de break ! 
     1402                                        case 0 : //hors contexte 
     1403                                                //On cherche le block éditable. 
     1404                                                var vNext = pFromStart ? pNode.firstChild || pNode.nextSibling : pNode.lastChild || pNode.previousSibling; 
     1405                                                if(vNext) this.moveCaretIn(vNext, pFromStart); 
     1406                                                else { 
     1407                                                        this.moveCaretOut(pNode, ! pFromStart); 
     1408                                                } 
     1409                                                break; 
     1410                                        } 
     1411                                ]]></body> 
     1412                        </method> 
     1413                        <!--  
     1414                        Gère la sortie du caret d'un noeud par la gauche (pThrowStart=true) ou par la droite (en mode LTR, l'inverse en RTL).  
     1415                        --> 
     1416                        <method name="moveCaretOut"> 
     1417                                <parameter name="pNode"/> 
     1418                                <parameter name="pThrowStart"/> 
     1419                                <body><![CDATA[ 
     1420                                        var vNext = pThrowStart ? pNode.previousSibling : pNode.nextSibling; 
     1421                                        switch(this.fClasses[pNode.nodeName].type) { 
     1422                                        case 10 : //text 
     1423                                                if(vNext) this.moveCaretIn(vNext, ! pThrowStart); 
     1424                                                else this.moveCaretOut(pNode.parentNode, pThrowStart); 
     1425                                                break; 
     1426                                        case 1 : //objectLeaf 
     1427                                        case 2 : //textLeaf 
     1428                                        case 3 : //style 
     1429                                        case 4 : //inlineContainer 
     1430                                                if(vNext && vNext.nodeType==3) this.moveCaretIn(vNext, ! pThrowStart); 
     1431                                                else { 
     1432                                                        //On impose des noeuds textes autour de ces noeuds inline 
     1433                                                        var vText = pNode.parentNode.insertBefore(this.fHTMLEditor.document.createTextNode(""), pThrowStart ? pNode : pNode.nextSibling); 
     1434                                                        this.fHTMLEditor.selection.collapse(vText, 0); 
     1435                                                } 
     1436                                                break; 
     1437                                        case 9 : //BR 
     1438                                                if(! pThrowStart) this.moveCaretOut(pNode.parentNode, pThrowStart); 
     1439                                                else { 
     1440                                                        if(vNext && vNext.nodeType==3) this.moveCaretIn(vNext, ! pThrowStart); 
     1441                                                        else { 
     1442                                                                //On impose un noeud texte avant le BR. 
     1443                                                                var vText = pNode.parentNode.insertBefore(this.fHTMLEditor.document.createTextNode(""), pNode); 
     1444                                                                this.fHTMLEditor.selection.collapse(vText, 0); 
     1445                                                        } 
     1446                                                } 
     1447                                                break; 
     1448                                        case 5 : //paraBlock 
     1449                                                if(vNext) this.moveCaretIn(vNext, ! pThrowStart); 
     1450                                                else { 
     1451                                                        this.moveCaretOut(pNode.parentNode, pThrowStart); 
     1452                                                } 
     1453                                                break; 
     1454                                        case 6 : //structure 
     1455                                        case 7 : //textBlock 
     1456                                        case 8 : //externalBlock 
     1457                                                var vClass = this.fClasses[pNode.nodeName]; 
     1458                                                if(vClass.isParaSibling && ( ! vNext || this.fClasses[vNext.nodeName].type != 5)) { 
     1459                                                        //On force l'insertion d'un para 
     1460                                                        vNext = this.insertParaBlock(pNode.parentNode, this.getOffsetInParent(pNode) + (pThrowStart ? 0 : 1) ); 
     1461                                                } 
     1462                                                if(vNext) this.moveCaretIn(vNext, ! pThrowStart); 
     1463                                                else this.moveCaretOut(pNode.parentNode, pThrowStart); 
     1464                                                break; 
     1465                                        case 0 : //on ne fait rien ! 
     1466                                                break; 
     1467                                        } 
    13401468                                ]]></body> 
    13411469                        </method> 
    … …  
    24482576                                        if(vModif == this.fHTMLEditor.getModificationCount()) { 
    24492577                                                //Bug Gecko 1.8 : le deleteSelection n'a pas d'effet suite à un état instable à l'init. Cet état se restabilise par une insertion de caractères 
    2450                                                 //xed.debug("Hack deleteSelection() Failed"); 
     2578                                                xed.debug("Hack deleteSelection() doit etre maintenu !!!!"); 
    24512579                                                if(vSel.isCollapsed) { 
    24522580                                                        this.fHTMLEditor.QueryInterface(Components.interfaces.nsIPlaintextEditor).insertText("a"); 
    … …  
    33843512                                        case 0 : break; 
    33853513                                        case 27 : //event.DOM_VK_ESCAPE  
     3514                                                event.preventDefault(); 
     3515                                                event.cancelBubble = false; 
     3516                                                break; 
    33863517                                        case 9 : //event.DOM_VK_TAB 
    33873518                                                event.preventDefault(); 
    33883519                                                event.cancelBubble = false; 
     3520                                                if( ! vSel.isCollapsed) vSel.collapseToStart(); 
     3521                                                var vTD = vSel.anchorNode; 
     3522                                                while(vTD && vTD.nodeName != "TD") vTD = vTD.parentNode; 
     3523                                                if(vTD) { 
     3524                                                        var vNextTD = vTD.nextSibling; 
     3525                                                        while(vNextTD && vNextTD.nodeName != "TD") vNextTD = vNextTD.nextSibling; 
     3526                                                        if(vNextTD) { 
     3527                                                                this.moveCaretIn(vNextTD, true); 
     3528                                                        } else { 
     3529                                                                var vTR = vTD.parentNode; 
     3530                                                                var vNextTR = vTR.nextSibling; 
     3531                                                                while(vNextTR && vNextTR.nodeName != "TR") vNextTR = vNextTR.nextSibling; 
     3532                                                                if(vNextTR) { 
     3533                                                                        vNextTD = vNextTR.firstChild; 
     3534                                                                        while(vNextTD && vNextTD.nodeName != "TD") vNextTD = vNextTD.nextSibling; 
     3535                                                                        if(vNextTD) this.moveCaretIn(vNextTD, true); 
     3536                                                                } else { 
     3537                                                                        var vTableEditor = this.fHTMLEditor.QueryInterface(Components.interfaces.nsITableEditor); 
     3538                                                                        vTableEditor.insertTableRow(1, true); 
     3539                                                                        this.moveCaretIn(vTR.nextSibling, true); 
     3540                                                                } 
     3541                                                        } 
     3542                                                } 
    33893543                                                break; 
    33903544                                        case 13 : //event.DOM_VK_RETURN  
    … …  
    35013655                                                if(this.fHTMLEditor.inlineSpellChecker && this.fHTMLEditor.inlineSpellChecker.HandleNavigationEvent) this.fHTMLEditor.inlineSpellChecker.HandleNavigationEvent(event, true, 0); 
    35023656                                                var vNode = vRange.startContainer; 
    3503                                                 //xed.debug("Left:::"+vNode.localName+" - "+vRange.startOffset); 
    3504                                                 var vType = this.fClasses[vNode.nodeName].type; 
    3505                                                 var vStart = (vRange.startOffset == 0); 
    3506                                                 if( vType == 10 && ! vStart) { 
    3507                                                         //On est au milieu d'un texte 
    3508                                                 } else if(vType==6 || vType==0) { 
    3509                                                         //On est au dessus d'un block ou en début d'un block, on cherche le précédent block éditable 
    3510                                                         var vPrev = this.getPreviousEditableBlock(vNode, vRange.startOffset); 
    3511                                                         if(vPrev) vSel.collapse(vPrev, vPrev.childNodes.length-1); //On se place avant le BR 
     3657                                                var vOffset = vRange.startOffset; 
     3658                                                if(vOffset==0) { 
     3659                                                        this.moveCaretOut(vNode, true); 
    35123660                                                        event.preventDefault(); 
     3661                                                } else if(vNode.nodeType==3){ 
     3662                                                        //On est au milieu d'un texte, comportement standard 
    35133663                                                } else { 
    3514                                                         //On est au début d'un noeud texte, ou entre 2 éléments. 
    3515                                                         var vPrevNode = (vType == 10) ? vNode.previousSibling : vStart ? null : vNode.childNodes.item(vRange.startOffset - 1); 
    3516                                                         while(vPrevNode && vPrevNode.nodeType==3 && vPrevNode.data.length == 0) { 
    3517                                                                 vPrevNode = vPrevNode.previousSibling; 
    3518                                                         } 
    3519                                                         if(vPrevNode == null) { 
    3520                                                                 if(vType >= 5 && vType < 9) { 
    3521                                                                         var vPrev = this.getPreviousEditableBlock(vNode, 0); 
    3522                                                                         if(vPrev) vSel.collapse(vPrev, vPrev.childNodes.length-1); //On se place avant le BR 
    3523                                                                 } else { 
    3524                                                                         vNode = vNode.parentNode; 
    3525                                                                         var vTypeParent = this.fClasses[vNode.nodeName].type; 
    3526                                                                         if(vTypeParent == 0 || vTypeParent >= 5) { 
    3527                                                                                 //On est à la racine d'un block, 
    3528                                                                                 var vPrev = this.getPreviousEditableBlock(vNode, 0); 
    3529                                                                                 if(vPrev) vSel.collapse(vPrev, vPrev.childNodes.length-1); //On se place avant le BR 
    3530                                                                         } else { 
    3531                                                                                 vPrevNode = vNode.previousSibling; 
    3532                                                                                 if(vPrevNode == null || vPrevNode.nodeType==1) { 
    3533                                                                                         var vText = vNode.parentNode.insertBefore(this.fHTMLEditor.document.createTextNode(""), vNode); 
    3534                                                                                         vSel.collapse(vText, 0); 
    3535                                                                                 } else { 
    3536                                                                                         vSel.collapse(vPrevNode, vPrevNode.data.length); 
    3537                                                                                 } 
    3538                                                                         } 
    3539                                                                 } 
    3540                                                         } else if(vPrevNode.nodeType == 3) { 
    3541                                                                 vSel.collapse(vPrevNode, vPrevNode.data.length - 1); 
    3542                                                         } else if(this.fClasses[vPrevNode.nodeName].type==1){ 
    3543                                                                 //ObjectLeaf 
    3544                                                                 this.focusObject(vPrevNode); 
    3545                                                         } else { 
    3546                                                                 vNode = vPrevNode; 
    3547                                                                 vPrevNode = vNode.lastChild; 
    3548                                                                 if(vPrevNode == null || vPrevNode.nodeType==1) { 
    3549                                                                         var vText = vNode.insertBefore(this.fHTMLEditor.document.createTextNode(""), null); 
    3550                                                                         vSel.collapse(vText, 0); 
    3551                                                                 } else { 
    3552                                                                         vSel.collapse(vPrevNode, vPrevNode.data.length); 
    3553                                                                 } 
    3554                                                         } 
     3664                                                        this.moveCaretIn(vNode.childNodes.item(vOffset - 1), false); 
    35553665                                                        event.preventDefault(); 
    35563666                                                } 
    … …  
    35613671                                                if(this.fHTMLEditor.inlineSpellChecker && this.fHTMLEditor.inlineSpellChecker.HandleNavigationEvent) this.fHTMLEditor.inlineSpellChecker.HandleNavigationEvent(event, true, 0); 
    35623672                                                var vNode = vRange.endContainer; 
    3563                                                 //xed.debug("Right:::"+vNode.localName+" - "+vRange.endOffset); 
    3564                                                 var vType, vEnd; 
     3673                                                var vOffset = vRange.endOffset; 
    35653674                                                if(vNode.nodeType == 3)  { 
    3566                                                         vType = 10; 
    3567                                                         vEnd = (vRange.endOffset == vNode.data.length); 
     3675                                                        if(vOffset == vNode.data.length) { 
     3676                                                                this.moveCaretOut(vNode, false); 
     3677                                                                event.preventDefault(); 
     3678                                                        } else { 
     3679                                                                //On est au milieu d'un texte, comportement standard 
     3680                                                        } 
    35683681                                                } else { 
    3569                                                         vType = this.fClasses[vNode.nodeName].type; 
    3570                                                         vEnd = (vRange.endOffset == vNode.childNodes.length); 
    3571                                                 } 
    3572                                                 if( vType == 10 && ! vEnd) { 
    3573                                                         //On est au milieu d'un texte 
    3574                                                 } else if(vType==6 || vType==0) { 
    3575                                                         //On est au dessus d'un block ou en fin d'un block, on cherche le prochain block éditable 
    3576                                                         var vNext = this.getNextEditableBlock(vNode, vRange.endOffset); 
    3577                                                         if(vNext) vSel.collapse(vNext, 0); 
     3682                                                        if(vOffset == vNode.childNodes.length) { 
     3683                                                                this.moveCaretOut(vNode, false); 
     3684                                                        } else { 
     3685                                                                this.moveCaretIn(vNode.childNodes.item(vOffset), true); 
     3686                                                        } 
    35783687                                                        event.preventDefault(); 
    3579                                                 } else { 
    3580                                                         //On est à la fin d'un noeud texte, on cherche le noeud suivant 
    3581                                                         var vNextNode = (vType == 10) ? vNode.nextSibling : vEnd ? null : vNode.childNodes.item(vRange.endOffset); 
    3582                                                         while(vNextNode && vNextNode.nodeType==3 && vNextNode.data.length == 0) { 
    3583                                                                 vNextNode = vNextNode.nextSibling; 
    3584                                                         } 
    3585                                                         if(vNextNode == null) { 
    3586                                                                 if(vType >= 5 && vType < 9) { 
    3587                                                                         var vNext = this.getNextEditableBlock(vNode, 0); 
    3588                                                                         if(vNext) vSel.collapse(vNext, 0); 
    3589                                                                 } else { 
    3590                                                                         vNode = vNode.parentNode; 
    3591                                                                         var vTypeParent = this.fClasses[vNode.nodeName].type; 
    3592                                                                         if(vTypeParent == 5 || vTypeParent == 7) { 
    3593                                                                                 //On est à la racine d'un block 
    3594                                                                                 var vNext = this.getNextEditableBlock(vNode, 0); 
    3595                                                                                 if(vNext) vSel.collapse(vNext, 0); 
    3596                                                                         } else { 
    3597                                                                                 vNextNode = vNode.nextSibling; 
    3598                                                                                 if(vNextNode == null || vNextNode.nodeType==1) { 
    3599                                                                                         var vText = vNode.parentNode.insertBefore(this.fHTMLEditor.document.createTextNode(""), vNextNode); 
    3600                                                                                         vSel.collapse(vText, 0); 
    3601                                                                                 } else { 
    3602                                                                                         vSel.collapse(vNextNode, 0); 
    3603                                                                                 } 
    3604                                                                         } 
    3605                                                                 } 
    3606                                                         } else if(vNextNode.localName == "BR"){ 
    3607                                                                 //Fin d'un block 
    3608                                                                 var vNext = this.getNextEditableBlock(vNode, 0); 
    3609                                                                 if(vNext) vSel.collapse(vNext, 0); 
    3610                                                         } else if(vNextNode.nodeType == 3) { 
    3611                                                                 vSel.collapse(vNextNode, 1); 
    3612                                                         } else if(this.fClasses[vNextNode.nodeName].type==1){ 
    3613                                                                 //ObjectLeaf 
    3614                                                                 this.focusObject(vNextNode); 
    3615                                                         } else { 
    3616                                                                 vNode = vNextNode; 
    3617                                                                 vNextNode = vNode.firstChild; 
    3618                                                                 if(vNextNode == null || vNextNode.nodeType == 1) { 
    3619                                                                         var vText = vNode.insertBefore(this.fHTMLEditor.document.createTextNode(""), vNextNode); 
    3620                                                                         vSel.collapse(vText, 0); 
    3621                                                                 } else { 
    3622                                                                         vSel.collapse(vNextNode, 0); 
    3623                                                                 } 
    3624                                                         } 
    3625                                                         event.preventDefault(); 
    3626                                                         break; 
    36273688                                                } 
    36283689                                                break; 
    … …  
    38803941                                this.resetDrag(); 
    38813942                        ]]></handler> 
     3943                        <!-- 
    38823944                        <handler event="DOMNodeRemoved"><![CDATA[ 
    38833945                                var vRemoved = event.target; 
    … …  
    38873949                                        var vParentClass = this.fClasses[vParent.nodeName]; 
    38883950                                        if(vParentClass.type==6 && vParentClass.isParaParent) { 
    3889                                                 //On est dans un set de structure. 
    3890                                                 xed.debug("ParaParent empty!!!!!!!!!"); 
     3951                                                //On est dans un set de para. 
     3952                                                //this.insertParaBlock(vParent, 0); 
    38913953                                        } 
    38923954                                } 
    38933955                        ]]></handler> 
     3956                        --> 
    38943957                </handlers> 
    38953958        </binding> 

  • trunk/Wsp_Modeling/spaces/gen/modelBuilder/bs.doss/sm_textPrim/xedUi/text.xbl.xml.xsl

    r11584 r11586  
    146146}; 
    147147vClasses.HEAD = vClasses.HTML; 
     148vClasses.TITLE = vClasses.HTML; 
    148149vClasses["#document"] = vClasses.HTML; 
    149150vClasses["#document-fragment"] = vClasses.HTML;