Newsgroup: it.comp.lang.javascript
Titolo: javascript 1.5

Non sono ancora riuscito a capire se javascript 1.5 supporta le classi o no?
Lo standard ECMA dice addirittura che è possibile derivare delle classi da
altre tipo "class beta extend alfa { }", ma se provo anche solo a fare una
semplice dichiarazione ("class prova { }") Mozilla se ne frega proprio...
Qualcuno mi sa chiarire il discorso per favore?
Grazie in anticipo

 altre tipo "class beta extend alfa { }",
Non lo standard ECMA a cui JS 1.5 fa riferimento (ECMA 262 Ed.3).
Penso tu ti riferisca all'ECMA 262 Ed.4, che - ai tempi, non so ora - 
era ancora WIP.
JS 2.0 e' solamente una proposta *sperimentale*.
-- 
C'ya,
ZER0
  :. job profile - coder.gfxer.webDesigner
"When you have eliminated the impossible, whatever remains,
however improbable, must be the truth." (S.H.)

> No, JS 1.5 non supporta le classi. E' prototype-based.
Mi puoi dare qualche info in più su "prototype-based". Magari qualche
esempio sarebbe il massimo...
Grazie ancora

 Magari qualche esempio sarebbe il massimo...
Il link che ti ho dato dovrebbe essere abbastanza esauriente (con esempi 
a seguito).. E' bene o male la stessa guida che vi era per JS 1.3 per 
Netscape 4.x


Ti ringrazio ma ancora non ho risolto il mio problema...dammi una mano!
dichiaro un nuovo oggetto in questo modo
"var Root = new Movie();"
Movie è un oggetto che ho definito io in C++ e fin qui nessun problema:
posso tranquillamente richiamare i metodi e le proprietà di tale oggetto
come da me definiti (es: Root.NextFrame(), Root.CurrentFrame = 2, ecc...) e,
testato, non fa una grinza.
Il problema nasce qui:
function OnClick()
{
NextFrame();
}
Mettiamo che definisco una funzione "OnClick()", come effettuo l'aggancio ti
tale funzione con l'oggetto Root in modo tale che se all'interno di
"OnClick" richiamo "NextFrame" la chiamata finale risulti Root.NextFrame() ?
Spero di essermi spiegato...
Grazie ancora della tua attenzione!

 Grazie ancora della tua attenzione!
Di niente. Puoi contraccambiare rispondendo alla domanda di cui prima :)


 Root.OnClick=OnClick;
Così ci ho già straprovato ma non funziona perchè se effettuo la chiamata
"OnClick" non viene implicitamente richiamato "Root.OnClick" (che è quello a
cui punto...).
Cosa ancora migliore per me sarebbe poter definire una cosa di questo tipo:
function Root.Alfa.OnClick()
{
    ...
}
cioè il target dell'oggetto più l'evento, ma così proprio non se ne
parla...confermi?
Ciao

 parla...confermi?
Confermo che quella sintassi non e' valida in JS (se non si gestisce un 
Alfa sull'oggetto Root), ma mi sfugge l'approccio, sinceramente.
Temo che il discorso si faccia complicato e abbastanza OT. Che ne dici 
se passiamo in mail e ne parliamo con calma, senza la nettiquette che ci 
pende sopra il capo?
Inoltre, di che tipo di applicativo si tratta? E' forse un gioco?


 pende sopra il capo?
Scrivo qui? 
zer0....@libero.it

 Scrivo qui? [cut]
Mi avevi gia' scritto, ti avevo anche risposto all'epoca, e gia' non ti 
ricordi? ;) Cmq si, l'indirizzo e' quello.


Spero di essermi spiegato...
Ora sparo la cazzata .... ma non basta
Movie.prototype.OnClick = function() {
	this.NextFrame();
}
...cioè a dir la verità non ho idea di come un oggetto in C++ possa essere
esteso via JS.
Però non mi sembra OT, anzi è interessantissimo!!
Ciao.
Faser
-- 
FABIO SERRA
*Questo testo deve essere valutato secondo il senso della RFC-3*
Per rispondere in e-mail sostituire "invalid" con "faser"
--------------------

 Però non mi sembra OT, anzi è interessantissimo!!
