Changeset 18 for trunk/lingosource/castlib3/ButtonManager.ls

Timestamp:

10/24/08 12:12:09 (4 years ago)

Author:

alex

Message:

updated movie to incorporate new version of library scripts

File:

• trunk/lingosource/castlib3/ButtonManager.ls (modified) (38 diffs)

trunk/lingosource/castlib3/ButtonManager.ls

@@ -1 @@
--- Manager for DrawTable Parentscript used on Bitmap sprites and 3-D Sprites
--- Alex da Franca ©2002  da.franca@online.de
+-- ButtonManager
+-----------------------------------
+-- CREATED:
+--             Alex da Franca c2002  alex@farbflash.de
+--
+-- DESCRIPTION:
+--             Manager for GenericButtonPS Parentscript used on Bitmap sprites and 3-D Sprites
+--
 -- Use this behavior on any dummy sprite to display a scrolling table with selectable items, text (fixed and editable) and images.
 -- It creates a temporary bitmap member, which is used to display the table on the stage.
 -- Specify the contents and appearance of the table in two property lists, which you pass to the mShowTable handler
 -- Use a copy of the parentscript "TableOptionsliste" to build these two lists and receive events from the table
-
-
+--
+-- REQUIRES:
+--             script "GenericButtonPS"
+--
+-- USAGE:
+-- -
+--
+-- HISTORY:
+--
 -- alex am Freitag, 23. April 2004
 -- added mRefreshSpriteRectAfterStageChange() handler to refresh the rect after a stage resize, sent from behavior "resizeStageBehavior"
