movieclip_class.c

flirt 一款纯c的flash解码程序。

			tmpcontext = dd_newActionContext(context->player, clipobj);

			ddActionFunction_call(ctor, clipobj, &tmpcontext, NULL, 0, DD_TRUE);
			
			if ( ctor->type == FUNCTION_BYTECODE )
				val = ddActionContext_execute(context->player, &tmpcontext);
			else
				val = ddActionContext_popValue(tmpcontext);
			
			ddActionValue_release(val);
			dd_destroyActionContext(tmpcontext);
		}
	}

	if ( initval.type != VALUE_NULL )
		ddActionValue_release(initval);
	
	ddActionValue_release(depthval);
	ddActionValue_release(nameval);
	ddActionValue_release(idval);

	return ddNullValue;
}


static ddActionValue
ddActionMovieClip_duplicateMovieClip(ddActionObject* object, ddActionContext* context, int nargs)
{
	ddActionMovieClip* clip = (ddActionMovieClip*)object;

	//if ( nargs != 2 )
	//	dd_warn("duplicateMovieClip expects at least 2 arguments");
	
	ddActionValue nameval = ddActionStack_pop(&context->stack);
	ddActionValue depthval = ddActionStack_pop(&context->stack);

	int depth = ddActionValue_getIntValue(depthval);
	char* name = ddActionValue_getStringValue(context, nameval);
	
	if ( clip->movieClip != NULL )
		ddDrawClip_duplicateClip(context->player, clip->movieClip, clip->movieClip->parentClip, depth, name);

	dd_free(name);
	
	ddActionValue_release(depthval);
	ddActionValue_release(nameval);
	
	return ddNullValue;
}


static ddActionValue
ddActionMovieClip_removeMovieClip(ddActionObject* object, ddActionContext* context, int nargs)
{
	dd_warn("removeMovieClip not implemented");
	/* no args */
	return ddNullValue;
}


static ddActionValue
ddActionMovieClip_unloadMovie(ddActionObject* object, ddActionContext* context, int nargs)
{
	dd_warn("unloadMovie not implemented");
	/* no args */
	return ddNullValue;
}


ddActionValue
ddActionMovieClip_startDrag(ddActionObject* object, ddActionContext* context, int nargs)
{
	ddActionMovieClip* clip = (ddActionMovieClip*)object;
	ddRect constrain = ddInvalidRect;
	int lock = DD_FALSE;

	/* one arg: lock center */
	/* five args: lock center, constraints- left, top, right, bottom */

	if ( nargs >= 1 )
	{
		ddActionValue val = ddActionStack_pop(&context->stack);
		lock = ddActionValue_getBooleanValue(val);
		ddActionValue_release(val);
		--nargs;
	}

	if ( nargs >= 4 )
	{
		ddActionValue leftval = ddActionStack_pop(&context->stack);
		ddActionValue topval = ddActionStack_pop(&context->stack);
		ddActionValue rightval = ddActionStack_pop(&context->stack);
		ddActionValue bottomval = ddActionStack_pop(&context->stack);

		constrain = dd_makeRect(FIXED_D(ddActionValue_getDoubleValue(leftval)),
						 FIXED_D(ddActionValue_getDoubleValue(topval)),
						 FIXED_D(ddActionValue_getDoubleValue(rightval)),
						 FIXED_D(ddActionValue_getDoubleValue(bottomval)));
		nargs -= 4;
	}

	while ( nargs-- > 0 )
		ddActionValue_release(ddActionStack_pop(&context->stack));

	if ( clip->movieClip != NULL )
		ddPlayer_startDrag(context->player, clip->movieClip, lock, constrain);

	return ddNullValue;
}


static ddActionValue
ddActionMovieClip_stopDrag(ddActionObject* object, ddActionContext* context, int nargs)
{
	ddPlayer_stopDrag(context->player);
	return ddNullValue;
}


static ddActionValue
ddActionMovieClip_hitTest(ddActionObject* object, ddActionContext* context, int nargs)
{
	ddActionMovieClip* clip = (ddActionMovieClip*)object;

	ddActionValue xval, yval;
	fixed x, y;
	int flag;

	if ( !ddActionObject_isKindOfClass(object, ddActionMovieClipClass) )
		return ddUndefValue;
	
	if ( nargs == 0 )
		return ddFalseValue;

	if ( nargs == 1 )
	{
		ddActionValue val = ddActionStack_pop(&context->stack);
		ddActionObject* obj = ddActionValue_getObjectValue(val);
		ddActionMovieClip* objclip = (ddActionMovieClip*)obj;
		
		ddActionValue_release(val);

		if ( !ddActionObject_isKindOfClass(obj, ddActionMovieClipClass) )
			return ddUndefValue;
		
		if ( obj == NULL || clip->movieClip != NULL )
			return ddFalseValue;

		if ( ddRect_intersectsRect(clip->movieClip->parent.bounds, objclip->movieClip->parent.bounds) )
			return ddTrueValue;
		else
			return ddFalseValue;
	}

	xval = ddActionStack_pop(&context->stack);
	yval = ddActionStack_pop(&context->stack);

	if ( nargs == 3 )
	{
		ddActionValue flagval = ddActionStack_pop(&context->stack);
		flag = ddActionValue_getBooleanValue(flagval);
		ddActionValue_release(flagval);
	}
	else
		flag = DD_FALSE;

	while ( nargs-- > 3 )
		ddActionValue_release(ddActionStack_pop(&context->stack));

	/* 3 args- x, y, shapeFlag (true: use shape, false: just bbox) */

	x = FIXED_D(ddActionValue_getDoubleValue(xval));
	y = FIXED_D(ddActionValue_getDoubleValue(yval));

	ddActionValue_release(xval);
	ddActionValue_release(yval);

	if ( clip->movieClip == NULL )
		return ddFalseValue;
	
	ddDrawClip_localToGlobal(clip->movieClip, &x, &y);

	if ( flag )
		return ddDrawClip_hitTest(clip->movieClip, x, y) ? ddTrueValue: ddFalseValue;
	else
		return ddRect_containsPoint(clip->movieClip->parent.bounds, x, y) ? ddTrueValue: ddFalseValue;
}


