JavascriptProva

domenica 31 marzo 2013

Parametri relativi alla posizione del blocco di caselle.

Ultimo aggiustamento: la posizione del blocco di caselle.

Una semplice aggiunta: le coordinate del blocco:
function CreaCaselle(X,Y,numero,altezzaColonna,classe,matrice){
 var casella;
 for(var n=0;n<numero;n++){  
  //codice che crea una casella di tipo div e l'appende al documento
  casella=document.createElement("div");
  document.body.appendChild(casella);
  
  //codice che "conforma" la casella attribuendole una classe del CSS
  casella.className=classe;
  
  //Codice che stabilisce le coordinate della casella in base all'altezza della colonna
  casella.style.top=Y+(EN(casella.currentStyle.height)*(n%altezzaColonna))+"px";
  casella.style.left=X+(EN(casella.currentStyle.width)*(Math.floor(n/altezzaColonna)))+"px"; 
  if(matrice) matrice.push(casella); 
 }
}
in modo da posizionarle dove meglio si ritiene.

Aggiungere le caselle a un Array (facoltativo)

Aggiungiamo anche un Array al quale aggiungere le caselle.
function CreaCaselle(numero,altezzaColonna,classe,matrice){
 var casella;
 for(var n=0;n<numero;n++){  
  //codice che crea una casella di tipo div e l'appende al documento
  casella=document.createElement("div");
  document.body.appendChild(casella);
  
  //codice che "conforma" la casella attribuendole una classe del CSS
  casella.className=classe;
  
  //Codice che stabilisce le coordinate della casella in base all'altezza della colonna
  casella.style.top=(EN(casella.currentStyle.height)*(n%altezzaColonna))+"px";
  casella.style.left=(EN(casella.currentStyle.width)*(Math.floor(n/altezzaColonna)))+"px"; 
  if(matrice) matrice.push(casella); 
 }
}
Così, se viene fornito l'ultimo parametro, ossia il nome di un Array al quale aggiungere le caselle, le caselle vi vengono aggiunte, altrimenti se non viene fornito il parametro, l'istruzione di aggiunta viene ignorata.
Si tratta di un parametro facoltativo.

Posizionamento in libreria della funzione creaCaselle, e successivi aggiustamenti.

Ora devo isolare la funzione che crea un gruppo di caselle... e porla in libreria.

Vediamo come si può fare...

Ecco: isolato il codice, e creata una funzione avente per parametri il numero totale di caselle e l'altezza della colonna (se per numero ho 10 e per altezza della colonna ho 3, mi creerà tre colonne da 3 caselle più una di una casella... e così via...
function CreaCaselle(numero,altezzaColonna){
        var casella;
 for(var n=0;n<numero;n++){  
  //codice che crea una casella di tipo div e l'appende al documento
  casella=document.createElement("div");
  document.body.appendChild(casella);
  
  //codice che "conforma" la casella attribuendole una classe del CSS
  casella.className="casella";
  
  //Codice che stabilisce le coordinate della casella in base all'altezza della colonna
  casella.style.top=(EN(casella.currentStyle.height)*(n%altezzaColonna))+"px";
  casella.style.left=(EN(casella.currentStyle.width)*(Math.floor(n/altezzaColonna)))+"px";  
 }
}
La posso mettere nella libreria, adesso.

Ci metto anche la funzione che crea la proprietà indexOf per i vecchi browser IE:
Array.prototype.indexOf=function(oggetto){
 for(var i=0;i<this.length;i++){
  if(this[i]==oggetto) return i;
 }
 return -1;
}
Così facciamo un po' d'ordine e la pagina principale diventa così (senza il problema degli Array e delle date, ancora):
<html>
<head>
<style>
.casella{
 border:1px solid blue;
 width:120px;
 height:15px;
 font-size:8px;
 position:absolute;
}
</style>

<script src="../librerie/funzioni.js"></script>
<script>
window.onload=main;

function main(){ 
 CreaCaselle(20,6); 
}
</script>
</head>
<body>
</body>
</html>