Sul fatto che sia interessante per me e per te non c'e' dubbio, ma 
rispetto all'NG credo che un topic del genere possa riguardare una 
minoranza (tre, quattro persone forse.. noi compresi). Mi sono spostato 
in mail (e da li' alla chat) perche' pensavo che l'argomento fosse solo 
tra me e Berserker.


rispetto all'NG credo che un topic del genere possa riguardare una 
Forse, si, comunque l'argomento mi pare perfettamente topic ...si parlava
di Javascript.
Ciao.
Faser
-- 
FABIO SERRA
*Questo testo deve essere valutato secondo il senso della RFC-3*
Per rispondere in e-mail sostituire "invalid" con "faser"
http://www.cfmentor.com
--------------------

 di Javascript.
Giusto, ma di un uso un po' particolare di Javascript.
Esistono NG appositi per parlare di implementazioni a cosi' basso 
livello di linguaggio di scripting, tra cui JS.
Qua si scende piu' sulla programmazione C++ che sul Javascript puro.
Il problema di base e' dato dal contesto in cui si usa spidermonkey, 
dall'enviroment (C++), non tanto da JS in se'.
L'OT a cui si poteva andare incontro, era questo. Una volta chiariti i 
problemi di integrazione C++/Script Engine, domande prettamente legati a 
sintassi JS sono ovviamente un'altro discorso :)
(Esempio, quando tu hai chiesto dell'object initializer.. anche se 
sviluppavi XUL etc).
Sommando a questo il fatto che a seguire il topic probabilmente s'era 
solo io e lui, ho pensato di passare in mail. :)


 Però non mi sembra OT, anzi è interessantissimo!!
