• Seenthis, j’ai une question (avec application à #SPIP). Est-ce qu’il existe une méthode recommandée pour indiquer, dans le code HTML, les ressources liées à la page, sans pour autant entraîner le navigateur ou le preloadeur à charger des ressources inutiles ?

    Le besoin auquel je veux répondre, c’est la possibilité d’aspirer/dupliquer un site Web sans avoir des fichiers qui manquent une fois hors ligne. En effet, j’ai régulièrement des ressources chargées dynamiquement (ne serait-ce que mes images responsive), qui ne sont pas récupérées de manière transparente par une aspiration de la page.

    Pour l’instant, je m’en sors « à la main » en ajoutant des :

    <link href… rel="a_telecharger">

    dans mes pages. Ça permet de récupérer tout ce dont j’aurai besoin hors-ligne (ou potentiellement besoin, puisque je suis en responsive, avec souvent des éléments chargés ou non).

    Mais je n’ai pas systématisé ça sur mes sites en production (et notamment pas dans les plugins qui génèrent ces pages), parce que je ne veux pas que Google m’aspire des fichiers que je ne veux pas « fabriquer » ou « utiliser » rien que pour lui (par exemple, les images responsive jamais utilisées, je préfère qu’elles ne soient pas générées pour rien), parce que je ne veux pas que navigateurs les chargent (ni les pré-chargent) alors qu’ils ne vont pas les utiliser…

    Et en gros, s’il y a une méthode connue et/ou recommandée, voir à quel point c’est une pratique à documenter/généraliser dans SPIP, pour avoir des sites qu’on peut aspirer/sauvegarder/dupliquer en statique à coup sûr.

    Note : si on va par là (et j’aimerais bien que ce soit au moins une option), il y a aussi les problèmes de noms de fichiers. Il faut que certains plugins fonctionnent systématiquement en URL « .html », et pas en interminables variables PHP (par exemple, j’utilise des choses comme {ajaxload=html}), et/ou éviter d’ajouter la date à la fin des fichiers (CSS/logos) parce que ça me pète mon aspiration…

    • Autre question liée, est-ce que je peux mettre un <link> à l’intérieur d’un <a>, du genre :

      <a href="truc.html">Le contenu usuel du lien
          <link href="maressource.jpg" rel="resource"
      </a>

      Parce que dans de nombreux cas, la fonction qui fabrique les ressources (et donc les potentiels <link> à ajouter pour les aspirer) ne sait pas si ce qu’elle va produire se trouve à l’intérieur d’une ancre (je pense évidemment aux images responsive, dont le fonctionnement est totalement indifférent au fait d’être à l’intérieur d’un lien hypertexte).

    • Bon, je me lance avec une mise à jour assez conséquence de mon #plugin #SPIP image_responsive :
      http://zone.spip.org/trac/spip-zone/browser/_plugins_/image_responsive

      On peut activer un define dans mes_options.php :

      define("_SPIP_LIER_RESSOURCES", true);

      (noter le choix d’un nom lié à SPIP et non au plugin, histoire de le réutiliser).

      Avec cette option, le plugin ajoute au code HTML généré une ribambelle de liens (qui n’affichent rien) de cette forme :

      <link href="truc.jpg" rel="attachment" property="url">

      (je suppose qu’on peut trouver mieux, mais comme pas trop de réponses à la question ci-dessus… et au moins avec ça le validateur-go-home arrête de m’engueuler).

      De cette façon, quand on aspire la page, on aspire aussi toutes les ressources qui seront nécessaire pour travailler en local.

      Avec image_responsive, évidemment, ça ne peut fonctionner que quand on définit une ou plusieurs tailles autorisées (ce qui est de toute façon un bon principe à la base).

  • Quelqu’un aurait un plugin à me recommander (ou un mode d’emploi) pour que je puisse mettre du code juste pour un article par exemple ? Je suis en train de passer mon site sous Wordpress et je fais des articles où je parle par exemple de slideshow, ou autres choses avec du jQuery et je ne voudrais pas surcharger le header du site dans son ensemble avec les fichiers js. Juste utiliser le js dans l’article concerné... Merci d’avance pour vos lumières ! J’ai essayé celui-là, mais je dois mal m’y prendre (http://css-javascript-toolbox.com/cjte-developer) #wordpress #plugin #code #js #jquery

  • Introduction d’un système de précalcul dans mon #plugin #SPIP image_responsive :
    http://zone.spip.org/trac/spip-zone/browser/_plugins_/image_responsive

    On peut ajouter dans mes_options.php :

    define("_IMAGE_RESPONSIVE_CALCULER", true);

    Dans ce cas, à chaque fois qu’on a utilisé image_responsive en indiquant des tailles prédéterminées, le plugin va fabriquer les images responsive précalculées en /local/cache-responsive. Depuis le début, le plugin ne précalcule pas les images, mais se contente de retourner vers un script /action/image_responsive.php qui fabrique/cache/sert les images à la volée.

    Avantage du pré-calcul :
    – si utilisé sur tout le site, on pourra décider de désactiver le script action, et ainsi éviter de se faire remplir le cache local par un crawler qui déciderait de demander toutes les tailles (de 1 à 1000 par exemple) de toutes les images du site…
    – le gros avantage immédiat c’est de servir des fichiers image directement depuis Apache, et non plus des scripts PHP qui expédient des images ; je pense que ça allège le serveur, et que c’est sans doute plus rapide si on n’est pas derrière Varnish – mais j’ignore absolument dans quelles proportions.

    Inconvénients du pré-calcul :
    – toutes les tailles autorisées d’image sont immédiatement fabriquées ; une fois que toutes les pages du site sont calculées, on atteint illico la taille max utilisée par les images responsive (sans le pré-calcul, seules les images réellement réclamées par des visiteurs sont fabriquées). Sur un gros site avec beaucoup d’images, cette taille est potentiellement phénoménale…
    – les pages du site sont beaucoup plus lourdes à calculer la première fois, puisqu’il faut précalculer toutes les tailles de toutes les images (principe des filtres graphiques). Sur un site très graphique, ça peut être très important.

  • Je continue avec mon #plugin #SPIP image_responsive :
    http://zone.spip.org/trac/spip-zone/browser/_plugins_/image_responsive

    Dans la variable des proportions d’image, il est désormais possible d’utiliser des valeurs en pourcentage. Par exemple : 71%x0 va recadrer l’image à 71% de sa largeur, en conservant sa hauteur.

    |image_responsive{
            588/840/1280/1920,
            0,
            0,
            (max-width: 420px)/(min-width:421px) and (max-width: 700px)/(min-width:701px) and (max-width:1280px)/,
            71%x0/83%x0/0x0/0x0
    }
  • Deflating #polygons in #leaflet
    http://oliverroick.de/code/2015/leaflet-deflate.html

    A common problem with dynamic web maps is the way polygons and lines are displayed in lower zoom levels. At some point, these geometries become too small to be noticeable on the #map. A straight forward solution is to replace the polygon or line with a marker at the feature’s centroid position. The new Leaflet #plugin Leaflet.Deflate does just that.

    https://github.com/oliverroick/Leaflet.Deflate

  • Grosse améliation de mon #plugin #SPIP image_responsive : il intègre désormais la gestion de la direction artistique, avec prise en compte (si l’on a envie) du centre d’intérêt automatique de l’image (avec le plugin centre_image :
    http://zone.spip.org/trac/spip-zone/browser/_plugins_/image_responsive

    Il y a maintenant une variable supplémentaire (optionnelle), qui doit d’utiliser avec les valeurs de mediaqueries de la variable précédente. Par exemple :

    [(#FICHIER|image_responsive{
            600/800/1400,
            0,
            0,
            /(min-width:801px) and (max-width:1000px)/(min-width: 1001px),
            1x1xfocusx2 / 3x4xtop / 4x2
    })]

    Ici on a donc :
    – soit une image de 600 pixels de large, 800 pixels de large ou 1400 pixels de large
    – pas de lazyload (0)
    – pas d’alignement vertical (0)
    – l’image de 800 est utilisée pour les écrans de 801 à 1000 pixels de large, l’image de 1400 pixels pour les écrans de plus de 1001 pixels (OK, c’est pas dément comme choix…)

    La nouvelle variable contient 3 valeurs séparées par des / (avec ou sans espaces), qui correspondent aux valeurs de mediaqueries précédentes. Chaque valeur est de ce type :
    largeurxhauteurxalignementxzoom

    Les valeurs alignement et zoom sont optionnelles. Ces quatre valeurs correspondent aux variables de la fonction image_proportions :

    Du coup :
    – 1x1xfocusx2, image retaillée au carré (1x1), avec centrage sur le point d’intérêt (focus), et zoom de valeur 2 ; utilisé par défaut ;
    – 3x4xtop, image taillée en quatre tiers verticalement, découpe sur le haut de l’aime, et pas de zoom ; utilisé pour les écrans de 801 à 1000 pixels ;
    – 4x2, image deux fois plus large que haute, recadrage au centre par défaut, pas de zoom ; utilisé pour les écrans de plus de 1001 pixels de large.

    Par ailleurs, ici on a indiqué 3 valeurs correspondant aux 3 media queries. Mais on peut aussi n’utiliser qu’une seule valeur de recadrage, qui sera alors systématiquement utilisée pour toutes les tailles (et cela fonctionnera aussi, dans cas, même si on n’utilise pas les mediaqueries).

    Plusieurs intérêts :
    – pouvoir utiliser des formats d’images différents selon les tailles d’affichage, et/ou orientations d’écran,
    – affiner ces recadrage en utilisant le centre d’intérêt automatique de l’image,
    – pouvoir zoomer dans l’image selon la taille d’affichage, éventuellement en centrant sur le point d’intérêt de l’image.

  • Évolutions de mon #plugin #SPIP image_responsive
    http://zone.spip.org/trac/spip-zone/browser/_plugins_/image_responsive

    – v5.1 : transparent pour l’utilisateur (sauf bug…), lorsqu’on utilise les fonctionnalités avancées qui fabriquent un srcset ou des <picture><source>, ce n’est plus mon javascript perso qui va gérer les remplacements d’images, mais le polyfill picturefill.js, plus puissant. (C’est en préparation à l’automatisation de l’ajout de la « direction artistique », qui demandera à utiliser les <source> au lieu d’un simple remplacement d’image proportionnelle ;

    – v5.2 : ça devient carrément marrant : ajout d’une quatrième variable à image_proportions, qui indique un niveau de zoom. Par exemple :

    [(#FICHIER|image_proportions{200,200,focus,2})]

    si cette valeur (ici : 2) est supérieure à 1 (en pratique : 1.2, 1.5…), alors le recadrage se fera en zoomant à l’intérieur de l’image. Si on a indiqué comme ici « focus », alors on zoome vers le centre d’intérêt de l’image
    (on n’est pas obligé de faire ça sur « focus », ça fonctionne aussi avec les autres types de recadrage).

    • Pour tester :

      <html>
      <body>

      <BOUCLE_documents(DOCUMENTS){0,10}{par hasard}{inverse}{extension=jpg}>
      <div>
              <div style="position: relative; display: inline-block;">
              [(#FICHIER|image_reduire{200})]
             
                      <div style="position: absolute; margin-left: -7px; margin-top: -7px; left: [(#FICHIER|centre_image_x|mult{100})]%; top: [(#FICHIER|centre_image_y|mult{100})]%">
                      <img src="[(#CHEMIN{imgs/croix.png})]">
                      </div>
             
              </div>
              [(#FICHIER|image_proportions{0,0,focus,2}|image_reduire{200})]
              [(#FICHIER|image_proportions{200,200,focus,2}|image_reduire{200})]
              [(#FICHIER|image_proportions{200,200,center, 2}|image_reduire{200})]
      </div>
      </BOUCLE_documents>

      </body>
      </html>
    • (Il faut donc maintenant que j’intègre tout ça directement dans la fonction |image_responsive. Ensuite il faudra bien qu’on ait une fonction pour corriger les centres d’intérêt des images, parce qu’avec le zoom, les erreurs deviennent bien plus pénibles.)

  • J’ai commencé un nouveau #plugin pour #SPIP : centre_image
    http://zone.spip.org/trac/spip-zone/browser/_plugins_/centre_image

    Après installation (PHP 5 au minimum : on a besoin de la fonction image_filter), on se retrouve avec 3 filtres qui s’appliquent à des images :
    centre_image($fichier) retourne un tableau array{x,y} du centre d’intérêt de l’image,
    centre_image_x($fichier) et centre_image_y($fichier) sont plus directement utilisables dans les squelettes, puisqu’ils retournent indépendamment la valeur x et la valeur y de la fonction précédente.

    x et y sont des valeurs entre 0 et 1 (x à 0 à gauche, 1 à droite ; y à 0 en haut, 1 en bas), qui donnent les coordonnées du « point d’intérêt » de l’image, calculé automatiquement sur le principe de l’« entropie ».

    Quelques éclaircissements :

    – un problème classique quand on recarde une image automatiquement, c’est que selon la nature de l’image, on n’obtient pas un recadrage pertinent (têtes coupées parce qu’on a visé trop bas, statue hors cadre parce qu’on a coupé au centre…) ; du coup, je viens déjà d’introduire un réglage automatique dans la fonction image_proportions livrée dans le plugin image_responsive (version 5.0 à l’instant) :
    ``image_proportions($img, 16, 9, "focus")``
    là où l’on pouvait déjà indiquer top, left… si on indique focus, alors l’image sera recadrée en fonction du résultat du nouveau plugin ;

    – une difficulté que je veux régler, c’est l’utilisation de grandes images en fond de page : quand on écrit la tritraille dessus, on fait dans le systématique, et du coup ce n’est pas forcément le plus heureux ; avec ce plugin, on peut décider que si le point d’intérêt de l’image est à gauche, alors on installera la titraille à droite sur l’image (et inversement) ;

    – une orientation que je veux développer pour le plugin image_responsive (d’où le passage en version 5) : faciliter et automatiser la « direction artistique », c’est-à-dire la possibilité d’afficher une version zommée sur le point d’intérêt de l’image quand on l’affiche en petit ; si je connais le « point d’intérêt » avec l’autre plugin, une partie du boulot est déjà fait…

    – le gros hic, c’est que la méthode fonctionne couci-couça (mais vu le but, je pense que c’est très acceptable : avant on coupait ou on plaçait les éléments carrément au pif)… la prochaine étape du développement va consister à donner des outils pour que le webmestre puisse, d’un clic, « forcer » le placement du point d’intérêt.

    • Un petit squelette pour tester sur des documents pris au hasard sur ton site :

      <html>
      <body>

      <BOUCLE_documents(DOCUMENTS){0,10}{par hasard}{inverse}{extension=jpg}>
      <div style="position: relative; float: left;">
      [(#FICHIER|image_reduire{200})]

              <div style="position: absolute; margin-left: -7px; margin-top: -7px; left: [(#FICHIER|centre_image_x|mult{100})]%; top: [(#FICHIER|centre_image_y|mult{100})]%">
              <img src="[(#CHEMIN{imgs/croix.png})]">
              </div>

      </div>
      </BOUCLE_documents>

      </body>
      </html>
    • @speciale : comme tu le vois, si tu passes par |mult{100}%, tu obtiens bien des pourcentages. J’ai préféré la vieille méthode du pseudo-pourcentage en stockant directement la valeur entre 0 et 1 (0.35 est égal à 35%), parce qu’avec des vrais pourcentages, il faudrait que je stocke aussi le symbole % dans la variable, et là c’est super-lourd derrière (si tu veux faire des manipulations mathématiques, tu dois alors d’abord virer le symbole de pourcentage…)

    • Sympa, je l’ai testé avec le petit squelette suivant et une sélection d’images déposées dans squelettes/images :

      <h1>dans ta face !</h1>
      <BOUCLE_ls(DATA){source glob,  #CHEMIN{images}/*.jpg}>
      [(#VALEUR|image_reduire{150})]
      [(#VALEUR|image_proportions{1,1,center}|image_reduire{150})]
      [(#VALEUR|image_proportions{1,1,focus}|image_reduire{150})]
      <hr />
      </BOUCLE_ls>

      J’ai bien fait attention à utiliser des images où « le centre d’intérêt » était déporté dans un coin et jamais au centre, et le résultat était souvent bon. Le squelette de test affiche l’image originale réduite à 150 px, puis la même « recadrée » au centre et enfin une version recadrée #automagiquement sur le focus. Du coup, cela permet de mettre en évidence l’action de l’argument focus par rapport à un recadrage au centre.

      Idée, je pense que ça serait sympa d’intégrer la fonction image_proportions dans le plugin filtres images du core (elle y a sa place amha). Et puis, cela permettrait aux personnes qui le souhaitent de jouer avec centre_image sans installer image_responsive. Tu en penses quoi @arno ?

      #spip_blog #merci :)

    • yep @b_b et @arno, je suis d’accord, je l’ai dit plusieurs fois : ça commence à faire un certain temps maintenant qu’on a nos fonctions d’images dans un plugin bien propre séparé du core (et fourni en dist), donc pour moi TOUTES les fonctions d’images intéressantes devraient s’y trouver, une fois qu’on les a un peu testé. D’après moi ça n’a pas de sens d’avoir plusieurs plugins différents comme « conteneur » de fonctions d’images (sur la zone/contrib il y avait un plugin de fonctions supplémentaires comme ça). On balance tous les trucs utiles dans le plugin commun.

      @nidal j’avais commencé un tout début de truc, mais jamais eu le temps de le faire en entier parce que sur mon temps libre j’essaye de ne pas coder. :)
      Mais je l’ai toujours en tête, et j’en ai même reparlé dans le cadre un projet pro cette semaine…

      Je ne pense pas que ce soit un truc énorme à faire, peut-être une idée d’atelier en plus pour la rencontre de Toulouse dans 3 semaines.

    • @b_b : je suis d’accord. La difficulté, c’est de savoir ensuite comment on continue à faire évoluer ces fonctions une fois qu’elles sont dans le core. (La dernière fois que j’ai voulu intervenir dans un plugin_dist, on m’a annulé ma modif en me renvoyant à des séries de tests à valider et tout et tout. Autant dire que ça me fait chier si c’est pour retourner là-dedans.)

      Après, en l’occurence, on a spip_proportions stable et bien pratique qu’on pourrait sans difficulté ajouter au core. Mais là il s’agit d’intégrer dedans la fonctionnalité « focus », qui est carrément expérimentale. Je ne sais pas trop comment on gèrerait ça.

    • @arno ça pourrait pas être géré à base de pipeline(s) ? La fonction image_proportions (générique, dans le noyau) pourrait avoir un pipeline quand on est dans le cas « focus ». Quand y a rien de spécial, ça prendrait le centre par exemple, mais un plugin pourrait s’insérer dedans et définir X et Y. Cette fonction n’aurait pas à connaître qui peut venir changer ça. Et ce serait donc au plugin centre_image de s’insérer dans le pipeline et de définir X et Y suivant sa méthode. Un truc comme ça.

      Après on peut aussi se dire qu’il n’y aura toujours qu’une seule manière de trouver un centre de manière automatique, et qu’il y ait une fonction unique (non existante par défaut) qui peut être définie (par un autre plugin donc) et quand elle est définie ça l’utilise pour sortir X et Y.

      Mais bon pipeline ou fonction unique, le principe reste le même : « image_proportions » doit juste permettre de s’y insérer (dans le cas « focus » tout du moins), en donnant l’image en question et en permettant de renvoyer un X et un Y.

    • Yo @arno, je viens de voir que tu viens de commiter un ajout pour permettre la définition explicite manuelle du focus d’une image : Allelujah ! :D

      Du coup ça correspond tout à fait au plugin « Focus » que j’avais mollement commencé et dont je parlais. Si ton plugin peut bien être utilisé de manière tout à fait autonome, c’est vraiment ça.

      Par contre je ne comprenais pas où tu stockais les coordonnées du focus. Mais après lecture, il semblerait que tu les gardes dans un fichier JSON contenant le MD5 de l’image, c’est ça ?

      Du coup, en plus d’être utilisable pour les images « spip_documents » avec l’ajout d’interface que tu as fait, c’est potentiellement utilisable aussi pour d’autres images non-"spip_documents", c’est ça ? (Bon ce sont des cas plus rares hein, mais c’est toujours bien de le savoir.)

      #merci !

    • @rastapopoulos : exactement, ça se base « bêtement » sur l’URL du fichier. Dans l’espace privé, ça récupère toutes les images qui ont un lien .hasbox et un type image/…. Et j’ai ajouté l’exclusion sur les images qui sont intégrées à l’intérieur des articles, sinon ça se met à déconner (à cause des doublons).

    • Attention : la nouvelle version réclame qu’on utilise la dernière version du plugin-dits medias, et mon plugin contient des motifs pour forcer l’affichage des images de portfolio en grand (150 pixels de large, et non plus les minuscules trucs de 60 pixels).

      C’est assez contraignant pour l’instant, en attendant qu’on modifie le comportement natif de medias (j’ai demandé à le faire ce matin, mais aucune réponse sur spip-dev).

      Dans l’interface privée, un javascript va attaquer les logos et les documents joints :

      Sur la seconde image, on voit bien la différence avec l’actuel : les vignettes sont de très bonne taille (ça donne une impression d’interface carrément plus moderne).

      Le javascript récupère chaque image, et à chacune ajoute un petit cadre vert (indiquant que le centre d’intérêt est chargé), et une croix à l’endroit du centre d’intérêt automatique.

      Si on veut corriger, c’est immédiat : on prend la croix, on la fait glisser vers le centre d’intérêt et voilà, c’est corrigé. Je vois pas comment faire plus simple.

    • Autre question : le filtre « image_recadre » du noyau sait aussi prendre en entrée un ratio maintenant ("3:2, +").
      (Et du coup image_proportions est-il d’ailleurs toujours pertinent, peut-être vaut-il mieux mutualiser puisque la fonction du noyau sait déjà le faire.)

      Mais du coup il manque le fait de pouvoir donner des pourcentages (ceux de centre_image) dans le troisième argument $position, il me semble, c’est ça ? (Car je crois que ça ne connait que top, left, etc.)

      Et un corollaire : dans ce genre de recadrage, si on donne le point de focus, c’est pour qu’il soit « à peu près » au centre une fois le recadrage terminé. Mais suivant où il est placé, ce n’est pas forcément pile au centre. S’il est proche d’un bord, ben ça doit s’arrêter au bord.

    • C’est assez contraignant pour l’instant, en attendant qu’on modifie le comportement natif de medias (j’ai demandé à le faire ce matin, mais aucune réponse sur spip-dev).

      ( je ne vois pas ton message sur spip-dev)

    • Oui, je suppose qu’il faudrait aussi améliorer image_recadre, mais encore une fois c’est une question pratique : image_proportions est chez moi et je peux le patcher instantanément. Dans le core je ne sais plus trop si j’ai le droit de patcher ou si je vais me faire jeter.

      Pour ta dernière remarque, oui c’est pris en compte : on recadrer au plus proche du centre d’intérêt, mais ça ne va pas forcément le placer au centre si ce point est près du bord. Mon code qui fait ça n’est pas d’une compacité folle, c’est parce que ça laisse la logique mathématique plus visible comme ça :-))

    • Ah et aussi en rapport : ce plugin jQuery qui recadre en javascript suivant le focus de chaque image (qu’on précise dans le code de l’image) :
      http://seenthis.net/messages/289821

      Cela peut être complémentaire pour générer moins d’images, et aussi pourquoi pas pour définir les hauteurs d’images en « em » afin d’être alignées sur la grille typo et les largeurs sur la grilles des colonnes (qui peut être en %), et donc pas toujours la même proportion suivant l’écran.

    • @rastapopoulos : j’ai un script remplir_image.js qui fait ça aussi. Mais l’avantage avec image_proportions et les nouvelles subtilités d’image_responsive (et <picture>), c’est qu’on n’attend plus sur javascript pour charger et afficher les images. Avec Chrome pour l’instant (et Firefox le mois prochain), c’est incroyablement plus réactif que quand on compte sur jQuery pour faire des calculs et des affichages.
      http://seenthis.net/messages/264068

    • @arno pour le core, logiquement, tu as le droit de patcher tant que ça ne casse rien à l’existant.

      Si on veut faire « propre », je crois qu’il y a deux méthodes pour ça :

      – Soit la fonction a une batterie de tests unitaires. Et donc tu peux modifier dans la branche stable (3.0), tester si ça renvoie toujours les bons trucs pour les anciens comportements, et si tests ok, commiter. Si on part du principe que les tests unitaires sont complets, alors tant que ça renvoie ok, toute modif peut être commitée sans danger.

      – Soit ya pas de tests, ou bien tu n’as pas le temps de comprendre comment les faire tourner (hihi). Dans ce cas, tu peux modifier dans la branche dev (3.1) ! Tu testes sur tes cas à toi (pas les tests unitaires normalisés du coup), et si tu penses que c’est bon, tu envoies en 3.1. Du coup c’est public et tu peux demander à d’autres de tester ton ajout. Si plusieurs personnes pensent que c’est bon (ou que personne ne répond pendant longtemps :D) : tu reportes ta modif dans la branche stable (3.0). Un « backport ».

      Ça ce sont les deux manières qui normalement devraient toujours marcher. Sinon c’est pas gentil. :)

      Après, au-delà, il est possible aussi de commiter directement en 3.0 sans tests unitaires, et reporter en 3.1 (c’est moins logique mais c’est logique quand on est dans un projet réel qui utilise la stable !). Là faut juste être sûr de soi, de ne rien casser.

      Enfin, mon avis purement personnel est que ce serait super que tu améliores image_recadre du noyau avec ces ajouts (notamment le fait de pouvoir lui passer les coordonnées précises), et que ça soit ainsi mutualisé dans un seul endroit (le plugin d’images du noyau, commun à tou⋅te⋅s).

    • Un truc qui me questionne : je vois que ça enregistre les coordonnées calculées ou forcées dans local/ ... du coup, si on vide le cache des images, on perd les coordonnées qu’on avait forcées à la mano en déplaçant la croix ?

      Est-ce qu’il ne vaudrait pas préférer, si on est dans le cas d’un document eregistré dans la table spip_documents, ajouter 1 ou 2 champs pour stocker les coordonnées ?

    • Là l’avantage c’est que ça marche pour n’importe quelle image, même quand c’est pas un document SPIP (les logos par exemple, mais ça pourrait être d’autres choses).

      Mais par contre oui, l’emplacement des JSON posent clairement un problème : une vraie information pérenne ne DOIT PAS se placer dans un dossier temporaire. :D

      Pour rappel, SPIP à 4 dossiers variables : 2 fixes, et 2 temporaires. Et dans le même temps : 2 accessibles, et 2 inaccessibles.

      Les noms des dossiers sont très mal choisis mais restent là par compatibilités. Mais dans le code les noms sont beaucoup plus clairs et logiques :

      – permanent_accessible : IMG
      – permanent_inaccessible : config
      – temporaire_accessible : local
      – temporaire_inaccessible : tmp

      En conséquence, les infos de positions sont permanentes, et accessibles. Et donc si on ne veut pas les enregistrer en base, mais dans des fichiers, alors elles devraient aller dans IMG, pas dans local.

    • @marcimat non non : image_recadre fait déjà les proportions (et je l’utilise régulièrement). Donc pas besoin d’ajouter une fonction pour ça à mon avis.

      Au lieu de faire |image_passe_partout|image_recadre maintenant je fais |image_reduire{taille maximum que je veux}|image_recadre{16:9,''}.

      Mais ce qu’il faudrait du coup, c’est améliorer image_recadre qu’on a déjà, pour lui intégrer la possibilité de définir le centre manuellement et précisément dans l’un de ses paramètres.

    • Ce plugin m’intéresse particulièrement en conjonction avec le plugin image_responsive, plus précisément dans ce qui était décrit dans le premier post avec la fonction image_proportion.
      Cependant,
      #FICHIER|image_proportions{16,9,"focus"}|image_responsive{320/640,1,0}
      avec ou sans guillemets à focus, ne semble rien donner de manière automatique. Si l’on définit le focus de l’image, cet argument semble inutile.
      Je suis en SPIP 3.0.20, Filtre image_responsive en 6.4.1 et Centre image en 0.5.1.

      Merci pour tous ces plugins et pour le coup de main :)

    • J’ai ajouté en SPIP 3.1, en espérant ne rien n’avoir cassé, la possibilité d’utiliser le centrage avec la fonction |image_recadre, du plugin fonctions_images qui est fourni par défaut avec SPIP

      Donc, on activant ce plugin, sans forcément avoir le plugin image_responsive, on peut utiliser des recadrages en centrant sur le point d’intérêt, de la sorte :

      [(#LOGO_ARTICLE|image_recadre{16:9, -, focus})]

      ou encore, pour avoir une taille spécifique

      [(#LOGO_ARTICLE|image_recadre{200:80, - focus}|image_reduire{200, 80})]

      Il y a aussi focus-center comme dans image_proportions.

    • J’ai une question : je viens de rajouter une invalidation du cache (http://zone.spip.org/trac/spip-zone/changeset/97747) pour pouvoir voir l’effet d’un changement du point d’intérêt immédiatement.
      Du coup, j’ai étudié un peu le code et j’ai été sidéré de voir qu’au lieu de sauvegarder dans la base, c’était un fichier .json qui était créé pour enregistrer la position du point d’intérêt.
      Qu’est-ce qui a présidé à ce choix technique ?

    • Je me suis fait une fonction sympa :

      // Permet de recadrer une image en la centrant sur son focus
      function focusimage($img, $largeur, $hauteur, $position = 'center') {
              if ((largeur($img) <= $largeur) AND (hauteur($img) <= $hauteur)) {
                      $img = image_recadre($img, "$largeur:$hauteur", '+', $position, 'transparent');
                      $img = image_recadre($img, $largeur, $hauteur, $position, 'transparent');
              } else  {
                      $img = image_recadre($img, "$largeur:$hauteur", '-', 'focus', 'transparent');
                      $img = image_reduire($img, $largeur, $hauteur, $position, 'transparent');
              }
              return $img;
      }

      Et si l’image est plus petite, elle est affichée au centre par défaut, mais on peut indiquer sa position.

    • Merci pour ce plugin qui s’avère rapidement être indispensable.
      Une chose à préciser dans une éventuelle future documentation (c’est peut-être mentionné dans le fil de discussion mais j’ai pas tout relu) : le point d’intérêt n’est pris en compte que si le filtre image_recadre est appliqué en premier à l’image.

      Ceci fonctionne :
      [(#LOGO_PATATE|image_recadre{4:3, -, focus}|image_machin|image_truc)]

      Mais pas cela :
      [(#LOGO_PATATE|image_machin|image_truc|image_recadre{4:3, -, focus})]

    • Oui et on disait avec @marcimat que peut-être ça pourrait être bien de garder en mémoire cette info au fil des modifs d’une image OU de garder en mémoire la toute première image source quand il y a une suite de filtres d’images d’affilée, et SI la dernière chose avant le « recadre » a les mêmes dimensions que l’image d’origine, alors on peut recadrer avec le même centre, même 12 filtres plus loin.

      Bon, en attendant, faut bien le mettre en premier…

  • Super amélioration de mon #plugin pour #SPIP, image_responsive :
    http://zone.spip.org/trac/spip-zone/browser/_plugins_/image_responsive

    Cette fois, j’introduis la possibilité de fabriquer le code <picture><source> complet pour complètement gérer les images responsive nativement (pour l’instant, dans Chrome).

    L’idée, c’est l’introduction d’un quatrième paramètre dans ma fonction, ce qui permet de définir les media queries correspondant à chaque taille d’image.

    Par exemple :

    [(#LOGO_ARTICLE_NORMAL
            |image_responsive{
                    0/50/100/200,
                    0,
                    0,
                    (max-width:470px)/(max-width:1009px)/
            }
    )]

    La première variable (0/50/100/200) est la liste des tailles d’images autorisées :
    – 0 n’est pas une taille d’image, ça signifie simplement qu’au chargement de la page, le <img> se fera sur rien.gif
    – ensuite on autorise des images de 50 pixels, 100 pixels, 200 pixels (donc trois tailles).

    Si on n’indique rien d’autre, on a le fonctionnement habituel du plugin : une fois la page chargée, un javascript calcule la taille de l’endroit qui contient cette image, et en fonction va appeler l’image à la bonne taille (et éventuellement en haute définition si écran haute déf.)

    La seconde variable permettrait de forcer le chargement en « lazy load ». Comme la valeur est zéro (par défaut), ce mode est désactivé. Si on avait forcé la valeur à 1, alors l’image ne serait chargée que si elle visible à l’écran (ou bientôt visible en scrollant). Ça permet, si on a envie, de ne pas charger des images qui seraient bien plus loin en bas de page. Ici, il est important de laisser à zéro, parce qu’on veut un code complet qui se charge dès avant le lancement de la page (voir en préchargement).

    La troisième variable est à zéro (par défaut). Si on met à un, alors on indique qu’on veut que les calculs se fassent sur la hauteur du conteneur, et non sur la largeur. Ici il faut laisser à zéro, je n’ai pas encore adapté mon code pour qu’il fonctionne avec les images alignées verticalement.

    La quatrième variable est la nouvelle : si on décide de l’utiliser, alors on va permettre au plugin de fabriquer le code complet qui fait fonctionner les images responsive directement en HTML5. C’est alors bien plus rapide à l’affichage, et le pré-chargement fonctionne sur ces images.

    Le code généré est le suivant :

    <picture style='padding:0;padding-bottom:63.5593220339%' class='conteneur_image_responsive_h'>
            <source media='(max-width:470px)'
                    srcset='
                            index.php?action=image_responsive&amp;img=IMG/arton5.jpg&amp;taille=50 1x,
                            index.php?action=image_responsive&amp;img=IMG/arton5.jpg&amp;taille=50&amp;dpr=2 2x
                    '>
            <source media='(max-width:1009px)'
                    srcset='
                            index.php?action=image_responsive&amp;img=IMG/arton5.jpg&amp;taille=100 1x,
                            index.php?action=image_responsive&amp;img=IMG/arton5.jpg&amp;taille=100&amp;dpr=2 2x
                    '>
            <source
                    srcset='
                            index.php?action=image_responsive&amp;img=IMG/arton5.jpg&amp;taille=200 1x,
                            index.php?action=image_responsive&amp;img=IMG/arton5.jpg&amp;taille=200&amp;dpr=2 2x
                    '>
            <img class='image_responsive' alt="" src='https://seenthis.net/rien.gif' data-src='IMG/arton5.jpg' data-l='2832' data-h='1800' data-tailles='[\&#034;50\&#034;,\&#034;100\&#034;,\&#034;200\&#034;]' />
    </picture>

    Le principe de cette variable est de contenir autant de mediaqueries qu’il y a de tailles autorisées dans la première variable, en les séparant par des slash (comme pour les tailles de la première variable). Pour rappel : le 0 ne compte pas comme une taille autorisée.

    Ici, on avait les tailles autorisées : 0/50/100/200. On a donc trois tailles autorisées. Dans les medias queries, il nous faut donc définir trois valeurs correspondant à ces tailles d’images autorisées :
    (max-width:470px)/(max-width:1009px)/

    Ce qui signifie :
    – utiliser l’image de largeur 50 dans le cas (max-width:470px)
    – utiliser celle de largeur 100 dans le cas (max-width:1009px)
    – utiliser l’image de largeur 200 dans les autres cas (par défaut donc).

    Noter le slash final, qui permet de voir qu’il y a bien une troisième valeur attendue (valeur vide).

    Le plugin fabrique donc les <source> correspondant à ces tailles, en indiquant à chaque fois l’image en définition 1x et l’image en haut définition (2x).

    Sur les navigateurs qui comprennent ça (Chrome), ça fonctionne très bien : les images sont chargées bien plus rapidement (puisqu’on n’attend plus le chargement de la page, des JS et des CSS avant de lancer le chargement des images), et le preloader est censé prendre en compte ces informations. (Et si on désactive Javascript : ça fonctionne parfaitement sur ces navigateurs…)

    Actuellement caniuse.com donne 40% des visiteurs compatibles (essentiellement : Chrome – donc c’est déjà pas rien) mais la prochaine version de Firefox va l’avoir, et vu que c’est Chrome c’est webkit, je ne vois pas pourquoi Safari traînerait encore longtemps. De toute façon, c’est un enrichissement progressif : si le navigateur ne pige pas, le plugin fonctionnera comme auparavant uniquement en Javascript. (Dommage quand même que ça ne fonctionne pas sur Safari mobile, quand même.)

  • Enrichissement du #plugin #SPIP inclure-ajaxload :
    http://zone.spip.org/trac/spip-zone/browser/_plugins_/inclure-ajaxload
    documenté ici :
    http://www.paris-beyrouth.org/tutoriaux-spip/article/plugin-inclure-ajaxload

    Je viens d’ajouter la possibilité d’utiliser les inclusions (ESI) de Varnish :
    https://www.varnish-cache.org/docs/3.0/tutorial/esi.html

    Pour cela, il suffit d’indiquer : {ajaxload=esi} et du coup cet include se fera directement au niveau de Varnish.

    Sur Flip-Zone, par exemple, j’ai des caisses entières de liens vers les articles du site (plus d’une dizaine sur chaque page), et ça devient :

    [(#INCLURE{fond=inc/lien_article}{id_article}{lang}{ajaxload=esi})]

    L’idée rigolote, c’est que le plugin balance le code alternatif en ajaxload classique si l’ESI n’est pas activé dans Varnish. Mais ce n’est pas vraiment une bonne idée de faire comme ça, parce que pour le coup je me rends compte que l’include ESI est également adapté aux includes d’entêtes (dans <head>), et que donc là l’inclusion ajax n’est pas pertinente (me semble-t-il). Faudrait peut-être prévoir une alternative plus « rustique »…

    • Cool ! je le testais à l’instant ;) mais pas en varnish … en plus court on peut écrire

      #INCLURE{fond=inc/lien_article,id_article,lang,ajaxload=esi}

      dis @arno, on présente comment du code sur seenthis ?

    • @touti : avec des backticks

      `coucou`

      et, si tu veux présenter ton code sur plusieurs lignes, tu en mets 3 au-dessus et 3 en dessous

    • Bon, il y a une grosse difficulté : les petites inclusions sont des appels SPIP basés sur var_ajax=recuperer. Et ces pages ne sont jamais mises en cache par Varnish (@fil me dit que c’est parce que dans ecrire/inc/actions.php, la fonction ajax_retour ne prévoit pas d’envoyer d’information de durée de vie du cache.

      Du coup, tel quel, mon inclusion ESI est particulièrement productive (j’ai planté Flip-Zone hier et ce matin) : au lieu d’appeler une page SPIP en cache de Varnish (et si elle ne l’est pas : un appel Apache), j’appelle une page qui contient des dizaines d’inclusions ESI qui demandent à charger des pages SPIP en var_ajax, pages qui ne sont justement pas en cache de Varnish, et déclenchent donc autant d’accès à Apache.

      Pour l’instant, tout ce que j’ai trouvé, c’est d’ajouter un réglage à la sauvage dans Varnish, au niveau vcl_fetch :

              if (req.url ~ "var_ajax=recuperer") {
                     set beresp.ttl = 3660s;
                     set beresp.http.Cache-Control = "max-age=3600";
                      set beresp.http.Vary = "Accept-Encoding";
                      remove beresp.http.X-VARNISH-TTL;
              }
  • Nouvelle version (4.0) de mon #plugin pour #SPIP, image_responsive :
    http://zone.spip.org/trac/spip-zone/browser/_plugins_/image_responsive

    Cette fois, je viens d’introduire un srcset dans l’image.

    Attention, pour l’instant, ça n’est pris en compte que si on n’a indiqué qu’une seule dimension pour l’image, par exemple :

    [(#LOGO_ARTICLE_NORMAL|image_responsive{200})]

    Dans ce cas, le logo est chargé en largeur de 200, avec un srcset pour le 1x et le 2x, c’est-à-dire qu’on a une image de taille unique, mais en simple ou double résolution (et, comme toujours avec mon plugin, la double résolution se fait avec une compression JPEG bien plus important).

    L’intérêt est, ici, que le preloader du navigateur fonctionne bien sur ce type d’images, et on n’attend plus le javascript pour charger la bonne image. Le javascript est tout de même là, parce que ce n’est pas encore compris par tous les navigateurs (50% d’adoption tout de même, notamment Safari et Chrome, prépondérants sur supports mobiles, qui représentent l’essentiel des écrans haute déf.) ; mais sur les navigateurs qui comprennent srcset, le javascript n’est plus utile dans ces cas-là.

    À terme, j’aimerais bien parvenir à passer toutes les options en srcset et picture/media, générés directement depuis mon plugin, mais pour l’instant je n’ai pas réellement de solution idéale. Un des écueils, c’est que dans mon principe, l’image haute définition ne doit pas être simplement l’image deux fois plus grande (sinon on a un JPEG deux fois plus lourd, alors qu’on est sur support mobile…), mais une version très compressée. Et il faudrait de plus introduire des mediaqueries dans l’appel de la fonction, et du coup on perd énormément de l’intérêt du truc.

  • Évolution de mon #plugin #SPIP image_responsive :
    http://zone.spip.org/trac/spip-zone/browser/_plugins_/image_responsive

    J’ai ajouté, dans la page « Admin / Vider le cache » un troisième pavé, permettant de gérer plus finement les images générées pour les besoins du responsive.

    Exemple sur un site avec des milliers d’images :

    L’idée, c’est d’essayer de faire la différence entre les images utilisées souvent (conserver le cache) et les images utilisées moins souvent (qu’on peut donc virer en priorité si on a besoin). Par approximation, je me base sur l’âge de dernier accès au fichier (fileatime() de PHP).

  • Ouf, on a lancé la semaine dernière la nouvelle version du site des Arts décoratifs :
    http://www.lesartsdecoratifs.fr

    C’est évidemment #SPIP-3 et #responsive.

    On avait réalisé la version précédente avec Mosquito en 2008, la nouvelle version reprend donc l’ancien site et l’augmente : il était donc important d’assurer autant que possible la compatibilité avec les anciens contenus, alors que graphiquement c’est radicalement différent.

    #shameless_autopromo

    • Une des nouveautés (dans mes scripts) par rapport à mes habitudes précédentes, c’est que j’ai systématisé la possibilité, pour le webmestre, de choisir des maquettes très différentes pour le texte d’un article, via le #plugin Compositions :
      http://contrib.spip.net/Compositions-2-et-3

      Sur mes sites habituels, la maquette standard est :
      – une colonne principe (large, gros texte) à gauche, et une petite colonne d’annexes (droite, petit texte) à droite :
      http://www.lesartsdecoratifs.fr/francais/bibliotheque/expositions/les-livres-pour-enfants-pendant-la
      http://www.lesartsdecoratifs.fr/francais/ateliers-du-carrousel/les-ateliers/pendant-les-vacances-scolaires

      Désormais, pour chaque article, le webmestre peut choisir :
      – une seule colonne de texte (c’est la nouvelle présentation préférée)
      http://www.lesartsdecoratifs.fr/francais/ateliers-du-carrousel/presentation/reperes-chronologiques
      – deux colonnes égales (pour textes courts uniquement, genre deux paragraphes l’un à côté de l’autre)
      – trois colonnes égales
      http://www.lesartsdecoratifs.fr/francais/qui-sommes-nous/pratique/3-sites-a-paris
      – une seule colonne alignée à gauche
      – une seule colonne alignée à droite

      À la base, il s’agit de répondre au besoin de rythmer les longforms, en adoptant des présentations différentes dans les différentes parties du texte. Malheureusement, au lancement du site, on n’a pas de « grande » exposition avec des tonnes de contenu, exploitant cette possibilité. Mais ça va venir… :-)

    • J’ai développé pour le site de subtiles modifications #responsive des raccourcis d’images de SPIP (les très classiques <img>, <doc>, <emb>), utilisés dans les quelques milliers de pages de l’ancienne version du site.

      Voir par exemple les images insérées ici :
      http://www.lesartsdecoratifs.fr/francais/musees/musee-nissim-de-camondo/actualites/actuellement/exposition/le-centenaire-de-l-hotel-camondo
      et jouer avec la largeur de la fenêtre sur une grande amplitude.

      – Les images sont insérées dans une <figure>.

      – D’abord, le positionnement des légendes des images change radicalement en fonction de la largeur de l’écran : quand j’ai assez de place (écran large), les légendes « sortent » de la colonne de texte. Le boulot, ici, est que ça fonctionne correctement selon les différentes maquettes (par exemple, la légende d’une image insérée à gauche dans une colonne de gauche pourra sortir de la colonne, mais pas dans une colonne de droite – puisque la légende irait s’afficher sur le texte de la colonne de gauche). Bref, il y a une petite foule de cas en fonction de la composition choisir et de la largeur de l’écran.

      – Si cette histoire de légende est une utilisation « jolie » du responsive, mais n’apporte pas grand chose réellement en lisibilité, il y a un problème pénible avec le responsive et les images alignées à droite ou à gauche : lorsque la largeur de la colonne de texte rétrécit (smartphone), le texte qui habille l’image se comporte de manière totalement farfelue (parce que les « lignes » de texte à côté de l’image deviennent vraiment trop courtes). J’ai donc ajouté un petit javascript qui calcule la largeur occupée par l’image par rapport à sa colonne de texte et, si le pourcentrage est trop élevé, décide de modifier l’affichage de l’image (on passe en afficher centré et on rejette le texte à la suite, comme un <img|center>).

      – Il y aussi des modèles d’insertion <video> qui fonctionnent en responsive :
      http://www.lesartsdecoratifs.fr/francais/ecole-camondo/debouches/conversations

      – Introduction d’une option <|large> dans les raccourcis, pour indiquer qu’on veut présenter les images de manière plus large que la colonne de texte. (Ça fonctionne aussi avec mes raccourcis d’intégration de vidéos.) Par exemple :
      http://www.lesartsdecoratifs.fr/francais/musees/musee-nissim-de-camondo/l-hotel-et-les-collections

    • Un détail intéressant : les menus de navigation en haut d’écran changent de présentation en fonction de la largeur de l’écran d’une manière un peu originale. Quand on passe de large à étroit :

      – d’abord, la taille du texte diminue (de manière un peu trop importante à mon goût, mais il était vital pour l’institution que toutes les entrées principales tiennent sur un écran d’iPad) ;
      – puis, si on n’arrive pas à faire tenir toutes les entrées des menus horizontaux dans la ligne, ceux qui « dépassent » sont affichées dans un entrée « ••• ».

      L’originalité, c’est que ce n’est pas du CSS responsive, mais un Javascript qui va calculer la situation.

    • Un aspect plus technique : certaines informations sont automatiquement rapatriées du système de billetterie (qui n’est pas de notre ressort). Par exemple :
      http://www.lesartsdecoratifs.fr/francais/activites/visites-guidees-parcours

      C’est donc un longform constitué de plusieurs articles. Chaque article contient des listes d’activités à venir, avec un titre, une description et une image, avec chacune une liste de dates et d’horaires dans le futur, avec un lien « Réserver ».

      Le webmestre dispose d’un raccourci avec plusieurs variables (le type d’événement, la tranche d’âge, le lien…), et la présentation est fabriquée automatiquement en SPIP, dans une #boucle_DATA qui tourne sur des appels de fichiers JSON fournis par le serveur de la billetterie.

    • Très intéressant comme toujours, merci pour ces détails.

      Pour l’accueil, le carrousel… ben. Carrousel quoi. Mais même quand on est obligé, ya quand même des « améliorations » possibles. Là déjà le constat :
      1) le carrousel se lance automatiquement = bad, bon, ok.
      2) mais il n’y a aucun contrôle pour l’arrêter.
      3) même quand la souris est dessus, ça ne s’arrête pas !
      4) et en plus le temps de rotation est trop court pour me permettre de lire tout le texte quand le titre est long (et cela sans handicap particulier, alors j’imagine pour PLEIN d’autres…)

      À minima, sans froisser les décideurs, je verrai au moins :
      1) augmenter le temps de rotation
      2) activer l’option pour stopper l’animation quand le focus ou le hover est dessus (dans à peu près toutes les libs ya ça)
      3) ajouter un troisième bouton « pause » (en plus de précédent/suivant), à partir du moment où on laisse le lancement automatique

    • @rastapopoulos : d’accord avec les limites du Carousel, mais il y a un moment, avec ce genre de chose en page d’accueil, où même la durée des transitions automatiques n’est plus une décision négociable. Cela dit, à la place d’un bouton « Pause », on a un gros bouton « Tous les événements », destiné à court-circuiter le carousel.

    • Wahou, même la durée de rotation est imposée ! C’est des oufs ! :D

      « Tous les événement » ça affiche un truc en surimpression et ça continue de bouger derrière ! À la limite si c’était avec un fond fixe… (mais faut le savoir quand même, c’est pas explicite que ça va « mettre en pause l’animation », ce que ça ne fait pas d’ailleurs pour l’instant)

      Un des problèmes graves d’accessibilité de ce genre de trucs, c’est entre autre pour les gens qui ont des problèmes de lecture, de concentration, d’attention, et qui ne doivent vraiment pas être perturbés par des éléments mobiles pendant qu’ils visionnent une page. Que ce soit des pubs ou du contenu, peu importe : pas d’animation non demandée explicitement par l’utilisateur.

      Mais bon, je sais bien ce que c’est quand c’est imposé… J’en fais souvent un combat de pédagogie d’ergonomie en début de projet, mais parfois c’est peine perdue…

    • Sinon, le détail qui me fait toujours sourire :

      – sur l’ancien site, taille du texte du chapeau : 12px
      – sur le nouveau site : 26px

      – sur l’ancien, texte courant : 12px
      – sur le nouveau site : 19px

    • Une page qui existait auparavant sous forme Flash : le plan du musée des Arts décoratifs
      http://www.lesartsdecoratifs.fr/francais/musees/musee-des-arts-decoratifs/parcours/plan-766/plan
      (cliquer sur un étage pour voir le truc se déplier)

      C’est donc désormais du HTML, et tout est géré dans l’interface privée de SPIP (nativement, d’ailleurs, c’est une rubrique avec des sous-rubriques et des articles virtuels, et les images sont des logos d’articles et de rubriques).

  • Évolution de mon #plugin #SPIP image_responsive :
    http://zone.spip.org/trac/spip-zone/browser/_plugins_/image_responsive

    Nouvelle fonction : background_responsive() (mêmes variables que image_responsive(), sauf l’option « vertical »). À installer par exemple dans un div, pour fabriquer une image de background, en mode « cover », chargée de manière responsive évidemment.

    <div class="interieur"[(#IMG_FOND|background_responsive{320/600/1280/1920, 1})]>

    Bien noter que ça ne fabrique pas, pour le coup, une <img>, mais un style="background" (et tout le tralala pour que ça tourne en responsive et en lazyload). Il faut donc l’intégrer à l’intérieur d’une balise (ici un div) pour que ça fonctionne. C’est d’ailleurs pour cela que ce n’est pas une fonction image_…, puisque ça ne donne pas un fichier image en sortie.

    Je croyais ne pas avoir trop besoin de gérer les images en background en responsive, puisque je m’en sors très bien d’habitude en utilisant une véritable image (responsive, donc) et son positionnement (voir mon petit remplir_image) :
    http://seenthis.net/messages/264068

    Mais on a obligatoirement besoin de background si on veut pouvoir passer des images en position:fixed réellement par rapport au viewport, pour les effets de parallax (tenter de faire la même chose avec des décalages verticaux lors du scroll, ça donne des animations qui sautent et qui collent mal à la tête).

    Sinon, par la suite, il faudrait uniformiser l’insertion de data-lazy et data-responsive dans le code de image_responsive (ici je ne peux pas ajouter de classe, parce que je suis déjà dans un div que je ne fabrique pas, contrairement au img).

    • Nouvel ajout : dans background-responsive, j’utilise deux images – une horizontale et une verticale (l’une étant calculée automatiquement à partir de l’autre) – que je stocke dans data-portrait-src et data-italien-src. De cette façon, au moment du choix de l’image en javascript, selon la taille d’affichage du conteneur (idéalement, ici, l’écran), ça va donc utiliser l’image qui a le moins de pertes.

      L’idée, c’est que si je prends une image horizontale, et que j’affichage ça pour « remplir » un écran vertical, j’étais obligé d’expédier une image faisant quasiment deux fois la taille de l’écran, avec la droite et la gauche de l’image en dehors de l’écran. Là, je limite beaucoup le problème. (Je pense que ça devient d’autant pertinent qu’on utilise ici de grandes images, potentiellement en double définition.)

  • Wildhoney/Leaflet.FreeDraw
    https://github.com/Wildhoney/Leaflet.FreeDraw

    FreeDraw allows you to draw a freehand polygon on the map – which is then converted to a normalised polygon which can be manipulated. demo : http://freedraw.herokuapp.com https://camo.githubusercontent.com/55c01123bc6ca471603ef19c1e2c8c3a582cbc78/687474703a2f2f692e696d6775722e636f6d2f3561623350346a2e706e67 Un #plugin qui utilise un strip de Calvin & Hobbes dans sa doc est forcément bon.

    #leaflet #drawing #polygons

  • slick - the last carousel you’ll ever need
    http://kenwheeler.github.io/slick

    Fully responsive. Scales with its container. Separate settings per breakpoint. Uses CSS3 when available. Fully functional when not. Swipe enabled. Or disabled, if you prefer. Desktop mouse dragging. Infinite looping. Fully accessible with arrow key navigation. Add, remove, filter & unfilter slides. Autoplay, dots, arrows, callbacks, etc...

    Peut être utile si jamais quelqu’un vous demande toujours un #slider...

    #jquery #plugin

  • Je récupère un vieux site #SPIP qui utilisait le #plugin « champs extra » pour stocker (notamment) une valeur « titre_logo ». Mais maintenant j’ai mon plugin plus récent et je n’ai donc plus besoin des extras.

    Pour tout de même accéder à ma « vieille » valeur (sans installer du tout le plugin « champs extra »), stockée sous forme de sérialisation dans une table #EXTRA, je fais directement ceci :

    [(#EXTRA|unserialize|table_valeur{titre_logo})]

    Après, une petite moulinette pour remettre ça dans le champ de spip_articles, c’est rien à faire…

  • thematic mapping blog: Showing geotagged photos on a #leaflet #map
    http://blog.thematicmapping.org/2014/08/showing-geotagged-photos-on-leaflet-map.html

    I’ve create a new #plugin, Leaflet.Photo, that allows you to add geotagged photos to your map, from any source. The plugin plays well with the great Leaflet.markercluster plugin, showing your photos in clusters. To make the plugin more versatile, it doesn’t deal with AJAX loading or image presentation except the thumbnails on the map. Use your AJAX loader of choice, and simply pass on an array of #photo objects to the plugin.

    The photo objects can include the properties you like, but the following are required:

    lat: latitude of photo

    lng: longitude og photo

    thumbnail: url to thumbnail photo

     (...)

    #geotag

  • J’ai un bug énorme dans la fonction imageconvolution de PHP en version 5.5.9 et 5.5.10, et qui n’a pas l’air documentée :
    http://php.net/manual/en/function.imageconvolution.php

    la troisième variable de la fonction, le divisor, ne semble plus fonctionner que si sa valeur est 1.

    J’ai donc modifié la fonction image_reduire_net de mon #plugin #SPIP image_responsive :
    http://zone.spip.org/trac/spip-zone/browser/_plugins_/image_responsive
    – je recalcule la matrice pour que sa somme soit égale à 1 ;
    – au passage, la fonction est passée dans un fichier séparé, ce qui permet de l’appeler en dehors du fichier d’action.

    Je n’ai rigoureusement rien trouvé à ce sujet, sauf un bug signalé dans un Git, comme quoi son renforcement en 5.5.9 devenait un blur. Chez moi, comme j’ai des valeurs différentes, ça me brûlait mes vignettes.

    (Bon, soit c’est mon MAMP qui est bugué, soit c’est le problème classique avec les fonctions graphiques : personne dans le libre ne les utilise jamais.)