/**
 * Logo Roll — aspetto e scorrimento. BLOCCO NUOVO, non un porting.
 *
 * La fascia di loghi che scorre: una striscia chiara, i loghi in fila dentro un riquadro
 * che non superano, e il nastro che scivola verso sinistra senza fine. In elewidget non c'è niente del
 * genere, quindi non c'è nessun markup da rispettare — la forma è quella del riferimento.
 *
 * ── LO SCORRIMENTO NON SI PUÒ FARE COL SOLO CSS, E VALE LA PENA DIRE PERCHÉ ────────────
 *
 * Un nastro che gira all'infinito ha bisogno di due cose che il foglio di stile non sa:
 * quante COPIE del gruppo di loghi servono per coprire lo schermo, e QUANTO è largo un
 * gruppo — che è la distanza esatta da percorrere prima di ricominciare, e l'unica che non
 * fa vedere il salto.
 *
 * Tutte e due dipendono dai loghi che ci ha messo l'autore e dalla larghezza dello schermo,
 * cioè da cose che si sanno solo a pagina montata. Le misura `js/widgets/logoroll.js` e le
 * consegna qui come due variabili — `--se-lr-passo` e `--se-lr-durata` — più la classe
 * `seLogoRoll--acceso`. Il movimento resta interamente del CSS: il JavaScript non sposta
 * niente a ogni fotogramma, dice solo di quanto e in quanto tempo.
 *
 * Il `50%` che si vede in giro (due copie e via) qui non va: funziona finché il gruppo è
 * più largo dello schermo, e con quattro loghi su un monitor largo si aprirebbe un vuoto.
 *
 * ⚠ FERMO NELL'EDITOR, ED È VOLUTO. Il canvas non carica i file di `js/widgets/`, quindi
 * nell'editor la classe `--acceso` non arriva mai e il nastro sta fermo. È la stessa scelta
 * del carosello di Icon Boxes: impaginare dentro una cosa che si muove è impossibile, e
 * l'autore deve vedere i suoi loghi, non inseguirli. Vedi la sezione del canvas in fondo.
 *
 * LO SCOPE. Tutto prefissato `.se-gjs-page`, che esiste sia sul frontend sia nel canvas.
 */

/* La radice è la MASCHERA: quello che esce di lato viene tagliato qui. Il taglio è netto,
   come nel riferimento — niente sfumatura ai bordi. */
.se-gjs-page .seLogoRoll {
	display: flex;
	align-items: center;
	width: 100%;
	overflow: hidden;
	padding: 2.5rem 0;

	/* Il riquadro in cui sta un logo: non più largo, non più alto. Sono due misure sole
	   perché il blocco ne ha bisogno in tre punti (il logo, il canvas, gli schermi
	   stretti) e devono restare la stessa cosa. Il perché di un riquadro invece di
	   un'altezza sola sta più sotto, sulla regola del logo.

	   ⚠ 240 È SCRITTO ANCHE NEL JAVASCRIPT, in `LARG_BASE` (js/components/logoroll.js e
	   js/widgets/logoroll.js): è la larghezza a cui corrisponde il fattore 1, cioè il
	   numero rispetto al quale si misura la larghezza scelta per un singolo logo.
	   Cambiarlo qui e non là vorrebbe dire un pannello che promette 240 e un sito che ne
	   dà altri. */
	--se-lr-larghezza: 240px;
	--se-lr-altezza: 110px;

	/* ⚠ SFONDO TRASPARENTE, e non è un'omissione: è il valore di partenza voluto.
	   C'era una striscia chiara (#f7f8f9) presa dal riferimento, ma un fondo dichiarato dal
	   componente è un fondo che si porta dietro ovunque lo si metta — e se sotto c'è già
	   una sezione colorata, si vede una banda più chiara che nessuno ha chiesto.
	   Chi la vuole la sceglie dallo Style Manager, e finisce nella regola per-id di quel
	   singolo blocco: si vede dove è stata decisa e si toglie da lì. */
	background-color: transparent;
}

/* Il nastro. `width: max-content` è quello che gli permette di essere più largo della
   maschera: senza, si fermerebbe alla larghezza del contenitore e i loghi si
   stringerebbero invece di uscire dal bordo. */
.se-gjs-page .seLogoRoll__pista {
	display: flex;
	align-items: center;
	width: max-content;
	flex: 0 0 auto;
}

/* Il gruppo: i loghi che l'autore ha messo, una volta sola. Le copie che il nastro
   contiene oltre a questo sono fatte a pagina montata e non stanno nel contenuto salvato.
   Il `padding-right` è lo stacco fra l'ultimo logo di un gruppo e il primo del successivo:
   senza, il nastro si richiuderebbe con due loghi appiccicati una volta ogni giro. */
