Wie kann ich feststellen ob ein Parentscript eine Eigenschaft hat

[bokel]

Ich möchte prüfen, ob ein Objekt einen Handler hat.
Das mache ich normalerweise mit handler.
Allerdings liefert handler false, wenn der Handler in einem
AncestorScript definiert ist.
Wenn ich jetzt einfach auf ancestor zugreife und das aktuelle Objekt keinen ancestor hat, kriege ich eine Fehlermeldung.
Wie kann ich feststellen, ob ein script-Objekt eine Eigenschaft hat, ohne eine Fehlermeldung zu bekommen ?

-- parentscript testObjekt
-- ein objekt ohne eigenschaften
on new me
     return me
end new
 
-- framescript test
-- eine instanz erzeugen 
on exitFrame
    instanz = script("testObjekt")
    if( voidP(instanz.eigenschaft)) then
          put "Die Eigenschaft gibt es nicht"
    end if
end exitFrame 

mfg. r

[bokel]

Eine ganz harte Möglichkeit habe ich gerade schon gefunden:
Ich kann die Fehlermeldungen unterdrücken, indem ich den AlertHook setze.
Aber gibt es nicht was sauberes ?

[rena]

Spontan fällt mir dazu nur ein, die Liste zu durchsuchen

instanz = script("testObjekt")
  repeat with n = 1 to instanz.count
      put instanz.getPropAt(n)
  end repeat

Gruß
Rena

[bokel]

Danke Rena, das macht Sinn

Ich hätte schwören können, dass getProp nicht mit Scripteigenschaften funktioniert, aber vielleicht war es doch schon zu spät gestern abend.

Hier ist meine Lösung