static ddActionValue
ddActionMovieClip_globalToLocal(ddActionObject* object, ddActionContext* context, int nargs)
{
	ddActionValue val = ddActionStack_pop(&context->stack);
	ddActionObject* obj = ddActionValue_getObjectValue(val);
	ddActionMovieClip* clip = (ddActionMovieClip*)object;

	ddActionValue xval, yval;
	fixed x, y;

	/* XXX - guess it's possible this could result in obj being freed.. */
	ddActionValue_release(val);

	if ( !ddActionObject_isKindOfClass(object, ddActionMovieClipClass) )
		return ddUndefValue;

	if ( obj == NULL || clip->movieClip == NULL )
		return ddNullValue;

	xval = ddActionHash_findValue(obj->properties, "x");
	yval = ddActionHash_findValue(obj->properties, "y");

	if ( xval.type == VALUE_NULL || yval.type == VALUE_NULL )
		return ddNullValue;

	x = FIXED_D(ddActionValue_getDoubleValue(xval));
	y = FIXED_D(ddActionValue_getDoubleValue(yval));

	ddDrawClip_globalToLocal(clip->movieClip, &x, &y);

	ddActionHash_setValue(obj->properties, strdup("x"), dd_newActionValue_double(DOUBLE_F(x)));
	ddActionHash_setValue(obj->properties, strdup("y"), dd_newActionValue_double(DOUBLE_F(y)));

	return ddNullValue;
}


static ddActionValue
ddActionMovieClip_localToGlobal(ddActionObject* object, ddActionContext* context, int nargs)
{
	ddActionValue val = ddActionStack_pop(&context->stack);
	ddActionObject* obj = ddActionValue_getObjectValue(val);
	ddActionMovieClip* clip = (ddActionMovieClip*)object;
	
	ddActionValue xval, yval;
	fixed x, y;

	/* XXX - guess it's possible this could result in obj being freed.. */
	ddActionValue_release(val);

	if ( !ddActionObject_isKindOfClass(object, ddActionMovieClipClass) )
		return ddUndefValue;
	
	if ( obj == NULL || clip->movieClip == NULL )
		return ddNullValue;

	xval = ddActionHash_findValue(obj->properties, "x");
	yval = ddActionHash_findValue(obj->properties, "y");

	if ( xval.type == VALUE_NULL || yval.type == VALUE_NULL )
		return ddNullValue;

	x = FIXED_D(ddActionValue_getDoubleValue(xval));
	y = FIXED_D(ddActionValue_getDoubleValue(yval));

	ddDrawClip_localToGlobal(clip->movieClip, &x, &y);

	ddActionHash_setValue(obj->properties, strdup("x"), dd_newActionValue_double(DOUBLE_F(x)));
	ddActionHash_setValue(obj->properties, strdup("y"), dd_newActionValue_double(DOUBLE_F(y)));

	return ddNullValue;
}


static char*
ddActionMovieClip_toString_recurse(ddActionMovieClip* c, char* str)
{
	if ( c->movieClip->parentClip != NULL )
		str = ddActionMovieClip_toString_recurse(c->movieClip->parentClip->actionClip, str);

	return str + sprintf(str, "%s.", c->name);
}


static ddActionValue
ddActionMovieClip_toString(ddActionObject* object, ddActionContext* context, int nargs)
{
	ddActionMovieClip* clip = (ddActionMovieClip*)object;
	char* name;
	char* p;

	if ( !ddActionObject_isKindOfClass(object, ddActionMovieClipClass) )
		return ddUndefValue;
	
	name = dd_malloc(256); // XXX
	name[0] = '\0';

	p = ddActionMovieClip_toString_recurse(clip, name);

	*--p = '\0';

	return dd_newActionValue_string_noCopy(name);
}