.se-gjs-page .seLogoRoll__gruppo {
	display: flex;
	align-items: center;
	gap: 5rem;
	padding-right: 5rem;
	flex: 0 0 auto;
}

/* Il collegamento attorno al logo. È un elemento del nastro come lo era l'immagine, e
   deve comportarsi allo stesso modo: `flex: 0 0 auto` perché non si stringa, e `display:
   flex` perché non aggiunga la riga di testo che un `<a>` inline si porta dietro — quel
   mezzo pixel sotto l'immagine falserebbe l'altezza del gruppo, che è la misura da cui
   dipende il passo dell'animazione.

   Nessun colore e nessuna sottolineatura: qui dentro non c'è testo, e le regole sui link
   del tema non devono lasciare traccia attorno a un logo. */
.se-gjs-page .seLogoRoll .seLogoRoll__link {
	flex: 0 0 auto;
	display: flex;
	align-items: center;
	line-height: 0;
	text-decoration: none;
}

/* ⚠ UN LOGO SENZA IMMAGINE NON OCCUPA POSTO NELLA FILA.
 *
 * Un `<a class="seLogoRoll__link"></a>` vuoto è il guscio di un logo a cui l'immagine è
 * stata tolta. Non mostra niente, ma resta un elemento della fila, e in una fila tenuta
 * insieme dal `gap` un elemento largo zero non è invisibile: è UN DOPPIO SPAZIO. Fra il
 * logo prima e quello dopo restano due volte 5rem, e quello che si vede è una spaziatura
 * che non è più fissa — cioè il difetto sbagliato, perché fa cercare la causa nella
 * distanza fra i loghi mentre la causa è un logo che non c'è.
 *
 * `display: none` lo toglie dal calcolo del flex, e i due spazi tornano uno. Vale sul
 * contenuto già salvato, dove qualche guscio c'è: nella home ce n'era uno in terza
 * posizione. Che il guscio non nasca più — l'immagine di un logo non si cancella dal
 * canvas — e che dal pannello ci si possa rimettere l'immagine è in
 * js/components/logoroll.js; questa regola è la rete per le pagine impaginate prima.
 *
 * `:empty` è esatto quanto serve: prende l'elemento senza NESSUN figlio e senza testo,
 * cioè solo il guscio. Un logo con la sua immagine dentro non lo è mai. */
.se-gjs-page .seLogoRoll .seLogoRoll__link:empty {
	display: none;
}

/* Un logo che porta da qualche parte lo dice: il cursore cambia e il logo si accende al
   passaggio. Solo con l'indirizzo — `:not([href])` è il tag che c'è sempre ma non è un
   link, vedi la funzione `logo()` nel componente. */
.se-gjs-page .seLogoRoll .seLogoRoll__link[href] {
	cursor: pointer;
}

.se-gjs-page .seLogoRoll .seLogoRoll__link[href] .seLogoRoll__logo {
	transition: opacity .2s ease;
}

.se-gjs-page .seLogoRoll .seLogoRoll__link[href]:hover .seLogoRoll__logo {
	opacity: .65;
}

