Visualizzazione dei risultati da 1 a 8 su 8
  1. #1
    Utente di HTML.it
    Registrato dal
    Oct 2009
    Messaggi
    78

    Animazione nel proprio sito.

    Salve,

    generalmente è molto tempo che non mi dedico più ai siti internet ma vorrei riprenderci la mano e sopratutto aggiornarmici.

    Starei cercando di creare una pagina dove al centro è presente un pulsante che dovrebbe generare una semplice animazione:

    -1-pulsante statico
    -2-se premuto genera un animazione
    -3-dissolvenza del pulsante
    -4-comparsa (mi sfugge al momento il contrario di dissolvenza) del menù e della home page

    Normalmente questo semplice processo l'avrei creato con estrema tranquillità in flash player, ma comprendo che ora come ora è un nome quasi obsoleto per i siti internet e per tanto mi domando, quale sarebbe la via più consona per generare questo effetto (se possibile in vettoriale)?

    Ringrazio anticipatamente per l'eventuale considerazione e colgo l'occasione per porgere i miei più sentiti omaggi a il forum tutto.

    Francesco M.

  2. #2
    Ciao Francesco,
    ho scritto un semplice esempio che dissolve un elemento con opacity=1 e fa comparire un elemento con opacity=0.
    - Dissolve.Add( id_name, step ); permette di "dissolvere" o "far comparire" l'elemento con id = idname.

    Spero che l'esempio sia chiaro e di esser stato di aiuto.
    Tony


    codice:
    <!DOCTYPE>
    <html>
      <head>
    <style>
    
    body { background-color:#FFD;}
    
    div {
      position:absolute;left:50%;top:50%;
      text-align:center;
      font:16px Arial;
    }
     
      
    </style>
    <script>
    
    
    function f_act_dissolve(){
                                                      
      Dissolve.Add("id_btn");
      Dissolve.Add('id_home',0.05);  
      setTimeout("Dissolve.Add('id_tonenge');",1000);    // dopo 1 secondo
    }
    
    
    //------------------------------------------------------------------------------
    Dissolve={
      act:0,
      aidn:[],
      tm:50,
      ostep:0.03,
    
    Add:function(idn,stp){
    with(Dissolve){
        if(!stp) stp=ostep;
        var d,o,j=document.getElementById(idn);
        o=parseInt(j.style.opacity);
        if(!o) o=0;
        d=(o>0.5)?-1:1;   
        aidn.push([j,o,d,stp]); 
        if(!act) { act=1; Cycle(); } 
    }},
    
    Cycle:function(){
    with(Dissolve){
      var r,n=aidn.length;
      if(!n) { act=0; return; }
      for(r=0;r<n;r++) Dis(r);
      for(r=n-1;r>=0;r--) if(!aidn[r].length) aidn.splice(r,1);    
    setTimeout(function(){ Cycle(); },tm);  
    }},
    
    Dis:function(r){
    with(Dissolve){
       var D=aidn[r];
       D[1] += (D[3]*D[2]);
       if(D[1]<0) D[1]=0;
       if(D[1]>1) D[1]=1;
       D[0].style.opacity=D[1];
       if(!D[1] || D[1]==1) aidn[r]=[];
    }}
    
    }
    //------------------------------------------------------------------------------
    
    
    </script>  
      </head>
      <body>
    
    <!-- div contenitore della Home page -->
    <div id='id_home' style='margin:-300px;width:600px;height:600px;background-color:#48E;opacity:0.0;'>
      <br><span onclick='f_act_dissolve();' style='cursor:pointer;text-decoration:underline;'>Torna indietro</span>
    </div>
    
    <!-- div contenitore pulsante -->
    <div id='id_btn' style='margin:-60px;width:120px;height:120px;background-color:#FF0;opacity:1.0;'>
      <br>Test<br>
      <br>
      <button onclick='f_act_dissolve();' style='cursor:pointer;'>Entra nel sito:</button>
    </div>
    
    
    <div id='id_tonenge' style='top:10px;font:bold 24px Arial;width:300px;margin-left:-150px;color:#B00;opacity:0.0;'>Tonenge</div>
    
      </body>
    </html>

  3. #3
    Utente di HTML.it
    Registrato dal
    Oct 2009
    Messaggi
    78
    Salve, come prima cosa ti ringrazio sentitamente per l'impegno dimostrato nel rispondermi, nell'ultimo periodo mi sto ri-dedicando allo studio e tra i vari temi anche JavaScript, sia come piacere personale sia per necessità d'integrarlo ad adobe edge, sta di fatto che ci sono dei passaggi nello script da te pubblicato che mi sfuggono di comprensione e mi chiedevo, sempre che non sia di eccessivo disturbo, se avresti potuto riproporre il codice con i dovuti commenti, scusami l'esigenza ma non sono avvezzo al copia ed incolla

    Tolto questo, grazie ancora ed a te i miei più sentiti omaggi,

    Francesco M.

  4. #4
    Ciao, sono pienamente d'accordo che è necessario comprendere gli script altrimenti non serve a nulla!

    codice:
    //------------------------------------------------------------------------------
    Dissolve={
      act:0,                 // se 0 nessuna dissolvenza in atto
      aidn:[],               // array di parametri delle dissolvenze
      tm:50,                 // tempo di attesa variazione di opacità (setTimeout)
      ostep:0.03,            // variazione di opacità di default
    
    
    Add:function(idn,stp){                            // idn è il nome dell'ID dell'elemento da nascondere/far comparire
    with(Dissolve){
        if(!stp) stp=ostep;                           // se non indicata usa il valore di default
        var d,o,j=document.getElementById(idn);       // j contiene è l'elemento su cui modificare l'opacità
        o=parseInt(j.style.opacity);                  // o contiene il valore di opacità iniziale 1.0 oppure 0.0
        if(!o) o=0;                                   //   se non settata poni a 0
        d=(o>0.5)?-1:1;                               // d determina se incrementare o decrementare l'opacità iniziale
        aidn.push([j,o,d,stp]);                       // metto nell'array aidn i 4 parametri necessari al ciclo di dissolvenza
        if(!act) { act=1; Cycle(); }                  // se non è attiva alcuna dissolvenza in Cycle() lancio la funzione 
    }},
    
    
    Cycle:function(){
    with(Dissolve){
      var r,n=aidn.length;                                        // n contiene il numero di dissolvenze da processare
      if(!n) { act=0; return; }                                   // se non ce ne sono  esco da Cycle()
      for(r=0;r<n;r++) Dis(r);                                    // per ogni gruppo di parametri che compongono una dissolvenza eseguo uno step di inc/dec dell'opacità
      for(r=n-1;r>=0;r--) if(!aidn[r].length) aidn.splice(r,1);   // quando termina una dissolvenza l'array dei 4 parametri viene annullato (*) e deve essere tolto da aidn in modo che non venga più eseguito 
    setTimeout(function(){ Cycle(); },tm);                        // ripeti Cycle ogni tm millesimi di secondo (fino a quando ci sono elementi in aidn ) 
    }},
    
    
    Dis:function(r){
    with(Dissolve){
       var D=aidn[r];                   // D è l'array dei 4 parametri di dissolvenza da processare
       D[1] += (D[3]*D[2]);             // D[1] è l'opacità attuale che deve essere incrementata di D[3] in valore assoluto (D[2] determina la direzione +1 -1) 
       if(D[1]<0) D[1]=0;               // se l'opacità è <0 il decremento è finito
       if(D[1]>1) D[1]=1;               // se >1 l'incremento è finito
       D[0].style.opacity=D[1];         // imposto l'opacità per l'elemento (D[0]) 
       if(!D[1] || D[1]==1) aidn[r]=[]; // se l'incremento o il decremento è finito annullo i 4 parametri della dissolvenza (*)
    }}
    
    
    }
    //------------------------------------------------------------------------------

  5. #5
    Utente di HTML.it
    Registrato dal
    Oct 2009
    Messaggi
    78
    Quote Originariamente inviata da Tonenge Visualizza il messaggio
    ...
    Grazie mille caro, io generalmente utilizzo una funziona contenente una variabile che identifica l'id dell'oggetto in considerazione e ne verifica lo stato di opacità (0 o 1) e a seguire attua un'interazione con le transizioni in CSS3 per il tempo di dissolvenza, ma obbiettivamente parlando non saprei definirti ancora se sia meglio o peggio.

    In realtà non è neanche proprio ciò che chiedevo nella domanda iniziale, ma ho trovato molto interessante il tuo esempio sopratutto sul piano di studio, mi mette di fronte ad una possibilità più ricca di elementi e sopratutto davanti ad una struttura di codice che non avrei potuto pensare con le mie attuali "competenze", per tanto tutto il resto non importa e te ne ringrazio.

    Avrei unicamente una domanda al momento, se io comincio a cliccare vollemente sui pulsanti per il fadein e fadeout prima dell'effettivo completamente della dissolvenza creo un baco al punto tale da poter far sparire tutti gli elementi... tu come risolveresti a livello teorico questo problema? (non serve che scrivi un nuovo codice, vorrei principalmente capire il pensiero che ne starebbe alla base)


    Tolto tutto, se può interessare, la mia domanda iniziale era tipo:


    • ho un animazione, supponiamo così strutturata: un quadrato con una transazione da destra a sinistra con una dissolvenza finale
    • ho un pulsante che attiva l'animazione
    • ho un div non visibile


    Come posso strutturare un codice javascript che mi permetta di visualizzare il div una volta terminata l'animazione?

    So che d'inizio la domanda non era per nulla chiara, ma ahimè non lo erano neanche molto le mie idee ;-)

    Comunque sia, grazie ancora per le spiegazione e la cortese disponibilità


    P.s dimenticavo, volevo chiederti altro due specificazioni, tu scrivi tipo add:function dis:function e via discorrendo, ma è come definire un nome ad una funzione tipo function hello () oppure identifica un metodo specifico? (scusami ma è una composizione di testo a me poco familiare)
    In ultimo ho delle perplessità sul parametro stp e su cosa richiami nella funzione e di conseguenza nell'array, fatico ancora un pochino ad inquadrare i parametri delle funzioni ... non so se mi spiego

  6. #6
    Ciao, ho apportato piccole modifiche di carattere esemplificativo, per animare il riquadro ho inserito la classe "cl_animate" al div relativo in modo che al click cambiando la posizione sia eseguita l'animazione.

    Per i click ripetuti è stato sufficiente controllare se era in atto una dissolvenza per non eseguire più volte l'azione.
    Ho inserito inoltre il display:none quando l'opacità diventava = 0 altrimenti era ancora possibile eseguire il click.

    In merito all'oggetto "Dissolve = { ... } " è una struttura javascript che permette di definire proprietà e metodi al suo interno però non permette l'istanziazione multipla.

    Avevo erroneamente interpretato la sola necessità di creare delle "dissolvenze". Scusa.


    Saluti Tony.


    codice:
    <!DOCTYPE>
    <html>
      <head>
    <style>
    
    
    body { background-color:#FFD; overflow:hidden;}
    
    
    div {
      text-align:center;
      font:16px Arial;
    }
    
    
    .cl_animate {
      transition: all 1.2s linear;
    }
    
    
      
    </style>
    <script>
    
    
    
    
    function f_act_dissolve(){
        
      if(Dissolve.act) return false;                            // se dissolvenza attiva non considerare i click
    
    
      Dissolve.Add("id_btn");
      Dissolve.Add("id_home"); 
       
      setTimeout(function(){ 
                    var j=document.getElementById("id_home"),
                      p=j.style.left,
                      pos=(p=="50%")?"130%":"50%";               // sposta da destra al centro (con animazione)  o da centro a destra 
                      j.style.left=pos; 
                 },55);                                          // attendi che l'elemento sia in display:block altrimenti l'animazione potrebbe non essere eseguita.
    }
    
    
    
    
    //------------------------------------------------------------------------------
    Dissolve={
      act:0,                 // se 0 nessuna dissolvenza in atto
      aidn:[],               // array di parametri delle dissolvenze
      tm:50,                 // tempo di attesa variazione di opacità (setTimeout)
      ostep:0.05,            // variazione di opacità di default
    
    
    Add:function(idn,stp){                            // idn è il nome dell'ID dell'elemento da nascondere/far comparire
    with(Dissolve){
        if(!stp) stp=ostep;                           // se non indicata usa il valore di default
        var d,o,j=document.getElementById(idn);       // j contiene è l'elemento su cui modificare l'opacità
        o=parseInt(j.style.opacity);                  // o contiene il valore di opacità iniziale 1.0 oppure 0.0
        if(!o) o=0;                                   //   se non settata poni a 0
        d=(o>0.5)?-1:1;                               // d determina se incrementare o decrementare l'opacità iniziale
        if(d>0) j.style.display="block";              // visualizza elemento in display:none
        aidn.push([j,o,d,stp]);                       // metto nell'array aidn i 4 parametri necessari al ciclo di dissolvenza
        if(!act) { act=1; Cycle(); }                  // se non è attiva alcuna dissolvenza in Cycle() lancio la funzione 
    }},
    
    
    Cycle:function(){
    with(Dissolve){
      var r,n=aidn.length;                                        // n contiene il numero di dissolvenze da processare
      if(!n) { act=0; return; }                                   // se non ce ne sono  esco da Cycle()
      for(r=0;r<n;r++) Dis(r);                                    // per ogni gruppo di parametri che compongono una dissolvenza eseguo uno step di inc/dec dell'opacità
      for(r=n-1;r>=0;r--) if(!aidn[r].length) aidn.splice(r,1);   // quando termina una dissolvenza l'array dei 4 parametri viene annullato (*) e deve essere tolto da aidn in modo che non venga più eseguito 
    setTimeout(function(){ Cycle(); },tm);                        // ripeti Cycle ogni tm millesimi di secondo (fino a quando ci sono elementi in aidn ) 
    }},
    
    
    Dis:function(r){
    with(Dissolve){
       var D=aidn[r];                   // D è l'array dei 4 parametri di dissolvenza da processare
       D[1] += (D[3]*D[2]);             // D[1] è l'opacità attuale che deve essere incrementata di D[3] in valore assoluto (D[2] determina la direzione +1 -1) 
       if(D[1]<0) {                     // se l'opacità è <0 il decremento è finito
        D[1]=0;  
        D[0].style.display="none";      // non più cliccabile
       }               
       if(D[1]>1) {
         D[1]=1;                        // se >1 l'incremento è finito
       }
       D[0].style.opacity=D[1];         // imposto l'opacità per l'elemento (D[0]) 
       if(!D[1] || D[1]==1) aidn[r]=[]; // se l'incremento o il decremento è finito annullo i 4 parametri della dissolvenza (*)
    
    
    }}
    
    
    }
    //------------------------------------------------------------------------------
    
    
    
    
    </script>  
      </head>
      <body>
    
    
    <!-- div contenitore della Home page -->
    <div id='id_home' class='cl_animate' style='position:absolute;left:130%;top:50%;margin:-300px;width:600px;height:600px;background-color:#48E;opacity:0.0;'>
      <br><span onclick='f_act_dissolve();' style='cursor:pointer;text-decoration:underline;'>Torna indietro</span>
    </div>
    
    
    <!-- div contenitore pulsante -->
    <div id='id_btn' style='position:absolute;left:50%;top:50%;margin:-60px;width:120px;height:120px;background-color:#FF0;opacity:1.0;'>
      <br>Test<br>
      <br>
      <button onclick='f_act_dissolve();' style='cursor:pointer;'>Entra nel sito:</button>
    </div>
    
    
      </body>
    </html>

  7. #7
    Utente di HTML.it
    Registrato dal
    Oct 2009
    Messaggi
    78
    Quote Originariamente inviata da Tonenge Visualizza il messaggio
    ...
    Grazie mille sei davvero gentilissimo nel tuo adoperarti per aiutarmi, ma, e devo confessare un poco di imbarazzo, credo nuovamente di non essere stato preciso nella mia spiegazione ed un poco me ne dispiace, mi spiego:

    La tranzazione del quadrato era un esempio puramente casuale, l'animazione su cui sto lavorando è di fatto molto più complicata e realizzata in adobe edge e già compresa di dissolvenza finale.

    In realtà a me servirebbe comprendere come strutturare un codice che dica: quando l'animazione è terminata avvia una funzione (in questo caso specifico una dissolvenza in entrata di un div)
    ma non capisco se devo impostare un termine di tempo, esempio l'animazione dura 30sec e quindi scrivere il codice dicendo che sarà valido dopo 30 sec, ma non so se fattibile o realmente funzionale o se posso definire il video all'interno di una funzione e dirgli di verificare se è attivo o meno e quindi rispondere di conseguenza... per quanto posso studiare JavaScript manco ancora della conoscenza di molti elementi e metodi e forse spesso mi creo problemi complessi che hanno in realtà soluzioni semplici

    Per quanto riguarda gli oggetti a livello teorico posso definire cosa sono e come funzionano, ma sul lato pratico pecco ancora molto e fatico effettivamente ad inquadrare tutti gli elementi e/o a strutturare qualcosa di propriamente corretto e funzionale...

    ...ma principalmente mi sfugge quel add: cycle: e via dicendo, sono elementi che al momento non ho ancora riscontrato nel mio studio, o per lo meno non come tipo di scrittura

  8. #8
    Utente di HTML.it
    Registrato dal
    Oct 2009
    Messaggi
    78
    In ogni modo, anche questo tuo ultimo esempio risulta per me un ottima base di studi ed è di base di gran ispirazione :-)))

Permessi di invio

  • Non puoi inserire discussioni
  • Non puoi inserire repliche
  • Non puoi inserire allegati
  • Non puoi modificare i tuoi messaggi
  •  
Powered by vBulletin® Version 4.2.1
Copyright © 2025 vBulletin Solutions, Inc. All rights reserved.