static ddActionValue
ddActionMovieClip_swapDepths(ddActionObject* object, ddActionContext* context, int nargs)
{
	ddActionMovieClip* clip = (ddActionMovieClip*)object;
	ddActionValue val = ddActionContext_popValue(context);
	int depth;

	if ( !ddActionObject_isKindOfClass(object, ddActionMovieClipClass) )
		return ddUndefValue;
	
	if ( val.type == VALUE_OBJECT && ddActionObject_isKindOfClass(val.data.objectValue, ddActionMovieClipClass) )
	{
		ddActionMovieClip* clip = (ddActionMovieClip*)val.data.objectValue;
		depth = ddDrawable_getDepth((ddDrawable*)clip->movieClip);
	}
	else
		depth = ddActionValue_getIntValue(val);
	
	ddDrawClip_swapDepths(clip->movieClip, depth);
	
	return ddNullValue;
}


static ddActionValue
ddActionMovieClip_createEmptyMovieClip(ddActionObject* object, ddActionContext* context, int nargs)
{
	ddActionValue depthval = ddActionContext_popValue(context);
	ddActionValue nameval = ddActionContext_popValue(context);

	char* name = ddActionValue_getStringValue_release(context, nameval);
	int depth = ddActionValue_getIntValue(depthval);

	fprintf(stderr, "createEmptyMovieClip('%s', %i)\n", name, depth);

	ddActionValue_release(depthval);

	return ddNullValue;
}

/*
 static
 getURL
 loadMovie
 loadVariables
 */

static ddActionValue
MovieClip_constructor(ddActionObject* object, ddActionContext* context, int nargs)
{
	ddActionObject* clipObject = (ddActionObject*)dd_newActionMovieClip(context->player, NULL);
	ddActionObject_setClass(clipObject, ddActionMovieClipClass);

	return dd_newActionValue_object(clipObject);
}


ddActionFunction*
dd_initMovieClipClass()
{
	ddActionFunction* ctor = dd_newActionNativeFunction(MovieClip_constructor, 0);
	
	ddActionObject* classObject;

	ddActionMovieClipClass = dd_newActionClass();
	classObject = (ddActionObject*)ddActionMovieClipClass;

	ddActionMovieClipClass->destroy = dd_destroyActionMovieClip;
	ddActionMovieClipClass->setProperty = ddActionMovieClip_setProperty;
	ddActionMovieClipClass->getProperty = ddActionMovieClip_getProperty;
	
	ddActionObject_addNativeMethod(classObject, strdup("gotoAndPlay"), ddActionMovieClip_gotoAndPlay, 1);
	ddActionObject_addNativeMethod(classObject, strdup("gotoAndStop"), ddActionMovieClip_gotoAndStop, 1);
	ddActionObject_addNativeMethod(classObject, strdup("nextFrame"), ddActionMovieClip_nextFrame, 0);
	ddActionObject_addNativeMethod(classObject, strdup("prevFrame"), ddActionMovieClip_prevFrame, 0);
	ddActionObject_addNativeMethod(classObject, strdup("play"), ddActionMovieClip_play, 0);
	ddActionObject_addNativeMethod(classObject, strdup("stop"), ddActionMovieClip_stop, 0);
	ddActionObject_addNativeMethod(classObject, strdup("getBounds"), ddActionMovieClip_getBounds, 0);
	ddActionObject_addNativeMethod(classObject, strdup("getBytesLoaded"), ddActionMovieClip_getBytesLoaded, 0);
	ddActionObject_addNativeMethod(classObject, strdup("getBytesTotal"), ddActionMovieClip_getBytesTotal, 0);
	ddActionObject_addNativeMethod(classObject, strdup("attachMovie"), ddActionMovieClip_attachMovie, FUNCTION_VARARGS);
	ddActionObject_addNativeMethod(classObject, strdup("startDrag"), ddActionMovieClip_startDrag, FUNCTION_VARARGS);
	ddActionObject_addNativeMethod(classObject, strdup("stopDrag"), ddActionMovieClip_stopDrag, 0);
	ddActionObject_addNativeMethod(classObject, strdup("globalToLocal"), ddActionMovieClip_globalToLocal, 1);
	ddActionObject_addNativeMethod(classObject, strdup("localToGlobal"), ddActionMovieClip_localToGlobal, 1);
	ddActionObject_addNativeMethod(classObject, strdup("duplicateMovieClip"), ddActionMovieClip_duplicateMovieClip, 2);
	ddActionObject_addNativeMethod(classObject, strdup("removeMovieClip"), ddActionMovieClip_removeMovieClip, 0);
	ddActionObject_addNativeMethod(classObject, strdup("unloadMovie"), ddActionMovieClip_unloadMovie, 2);
	ddActionObject_addNativeMethod(classObject, strdup("hitTest"), ddActionMovieClip_hitTest, FUNCTION_VARARGS);
	ddActionObject_addNativeMethod(classObject, strdup("toString"), ddActionMovieClip_toString, 0);
	ddActionObject_addNativeMethod(classObject, strdup("swapDepths"), ddActionMovieClip_swapDepths, 1);
	ddActionObject_addNativeMethod(classObject, strdup("createEmptyMovieClip"), ddActionMovieClip_createEmptyMovieClip, 1);
	
	ddActionFunction_setPrototype(ctor, classObject);

	return ctor;
}