@@ -60 +73 @@
 
 
+---------------------------------
+-- Scriptmarker (18.09.2008 at 12:06 Uhr): alex changes // Scriptmarker
+-- added handler mSetBroadcastlist to SET the ENTIRE list of callback instances
+-- it now also supports callBackObjects a la [#target, #handler, ...] as callback objects,
+-- which allows for additional parameters in that callbackObject, which gets send as parameter
+
+-- added three new handlers: mSetEventsToProcessList, mAddToEventsToProcessList, mRemoveFromEventsToProcessList
+-- use these handlers to change the events which shall be processed (which trigger events to the event listeners)
+-- -- mSetEventsToProcessList sets the entire list
+-- -- mAddToEventsToProcessList adds an event to the list of events which will be processed
+-- -- mRemoveFromEventsToProcessList removes an event from the list of events which will be processed
+-- -- -- possible events are: #mouseUp, #mouseDown, #mouseEnter, #mouseLeave
+
+-----------------------------------
+
+
+
+property pKanal, pMember
+
 -- xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
 -- xxxxxxxxxxxxxxxxxx PROPERTIES
 -- xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
 
-property pKanal, pMember
 property pOldKeyDown
 property pMyScriptObject
@@ -116 +147 @@
 
 on interface me
-  str = "Button Script  by alex da franca ©2005 -- alex@farbflash.de -- all rigths reserved"
+  str = "Button Script  by alex da franca c2005 -- alex@farbflash.de -- all rigths reserved"
   put RETURN & "version 1.0" after str
   put RETURN & "--------------------------------------------------------" after str
@@ -238 +269 @@
 on mInitProperties me, pipeline
   
-  pIncludes = (mGetAleXtras()).getaprop(#scripts)
+  pIncludes = xscr()
   
   pKeyboardshortcutList = [:]
@@ -276 +307 @@
       -- alex am 8. Oktober 2004 um 10:32
       --      pMember = new(#bitmap)
-      pMember = call(#mGetNewMember, [pIncludes.getaprop(#commonmoviescript)], #bitmap)
+      pMember = pIncludes.mGetNewMember(#bitmap)
       --/ alex am 8. Oktober 2004 um 10:32
       
@@ -364 +395 @@
       -- alex am 8. Oktober 2004 um 10:32
       --      pMember.erase()
-      call(#mEraseMember, [pIncludes.getaprop(#commonmoviescript)], pMember)
+      pIncludes.mEraseMember(pMember)
       -- alex am 8. Oktober 2004 um 10:32
     end if
@@ -735 +766 @@
 
 on mAddButton me, options
+  -----------------------------------
+  -- ACTION: Add a new button. When used on a 2-D sprite, we will always have only one button per behavior
+  --         But if this is used on a 3-D sprite, we have only one behavior hosting different buttons as overlays on the 3-D sprite
+  --         Therefore we have a list of button objects
+  -- INPUT: <options> ; property list ; huge number of properties describing the button, most of which comes from mGetDefaultButtonList()
+  --                    see script "defaultLayoutDefinitions" for all properties, which are available for the layout of the button
+  --                see the below example for the porperties concerning this script:
+  -- RETURNS: -
+  -- CALLER: -
+  -- EXAMPLE: 
+  --
+  --    buttonmembername = "buttonImage"
+  --    options = mGetDefaultButtonList()
+  --    options[#label] = "Choose new model"
+  --    i = member(buttonmembername).image.duplicate()
+  --    options[#myName] = "versionInfoIcon"
+  --    options[#myRect] = rect(0, 0, i.width, i.height)
+  --    options[#marginH] = 0
+  --    options[#marginV] = 0
+  --    options[#broadcastSprites] = [me]
+  --    options[#callFunction] = #mVersionInfoIconClicked
+  --    options[#myName] = buttonmembername
+  --    options[#normalImage] = buttonmembername
+  --    options[#eventsToProcess] = [#mouseDown, #mouseUp]
+  --    options[#disableBlend] = 0
+  --    options[#enabled] = 1
+  --    options[#recalcPosition] = point(0, 0) -- reposition the button on window resize (requires script "resizeWindowScripts" to get resize event)
+  --    
+  --    spr = xscr().mGetKanal(#sceneSprite)
+  --    sendSprite(spr, #mAddButton, options)
+  -----------------------------------
   
   if not(listP(pButtonList)) then mInitProperties me
@@ -744 +806 @@
     options = pOptionsListe
     
-    if call(#mGetMemType, [pIncludes.getaprop(#commonmoviescript)], pMember) = #shockwave3d then -- 3-D mode
+    if pIncludes.mGetMemType(pMember) = #shockwave3d then -- 3-D mode
       r = options[#myRect]
       
@@ -833 +895 @@
   
   GenericButtonPS = mGetXScript(#GenericButtonPS)
-  if voidP(GenericButtonPS) then exit
-  
-  if not objectP(theObject.getaprop(#myScriptObject)) then theObject[#myScriptObject] = new(GenericButtonPS)
+  if listP(GenericButtonPS) then exit
+  
+  if not objectP(theObject.getaprop(#myScriptObject)) then
+    if ilk(GenericButtonPS) = #instance then GenericButtonPS = GenericButtonPS.script
+    theObject[#myScriptObject] = new(GenericButtonPS)
+  end if
   
   if objectP(theObject.getaprop(#myScriptObject)) then -- if we succeded in initializing a button parent script (only fails if script "GenericButtonPS" isn't present))
@@ -871 +936 @@
       mo = pMember.model(val)
       if not(voidP(mo)) then
-        scr = call(#mGetParentScriptList, [pIncludes.getaprop(#commonmoviescript)], mo)
+        scr = pIncludes.mGetParentScriptList(mo)
         
         repeat with n = scr.count down to 1
@@ -900 +965 @@
 
 on mRemoveButton me, tabname
+  -----------------------------------
+  -- ACTION: Remove the specified button
+  -- INPUT: string ; button name
+  -- RETURNS: -
+  -- DEBUG:
+  --    spr = xscr().mGetKanal(#sceneSprite)
+  --    sendSprite(spr, #mRemoveButton, "versionInfoIcon")
+  -----------------------------------
+  
   if not(pButtonList.count) then exit
   
@@ -981 +1055 @@
     -- instead put the removal into a seperate, indepandant event
     
-    dto = call(#mCreateTimeout, [pIncludes.getaprop(#commonmoviescript)], pTextureBaseName&"_cleanup", 100, #mRemoveEmptyListEntries, me)
-    --    if mCheckWoody() = 1 then
-    --      dto = timeout().new(pTextureBaseName&"_cleanup", 100, #mRemoveEmptyListEntries, me)
-    --    else
-    --      dto = timeout(pTextureBaseName&"_cleanup").new(100, #mRemoveEmptyListEntries, me)
-    --    end if
+    dto = pIncludes.mCreateTimeout(pTextureBaseName&"_cleanup", 100, #mRemoveEmptyListEntries, me)
     
   end if
@@ -998 +1067 @@
 end
 
-
--- xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
--- comes from the drop down menu, if any
+-- xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+-- -- comes from the drop down menu, if any
 
 on mHiliteMenu me, val
@@ -1006 +1074 @@
 end
 
-
-
-
 -- xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
 -- xxxxxxxxxxxxxxxxxx Public Handlers to change, control or get the button contents and properties
@@ -1014 +1079 @@
 
 
--- xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
--- check if a button is present -> this script normally simply applies all to the first button in the list, if tabname is unknown/undefined
--- sometimes, this is NOT what I want...
-
 on mIsButtonPresent me, tabname
+  -----------------------------------
+  -- ACTION:   check if a button is present -> this script normally simply applies all to the first button in the list, if tabname is unknown/undefined
+  --           sometimes, this is NOT what I want, therefore I needed a handler to tell, if a given button is present
+  -- INPUT:   <tabname> ; string ; name of the button we want to check
+  -- RETURNS:  boolean ; true, if button exists, false otherwise
+  -----------------------------------
   
   if not(pButtonList.count) then return 0
   
-  return (ilk(pButtonList.getaprop(tabname)) = #proplist)
-  
-end
-
--- xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
--- get the propertylist of the button; e.g. to query the label etc.
--- returns: #property list
+  return objectP(pButtonList.getaprop(tabname))
+  
+end
+
+-- xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+
 
 on mGetButtonProps me, tabname
+  -----------------------------------
+  -- ACTION:   get the propertylist of the button; e.g. to query the label etc.
+  -- INPUT:    <tabname> ; string ; name of the button we want to address
+  -- RETURNS:  #property list ; all button properties
+  -----------------------------------
   
   if not(pButtonList.count) then return [:]
@@ -1045 +1116 @@
 -- xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
 
--- change the text:
--- accepts: #string
 on mChangeLabel me, newLabel, tabname
+  -----------------------------------
+  -- ACTION:   change the button label text => re-render the text and redraw the images
+  -- INPUT:    <newLabel> ; string ; new label
+  --           <tabname> ; string ; name of the button we want to address
+  -- RETURNS: -
+  -----------------------------------
+  
   if ilk(newLabel) <> #string then exit
   
@@ -1060 +1136 @@
 
 -- xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
--- special case of label change
+
+on mChangeLanguage me, tabname
+  -----------------------------------
+  -- ACTION:   special case of label change
 -- if mTranslate() yields another result the labels will change
--- accepts: #string
-on mChangeLanguage me, tabname
+  --           the new label will be determined by the "global" handler mTranslate()
+  --           mTranslate is a handler of "commonMovieScript"
+  -- INPUT:    <tabname> ; string ; name of the button we want to address
+  -- RETURNS: -
+  -----------------------------------
   
   if not(pButtonList.count) then exit
@@ -1074 +1156 @@
 
 -- xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
--- ullala changed 05
+
 on mPause me, tValue
+  -----------------------------------
+  -- ACTION:   disable ALL events of this script, if pPause is true
+  --           (can't remember why ulla put that here, normally we would to enable/disable specific buttons)
+  --           this property disables ALL events for ALL buttons,
+  --           I guess it is only useful, if we have only one button => 2-D sprite
+  -- INPUT: <tValue> ; boolean (integer)
+  -- RETURNS: -
+  -----------------------------------
+  
   pPause = tValue
 end
 
 -- xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
--- toggle the enabled state of the button; 1 = enable, 0 = disable
--- accepts: #integer
+
 on mEnableButton me, val, tabname, alleAusser
+  -----------------------------------
+  -- ACTION:   toggle the enabled state of the button
+  --
+  -- INPUT:    <val> ; boolean (integer) ; 1 = enable, 0 = disable
+  --           <tabname> ; string OR list ; name of the button we want to address or linear list of names of buttons we want to address
+  --           <alleAusser> ; boolean (integer) ; reverse the action if true not the addressed buttons are toggled, but rather
+  --                           all buttons EXCEPT the ones specified in <tabname>
+  -- RETURNS: -
+  -----------------------------------
   
   if not(pButtonList.count) then exit
@@ -1118 +1217 @@
 
 -- xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
--- get the enabled state of the button; 1 = enabled, 0 = disabled
--- returns: #integer
 
 on mGetButtonEnabledState me, tabname
+  -----------------------------------
+  -- ACTION:   get the enabled state of the button
+  --
+  -- INPUT:    <tabname> ; string ; name of the button we want to address
+  -- RETURNS:  boolean (integer)
+  -----------------------------------
   
   if not(pButtonList.count) then return 0
@@ -1134 +1237 @@
 
 -- xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
--- change the event which shall be sent on mouseUp
+-- 
 -- accepts: #symbol, #string
+
 on mSetButtonFunction me, newFunction, tabname
+  -----------------------------------
+  -- ACTION:   change the event which shall be sent to the lsiteners
+  --
+  -- INPUT:   <newFunction> ; symbol or string ; name of the event to send to the listeners
+  --                          Note, that a listener can define itself via a callbackObject,
+  --                          which is made of a #target and a #handler, in that case #handler overrides this functionname
+  --                          and every button can define its own handlernames to call on events
+  --          <tabname> ; string ; name of the button we want to address
+  -- RETURNS:  -
+  -----------------------------------
   
   if not(pButtonList.count) then exit
@@ -1151 +1265 @@
 
 -- xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
--- add a reference to an instance or sprite to the list of instances that get sent the event
--- accepts: #object, #integer
-on mAddToButtonBroadcastlist me, referenz, tabname
+-- 
+-- accepts: #list
+
+on mSetBroadcastlist me, newBroadCastList, tabname
+  -----------------------------------
+  -- ACTION:   set the entire list of broadcastsprites
+  --          (list with references to an instance or sprite from the list of instances that get sent the event)
+  --
+  -- INPUT:   <newBroadCastList> ; linear list ; list of event listeners
+  --          (event listeners can be objects, strings, integers, symbols, callBackObjects [#handler:#buttonEvent, #target:me])
+  --          <tabname> ; string ; name of the button we want to address
+  -- RETURNS:  -
+  -----------------------------------
+  
+  if not(listP(newBroadCastList)) then exit
   
   if not(pButtonList.count) then exit
@@ -1163 +1289 @@
   theObject = theObject.getaprop(#myScriptObject)
   
-  if not(theObject.pOptions.broadcastSprites).getPos(referenz) then theObject.pOptions.broadcastSprites.add(referenz)
-end
-
--- xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
--- remove a reference to an instance or sprite from the list of instances that get sent the event
--- accepts: #object, #integer
-on mRemoveFromButtonBroadcastlist me, referenz, tabname
+  theObject.pOptions[#broadcastSprites] = newBroadCastList
+  
+end
+
+-- xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+-- 
+-- accepts: 
+
+on mAddToButtonBroadcastlist me, referenz, tabname
+  -----------------------------------
+  -- ACTION:   add a reference to an instance or sprite to the list of instances that get sent the event
+  --
+  -- INPUT:   <referenz> ; #object, #integer, #string, #symbol, callBackObject
+  --          <tabname> ; string ; name of the button we want to address
+  -- RETURNS:  -
+  -----------------------------------
   
   if not(pButtonList.count) then exit
@@ -1179 +1314 @@
   theObject = theObject.getaprop(#myScriptObject)
   
+  if not(theObject.pOptions.broadcastSprites).getPos(referenz) then theObject.pOptions.broadcastSprites.add(referenz)
+end
+
+-- xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+
+on mRemoveFromButtonBroadcastlist me, referenz, tabname
+  -----------------------------------
+  -- ACTION:   remove a reference to an instance or sprite from the list of instances that get sent the event
+  --
+  -- INPUT:   <referenz> ; #object, #integer, #string, #symbol, callBackObject
+  --          <tabname> ; string ; name of the button we want to address
+  -- RETURNS:  -
+  -----------------------------------
+  
+  if not(pButtonList.count) then exit
+  
+  if not voidP(tabname) then theObject = pButtonList.getaprop(tabname)
+  else theObject = 0
+  if ilk(theObject) <> #proplist then theObject = pButtonList[1]
+  
+  theObject = theObject.getaprop(#myScriptObject)
+  
   theObject.pOptions.broadcastSprites.deleteOne(referenz)
   
@@ -1184 +1341 @@
 
 -- xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
--- get the enabled state of the button; 1 = enabled, 0 = disabled
--- returns: #integer
+-- 
+
+-- accepts: #list
+
+on mSetEventsToProcessList me, newEventList, tabname
+  -----------------------------------
+  -- ACTION:   set the entire list of events, which will be processed
+  --
+  -- INPUT:   <newEventList> ; linear list ; list of events to process for a specific button
+  --               events which can be processed are: #mouseUp, #mouseDown, #mouseEnter, #mouseLeave
+  --          <tabname> ; string ; name of the button we want to address
+  -- RETURNS:  -
+  -----------------------------------
+  
+  if not(listP(newEventList)) then exit
+  
+  if not(pButtonList.count) then exit
+  
+  if not voidP(tabname) then theObject = pButtonList.getaprop(tabname)
+  else theObject = 0
+  if ilk(theObject) <> #proplist then theObject = pButtonList[1]
+  
+  theObject = theObject.getaprop(#myScriptObject)
+  
+  theObject.pOptions[#eventsToProcess] = newEventList
+  
+end
+
+-- xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+-- 
+-- -- -- events which can be processed are: #mouseUp, #mouseDown, #mouseEnter, #mouseLeave
+-- accepts: #symbol
+
+on mAddToEventsToProcessList me, theEvent, tabname
+  -----------------------------------
+  -- ACTION:   add an event to the list of processed events
+  --
+  -- INPUT:   <theEvent> ; symbol
+  --               events which can be processed are: #mouseUp, #mouseDown, #mouseEnter, #mouseLeave
+  --          <tabname> ; string ; name of the button we want to address
+  -- RETURNS:  -
+  -----------------------------------
+  
+  if not(pButtonList.count) then exit
+  
+  if not voidP(tabname) then theObject = pButtonList.getaprop(tabname)
+  else theObject = 0
+  if ilk(theObject) <> #proplist then theObject = pButtonList[1]
+  
+  theObject = theObject.getaprop(#myScriptObject)
+  
+  eventsToProcess = theObject.pOptions[#eventsToProcess]
+  if not(listP(eventsToProcess)) then
+    theObject.pOptions[#eventsToProcess] = [theEvent]
+  else
+    eventsToProcess.deleteOne(theEvent)
+    eventsToProcess.add(theEvent)
+  end if
+  
+end
+
+-- xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+
+on mRemoveFromEventsToProcessList me, theEvent, tabname
+  -----------------------------------
+  -- ACTION:   remove an event from the list of processed events
+  --
+  -- INPUT:   <theEvent> ; symbol
+  --               events which can be processed are: #mouseUp, #mouseDown, #mouseEnter, #mouseLeave
+  --          <tabname> ; string ; name of the button we want to address
+  -- RETURNS:  -
+  -----------------------------------
+  
+  if not(pButtonList.count) then exit
+  
+  if not voidP(tabname) then theObject = pButtonList.getaprop(tabname)
+  else theObject = 0
+  if ilk(theObject) <> #proplist then theObject = pButtonList[1]
+  
+  theObject = theObject.getaprop(#myScriptObject)
+  
+  eventsToProcess = theObject.pOptions[#eventsToProcess]
+  if not(listP(eventsToProcess)) then
+    theObject.pOptions[#eventsToProcess] = []
+  else
+    eventsToProcess.deleteOne(theEvent)
+  end if
+  
+end
+
+-- xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+
 on mGetButtonState me, tabname
+  -----------------------------------
+  -- ACTION:   get the selected state of the button (radio or toggle button - checkbox)
+  -- INPUT:   <tabname> ; string ; name of the button we want to address
+  -- RETURNS:  boolean (integer)
+  -----------------------------------
   
   if not(pButtonList.count) then return 0
@@ -1198 +1450 @@
 
 -- xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
--- set the enabled state of the button; 1 = enabled, 0 = disabled
--- accepts: #integer
+
 on mSetButtonState me, selState, tabname
+  -----------------------------------
+  -- ACTION:   set the selected state of the button (radio or toggle button - checkbox)
+  --
+  -- INPUT:    <selState> ; boolean (integer) ; true => selected, false => not selected
+  --           <tabname> ; string ; name of the button we want to address
+  -- RETURNS:  -
+  -----------------------------------
   
   if not(pButtonList.count) then exit
@@ -1227 +1485 @@
 
 on mTranslateAllButtonRects me, delta
+  -----------------------------------
+  -- ACTION:   move all buttons by point <delta>
+  --
+  -- INPUT:    <delta> ; point ; offset x and offset y to move the button sprite/overlay
+  -- RETURNS:  -
+  -----------------------------------
+  
   repeat with n = count(pButtonList) down to 1
     mTranslateButtonRect me, delta, pButtonList.getPropAt(n)
@@ -1236 +1501 @@
 
 on mTranslateButtonRect me, trans, tabname
+  -----------------------------------
+  -- ACTION:   move a single button by point <trans>
+  --
+  -- INPUT:    <trans> ; point ; offset x and offset y to move the button sprite/overlay
+  --           <tabname> ; string ; name of the button we want to address
+  -- RETURNS:  -
+  -----------------------------------
+  
   if not(pButtonList.count) then exit
   
@@ -1249 +1522 @@
 
 on mSetCurrentButtonRect me, newRect, tabname
+  -----------------------------------
+  -- ACTION:   set the rect of the specified button to absolut stage coordinates
+  --          (this may distort the button, so best is to use the rect you get from mGetCurrentButtonRect())
+  --
+  -- INPUT:    <newRect> ; rect ; new button rect
+  --           <tabname> ; string ; name of the button we want to address
+  -- RETURNS:  -
+  -----------------------------------
+  
   if not(pButtonList.count) then exit
   
@@ -1263 +1545 @@
 
 on mGetCurrentButtonRect me, tabname
+  -----------------------------------
+  -- ACTION:   get the rect of the specified button in absolut stage coordinates
+  --
+  -- INPUT:    <tabname> ; string ; name of the button we want to address
+  -- RETURNS:  rect
+  -----------------------------------
+  
   if not(pButtonList.count) then return 0
   
@@ -1274 +1563 @@
 end
 
--- xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+
+-- xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+on _____SEMI_PUBLIC_HANDLERS
+  -- handlers from other scripts, in this case from the resize stage behavior
+end
+-- xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+
 -- event from the resize bar behavior
 
@@ -1414 +1709 @@
         
         
-        blenderTO = call(#mCreateTimeout, [pIncludes.getaprop(#commonmoviescript)], "ButtonManager_BlenderTimeout", 30, #mDoBlendAnimation, me)
+        blenderTO = pIncludes.mCreateTimeout("ButtonManager_BlenderTimeout", 30, #mDoBlendAnimation, me)
         --          if mCheckWoody() = 1 then
         --            blenderTO = timeout().new("ButtonManager_BlenderTimeout", 30, #mDoBlendAnimation, me)
@@ -1445 +1740 @@
     
     callFunction = eventList.getaprop(#callFunction)
-    if ilk(callFunction) = #symbol then
-      anz = eventList[#broadcastSprites].count
+    --    if ilk(callFunction) = #symbol then
+    anz = count(eventList[#broadcastSprites])
       eventList[#secondEvent] = secondEvent
       if not(anz) then
+      if ilk(callFunction) = #symbol then
         sendAllSprites(callFunction, whichEvent, eventList, me, callerObject)
+      end if
       else if eventList[#broadcastSprites][1] = -1 then
+      if ilk(callFunction) = #symbol then
         str = string(callFunction)&&"#"&whichEvent&","&&QUOTE&eventList.getaprop(#label)&QUOTE&","&&eventList.getaprop(#selected)&","&&secondEvent
         do str
+      end if
       else if eventList[#broadcastSprites][1] = 0 then
+      if ilk(callFunction) = #symbol then
         sendSprite(me.spritenum, callFunction, whichEvent, eventList, me, callerObject)
+      end if
       else
         repeat with n = 1 to anz
           this = eventList[#broadcastSprites][n]
           if integerP(this) then
+          if ilk(callFunction) = #symbol then
             sendSprite(this, callFunction, whichEvent, eventList, me, callerObject)
+          end if
           else if ilk(this) = #instance then
+          if ilk(callFunction) = #symbol then
             call(callFunction, [this], whichEvent, eventList, me, callerObject)
+          end if
           else if ilk(this) = #script then
+          if ilk(callFunction) = #symbol then
             call(callFunction, [this], whichEvent, eventList, me, callerObject)
-          else
-            derkanal = call(#mGetKanal, [pIncludes.getaprop(#commonmoviescript)], this)
+          end if
+        else if ilk(this) = #proplist then
+          cfunc = this[#handler]
+          if ilk(cfunc) <> #symbol then cfunc = callFunction
+          if ilk(cfunc) = #symbol then
+            tgt = this[#target]
+            if objectP(tgt) then
+              call(cfunc, [tgt], whichEvent, eventList, me, callerObject, this)
+            else
+              derkanal = pIncludes.mGetKanal(tgt)
+              if derkanal > 0 then sendSprite(derkanal, cfunc, whichEvent, eventList, me, callerObject, this)
+            end if
+          end if
+        else
+          if ilk(callFunction) = #symbol then
+            derkanal = pIncludes.mGetKanal(this)
             if derkanal > 0 then sendSprite(derkanal, callFunction, whichEvent, eventList, me, callerObject)
           end if
-        end repeat
-      end if
+        end if
+      end repeat
+      --      end if
     end if
     
@@ -2018 +2339 @@
               retval = 1
               
+              thisButton.setaprop(#currentPressed, 0)
+              
               exit repeat
               
@@ -2028 +2351 @@
             end if
           end if
+          
         end if
       end if
@@ -2034 +2358 @@
   end if
   
+  if count(pButtonList) > 0 then
   repeat with n = n down to 1
     thisButton = pButtonList[n]
     if thisButton.getaprop(#currentPressed) = 1 then
       call(#myMouseUpOutside, [thisButton.getaprop(#myScriptObject)])
+        thisButton.setaprop(#currentPressed, 0)
     end if
   end repeat
+  end if
   
   return retval
@@ -2154 +2481 @@
 on myKeyDown me, tk, kc, theName
   
-  if call(#mHandleKeyEvent, [pIncludes.getaprop(#commonmoviescript)], tk, kc) then exit -- this is a movielevel handler, which gets keyevents first for example to quit the movie
+  if pIncludes.mHandleKeyEvent(tk, kc) then exit -- this is a movielevel handler, which gets keyevents first for example to quit the movie
   
   if not pAktiv then exit
@@ -2164 +2491 @@
   else
     theObject = pButtonList.getaprop(theName)
-    if ilk(theObject) = #proplist then
+    if objectP(theObject) then
       call(#mKeyDown, [theObject.getaprop(#myScriptObject)], tk, kc)
     end if
@@ -2200 +2527 @@
   breite = whichImg.width
   hoehe = whichImg.height
-  powerbreite = call(#mGetNextPowerOfTwo, [pIncludes.getaprop(#commonmoviescript)], breite)
-  powerhoehe = call(#mGetNextPowerOfTwo, [pIncludes.getaprop(#commonmoviescript)], hoehe)
+  powerbreite = pIncludes.mGetNextPowerOfTwo(breite)
+  powerhoehe = pIncludes.mGetNextPowerOfTwo(hoehe)
   
   if (powerbreite <> breite) or (powerhoehe <> hoehe) then