Però bisogna specificare nei parametri della funzione CreaCaselle anche la classe del foglio di stile che si vuole dare alle caselle: essa non può essere predefinita nella funzione!
Poca difficoltà nel fare questo: modifichiamo in modo che il nome della classe venga passato come parametro.
function CreaCaselle(numero,altezzaColonna,classe){
 var casella;
 for(var n=0;n<numero;n++){  
  //codice che crea una casella di tipo div e l'appende al documento
  casella=document.createElement("div");
  document.body.appendChild(casella);
  
  //codice che "conforma" la casella attribuendole una classe del CSS
  casella.className=classe;
  
  //Codice che stabilisce le coordinate della casella in base all'altezza della colonna
  casella.style.top=(EN(casella.currentStyle.height)*(n%altezzaColonna))+"px";
  casella.style.left=(EN(casella.currentStyle.width)*(Math.floor(n/altezzaColonna)))+"px";  
 }
}
cosicchè, avendo due stili nella sezione CSS, posso, variando il parametro, avere due formati completamente diversi delle mie caselle:
<html>
<head>
<style>
.casella{
 border:1px solid blue;
 width:120px;
 height:15px;
 font-size:8px;
 position:absolute;
}

.casella2{
 border:1px solid red;
 width:300px;
 height:20px;
 font-size:8px;
 position:absolute;
}
</style>

<script src="../librerie/funzioni.js"></script>
<script>
window.onload=main;

function main(){ 
 CreaCaselle(20,6,"casella2"); 
}
</script>
</head>
<body>
</body>
</html>
Ecco, cambiando la stringa passata come parametro posso far sì che le caselle abbiano lo stile casella o casella2.

Creazione della proprietà indexOf degli Array nei vecchi browser IE (come io posseggo su questo computer)

Ecco risolto il modo di individuare, a ogni oggetto di un array che venga cliccato, l'individuazione del suo indice nell'ambito della matrice, superando il problema dei vecchi browser IE che non implementano la proprietà indexOf.

Usando il prototipo dell'oggetto Array:
Array.prototype.indexOf=function(oggetto){
 for(var i=0;i<this.length;i++){
  if(this[i]==oggetto) return i;
 }
 return -1;
}
ottengo come risultato, nell'Array che creerò successivamente, l'esistenza di una proprietà indexOf che mi restituisce l'indice dell'elemento passato come parametro se il parametro è presente, altrimenti mi restituisce -1.

Cliccando su una casella dell'array, l'evento onmousedown viene recepito dall'oggetto document (l'evento "bubbla" e viene recepito da quello gerarchicamente superiore), ma event.srcElement mi offre l'elemento su cui si è avuto l'evento. Quindi posso scrivere:
document.onmousedown=function(){alert(Nomi.indexOf(event.srcElement))};
e ottengo l'indice dell'elemento nell'ambito dell'Array!

Creazione di Array di caselle del calendario.

Adesso cerchiamo di incasellare queste caselle in un Array!

<script src="../librerie/funzioni.js"></script>

<script>
var casella;
var CaselleInColonna;
var NumeroCaselle;

window.onload=main;
NumeroCaselle=30;
CaselleInColonna=30;
var dat;
function main(){
 dat=new Date();
 dat.setDate(1);
 
 var Nomi =new Array();
 
 for(var n=0;n<NumeroCaselle;n++){
  casella=document.createElement("div");
  document.body.appendChild(casella);
  casella.className="casella";
  casella.style.top=(EN(casella.currentStyle.height)*(n%CaselleInColonna))+"px";
  casella.style.left=(EN(casella.currentStyle.width)*(Math.floor(n/CaselleInColonna)))+"px";
  casella.innerHTML=dataString(dat,WDLETTERALE);
  Nomi.push(casella);
  dat.setDate(1+dat.getDate());  
 }
 alert(Nomi[3].innerHTML);
}



</script>
La riga in verde è una riga-test che mi restituisce il contenuto della quarta casella...

sabato 30 marzo 2013

Miglioramento della funzione che esprime la data di oggi in vari formati.

...ma meglio farlo definendo delle costanti, anzichè delle stringhe:
var WeekDays=new Array("domenica","lunedi","martedi","mercoledi","giovedi","venerdi","sabato");
var Months=new Array("gennaio","febbraio","marzo","aprile","maggio","giugno","luglio","agosto","settembre","ottobre","novembre","dicembre");
 
