Initial commit
This commit is contained in:
903
engines/director/lingo/lingo-events.cpp
Normal file
903
engines/director/lingo/lingo-events.cpp
Normal file
@@ -0,0 +1,903 @@
|
||||
/* ScummVM - Graphic Adventure Engine
|
||||
*
|
||||
* ScummVM is the legal property of its developers, whose names
|
||||
* are too numerous to list here. Please refer to the COPYRIGHT
|
||||
* file distributed with this source distribution.
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*
|
||||
*/
|
||||
|
||||
#include "director/director.h"
|
||||
#include "director/debugger.h"
|
||||
#include "director/lingo/lingo.h"
|
||||
#include "director/lingo/lingo-builtins.h"
|
||||
#include "director/lingo/lingo-code.h"
|
||||
#include "director/lingo/lingo-object.h"
|
||||
#include "director/cast.h"
|
||||
#include "director/castmember/castmember.h"
|
||||
#include "director/channel.h"
|
||||
#include "director/frame.h"
|
||||
#include "director/movie.h"
|
||||
#include "director/score.h"
|
||||
#include "director/sprite.h"
|
||||
#include "director/types.h"
|
||||
#include "director/window.h"
|
||||
|
||||
namespace Director {
|
||||
|
||||
struct EventHandlerType {
|
||||
LEvent handler;
|
||||
const char *name;
|
||||
} static const eventHandlerDescs[] = {
|
||||
{ kEventPrepareMovie, "prepareMovie" }, // D6
|
||||
{ kEventStartMovie, "startMovie" }, // D3
|
||||
{ kEventStepMovie, "stepMovie" }, // D3
|
||||
{ kEventStopMovie, "stopMovie" }, // D3
|
||||
|
||||
{ kEventBeginSprite, "beginSprite" }, // D6
|
||||
{ kEventEndSprite, "endSprite" }, // D6
|
||||
|
||||
{ kEventEnterFrame, "enterFrame" }, // D4
|
||||
{ kEventPrepareFrame, "prepareFrame" }, // D6
|
||||
{ kEventIdle, "idle" }, // D3
|
||||
{ kEventStepFrame, "stepFrame"}, // D5
|
||||
{ kEventExitFrame, "exitFrame" }, // D4
|
||||
|
||||
{ kEventActivateWindow, "activateWindow" }, // D5
|
||||
{ kEventDeactivateWindow, "deactivateWindow" }, // D5
|
||||
{ kEventMoveWindow, "moveWindow" }, // D5
|
||||
{ kEventResizeWindow, "resizeWindow" }, // D5
|
||||
{ kEventOpenWindow, "openWindow" }, // D5
|
||||
{ kEventCloseWindow, "closeWindow" }, // D5
|
||||
{ kEventZoomWindow, "zoomWindow" }, // D5
|
||||
|
||||
{ kEventKeyUp, "keyUp" }, // D4
|
||||
{ kEventKeyDown, "keyDown" }, // D2 w D4 (as when from D2)
|
||||
{ kEventMouseUp, "mouseUp" }, // D2 w D3
|
||||
{ kEventMouseDown, "mouseDown" }, // D2 w D3
|
||||
{ kEventRightMouseDown, "rightMouseDown" }, // D5
|
||||
{ kEventRightMouseUp, "rightMouseUp" }, // D5
|
||||
{ kEventMouseEnter, "mouseEnter" }, // D6, present in D5
|
||||
{ kEventMouseLeave, "mouseLeave" }, // D6, present in D5
|
||||
{ kEventMouseUpOutSide, "mouseUpOutSide" }, // D6
|
||||
{ kEventMouseWithin, "mouseWithin" }, // D6, present in D5
|
||||
|
||||
{ kEventTimeout, "timeout" }, // D2 as when
|
||||
{ kEventCuePassed, "cuePassed" }, // D6
|
||||
|
||||
{ kEventStartUp, "startUp" },
|
||||
|
||||
{ kEventGetBehaviorDescription, "getBehaviorDescription" }, // D6
|
||||
{ kEventGetPropertyDescriptionList, "getPropertyDescriptionList" }, // D6
|
||||
{ kEventRunPropertyDialog, "runPropertyDialog" }, // D6
|
||||
|
||||
{ kEventGeneric, "scummvm_generic" },
|
||||
|
||||
{ kEventNone, nullptr }
|
||||
};
|
||||
|
||||
void Lingo::initEventHandlerTypes() {
|
||||
for (const EventHandlerType *t = &eventHandlerDescs[0]; t->handler != kEventNone; ++t) {
|
||||
_eventHandlerTypeIds[t->name] = t->handler;
|
||||
_eventHandlerTypes[t->handler] = t->name;
|
||||
}
|
||||
_eventHandlerTypes[kEventNone] = 0;
|
||||
}
|
||||
|
||||
ScriptType Lingo::event2script(LEvent ev) {
|
||||
if (_vm->getVersion() < 400) {
|
||||
switch (ev) {
|
||||
//case kEventStartMovie: // We are precompiling it now
|
||||
// return kMovieScript;
|
||||
case kEventExitFrame:
|
||||
return kScoreScript;
|
||||
default:
|
||||
return kNoneScript;
|
||||
}
|
||||
}
|
||||
|
||||
return kNoneScript;
|
||||
}
|
||||
|
||||
void Movie::setPrimaryEventHandler(LEvent event, const Common::String &code) {
|
||||
debugC(3, kDebugLingoExec, "setting primary event handler (%s)", _lingo->_eventHandlerTypes[event]);
|
||||
LingoArchive *mainArchive = getMainLingoArch();
|
||||
mainArchive->primaryEventHandlers[event] = code;
|
||||
mainArchive->replaceCode(code, kEventScript, event);
|
||||
}
|
||||
|
||||
void Movie::resolveScriptEvent(LingoEvent &event) {
|
||||
// Resolve the script details of an event.
|
||||
// This must be done at execution time, as it relies on
|
||||
// e.g. the current frame, the current arrangement of sprites...
|
||||
uint16 spriteId = 0;
|
||||
if (event.mousePos != Common::Point(-1, -1)) {
|
||||
// Fetch the sprite underneath the mouse cursor.
|
||||
|
||||
// D3 doesn't have both mouse up and down.
|
||||
// But we still want to know if the mouse is down for press effects.
|
||||
// Since we don't have mouse up and down before D3, then we use ActiveSprite
|
||||
if (g_director->getVersion() < 400)
|
||||
spriteId = _score->getActiveSpriteIDFromPos(event.mousePos);
|
||||
else
|
||||
spriteId = _score->getMouseSpriteIDFromPos(event.mousePos);
|
||||
|
||||
if (event.event == kEventMouseDown || event.event == kEventRightMouseDown)
|
||||
_lastClickedSpriteId = _score->getActiveSpriteIDFromPos(event.mousePos); // the clickOn
|
||||
}
|
||||
// Very occasionally, we want to specify an event with a channel ID
|
||||
// rather than infer it from the position. Allow it to override.
|
||||
if (event.channelId == 0) {
|
||||
event.channelId = spriteId;
|
||||
}
|
||||
|
||||
// mouseDown/mouseUp events will have one of each of the source types queued.
|
||||
// run these steps at the very beginning (i.e. before the first source type).
|
||||
if (event.eventHandlerSourceType == kPrimaryHandler) {
|
||||
if ((event.event == kEventMouseDown) || (event.event == kEventRightMouseDown)) {
|
||||
if (!event.channelId && _isBeepOn) {
|
||||
g_lingo->func_beep(1);
|
||||
}
|
||||
|
||||
if (event.channelId > 0) {
|
||||
if (_score->_channels[event.channelId]->_sprite->shouldHilite()) {
|
||||
_currentHiliteChannelId = event.channelId;
|
||||
g_director->_wm->_hilitingWidget = true;
|
||||
g_director->getCurrentWindow()->setDirty(true);
|
||||
g_director->getCurrentWindow()->addDirtyRect(_score->_channels[_currentHiliteChannelId]->getBbox());
|
||||
}
|
||||
|
||||
CastMember *cast = getCastMember(_score->_channels[event.channelId]->_sprite->_castId);
|
||||
if (cast && cast->_type == kCastButton)
|
||||
_mouseDownWasInButton = true;
|
||||
|
||||
if (_score->_channels[event.channelId]->_sprite->_moveable) {
|
||||
_draggingSpriteOffset = _score->_channels[event.channelId]->getPosition() - event.mousePos;
|
||||
_currentDraggedChannel = _score->_channels[event.channelId];
|
||||
}
|
||||
|
||||
// In the case of clicking the mouse, it is possible for a mouseDown action to
|
||||
// change the cast member underneath. on mouseUp should always load the cast
|
||||
// script for the original cast member, not the new one.
|
||||
_currentMouseDownCastID = _score->_channels[event.channelId]->_sprite->_castId;
|
||||
_currentMouseDownSpriteScriptID = _score->_channels[event.channelId]->_sprite->_scriptId;
|
||||
_currentMouseDownSpriteImmediate = _score->_channels[event.channelId]->_sprite->_immediate;
|
||||
} else {
|
||||
_currentHiliteChannelId = 0;
|
||||
_mouseDownWasInButton = false;
|
||||
_draggingSpriteOffset = Common::Point(0, 0);
|
||||
_currentDraggedChannel = nullptr;
|
||||
_currentMouseDownCastID = CastMemberID();
|
||||
_currentMouseDownSpriteScriptID = CastMemberID();
|
||||
_currentMouseDownSpriteImmediate = false;
|
||||
}
|
||||
|
||||
} else if ((event.event == kEventMouseUp) || (event.event == kEventRightMouseUp)) {
|
||||
if (_currentHiliteChannelId && _score->_channels[_currentHiliteChannelId]) {
|
||||
g_director->getCurrentWindow()->setDirty(true);
|
||||
g_director->getCurrentWindow()->addDirtyRect(_score->_channels[_currentHiliteChannelId]->getBbox());
|
||||
}
|
||||
g_director->_wm->_hilitingWidget = false;
|
||||
|
||||
_currentDraggedChannel = nullptr;
|
||||
|
||||
// If this is a button cast member, and the last mouse down event was in a button
|
||||
// (any button), flip this button's hilite flag.
|
||||
// Now you might think, "Wait, we don't flip this flag in the mouseDown event.
|
||||
// And why any button??? This doesn't make any sense."
|
||||
// No, it doesn't make sense, but it's what Director does.
|
||||
if (_mouseDownWasInButton && event.channelId) {
|
||||
CastMember *cast = getCastMember(_score->_channels[event.channelId]->_sprite->_castId);
|
||||
if (cast && cast->_type == kCastButton)
|
||||
cast->_hilite = !cast->_hilite;
|
||||
}
|
||||
_currentHiliteChannelId = 0;
|
||||
_mouseDownWasInButton = false;
|
||||
g_director->loadSlowdownCooloff();
|
||||
}
|
||||
}
|
||||
|
||||
switch (event.eventHandlerSourceType) {
|
||||
case kPrimaryHandler:
|
||||
// Run the primary event handler.
|
||||
// Note that this isn't a "real" cast member ID, it's just the enum
|
||||
// of the type of event, so it can be crammed into the script context
|
||||
// index. kEventScript is a script type reserved for the primary event
|
||||
// handlers (e.g. the mouseDownScript, the mouseUpScript), so there will
|
||||
// be no collision with script cast members like ScoreScripts.
|
||||
{
|
||||
CastMemberID scriptId(event.event, DEFAULT_CAST_LIB);
|
||||
if (getScriptContext(kEventScript, scriptId)) {
|
||||
event.event = kEventGeneric;
|
||||
event.scriptType = kEventScript;
|
||||
event.scriptId = scriptId;
|
||||
}
|
||||
}
|
||||
break;
|
||||
/* When the mouseDown or mouseUp occurs over a sprite, the message
|
||||
* goes first to the sprite script, then to the script of the cast
|
||||
* member, to the frame script and finally to the movie scripts.
|
||||
*
|
||||
* When the mouseDown or mouseUp doesn't occur over a sprite, the
|
||||
* message goes to the frame script and then to the movie script.
|
||||
*
|
||||
* When more than one movie script [...]
|
||||
* [D4 docs] */
|
||||
case kSpriteHandler:
|
||||
{
|
||||
CastMemberID scriptId;
|
||||
bool immediate = false;
|
||||
Common::String initializerParams;
|
||||
// mouseUp events seem to check the frame script ID from the original mouseDown event
|
||||
// In Director 5 and above, we always generate event for the actual sprite under the mouse
|
||||
if (((event.event == kEventMouseUp) || (event.event == kEventRightMouseUp)) && _vm->getVersion() < 500) {
|
||||
scriptId = _currentMouseDownSpriteScriptID;
|
||||
immediate = _currentMouseDownSpriteImmediate;
|
||||
} else {
|
||||
if (!event.channelId)
|
||||
return;
|
||||
Frame *currentFrame = _score->_currentFrame;
|
||||
assert(currentFrame != nullptr);
|
||||
Sprite *sprite = _score->getSpriteById(event.channelId);
|
||||
if (!sprite)
|
||||
return;
|
||||
|
||||
if (_vm->getVersion() >= 600) {
|
||||
if (event.behaviorIndex >= 0) {
|
||||
if (event.behaviorIndex >= (int)sprite->_behaviors.size()) {
|
||||
warning("Movie::resolveScriptEvent: invalid behavior index %d, ignoring", event.behaviorIndex);
|
||||
} else {
|
||||
scriptId = sprite->_behaviors[event.behaviorIndex].memberID;
|
||||
initializerParams = sprite->_behaviors[event.behaviorIndex].initializerParams;
|
||||
}
|
||||
} else {
|
||||
_lastClickedSpriteId = 0;
|
||||
return;
|
||||
}
|
||||
} else {
|
||||
if (!sprite->_scriptId.member) {
|
||||
_lastClickedSpriteId = 0;
|
||||
return;
|
||||
}
|
||||
|
||||
scriptId = sprite->_scriptId;
|
||||
}
|
||||
|
||||
immediate = sprite->_immediate;
|
||||
}
|
||||
|
||||
if (_vm->getVersion() >= 600) {
|
||||
event.scriptType = kScoreScript;
|
||||
event.scriptId = scriptId;
|
||||
if (event.behaviorIndex >= 0 && event.behaviorIndex < (int)_score->_channels[event.channelId]->_scriptInstanceList.size())
|
||||
event.scriptInstance = _score->_channels[event.channelId]->_scriptInstanceList[event.behaviorIndex].u.obj;
|
||||
else
|
||||
warning("resolveScriptEvent: behaviorIndex %d out of range", event.behaviorIndex);
|
||||
return;
|
||||
}
|
||||
|
||||
// Sprite (score) script
|
||||
ScriptContext *script = getScriptContext(kScoreScript, scriptId);
|
||||
if (script) {
|
||||
if (script->_eventHandlers.contains(event.event)) {
|
||||
// D4-style event handler
|
||||
event.scriptType = kScoreScript;
|
||||
event.scriptId = scriptId;
|
||||
} else if (script->_eventHandlers.contains(kEventGeneric)) {
|
||||
// D3-style sprite script, not contained in a handler
|
||||
// If sprite is immediate, its script is run on mouseDown, otherwise on mouseUp
|
||||
if ((event.event == kEventMouseDown && immediate) || (event.event == kEventMouseUp && !immediate)) {
|
||||
event.event = kEventGeneric;
|
||||
event.scriptType = kScoreScript;
|
||||
event.scriptId = scriptId;
|
||||
}
|
||||
return; // FIXME: Do not execute the cast script if there is a D3-style sprite script
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
case kCastHandler:
|
||||
{
|
||||
// Cast script
|
||||
// A strange quirk; if we're in a mouseDown event, Director will test
|
||||
// at runtime to find out whatever is under the mouse and use that.
|
||||
// If we're in a mouseUp event, Director will use whatever was
|
||||
// discovered -at the very beginning- of the mouseDown event chain.
|
||||
// This means e.g. the cast member can be swapped out from underneath in
|
||||
// the mouseDown sprite script and the event passed down, which
|
||||
// will mean the old cast member cast script does not get a mouseDown
|
||||
// call, but it -does- get a mouseUp call.
|
||||
// A bit unhinged, but we have a test that proves Director does this,
|
||||
// so we have to do it too.
|
||||
//
|
||||
// mouseEnter and mouseLeave events should also defer to the value of channelId.
|
||||
CastMemberID targetCast = _currentMouseDownCastID;
|
||||
if ((event.event == kEventMouseDown) || (event.event == kEventRightMouseDown) ||
|
||||
(event.event == kEventMouseEnter) || (event.event == kEventMouseLeave)) {
|
||||
if (!event.channelId)
|
||||
return;
|
||||
Sprite *sprite = _score->getSpriteById(event.channelId);
|
||||
targetCast = sprite->_castId;
|
||||
}
|
||||
|
||||
ScriptContext *script = getScriptContext(kCastScript, targetCast);
|
||||
if (script && script->_eventHandlers.contains(event.event)) {
|
||||
event.scriptType = kCastScript;
|
||||
event.scriptId = targetCast;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case kFrameHandler:
|
||||
{
|
||||
/* [in D4] the enterFrame, exitFrame, idle and timeout messages
|
||||
* are sent to a frame script and then a movie script. If the
|
||||
* current frame has no frame script when the event occurs, the
|
||||
* message goes to movie scripts.
|
||||
* [p.81 of D4 docs]
|
||||
*/
|
||||
|
||||
if (_score->_currentFrame == nullptr)
|
||||
return;
|
||||
|
||||
if (_vm->getVersion() >= 600) {
|
||||
if (_score->_scriptChannelScriptInstance.type == OBJECT) {
|
||||
event.scriptType = kScoreScript;
|
||||
event.scriptId = CastMemberID(); // No ID for the script channel script
|
||||
event.scriptInstance = _score->_scriptChannelScriptInstance.u.obj;
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
// Pre D6
|
||||
CastMemberID scriptId = _score->_currentFrame->_mainChannels.actionId;
|
||||
if (!scriptId.member)
|
||||
return;
|
||||
|
||||
ScriptContext *script = getScriptContext(kScoreScript, scriptId);
|
||||
if (!script)
|
||||
return;
|
||||
|
||||
if (script->_eventHandlers.contains(event.event)) {
|
||||
event.scriptType = kScoreScript;
|
||||
event.scriptId = scriptId;
|
||||
return;
|
||||
}
|
||||
|
||||
// Scopeless statements (ie one lined lingo commands) are executed at exitFrame
|
||||
// A score script can have both scopeless and scoped lingo. (eg. porting from D3.1 to D4)
|
||||
// In the event of both being specified in the ScoreScript, the scopeless handler is ignored.
|
||||
|
||||
if (event.event == kEventExitFrame && script->_eventHandlers.contains(kEventGeneric) &&
|
||||
!(script->_eventHandlers.contains(kEventExitFrame) || script->_eventHandlers.contains(kEventEnterFrame))) {
|
||||
event.event = kEventGeneric;
|
||||
event.scriptType = kScoreScript;
|
||||
event.scriptId = scriptId;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case kMovieHandler:
|
||||
{
|
||||
/* If more than one movie script handles the same message, Lingo
|
||||
* searches the movie scripts according to their order in the cast
|
||||
* window [p.81 of D4 docs]
|
||||
*/
|
||||
|
||||
// FIXME: shared cast movie scripts could come before main movie ones
|
||||
// Movie scripts are fixed, so it's fine to look them up in advance.
|
||||
for (auto &cast : _casts) {
|
||||
LingoArchive *archive = cast._value->_lingoArchive;
|
||||
for (auto &it : archive->scriptContexts[kMovieScript]) {
|
||||
if (it._value->_eventHandlers.contains(event.event)) {
|
||||
event.scriptType = kMovieScript;
|
||||
event.scriptId = CastMemberID(it._key, cast._key);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
LingoArchive *sharedArchive = getSharedLingoArch();
|
||||
if (sharedArchive) {
|
||||
for (auto &it : sharedArchive->scriptContexts[kMovieScript]) {
|
||||
if (it._value->_eventHandlers.contains(event.event)) {
|
||||
event.scriptType = kMovieScript;
|
||||
event.scriptId = CastMemberID(it._key, DEFAULT_CAST_LIB);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void Movie::queueEvent(Common::Queue<LingoEvent> &queue, LEvent event, int targetId, Common::Point pos) {
|
||||
if (_nextEventId < 0)
|
||||
_nextEventId = 0;
|
||||
_nextEventId++;
|
||||
int eventId = _nextEventId;
|
||||
|
||||
int oldQueueSize = queue.size();
|
||||
|
||||
uint16 channelId = 0;
|
||||
uint16 pointedSpriteId = 0;
|
||||
|
||||
// In D6+ there are multiple behavors per sprite, find the sprite
|
||||
if (g_director->getVersion() >= 600) {
|
||||
if (targetId == 0) {
|
||||
pointedSpriteId = _score->getMouseSpriteIDFromPos(pos);
|
||||
} else {
|
||||
pointedSpriteId = targetId;
|
||||
}
|
||||
}
|
||||
|
||||
/* When an event occurs the message [...] is first sent to a
|
||||
* primary event handler: [... if exists it is executed] and the
|
||||
* event is passed on to other objects unless you explicitly stop
|
||||
* the message by including the dontPassEvent command in the script
|
||||
* [D4 docs page 77]
|
||||
*/
|
||||
/* N.B.: No primary event handlers for events other than
|
||||
* keyup, keydown, mouseup, mousedown, timeout
|
||||
* [see: www.columbia.edu/itc/visualarts/r4110/s2001/handouts
|
||||
* /03_03_Event_Hierarchy.pdf]
|
||||
*/
|
||||
switch (event) {
|
||||
case kEventMouseDown:
|
||||
case kEventMouseUp:
|
||||
case kEventRightMouseDown:
|
||||
case kEventRightMouseUp:
|
||||
case kEventKeyUp:
|
||||
case kEventKeyDown:
|
||||
case kEventTimeout:
|
||||
{
|
||||
// Queue a call to the the primary event handler.
|
||||
// As per above, by default this will pass through to any subsequent handlers,
|
||||
// unless the script calls "dontPassEvent".
|
||||
queue.push(LingoEvent(event, eventId, kPrimaryHandler, true, pos));
|
||||
|
||||
// Key up and key down events can be sent to the channel with an active widget
|
||||
if ((event == kEventKeyUp) || (event == kEventKeyDown)) {
|
||||
channelId = targetId;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case kEventMenuCallback:
|
||||
{
|
||||
CastMemberID scriptID = CastMemberID(targetId, DEFAULT_CAST_LIB);
|
||||
if (getScriptContext(kEventScript, scriptID)) {
|
||||
queue.push(LingoEvent(kEventGeneric, eventId, kEventScript, true, scriptID, pos));
|
||||
}
|
||||
}
|
||||
break;
|
||||
// For mouseEnter/mouseLeave events, we want to specify exactly what sprite channel to resolve to.
|
||||
case kEventMouseEnter:
|
||||
case kEventMouseLeave:
|
||||
case kEventPrepareFrame:
|
||||
case kEventBeginSprite:
|
||||
case kEventEndSprite:
|
||||
case kEventMouseUpOutSide: // D6+
|
||||
case kEventMouseWithin: // D6+
|
||||
if (targetId != 0) {
|
||||
channelId = targetId;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
if (_vm->getVersion() < 400) {
|
||||
// In D2-3, specific objects handle each event, with no passing
|
||||
switch(event) {
|
||||
case kEventMouseUp:
|
||||
case kEventMouseDown:
|
||||
queue.push(LingoEvent(event, eventId, kSpriteHandler, false, pos));
|
||||
queue.push(LingoEvent(event, eventId, kCastHandler, false, pos));
|
||||
break;
|
||||
|
||||
case kEventExitFrame:
|
||||
queue.push(LingoEvent(event, eventId, kFrameHandler, false, pos));
|
||||
break;
|
||||
|
||||
case kEventIdle:
|
||||
case kEventStartUp:
|
||||
case kEventStartMovie:
|
||||
case kEventStepMovie:
|
||||
case kEventStopMovie:
|
||||
queue.push(LingoEvent(event, eventId, kMovieHandler, false, pos));
|
||||
break;
|
||||
|
||||
// no-op; only handled by the primary event handler above
|
||||
// empty case avoids them generating logs from the default
|
||||
// unhandled event case below.
|
||||
case kEventKeyUp:
|
||||
case kEventKeyDown:
|
||||
case kEventTimeout:
|
||||
break;
|
||||
|
||||
default:
|
||||
warning("registerEvent: Unhandled event %s", _lingo->_eventHandlerTypes[event]);
|
||||
}
|
||||
} else {
|
||||
/* In D4+, queue any objects that responds to this event, in order of precedence.
|
||||
* (Sprite -> Cast Member -> Frame -> Movie)
|
||||
* Once one of these objects handles the event, any event handlers queued
|
||||
* for the same event will be ignored unless the pass command was called.
|
||||
*/
|
||||
switch (event) {
|
||||
case kEventKeyUp:
|
||||
case kEventKeyDown:
|
||||
case kEventMouseUp:
|
||||
case kEventMouseDown:
|
||||
case kEventRightMouseUp:
|
||||
case kEventRightMouseDown:
|
||||
case kEventBeginSprite:
|
||||
case kEventEndSprite:
|
||||
case kEventMouseEnter:
|
||||
case kEventMouseLeave:
|
||||
case kEventPrepareFrame: // D6+
|
||||
case kEventMouseUpOutSide: // D6+
|
||||
case kEventMouseWithin: // D6+
|
||||
if (_vm->getVersion() >= 600) {
|
||||
if (pointedSpriteId != 0) {
|
||||
Channel *channel = _score->getChannelById(pointedSpriteId);
|
||||
|
||||
// Generate event for each behavior, and pass through for all but the last one.
|
||||
// This is to allow multiple behaviors on a single sprite to each have a
|
||||
// chance to handle the event.
|
||||
for (uint i = 0; i < channel->_scriptInstanceList.size(); i++) {
|
||||
bool passThrough = (i != channel->_scriptInstanceList.size() - 1);
|
||||
queue.push(LingoEvent(event, eventId, kSpriteHandler, passThrough, pos, pointedSpriteId, i));
|
||||
}
|
||||
|
||||
if (event == kEventBeginSprite || event == kEventEndSprite || event == kEventMouseUpOutSide) {
|
||||
// These events do not go any further than the sprite behaviors
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
// We have no sprite under the mouse, no SpriteHandler to queue.
|
||||
}
|
||||
} else {
|
||||
queue.push(LingoEvent(event, eventId, kSpriteHandler, false, pos, channelId));
|
||||
}
|
||||
queue.push(LingoEvent(event, eventId, kCastHandler, false, pos, channelId));
|
||||
// fall through
|
||||
|
||||
case kEventIdle:
|
||||
case kEventEnterFrame:
|
||||
case kEventExitFrame:
|
||||
case kEventTimeout:
|
||||
queue.push(LingoEvent(event, eventId, kFrameHandler, false, pos, channelId));
|
||||
// fall through
|
||||
|
||||
case kEventStartUp:
|
||||
case kEventStartMovie:
|
||||
case kEventStepMovie:
|
||||
case kEventStopMovie:
|
||||
|
||||
case kEventPrepareMovie: // D6
|
||||
|
||||
case kEventActivateWindow: // D5
|
||||
case kEventDeactivateWindow: // D5
|
||||
case kEventMoveWindow: // D5
|
||||
case kEventResizeWindow: // D5
|
||||
case kEventOpenWindow: // D5
|
||||
case kEventCloseWindow: // D5
|
||||
case kEventZoomWindow: // D5
|
||||
queue.push(LingoEvent(event, eventId, kMovieHandler, false, pos, channelId));
|
||||
break;
|
||||
|
||||
default:
|
||||
warning("registerEvent: Unhandled event %s", _lingo->_eventHandlerTypes[event]);
|
||||
}
|
||||
}
|
||||
|
||||
if (oldQueueSize == queue.size()) {
|
||||
debugC(9, kDebugEvents, "Lingo::queueEvent(%s): no event handler", _lingo->_eventHandlerTypes[event]);
|
||||
}
|
||||
}
|
||||
|
||||
void Movie::queueInputEvent(LEvent event, int targetId, Common::Point pos) {
|
||||
queueEvent(_inputEventQueue, event, targetId, pos);
|
||||
}
|
||||
|
||||
void Movie::processEvent(LEvent event, int targetId) {
|
||||
Common::Queue<LingoEvent> queue;
|
||||
queueEvent(queue, event, targetId);
|
||||
_vm->setCurrentWindow(this->getWindow());
|
||||
_lingo->processEvents(queue, false);
|
||||
}
|
||||
|
||||
void Movie::broadcastEvent(LEvent event) {
|
||||
Common::Queue<LingoEvent> queue;
|
||||
|
||||
for (uint i = 1; i < _score->_channels.size(); i++) {
|
||||
if (_score->_channels[i] && _score->_channels[i]->_sprite && _score->_channels[i]->_sprite->_behaviors.size()) {
|
||||
queueEvent(queue, event, i);
|
||||
}
|
||||
}
|
||||
_vm->setCurrentWindow(this->getWindow());
|
||||
_lingo->processEvents(queue, false);
|
||||
}
|
||||
|
||||
void Lingo::processEvents(Common::Queue<LingoEvent> &queue, bool isInputEvent) {
|
||||
if (isInputEvent && _currentInputEvent.type != VOIDSYM) {
|
||||
// only one input event should be in flight at a time.
|
||||
return;
|
||||
}
|
||||
Movie *movie = _vm->getCurrentMovie();
|
||||
Score *sc = movie->getScore();
|
||||
|
||||
bool behavioursCompleted = false;
|
||||
|
||||
while (!queue.empty()) {
|
||||
LingoEvent el = queue.pop();
|
||||
|
||||
if (sc->_playState == kPlayStopped && el.event != kEventStopMovie)
|
||||
continue;
|
||||
|
||||
// fetch the sprite ID, script ID to call, etc if not present.
|
||||
movie->resolveScriptEvent(el);
|
||||
|
||||
if (el.scriptType == kNoneScript) {
|
||||
debugC(9, kDebugEvents, "Lingo::processEvents: no matching script for event (%s, %s, %s, %d), continuing",
|
||||
_eventHandlerTypes[el.event], scriptType2str(el.scriptType), el.scriptId.asString().c_str(), el.channelId
|
||||
);
|
||||
continue;
|
||||
}
|
||||
|
||||
int lastEventId = movie->_lastEventId.getValOrDefault(el.event, 0);
|
||||
if (lastEventId && lastEventId == el.eventId && !_passEvent) {
|
||||
debugC(5, kDebugEvents, "Lingo::processEvents: swallowed event (%s, %s, %s, %d) because _passEvent was false",
|
||||
_eventHandlerTypes[el.event], scriptType2str(el.scriptType), el.scriptId.asString().c_str(), el.channelId
|
||||
);
|
||||
continue;
|
||||
}
|
||||
|
||||
_passEvent = el.passByDefault;
|
||||
|
||||
debugC(5, kDebugEvents, "Lingo::processEvents: starting event script (%s, %s, %s, %d)",
|
||||
_eventHandlerTypes[el.event], scriptType2str(el.scriptType), el.scriptId.asString().c_str(), el.channelId
|
||||
);
|
||||
bool completed = processEvent(el.event, el.scriptType, el.scriptId, el.channelId, el.scriptInstance);
|
||||
movie->_lastEventId[el.event] = el.eventId;
|
||||
|
||||
if (_vm->getVersion() >= 600) {
|
||||
// Reset it for further event processing
|
||||
g_director->getCurrentMovie()->_currentSpriteNum = 0;
|
||||
|
||||
// We need to execute all behaviours before deciding if we pass
|
||||
// through or not
|
||||
if (el.scriptType == kScoreScript && el.passByDefault == true) {
|
||||
behavioursCompleted |= completed;
|
||||
completed = true;
|
||||
} else {
|
||||
completed |= behavioursCompleted;
|
||||
}
|
||||
}
|
||||
|
||||
if (isInputEvent && !completed) {
|
||||
debugC(5, kDebugEvents, "Lingo::processEvents: context frozen on an input event, stopping");
|
||||
LingoState *state = g_director->getCurrentWindow()->getLastFrozenLingoState();
|
||||
if (state && !state->callstack.empty()) {
|
||||
_currentInputEvent = state->callstack.front()->sp;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
bool Lingo::processEvent(LEvent event, ScriptType st, CastMemberID scriptId, int channelId, AbstractObject *obj) {
|
||||
_currentChannelId = channelId;
|
||||
|
||||
if (!_eventHandlerTypes.contains(event))
|
||||
error("processEvent: Unknown event %d", event);
|
||||
|
||||
|
||||
if (g_director->getVersion() >= 600 && st == kScoreScript && obj) {
|
||||
if (obj->getMethod(_eventHandlerTypes[event]).type != VOIDSYM) {
|
||||
g_director->getCurrentMovie()->_currentSpriteNum = channelId;
|
||||
push(Datum(obj));
|
||||
LC::call(_eventHandlerTypes[event], 1, false);
|
||||
return execute();
|
||||
} else {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
ScriptContext *script = g_director->getCurrentMovie()->getScriptContext(st, scriptId);
|
||||
int nargs = 0;
|
||||
|
||||
if (script && script->_eventHandlers.contains(event)) {
|
||||
debugC(1, kDebugEvents, "Lingo::processEvent(%s, %s, %s): executing event handler", _eventHandlerTypes[event], scriptType2str(st), scriptId.asString().c_str());
|
||||
g_debugger->eventHook(event);
|
||||
|
||||
// Normally event handlers are called with no arguments, however RolloverToolkit expects
|
||||
// the first argument to be the sprite number.
|
||||
if ((event == kEventMouseEnter && script->_eventHandlers[event].name->equalsIgnoreCase("startRollover")) ||
|
||||
(event == kEventMouseLeave && script->_eventHandlers[event].name->equalsIgnoreCase("endRollover"))) {
|
||||
push(Datum(channelId));
|
||||
nargs = 1;
|
||||
}
|
||||
|
||||
LC::call(script->_eventHandlers[event], nargs, false);
|
||||
return execute();
|
||||
} else {
|
||||
debugC(9, kDebugEvents, "Lingo::processEvent(%s, %s, %s): no handler", _eventHandlerTypes[event], scriptType2str(st), scriptId.asString().c_str());
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
/***********************
|
||||
* Script Instances
|
||||
***********************/
|
||||
|
||||
void Score::killScriptInstances(int frameNum) {
|
||||
if (_version < kFileVer600) // No-op for early Directors
|
||||
return;
|
||||
|
||||
if (frameNum < _currentFrame->_mainChannels.scriptSpriteInfo.startFrame ||
|
||||
frameNum > _currentFrame->_mainChannels.scriptSpriteInfo.endFrame) {
|
||||
if (_scriptChannelScriptInstance.type == OBJECT) {
|
||||
_scriptChannelScriptInstance = Datum();
|
||||
debugC(1, kDebugLingoExec, "Score::killScriptInstances(): Killed script instances for script channel. frame %d [%d-%d]",
|
||||
frameNum,
|
||||
_currentFrame->_mainChannels.scriptSpriteInfo.startFrame,
|
||||
_currentFrame->_mainChannels.scriptSpriteInfo.endFrame);
|
||||
}
|
||||
}
|
||||
|
||||
for (int i = 0; i < (int)_channels.size(); i++) {
|
||||
Channel *channel = _channels[i];
|
||||
|
||||
if (channel->_scriptInstanceList.size() == 0)
|
||||
continue;
|
||||
|
||||
if (frameNum < channel->_startFrame || frameNum > channel->_endFrame) {
|
||||
bool prevDis = _disableGoPlayUpdateStage;
|
||||
_disableGoPlayUpdateStage = true;
|
||||
_movie->processEvent(kEventEndSprite, i);
|
||||
_disableGoPlayUpdateStage = prevDis;
|
||||
|
||||
channel->_scriptInstanceList.clear();
|
||||
channel->_sprite->_behaviors.clear();
|
||||
debugC(1, kDebugLingoExec, "Score::killScriptInstances(): Killed script instances for channel %d. frame %d [%d-%d]",
|
||||
i + 1, frameNum, channel->_startFrame, channel->_endFrame);
|
||||
|
||||
channel->_startFrame = channel->_endFrame = -1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Datum Score::createScriptInstance(BehaviorElement *behavior) {
|
||||
// Instantiate the behavior
|
||||
ScriptContext *scr = _movie->getScriptContext(kScoreScript, behavior->memberID);
|
||||
|
||||
// Some movies have behaviors with missing scripts
|
||||
if (scr == nullptr) {
|
||||
debugC(7, kDebugLingoExec, "Score::createScriptInstance(): Missing script for behavior %s", behavior->toString().c_str());
|
||||
return Datum();
|
||||
}
|
||||
|
||||
g_lingo->push(scr);
|
||||
LC::call("new", 1, true);
|
||||
Datum instance = g_lingo->pop();
|
||||
|
||||
if (instance.type != OBJECT) {
|
||||
warning("Score::createScriptInstance(): Could not instantiate behavior %s", behavior->toString().c_str());
|
||||
return Datum();
|
||||
}
|
||||
|
||||
debugC(1, kDebugLingoExec, " Instantiated behavior %s", behavior->toString().c_str());
|
||||
|
||||
// No initializer, we are done
|
||||
if (behavior->initializerIndex == 0)
|
||||
return instance;
|
||||
|
||||
// Evaluate the params
|
||||
g_lingo->push(behavior->initializerParams);
|
||||
LB::b_value(1);
|
||||
g_lingo->execute();
|
||||
|
||||
if (debugChannelSet(5, kDebugLingoExec)) {
|
||||
g_lingo->printStack(" Parsed behavior parameters: ", 0);
|
||||
}
|
||||
|
||||
if (g_lingo->_state->stack.size() == 0) {
|
||||
warning("Score::createScriptInstance(): Could not evaluate initializer params '%s' for behavior %s",
|
||||
behavior->initializerParams.c_str(), behavior->toString().c_str());
|
||||
return instance;
|
||||
}
|
||||
|
||||
Datum proplist = _lingo->pop();
|
||||
|
||||
if (proplist.type != PARRAY) {
|
||||
warning("Score::createScriptInstance(): Could not evaluate initializer params '%s' for behavior %s",
|
||||
behavior->initializerParams.c_str(), behavior->toString().c_str());
|
||||
return instance;
|
||||
}
|
||||
|
||||
debugC(2, kDebugLingoExec, " Setting %d properties", proplist.u.parr->arr.size());
|
||||
|
||||
for (uint k = 0; k < proplist.u.parr->arr.size(); k++) {
|
||||
Datum key = proplist.u.parr->arr[k].p;
|
||||
Datum val = proplist.u.parr->arr[k].v;
|
||||
|
||||
instance.u.obj->setProp(key.asString(), val);
|
||||
}
|
||||
|
||||
return instance;
|
||||
}
|
||||
|
||||
|
||||
void Score::createScriptInstances(int frameNum) {
|
||||
if (_version < kFileVer600) // No-op for early Directors
|
||||
return;
|
||||
|
||||
if (frameNum >= _currentFrame->_mainChannels.scriptSpriteInfo.startFrame &&
|
||||
frameNum <= _currentFrame->_mainChannels.scriptSpriteInfo.endFrame) {
|
||||
|
||||
// We have no instantiated script
|
||||
if (_scriptChannelScriptInstance.type != OBJECT) {
|
||||
if (_currentFrame->_mainChannels.behaviors.size() > 0) {
|
||||
debugC(1, kDebugLingoExec, "Score::createScriptInstances(): Creating script instances for script channel, frames [%d-%d]",
|
||||
_currentFrame->_mainChannels.scriptSpriteInfo.startFrame,
|
||||
_currentFrame->_mainChannels.scriptSpriteInfo.endFrame);
|
||||
_scriptChannelScriptInstance = createScriptInstance(&_currentFrame->_mainChannels.behaviors[0]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (int i = 0; i < (int)_channels.size(); i++) {
|
||||
Channel *channel = _channels[i];
|
||||
Sprite *sprite = channel->_sprite;
|
||||
|
||||
// The frame does not belong to the range
|
||||
if (frameNum < channel->_startFrame || frameNum > channel->_endFrame)
|
||||
continue;
|
||||
|
||||
// We create scriptInstance only for new sprites
|
||||
if (channel->_scriptInstanceList.size() != 0)
|
||||
continue;
|
||||
|
||||
// No behaviors, nothing to do
|
||||
if (sprite->_behaviors.size() == 0)
|
||||
continue;
|
||||
|
||||
debugC(1, kDebugLingoExec, "Score::createScriptInstances(): Creating script instances for channel %d, %d behaviors, frames [%d-%d]",
|
||||
i + 1, sprite->_behaviors.size(), channel->_startFrame, channel->_endFrame);
|
||||
|
||||
for (uint j = 0; j < sprite->_behaviors.size(); j++) {
|
||||
Datum instance = createScriptInstance(&sprite->_behaviors[j]);
|
||||
|
||||
if (instance.type != OBJECT) {
|
||||
if (!instance.isVoid())
|
||||
warning("Score::createScriptInstances(): Could not instantiate behavior %s", sprite->_behaviors[j].toString().c_str());
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
channel->_scriptInstanceList.push_back(instance);
|
||||
}
|
||||
|
||||
bool prevDis = _disableGoPlayUpdateStage;
|
||||
_disableGoPlayUpdateStage = true;
|
||||
_movie->processEvent(kEventBeginSprite, i);
|
||||
_disableGoPlayUpdateStage = prevDis;
|
||||
}
|
||||
}
|
||||
|
||||
} // End of namespace Director
|
||||
Reference in New Issue
Block a user