----
-- Liefere das Objekt in der Vererbungskette, das den Handler wirklich hat oder VOID
----
on findHandler obj, handlerSymbol
  o = obj
  repeat while ( not voidP(o))
    if( o.handler( handlerSymbol)) then 
      return o
    end if
    o = o.getAProp(#ancestor)
  end repeat
  return VOID
end findHandler

mfg r.

[bokel]

Und hier ist der Anwendungsfall:
Ich brauchte es für einen Broadcaster wie es ihn in ActionScript gibt.
Der Broadcaster verschickt Nachrichten an Scriptinstanzen.
Es gibt in Lingo die Möglichkeit, mit sendAllSprites Nachrichten an Sprites zu verschicken.
Das funktioniert allerdings nicht für Scriptinstanzen.
Der Broadcaster ermöglicht genau das.

-- Parentscript Broadcaster
-- Ein Broadcasterobjekt verwaltet eine Liste von Listenern, 
-- denen man Nachrichten schicken kann. Dazu implementieren
-- die Listener die Nachricht als Methode on [msg] me, params 
-- mit der sie die empfangenen Nachrichten verarbeiten können. 
-- 
-- Es macht nichts, wenn ein Objekt eine Msg nicht versteht, 
-- weil vor dem Senden geprüft wird, ob die Methode in dem 
-- Objekt existiert
--
-- @author Ralf Bokelberg <info@bokelberg.de>
-- @date 2004/02/08

property myListeners


on new me
  myListeners = []
  return me
end new


on addListener me, listener
  me.removeListener( listener)
  myListeners.add( listener)
end addListener


on removeListener me, listener
  myListeners.deleteOne( listener)
end remoeveListener


on findListener me, listener
  return myListeners.getOne( listener)
end findListener


on getListenerCount me
  return count( myListeners)
end geListenerCount


on broadcastMessage me, msgSymbol, sender, parm1, parm2, parm3
      call( msgSymbol, myListeners, sender, parm1, parm2, parm3)
end broadcastMessage

Und hier ist ein Anwendungsbeispiel.
Wir erzeugen drei TestObject-Objekte (die von TestAncestorObject erben) und übergeben sie dem Broadcaster als Listener.
Anschliessend schicken wir die Nachrichten #testMethod, #testAncestorMethod und #testNichtVorhanden an alle Listener.

-- Framescript init
on exitFrame me
  
  bc = script("Broadcaster").new()
  
  obj1 = script("TestObject").new("obj1")
  obj2 = script("TestObject").new("obj2")
  obj3 = script("TestObject").new("obj3")
  
  bc.addListener( obj1)
  bc.addListener( obj2)
  bc.addListener( obj3)
  
  put "---------------"
  bc.broadcastMessage( #testMethod, 1, 2, 3)
  put "---------------"
  bc.broadcastMessage( #testAncestorMethod, 1, 2, 3)
  put "---------------"
  bc.broadcastMessage( #testNichtVorhanden, 1, 2, 3)
  put RETURN
end

-- Parentscript TestObject
property ancestor

on new me, name 
  ancestor = script("TestAncestorObject").new( name)
  return me
end new


on testMethod me, p1, p2, p3
  put "TestObject.testMethod" && ancestor.myName && p1 && p2 && p3
end testMethod

-- Parentscript TestAncestorObject
property myName

on new me, name 
  myName = name
  return me
end new

on testAncestorMethod me, p1, p2, p3
  put "TestAncestorObject.testAncestorMethod" && myName && p1 && p2 && p3
end testAncestorMethod

Die Ausgabe muesste dann etwa so aussehen:
-- "---------------"
-- "TestObject.testMethod obj1 1 2 3"
-- "TestObject.testMethod obj2 1 2 3"
-- "TestObject.testMethod obj3 1 2 3"
-- "---------------"
-- "TestAncestorObject.testAncestorMethod obj1 1 2 3"
-- "TestAncestorObject.testAncestorMethod obj2 1 2 3"
-- "TestAncestorObject.testAncestorMethod obj3 1 2 3"
-- "---------------"
-- "


Edit:
Wie ich gerade erfahren habe, kann "call" schon allein fast alles, was wir für den Broadcaster brauchen. Es kann eine Liste von ScriptInstanzen benutzen und wenn es eine Liste ist, erscheinen auch keine Warnhinweise, wenn eine Instanz den entsprechenden Handler nicht hat. Also weg mit dem ganzen Schmarrn (oben geändert)


mfg .r

[rena]

Cool ... danke
Das werd ich doch bei Gelegenheit glatt mal ausprobieren ...

Grüßle
Rena

[MrHoga]

Wie ich gerade erfahren habe, kann "call" schon allein fast alles, was wir für den Broadcaster brauchen. Es kann eine Liste von ScriptInstanzen benutzen und wenn es eine Liste ist, erscheinen auch keine Warnhinweise, wenn eine Instanz den entsprechenden Handler nicht hat. Also weg mit dem ganzen Schmarrn

Fantastisch bokel!

Das ist genau das, was ich (vor 2,5 Std ) in LingoPark gesucht
habe. Du scheinst ein echtes Gespür für die Bedürfnisse der
Menschen zu haben. Berufsbedingt?
Ich möchte mich hiermit vehement für die Beibehaltung des
Lingoforums im Flashforum aussprechen.
Vielen Dank
h.

[MrHoga]

Hatte mir überlegt, wie ich es anstellen könnte, daß ein Event von
Objekt zu Objekt weitergegeben wird. D.h. das angesprochene Objekt
gibt den Event an seine Listener weiter. Meine bisherige
Lösung:

-- ---- Parentscript "cls_EventHandling" ----------
------------------------------------------------------------


-- interneProperties:

property pListeners	-- Liste mit den registrierten Listenern



-- ---------- Methoden: ------------------

on addListener(me, theListener)
	if voidP(pListeners) then
		pListeners = []
	end if
	pListeners.append(theListener)
end addListener


on removeListener(me, theListener)
	if not voidP(pListeners) then
		pListeners.deleteOne(theListener)
	end if
end removeListener

on doEvent(me, paramList)  --paramList = [#Event, param]	
	meList = [me]
	if paramList.count > 1 then
		call(paramList[1], meList, paramList[2])
	else
		call(paramList[1], meList)
	end if
	me.dispatchEvent(paramList)
end doEvent

on dispatchEvent(me, paramList)
	if not voidP(pListeners) then
		call(#doEvent, pListeners, paramList)
	end if
end dispatchEvent

Hat aber den Nachteil, daß auch alle Listener angesprochen werden,
die mit dem Event nichts anfangen können.
Fällt da jemandem noch was Besseres ein?
Gruß h.

[bokel]

In Flash wird es so gemacht, dass für jedes Event eine eigene Liste von Listenern gepflegt wird.
Du kannst dafür das Event als Index in einer assoziativen Liste benutzen.

mfg r.

[MrHoga]

Ah, vielen Dank.
Meinst Du in etwa

pListeners = [#event1:[listener1, listener2], #event2:[listener2]]

da ich ja u.U. mehrere Listener einem Event zuorden möchte,
oder hättest Du einen anderen Vorschlag?
Gruß h.

[bokel]

Genau so.

mfg .r