/* IL LOGO STA DENTRO UN RIQUADRO, NON SU UN'ALTEZZA FISSA.
 *
 * I loghi arrivano da file di forma qualunque: c'è la scritta lunga e bassa e c'è lo
 * stemma quadrato. Portarli tutti alla STESSA ALTEZZA — che è quello che faceva questo
 * blocco, `height: 56px` — sembra la cosa ordinata da fare, e invece è quella che
 * scompagina la fila: la scritta lunga a 56 di altezza diventa larga quattrocento pixel e
 * si mangia mezzo nastro, e lo stemma quadrato, che a 56 è alto 56, accanto sparisce.
 *
 * Il modo che tiene è il riquadro: un logo non supera `--se-lr-larghezza` né
 * `--se-lr-altezza`, e dentro quel limite resta come è nato. La scritta lunga arriva al
 * bordo largo e resta bassa, lo stemma arriva al bordo alto e resta stretto; nessuno dei
 * due viene ingrandito oltre la propria misura, perché i massimi non spingono, trattengono
 * soltanto. È come impagina Elementor la stessa fascia, ed è il riferimento da cui questo
 * blocco è stato rifatto.
 *
 * ⚠ QUI PRIMA C'ERA SCRITTO CHE `max-height` NON FUNZIONA. Il fatto misurato era vero, la
 * causa era mal attribuita, e vale la pena lasciarla scritta giusta perché è una trappola
 * che torna. Misurato in Chromium, tre loghi da 300×80 con `max-height: 56px`: gruppo
 * largo 240px — cioè i soli spazi fra i loghi — e immagini schiacciate in quel poco. La
 * colpa non è di `max-height`: è del `max-width: 100%` che il reset del tema mette su ogni
 * immagine. Una PERCENTUALE si misura sul contenitore, il contenitore è largo quanto il
 * suo contenuto, e il contenuto è largo quanto la percentuale: il cerchio si chiude con
 * ogni logo che conta zero. Il guaio non era cosmetico — quella larghezza sbagliata è la
 * stessa che `js/widgets/logoroll.js` prende per passo dell'animazione.
 *
 * Il `max-width` qui sotto è in PIXEL, e con quello il cerchio non si apre nemmeno: la
 * larghezza di ogni logo è il rapporto d'immagine applicato a due limiti fissi, cioè un
 * numero definito, e il gruppo si misura giusto. È anche il motivo per cui i due limiti
 * non possono diventare percentuali senza rompere lo scorrimento.
 *
 * ⚠ IL SELETTORE RIPETE `.seLogoRoll`, e non è ridondanza: serve a vincere.
 * se-builder-content.css dichiara `.se-gjs-page .gjs-cell img { max-width:100%; height:auto }`
 * per tutte le immagini dentro una colonna — vale (0,2,1), mentre
 * `.se-gjs-page .seLogoRoll__logo` vale (0,2,0) e PERDE: nel confronto conta prima il
 * numero di classi, e lì la regola generale ne ha una in più.
 * Il risultato era che nel canvas i loghi tornavano ad altezza automatica e larghi quanto
 * la colonna: enormi, uno per riga. Con il contenitore nella catena si arriva a (0,3,0) e
 * la misura giusta vince, senza ricorrere a `!important`.
 *
 * ⚠ I DUE `!important` SONO L'ECCEZIONE MOTIVATA alla regola di non usarli, e riguardano
 * i blocchi impaginati prima. Finché il logo si poteva ridimensionare a mano — vedi la nota
 * in js/components/logoroll.js, ora non si può più — un trascinamento scriveva `width` e
 * `height` in pixel nella regola per-id di QUELLA immagine: (1,1,0), che nessun selettore
 * di classe raggiunge. Quelle misure sono ancora nel contenuto salvato di chi ha già
 * impaginato una fascia, e non basta che i due massimi le contengano: un logo quadrato
 * dichiarato 306×309 e trattenuto a 80 di altezza si ferma a 79 di larghezza, ma il suo
 * riquadro resta largo 180, e quei cento pixel vuoti sono esattamente lo spazio enorme che
 * si voleva togliere. Il browser, quando `width` e `height` sono dichiarate tutte e due,
 * taglia le due misure ognuna per conto suo e non tiene il rapporto — è la stessa ragione
 * per cui ogni reset scrive `img { max-width: 100%; height: auto }`, questo compreso.
 *
 * Con `auto` forzato la misura torna a essere l'immagine più i due limiti, il rapporto è
 * salvo e il riquadro è stretto quanto il logo. La misura di un logo non è dell'immagine:
 * è del blocco, e questo è il posto in cui si cambia per tutti.
 *
 * ── UN LOGO PUÒ AVERE UN RIQUADRO SUO: `--se-lr-scala` ────────────────────────────────
 *
 * I loghi non pesano tutti uguale. Una scritta sottile e chiara accanto a uno stemma pieno
 * si vede molto meno, anche se occupa lo stesso riquadro, e l'unico che può dirlo è chi
 * guarda la fascia. Nel pannello ogni logo ha quindi la sua larghezza, e quel numero
 * arriva qui come un FATTORE — non come una misura — scritto sull'elemento del logo da
 * js/widgets/logoroll.js (sul sito) e da js/components/logoroll.js (nel canvas).
 *
 * ⚠ IL FATTORE MOLTIPLICA TUTTE E DUE LE MISURE, e non è una libertà presa: allargare
 * soltanto il riquadro non ingrandirebbe niente. Un logo alto — uno stemma, un tondo — è
 * trattenuto dall'ALTEZZA, e con l'altezza ferma resterebbe grande uguale dentro un
 * riquadro più largo, cioè l'autore muoverebbe il cursore senza vedere succedere niente.
 * Moltiplicate insieme, il rapporto del riquadro non cambia e ogni logo cresce davvero.
 *
 * ⚠ ED È UN FATTORE, NON UNA MISURA IN PIXEL, perché la misura in pixel non
 * sopravviverebbe agli schermi stretti: un logo dichiarato 320px resterebbe 320 anche su
 * un telefono, dove il riquadro di tutti gli altri scende a 160. Un fattore si applica a
 * qualunque riquadro, quindi la scelta dell'autore vale su ogni schermo senza che ci sia
 * niente da ripetere nella media query. */