var WDLETTERALE=0;
var WDNUMERICO=1;
var LETTERALE=2;
var NUMERICO=3;

 
function dataString(formato){
 var D,WD,M,Y
 var dat=new Date();
 D=dat.getDate();
 WD=dat.getDay();
 M=dat.getMonth();
 Y=dat.getYear();
 if(formato==WDLETTERALE){
  return (WeekDays[WD]+" "+D+" "+Months[M]+" "+Y);
 }else if (formato==WDNUMERICO){
  return (WeekDays[WD]+" "+D+" "+(M+1)+" "+Y);
 }else if (formato==LETTERALE){
  return (D+" "+Months[M]+" "+Y);
 }else if (formato ==NUMERICO){
  return (D+" "+(M+1)+" "+Y);
 }else if(formato==null){
  return (D+" "+(M+1)+" "+Y);
 }
}
richiamandole così:
<script src="../librerie/funzioni.js"></script>

....................

function main(){
 alert(dataString(WDLETTERALE));
 alert(dataString(WDNUMERICO));
 alert(dataString(LETTERALE));
 alert(dataString(NUMERICO));
 alert(dataString());
}

Una funzione che esprime la data di oggi in vari formati.

Ecco! Ho creato una funzione che mostra la data di oggi nel formato voluto a seconda del parametro. Inserendola nelle librerie, non appesantisce il codice principale:
var WeekDays=new Array("domenica","lunedi","martedi","mercoledi","giovedi","venerdi","sabato");
var Months=new Array("gennaio","febbraio","marzo","aprile","maggio","giugno","luglio","agosto","settembre","ottobre","novembre","dicembre");
 
 
function dataString(formato){
 var D,WD,M,Y
 var dat=new Date();
 D=dat.getDate();
 WD=dat.getDay();
 M=dat.getMonth();
 Y=dat.getYear();
 if(formato=="weekday letterale"){
  return (WeekDays[WD]+" "+D+" "+Months[M]+" "+Y);
 }else if (formato=="weekday numerico"){
  return (WeekDays[WD]+" "+D+" "+(M+1)+" "+Y);
 }else if (formato=="letterale"){
  return (D+" "+Months[M]+" "+Y);
 }else if (formato =="numerico"){
  return (D+" "+(M+1)+" "+Y);
 }else{
  return (D+" "+(M+1)+" "+Y);
 }
}
richiamata dal programma principale in questo modo:
<script src="../librerie/funzioni.js"></script>

..........

function main(){
 alert(dataString("weekday letterale"));
 alert(dataString("weekday numerico"));
 alert(dataString("letterale"));
 alert(dataString("numerico"));
 alert(dataString());
}
Buono!

venerdì 29 marzo 2013

Gestiamo le date per creare un calendario...

Ora voglio delle caselle disposte in forma di calendario, con le date di un mese.

Ripassiamo come gestire le date con Javascript...

Ecco il codice che mi mette in una casella di dialogo la data scritta per esteso in italiano:
function main(){
 var D,WD,M,Y
 var WeekDays=new Array("domenica","lunedi","martedi","mercoledi","giovedi","venerdi","sabato");
 var Months=new Array("gennaio","febbraio","marzo","aprile","maggio","giugno","luglio","agosto","settembre","ottobre","novembre","dicembre");
 var dat=new Date();
 D=dat.getDate();
 WD=dat.getDay();
 M=dat.getMonth();
 Y=dat.getYear();
 alert(WeekDays[WD]+" "+D+" "+Months[M]+" "+Y);
}

giovedì 28 marzo 2013

Ecco la disposizione delle caselle in colonne ben realizzata!

Per prima cosa definire il numero delle caselle che si vuole, quindi l'altezza delle colonne.

Ecco: trovata la soluzione: 30 caselle disposte in 4 colonne di 7 elementi col resto di due.
<html>
<head>
<style>
.casella{
 border:1px solid red;
 width:200px;
 height:20px;
 position:absolute;
}
</style>

