Bonjour,
Bien on va pouvoir construire quelque chose.
Pour te répondre je vzais d'abord utiliser les citations pour les points où un accord est nécessaire pour aller plus avant :
Je ne sais si j’ai bien compris ton problème
Plutôt : le problème que je pose problème pour lequel dans le cas que je formule (simplifié mais qui pose le cœur du problème) auquel je n'ai pas de bonne réponse (du moins pas trop compliquée, et j'ai développé une bibliothèque plutôt importante de fonctions qui ne marche pas encore bien, voir plus loin).
Le problème est que tu n’as pas de moyen fiable de faire ouvrir la page à coup sûr dans un onglet plutôt qu’une fenêtre séparée,
. Si, par défaut si l'on n'indique pas de paramètre dans window.open un onglet sera ouvert et non une fenêtre (
1 2
| window.open(url,name,'') // ouvre un onglet pour l'url
window.open("",name,"") // renvoie un handle -ref de l'onglet name existant ou ouvre un nouvel onglet portant le nom name et blank, l'instruction précédente le peuplera |
)
Ainsi, si tu veux fixer un même comportement dans toutes les situations, il faut passer par du code avec de plus grands privilèges, et du coup tu ne développes plus une application mais une extension. Je n’ai pas l’impression que ce soit ton objectif.
Tout à fait exact, en particulier les bibliothèques "tabs" ne peuvent être utilisées alors qu'elle le seront avec des plugings.
Concernant les fermetures intempestives ou accidentelles, tu peux utiliser des requêtes en arrière-plan pour sauvegarder sur un serveur l’état dans lequel est l’application, à intervalles réguliers. Mais cela nécessite que tes utilisateurs soient enregistrés.
Oui mais pas les références aux onglets ouverts, juste la table des noms et autres data utiles (voir le problème plus loin)
Donc, non, pour le stockage ça marche très bien j'utilise une combinaison de cookie et localstorage pour sauver l'environnement de l'application en cas de crash (par contre je rappelle que les références aux onglets ne peuvent être sauvées, cela n'aurait d'ailleurs aucun sens sauver un pointeur...).
Par contre pour le courant, je passe tout en mémoire en utilisant les handles de fenêtres ouvertes (j'ai pour tous les onglets ouverts un seul pointeur vers l'objet "tabs"). Tant que la fenêtre d'origine reste ouverte elle est maitre mais quand elle est fermée elle repasse le bébé à la suivante (toute modification est donc visible depuis tous les onglets). J'envisage par la suite d'utiliser Ajax pour sauver cet environnement et pouvoir le retrouver sur toute machine utilisée. Cela touche aussi d'autres données telles l'historique de visite et des marque pages et annotations (un Diigo dédié et intégré en quelque sorte). Par contre le contrôle et la restauration d'environnement reste impossible, voir plus loin.
Concernant la duplication d’onglets, une fenêtre nommée résous la moitié du problème. Pour l’autre moitié on peut imaginer faire passer des informations d’une fenêtre à l’autre en utilisant postMessage.
Malheureusement non, je parle de la duplication faite soit par le navigateur soit par un plugin, ils génèrent dans ce cas un doublon, eh oui. Seule la dernière sera visible et l'autre restera masquée (le handle mémorisé accèdera à la fenêtre référencée mais window.open('',<name>,'') renverra le handle de la copie... (constaté une fois j'ai abandonné la gestion des doublons, je devrai refaire un test pour confirmer, mais aussi développer une démo tant il y a de St Thomas ici, mais qui ne sont pas assez intéressés pour vérifier par eux-mêmes). Il semble que les noms soient stockés dans une liste (comme je fais) et que la recherche s'arrête à la première rencontrée (laissant le seconde masquée). On peut d'ailleurs forcer une fenêtre à se renommer pour vérifier l'existence d'un doublon par exemple, mais ça on en sait pas bien faire...). Pour ce qui est du partage de données j'utilise en fonctionnement courant directement javascript en conservant la liste des pointeurs vers les onglets, cela fonctionne parfaitement (si l'onglet n'a pas été détruit entre temps..., et ça c'est un crash de navigateur, donc une gestion d'erreur est indispensable).
De la même manière, tu peux afficher la table des matières dans un panneau latéral (comme dans les lecteurs PDF).
Oui, c'est ce que je fais (il n'y a pas de plugin WordPress qui le fasse, il me faudrait un acolyte pour le produire), j'ai un ensemble assez important (entre 3 et 4000 lignes de code) qui génère en php la table des matières et une bibliothèque locale qui gère le contenu de volets latéraux (nombre illimité avec des widgets, dont la table des matières, mais aussi la liste des onglets ouverts, l'historique etc...). La première difficulté a été d'ailleurs (ce que ne fait aucun plugin gestionnaire de sommaire de Wordpress) de créer un sommaire qui comprend les liens "externes" pour les "sections" qui ne sont pas la section courante dans un document découpé (Ceci a obligé à développer une bibliothèque complète pour gérer tous les clicks sur liens).
Le problème des index et autres tables des matières est qu'il est commun, le plus souvent, à plusieurs onglets ouverts (quand on clique un lien du texte vers lui-même mais dans un autre section en demande "nouvel onglet"). Tout cela impose la gestion d'un objet "tabs" commun a tous les onglets qui contient à la fois les onglets ouverts et pour lequel les références sont correctes dont l'onglet auquel on veut donner le focus par un instruction du type
<thetab_handle>.<element>.focus()
", mais aussi les onglets fermés ou "pourris".
En fait le problème absolument essentiel est l'impossibilité pratique de nettoyer et garder des références devenues invalides, et pourquoi ? Parce qu'il est impossible en l'état actuel du jeu d'instruction de vérifier si un onglet dont on a le nom (tables courante ou restaurée depuis le stockage, mais évidemment sans handle) existe ou non. Pour vérifier le seul outil est window.open("",<name>,"") qui a le défaut rédhibitoire d'ouvrir obligatoirement un nouvelle onglet si le nom n'existe pas et avec ça, non seulement on peut aller à l'encontre de la volonté de l'utilisateur (qui a pu fermer l'onglet en utilisant la "X", mais on plante la plupart des navigateurs sous Android par la répétition d'ouverture-fermeture d'onglets lors de contrôles effectués par l'application). En conséquence on ne peut pas vérifier, on peut juste ouvrir un onglet par une action volontaire de l'utilisateur.
Je suis persuadé que pour faire quelque chose de fiable il faudrait disposer de l'instruction suivante :
window.open('',<name>,"check=yes") // returns NULL si le nom n'existe pas, le handle vers l'onglet si il existe
Qui retournerait "null" si elle n'existe pas (au lieu d'ouvrir un nouvel onglet) sinon le handle de la fenêtre au lieu de l'ouverture par défaut.
En ce qui concerne la sécurité je ne vois pas quel problème cela pourrait poser, à condition que l'utilisateur prenne les précautions utiles pour protéger son système de noms, le tout en sachant que l'accès aux noms ne peut être exécuté que pour un même domaine.
Pour l'instant j'ai donc du abandonner :
- le test de doublons
- le nettoyage correct des erreurs (lors de restaurations ou lors de l'affichage de la liste) et le test d'un onglet correctement référencé mais pointant vers un onglet détruit, caché... d'où une gestion d'erreurs rigoureuse nécessaire. L'objet "tabs" permet doc de lister dans un panneau latéral les onglets ouverts ou fermés volontairement (historique), outil de navigation dans le document et optionnellement dans tout le blog, et assurant de manière annexe la gestion d'historique comme le font divers plugins et navigateurs
- la restauration correcte d'une session sur le blog (après un crash). Les onglets sont, ou non, ré-ouverts par le navigateur, mais le rapprochement de la table sauvée et de l'état du navigateur est impossible. L'utilisateur a donc à sa disposition uniquement la liste des onglets théoriquement ouverts (non contrôlée) et le click ouvrira éventuellement un doublon (néanmoins le restauration après crash avec Chrome, FireFox, Opera restaure les noms).
Le tout, de ce que j'ai écrit, constitue une bibliothèque qui reste lourde et complexe et n'offre pas la fiabilité souhaitable ni encore pour l'utilisateur l'ergonomie que je vise.
Le volume serait probablement divisé par un facteur cinq si l'instruction "window.open avec check name" existait.
J'ai déja essayé d'expliquer l'utilité de cette évolution de l'instruction "window.open" que je propose, mais je n'ai pas eu d'écho.
Je pense soumettre le sujet au développement Mozilla prochainement. A noter que cette évolution respecte une parfaite compatibilité ascendante (comportement identique en l'absence du nouveau paramètre) et qu'il n'y a que quelques lignes de code à changer sans risque d'incidences.
J'ai évidemment conscience de bâtir une application qui possède des fonctions internes d'un navigateur (onglets ouverts, historique), mais aussi des fonctions supplémentaires et constitue une bibliothèque qui peut devenir importante en tant qu'outil de développement (en JQuery à 70%).
Malheureusement de plus l'instruction window.open se comporte dans le détail de manière différente d'un navigateur à l'autre.
Sans :
- une uniformisation du comportement de la fonction (dont l'unicité des noms dans un domaine et l'accès par le nom dans un domaine quelque soit la filiation des fenêtres)
- l'instruction que je propose qui permet de tester les noms et synchroniser une table de noms et les onglets réellement ouverts
Le problème me parait inextricable, ce qui interdit le développement de toutes les fonctionnalités que j'ai évoquées.
Cordialement
Trebly
_________________________________________________________________________________________________
Note1 : le tout c'est 5000 lignes de js (200ko compressé) et 8000 pour la génération de sommaire en php (mais c'est techniquement indépendant), ceci, pour le volume de travail, sans compter les adaptations de plugins Wordpress externes qui se sont avérés nécessaires.
_________________________________________________________________________________________________
Note2 : je pense que peu de développeurs imaginent les possibilités qu'offrent le développement que j'ai amorcé et qui est très loin du spécifique.
_________________________________________________________________________________________________
Note3 : Mozilla English window.open donne des informations. J'y ai ajouté une note à propos du comportement variable des navigateurs (non encore introduite en version française). Je modifie en ajoutant cette note3. Je viens de vérifier que avec chrome (dernière version courante) la règle selon laquelle window.open("",<name>,"") renvoyait le handle du <name> dans le domaine n'est pas appliquée correctement. Chrome fonctionne toujours avec la règle de la hiérarchie d'ouverture. Seul un "ancestor" (parent) peut accéder à une fenêtre par son nom sinon un doublon (même url) est ouvert. Hors comme il est impossible de tester les doublons de noms de multiples fenêtres pourront porter le même nom et seront inaccessibles. De plus si des données sont saisies il a a un risque de confusion et d'incohérences majeur.
Partager