.se-gjs-page .seLogoRoll .seLogoRoll__logo {
	flex: 0 0 auto;
	display: block;
	width: auto !important;
	height: auto !important;
	max-width: calc( var( --se-lr-larghezza, 240px ) * var( --se-lr-scala, 1 ) );
	max-height: calc( var( --se-lr-altezza, 110px ) * var( --se-lr-scala, 1 ) );
	object-fit: contain;
}

/* Il movimento. Il punto d'arrivo è una variabile: il fotogramma finale non è «metà del
   nastro» ma «un gruppo esatto più in là», che è l'unica misura che fa ricominciare il
   giro senza che si veda il punto di sutura. */
@keyframes seLogoRollScorri {
	from { transform: translateX(0); }
	to { transform: translateX(var(--se-lr-passo, 0px)); }
}

/* `seLogoRoll--acceso` la mette il JavaScript dopo aver misurato. Finché non c'è — nel
   canvas, o se lo script non gira — i loghi restano in fila, fermi: una fascia che non
   scorre è molto meglio di una fascia vuota. */
.se-gjs-page .seLogoRoll--acceso .seLogoRoll__pista {
	animation: seLogoRollScorri var(--se-lr-durata, 30s) linear infinite;
	will-change: transform;
}

/* Chi ha chiesto al sistema operativo di non far muovere le cose non se le vede muovere.
   Non è un vezzo: un movimento continuo che non si può fermare è esattamente il caso che
   il criterio 2.2.2 delle WCAG chiede di evitare. Restano i primi loghi, fermi e
   leggibili. */
@media (prefers-reduced-motion: reduce) {
	.se-gjs-page .seLogoRoll--acceso .seLogoRoll__pista {
		animation: none;
	}
}

@media screen and (max-width: 767px) {
	/* Il riquadro si stringe, e basta cambiare le due misure: la regola del logo le legge
	   da qui, e non c'è niente da ripetere. */
	.se-gjs-page .seLogoRoll {
		padding: 1.5rem 0;
		--se-lr-larghezza: 160px;
		--se-lr-altezza: 74px;
	}

	.se-gjs-page .seLogoRoll__gruppo {
		gap: 3rem;
		padding-right: 3rem;
	}
}

/* ────────────────────────────────────────────────────────────────────────────────────── *
 * SOLO NELL'EDITOR — `.se-gjs-canvas`
 *
 * `.se-gjs-canvas` è la classe che il builder mette sull'<html> dell'iframe del canvas, ed
 * esiste solo lì: quello che sta qui sotto non arriva mai sul sito.
 *
 * Nel canvas il nastro è fermo e non c'è nessuna copia, quindi la maschera farebbe un
 * danno solo: i loghi oltre la larghezza del blocco sparirebbero, e l'autore non avrebbe
 * modo di vedere — né di selezionare — quelli che ha appena aggiunto. Qui il gruppo va a
 * capo e la maschera si apre.
 * ────────────────────────────────────────────────────────────────────────────────────── */

.se-gjs-canvas .seLogoRoll {
	overflow: visible;
	/* Un po' di respiro ai lati che sul sito non serve: là il primo logo è tagliato dalla
	   maschera perché sta scorrendo, qui sarebbe solo appiccicato al bordo. */
	padding: 2.5rem 1rem;
}

/* ⚠ Le tre larghezze qui sotto vanno insieme, e nessuna delle tre si può togliere.
   Il nastro nasce `width: max-content` e il gruppo `flex: 0 0 auto`: sono le due cose che
   sul sito gli permettono di essere più largo dello schermo, ed è esattamente quello che
   qui impedisce l'andata a capo. Un `flex-wrap: wrap` da solo non fa niente, perché un
   contenitore largo quanto il suo contenuto non ha mai una riga da spezzare. */
.se-gjs-canvas .seLogoRoll__pista {
	width: 100%;
	min-width: 0;
}

.se-gjs-canvas .seLogoRoll__gruppo {
	width: 100%;
	min-width: 0;
	flex: 0 1 auto;
	flex-wrap: wrap;
	row-gap: 2rem;
	padding-right: 0;
}