<script src="../librerie/funzioni.js"></script>

<script>
var casella;
var CaselleInColonna;
var NumeroCaselle;

window.onload=main;
NumeroCaselle=30;
CaselleInColonna=7;
function main(){
 for(var n=0;n<NumeroCaselle;n++){
  casella=document.createElement("div");
  document.body.appendChild(casella);
  casella.className="casella";
  casella.style.top=(EN(casella.currentStyle.height)*(n%CaselleInColonna))+"px";
  casella.style.left=(EN(casella.currentStyle.width)*(Math.floor(n/CaselleInColonna)))+"px";
 }
}
</script>
</head>
<body>

</body>
</html>

martedì 26 marzo 2013

Righe e colonne.

Una nuova implementazione di un calendario...

<html>
<head>
<style>
.casella{
 border:2px solid blue;
 width:200px;
 height:100px;
 position:absolute;
}
</style>


<script>
var casella;
window.onload=main;
function main(){
 
 casella=document.createElement("div");
 casella.className="casella";
 document.body.appendChild(casella);
}
</script>
</head>
<body>

</body>
</html>
Questo crea una semplice casella ex novo... come già sapevamo...
Possiamo anche creare una funzione ex novo...
<html>
<head>
<style>
.casella{
 border:2px solid red;
 width:200px;
 height:100px;
 position:absolute;
}
</style>


<script>
var casella;
window.onload=main;
function main(){
 
 creaCasella("div","casella");
}
function creaCasella(tipo,classe){
 casella=document.createElement(tipo);
 casella.className=classe;
 document.body.appendChild(casella);
}
</script>
</head>
<body>

</body>
</html>
Bene. Ovviamente funziona... Ora introduciamo le coordinate...

Ma dobbiamo calcolare le righe e le colonne.

Ecco un modo di usare l'operazione modulo per calcolare il numero delle celle contenute in una colonna:
<html>
<head>
<style>
.casella{
 border:2px solid red;
 width:200px;
 height:10px;
 position:absolute;
}
</style>

<script src="../librerie/funzioni.js"></script>

<script>
var casella;
window.onload=main;
function main(){
 for(var n=0;n<7;n++){
  creaCasella("div","casella",0,30*(n%7));
 }
}
function creaCasella(tipo,classe, sinistra, alto){
 casella=document.createElement(tipo);
 casella.className=classe;
 casella.style.top=alto+"px";
 casella.style.left=sinistra+"px";
 document.body.appendChild(casella);
}
</script>
</head>
<body>

</body>
</html>

venerdì 22 marzo 2013

Cominciamo a muovere insieme genitori e figli...

function OnMouseDown(){
 if(event.srcElement.parentNode!=document.body){
  oggetto=event.srcElement.parentNode;
 }else{
  oggetto=event.srcElement;
 }

O meglio anche una strategia che ritrovi il parente più "anziano"...
function OnMouseDown(){
 oggetto=event.srcElement;
 while (oggetto.parentNode!=document.body){
  oggetto=event.srcElement.parentNode;
 }
Così da qualunque elemento si parta, alla fine si fa sempre riferimento al "parente" più anziano!

lunedì 18 marzo 2013

Eventi nell'ambito del DOM

Un oggetto genitore e un oggetto figlio:
<div id="oggetto">
 <div id="oggetto1">
 </div>
</div>
Secondo i fogli di stile, li coloro diversamente e do loro una grandezza consona:
#oggetto{
 top:0px;
 left:10px;
 width:100px;
 height:100px;
 background-color:red;
 position:absolute;
} 
#oggetto1{
 width:50px;
 height:50px;
 background-color:blue;
 position:absolute;
}
Ecco...

Ora, essendo la mia pagina collegata alle opportune mie "librerie" dragdropS.js e funzioni.js, che consentono il trascinamento degli oggetti, vado a trascinare il "contenitore", ossia il "genitore".
Se trascino il genitore, anche il figlio si muove solidalmente.
Se trascino il figlio, questo se ne va per cavoli suoi.

Perchè?