Eccotelo :
---------------------------------------------------------------
Header
---------------------------------------------------------------
#ifndef _MOVIE_H
#define _MOVIE_H
#include "js\jsapi.h"
class CMovie
{
private:
 CMovie();
 virtual ~CMovie();
public:
 static JSObject * Init(JSContext *cx, JSObject *obj, JSObject *proto =
NULL);
private:
 static JSBool Constructor(JSContext *cx, JSObject *obj, uintN argc, jsval
*argv, jsval *rval);
 static void Destructor(JSContext *cx, JSObject *obj);
 static JSBool NextFrame(JSContext *cx, JSObject *obj, uintN argc, jsval
*argv, jsval *rval);
 static JSBool PrevFrame(JSContext *cx, JSObject *obj, uintN argc, jsval
*argv, jsval *rval);
 static JSBool GetProperty(JSContext *cx, JSObject *obj, jsval id, jsval
*vp);
 static JSBool SetProperty(JSContext *cx, JSObject *obj, jsval id, jsval
*vp);
 static JSClass MovieClassInfo;
private:
 static JSFunctionSpec MovieClassMethods[];
 enum
 {
  CurrentFrameProp
 };
 static JSPropertySpec MovieClassProperties[];
public:
 inline const int & GetFrame() const { return m_CurrentFrame; };
 inline void SetFrame(int Frame) { m_CurrentFrame = Frame; };
 inline void NextFrame() { m_CurrentFrame++; };
 inline void PrevFrame() { if(m_CurrentFrame > 0) m_CurrentFrame--; };
protected:
 int m_CurrentFrame;
};
#endif // _MOVIE_H
---------------------------------------------------------------
Source
---------------------------------------------------------------
#include "Movie.h"
JSClass CMovie::MovieClassInfo =
{
 "Movie",    // name
 JSCLASS_HAS_PRIVATE, // flags
 JS_PropertyStub,  // addProperty
 JS_PropertyStub,  // delProperty
 CMovie::GetProperty, // getProperty
 CMovie::SetProperty, // setProperty
 JS_EnumerateStub,  // enumerate
 JS_ResolveStub,   // resolve
 JS_ConvertStub,   // convert
 CMovie::Destructor  // Finalize
};
JSPropertySpec CMovie::MovieClassProperties[] =
{
    { "CurrentFrame", CurrentFrameProp, JSPROP_ENUMERATE },
 { NULL } // Fine della dichiarazione delle proprietà della classe
};
JSFunctionSpec CMovie::MovieClassMethods[] =
{
 {
  "NextFrame",  // Nome del metodo visibile nello script
  NextFrame,   // Puntatore alla funzione da richiamare
  0,     // Numero di argomenti
  0,
  0
 },
 {
  "PrevFrame",
  PrevFrame,
  0,
  0,
  0
 },
 { NULL } // Fine della dichiarazione dei metodi della classe
};
CMovie::CMovie()
{
 m_CurrentFrame = 0;
}
CMovie::~CMovie()
{
}
JSObject *CMovie::Init(JSContext *cx, JSObject *obj, JSObject *proto)
{
 // Crea il nuovo oggetto CMovie specificandone il costruttore da richiamare
e i metodi della classe
    JSObject *pInitMovie = JS_InitClass(cx, obj, proto, &MovieClassInfo,
CMovie::Constructor, 0, NULL, CMovie::MovieClassMethods, NULL, NULL);
 // Specifica le proprietà per l'oggetto
 JS_DefineProperties(cx, pInitMovie, CMovie::MovieClassProperties);
 return pInitMovie;
}
JSBool CMovie::Constructor(JSContext *cx, JSObject *obj, uintN argc, jsval
*argv, jsval *rval)
{
 // Crea il nuovo oggetto CMovie
 CMovie *pNewMovieObject = new CMovie();
 // Salva il puntatore al nuovo oggetto CMovie nello script
 JS_SetPrivate(cx, obj, pNewMovieObject);
 return JS_TRUE;
}
void CMovie::Destructor(JSContext *cx, JSObject *obj)
{
 // Ottiene il puntatore all'oggetto CMovie precedentemente salvato nello
script (nel costruttore)
 CMovie *pMovieObject = (CMovie *) JS_GetPrivate(cx, obj);
 delete pMovieObject;
}
JSBool CMovie::NextFrame(JSContext *cx, JSObject *obj, uintN argc, jsval
*argv, jsval *rval)
{
 // Ricava il puntatore all'oggetto CMovie dallo script
 CMovie *pThis = (CMovie *) JS_GetPrivate(cx, obj);
 if(pThis)
 {
  pThis->NextFrame();
  return JS_TRUE;
 }
 return JS_FALSE;
}
JSBool CMovie::PrevFrame(JSContext *cx, JSObject *obj, uintN argc, jsval
*argv, jsval *rval)
{
 CMovie *pThis = (CMovie *) JS_GetPrivate(cx, obj);
 if(pThis)
 {
  pThis->PrevFrame();
  return JS_TRUE;
 }
 return JS_FALSE;
}
JSBool CMovie::GetProperty(JSContext *cx, JSObject *obj, jsval id, jsval
*vp)
{
    if(JSVAL_IS_INT(id))
 {
  CMovie *pMovie = (CMovie *) JS_GetPrivate(cx, obj);
  switch(JSVAL_TO_INT(id))
  {
  case CurrentFrameProp:
        {
         *vp = INT_TO_JSVAL(pMovie->GetFrame());
        }
    break;
  default:    return JS_FALSE;
        }
  return JS_TRUE;
    }
    return JS_TRUE;
}
JSBool CMovie::SetProperty(JSContext *cx, JSObject *obj, jsval id, jsval
*vp)
{
 if(JSVAL_IS_INT(id))
 {
  CMovie *pMovie = (CMovie *) JS_GetPrivate(cx, obj);
  switch(JSVAL_TO_INT(id))
  {
  case CurrentFrameProp:
        {
         int32 NewFrame;
         if(JS_ValueToInt32(cx, *vp, &NewFrame) == JS_FALSE)
          return JS_FALSE;
         pMovie->SetFrame(NewFrame);
        }
   break;
  default:    return JS_FALSE;
        }
  return JS_TRUE;
    }
    return JS_TRUE;
}
---------------------------------------------------------------

 Eccotelo :
[cut C++ code]
Faser, capito perche' dicevo che si andava sull' OT? ;)