Se ho capito bene, il bubbling fa in modo che l'evento subito dal figlio venga intercettato ed elaborato dal genitore.
No!
Nel mio dragdrop, l'evento non è intercettato dai DIV, ma da document. Questo impone un diverso modo di pensare...

venerdì 15 marzo 2013

Creato finalmente il codice di gestione delle collisioni, ci si studia un po' sopra.

Bene! Non metto qui il codice per esteso, ma cerco di aggiustarmelo in modo tale da incapsularmelo un po'.

Sembra che finalmente ci sono riuscito!, a fare un codice per la gestione delle collisioni.
Dopo un paio di bugs, uno che mi ha fatto sputare il sangue e un altro che ho capito subito e risolto con poca fatica, sembra che adesso sia perfetto.


Gestiamo ora il modo di chiamare questo modulo, che si chiama dragdrop.js.

Quando volevo usare quel dragdrop.js che avevo costruito basandomi sul tutorial per il trascinamento trovato in rete, l'unica cosa fondamentale era l'operazione
window.onload=main;
 
function main(){
 document.onmousedown=OnMouseDown;
}
Ossia innescare la funzione main() al caricamento della finestra e quindi, nel contesto della funzione main() assimilare l'evento mousedown alla funzione OnMouseDown.

Ora, invece, sulla pagina che usa il modulo dragdrop.js il codice è un po' più complesso perchè deve definire la matrice di ostacoli:
var ostacoli;
window.onload=main;

function main(){
 ostacoli=document.getElementsByTagName("div");
 document.onmousedown=OnMouseDown;
}
In questo caso ho impostato come matrice l'insieme degli elemento div, ma posso impostare qualunque matrice mediante l'uso dell'oggetto Array.
Quindi, riepilogando, le uniche condizioni per usare il modulo dragdrop.js sono:
  • associare all'evento onmousedown la funzione OnMouseDown;
  • impostare la matrice di ostacoli.
A questo punto la prossima mossa è creare matrici diverse da questa, immettendo elementi selezionati in essa e non tutti i DIV in generale.

giovedì 7 marzo 2013

Appunto bozza ennesima strategia nel tentativo di un codice per le collisioni (dannazione!)

Una bozza dell'ennesimo tentativo di strategia per le collisioni (speriamo che sia la volta buona). Appunto per ricopiare il codice da altro computer.
var BaseX, BaseY;
var MouseX, MouseY;
var oggetto;
var ostacolo;
var ostacolo2;
var prevSx,prevDx,prevHi,prevLo;
var MotoOrizzontale=true;
var MotoVerticale=true;
var ostacoli;
var Sx,Hi;
var ConsentitoADestra;
var ConsentitoASinistra=true;
function OnMouseDown(){
 ostacoli=document.getElementsByTagName("div");
 ostacolo=$("ostacolo1");
 ostacolo2=$("ostacolo2");
 oggetto=event.srcElement;
 oggetto.onselectstart=function(){return false};
 BaseX=EN(oggetto.currentStyle.left);
 BaseY=EN(oggetto.currentStyle.top);
 MouseX=event.clientX;
 MouseY=event.clientY;
 document.onmousemove=OnMouseMove;
 document.onmouseup=OnMouseUp;
 
}

function OnMouseMove(){
 prevSx=sinistro(oggetto);
 prevDx=destro(oggetto);
 prevHi=alto(oggetto);
 prevLo=basso(oggetto);
 
 Sx=BaseX+event.clientX-MouseX;
 Hi=BaseY+event.clientY-MouseY
 
 $("test").innerHTML=DirezioneOrizzontale(Sx,prevSx);
 if (ConsentitoADestra){
  if(DirezioneOrizzontale(Sx,prevSx)=="destra") oggetto.style.left=Sx+"px";
 }
 if (ConsentitoASinistra){
  if(DirezioneOrizzontale(Sx,prevSx)=="sinistra") oggetto.style.left=Sx+"px";
 }
 oggetto.style.top=Hi+"px";
 
 
 
 
} 
 

function DirezioneOrizzontale(X, prevX){
 if(X>prevX) {
  return "destra";
 }else if(X<prevX) {
  return "sinistra";
 }else{
  return "fermo";
 }
}
 
 /*if(sinistro(oggetto)<100) {
  MotoOrizzontale=false;
  oggetto.style.left=(100)+"px";
 }else{
  MotoOrizzontale=true;
 }
 
 
 
 if(basso(oggetto)>300) {
  MotoVerticale=false;
  oggetto.style.top=(300-altezza(oggetto))+"px";
 }else{
  MotoVerticale=true;
 }*/




function OnMouseUp(){
 
 document.onmousemove=null;
}


//FUNZIONI DINAMICHE VERSO LE QUATTRO SEMIPROIEZIONI
//----------------------------------------------------------------------------------------
function OggettoVersoLaSemiproiezioneOrizzontaleDestra(ost){
 if(prevDx<=sinistro(ost) && OggettoNellaSemiproiezioneOrizzontaleDestra(ost)) return true;
}

function OggettoVersoLaSemiproiezioneOrizzontaleSinistra(ost){
 if(prevSx>=destro(ost) && OggettoNellaSemiproiezioneOrizzontaleSinistra(ost)) return true;
}

function OggettoVersoLaSemiproiezioneVerticaleInferiore(ost){
 if(prevLo<=alto(ost) && OggettoNellaSemiproiezioneVerticaleInferiore(ost)) return true;
}

function OggettoVersoLaSemiproiezioneVerticaleSuperiore(ost){
 if(prevHi>=basso(ost) && OggettoNellaSemiproiezioneVerticaleSuperiore(ost)) return true;
}
//-----------------------------------------------------------------------------------------


//FUNZIONI STATICHE SULLE QUATTRO SEMIPROIEZIONI
//----------------------------------------------------------------------------------------------
function OggettoNellaSemiproiezioneOrizzontaleDestra(ost){
 if(OggettoNellaProiezioneOrizzontale(ost) && OggettoNelSemicampoDestro(ost)) return true;
}

function OggettoNellaSemiproiezioneOrizzontaleSinistra(ost){
 if(OggettoNellaProiezioneOrizzontale(ost) && OggettoNelSemicampoSinistro(ost)) return true;
}

function OggettoNellaSemiproiezioneVerticaleInferiore(ost){
 if(OggettoNellaProiezioneVerticale(ost) && OggettoNelSemicampoInferiore(ost)) return true;
}

function OggettoNellaSemiproiezioneVerticaleSuperiore(ost){
 if(OggettoNellaProiezioneVerticale(ost) && OggettoNelSemicampoSuperiore(ost)) return true;
}
//----------------------------------------------------------------------------------------------



//FUNZIONI STATICHE SULLE DUE PROIEZIONI
//----------------------------------------------------------------------------------------------
function OggettoNellaProiezioneOrizzontale(ost){
 if(OggettoNelSemicampoSuperiore(ost) && OggettoNelSemicampoInferiore(ost)) return true;
}

function OggettoNellaProiezioneVerticale(ost){
 if(OggettoNelSemicampoDestro(ost) && OggettoNelSemicampoSinistro(ost)) return true;
}
//-----------------------------------------------------------------------------------------------


//FUNZIONI STATICHE SUI QUATTRO SEMICAMPI
//-----------------------------------------------------------------------------------------------
function OggettoNelSemicampoDestro(ost){
 if(destro(oggetto)>sinistro(ost)) return true;
}

function OggettoNelSemicampoSinistro(ost){
 if(sinistro(oggetto)<destro(ost)) return true;
}

function OggettoNelSemicampoInferiore(ost){
 if(basso(oggetto)>alto(ost)) return true;
}

function OggettoNelSemicampoSuperiore(ost){
 if(alto(oggetto)<basso(ost)) return true;
}
//----------------------------------------------------------------------------------------------

function sinistro(ogg){
 return EN(ogg.currentStyle.left);
}

function larghezza(ogg){
 return EN(ogg.currentStyle.width);
}

function destro(ogg){
 return EN(sinistro(ogg)+larghezza(ogg));
}

function alto(ogg){
 return EN(ogg.currentStyle.top);
}
 
function altezza(ogg){
 return EN(ogg.currentStyle.height);
}

function basso(ogg){
 return EN(alto(ogg)+altezza(ogg));
}