void
swfdec_bitmap_data_get_rectangle (SwfdecAsContext *cx, SwfdecAsObject *object,
guint argc, SwfdecAsValue *argv, SwfdecAsValue *ret)
{
SwfdecBitmapData *bitmap;
SwfdecAsObject *o;
SwfdecAsValue args[4];
SWFDEC_AS_CHECK (SWFDEC_TYPE_BITMAP_DATA, &bitmap, "");
SWFDEC_AS_VALUE_SET_INT (ret, -1);
if (bitmap->surface == NULL)
return;
swfdec_as_object_get_variable (cx->global, SWFDEC_AS_STR_flash, args);
if (!SWFDEC_AS_VALUE_IS_OBJECT (args))
return;
o = SWFDEC_AS_VALUE_GET_OBJECT (args);
swfdec_as_object_get_variable (o, SWFDEC_AS_STR_geom, args);
if (!SWFDEC_AS_VALUE_IS_OBJECT (args))
return;
o = SWFDEC_AS_VALUE_GET_OBJECT (args);
swfdec_as_object_get_variable (o, SWFDEC_AS_STR_Rectangle, args);
if (!SWFDEC_AS_VALUE_IS_OBJECT (args))
return;
o = SWFDEC_AS_VALUE_GET_OBJECT (args);
if (!SWFDEC_IS_AS_FUNCTION (o))
return;
SWFDEC_AS_VALUE_SET_INT (&args[0], 0);
SWFDEC_AS_VALUE_SET_INT (&args[1], 0);
SWFDEC_AS_VALUE_SET_INT (&args[2], cairo_image_surface_get_width (bitmap->surface));
SWFDEC_AS_VALUE_SET_INT (&args[3], cairo_image_surface_get_height (bitmap->surface));
swfdec_as_object_create (SWFDEC_AS_FUNCTION (o), 4, args, ret);
}
void
swfdec_as_array_do_shift (SwfdecAsContext *cx, SwfdecAsObject *object,
guint argc, SwfdecAsValue *argv, SwfdecAsValue *ret)
{
gint32 length;
const char *var;
if (object == NULL || SWFDEC_IS_MOVIE (object))
return;
// don't allow negative length
length = swfdec_as_array_length (object);
if (length <= 0)
return;
swfdec_as_object_get_variable (object, SWFDEC_AS_STR_0, ret);
swfdec_as_array_move_range (object, 1, length - 1, 0);
// if not Array, leave the length unchanged, and don't remove the element
if (SWFDEC_IS_AS_ARRAY (object)) {
swfdec_as_array_set_length_object (object, length - 1);
} else {
// we have to put the last element back, because we used move, not copy
SwfdecAsValue val;
if (length > 1) {
var = swfdec_as_integer_to_string (swfdec_gc_object_get_context (object), length - 2);
swfdec_as_object_get_variable (object, var, &val);
} else {
val = *ret;
}
var = swfdec_as_integer_to_string (swfdec_gc_object_get_context (object), length - 1);
swfdec_as_object_set_variable (object, var, &val);
}
}
static void
swfdec_print_job_init_properties (SwfdecAsContext *cx)
{
SwfdecAsValue val;
SwfdecAsObject *xml, *proto;
// FIXME: We should only initialize if the prototype Object has not been
// initialized by any object's constructor with native properties
// (TextField, TextFormat, XML, XMLNode at least)
g_return_if_fail (SWFDEC_IS_AS_CONTEXT (cx));
swfdec_as_object_get_variable (cx->global, SWFDEC_AS_STR_PrintJob, &val);
if (!SWFDEC_AS_VALUE_IS_OBJECT (val))
return;
xml = SWFDEC_AS_VALUE_GET_OBJECT (val);
swfdec_as_object_get_variable (xml, SWFDEC_AS_STR_prototype, &val);
if (!SWFDEC_AS_VALUE_IS_OBJECT (val))
return;
proto = SWFDEC_AS_VALUE_GET_OBJECT (val);
swfdec_as_object_add_native_variable (proto, SWFDEC_AS_STR_orientation,
swfdec_print_job_get_orientation, NULL);
swfdec_as_object_add_native_variable (proto, SWFDEC_AS_STR_pageHeight,
swfdec_print_job_get_pageHeight, NULL);
swfdec_as_object_add_native_variable (proto, SWFDEC_AS_STR_pageWidth,
swfdec_print_job_get_pageWidth, NULL);
swfdec_as_object_add_native_variable (proto, SWFDEC_AS_STR_paperHeight,
swfdec_print_job_get_paperHeight, NULL);
swfdec_as_object_add_native_variable (proto, SWFDEC_AS_STR_paperWidth,
swfdec_print_job_get_paperWidth, NULL);
}
static guint
check_object_variables (void)
{
SwfdecAsObject *o, *o2;
guint errors = 0;
SwfdecAsContext *context;
const char *s;
gpointer check = GUINT_TO_POINTER (-1); /* NOT NULL */
gpointer check2 = GUINT_TO_POINTER (-1); /* NOT NULL */
SwfdecAsValue v1, v2;
context = g_object_new (SWFDEC_TYPE_AS_CONTEXT, NULL);
swfdec_as_context_startup (context);
g_assert (check != NULL);
o = swfdec_as_object_new (context);
o2 = swfdec_as_object_new (context);
g_object_add_weak_pointer (G_OBJECT (o), &check);
g_object_add_weak_pointer (G_OBJECT (o2), &check2);
s = swfdec_as_context_get_string (context, "foo");
/* step one: set a variable */
SWFDEC_AS_VALUE_SET_OBJECT (&v1, o);
swfdec_as_object_set_variable (context->global, s, &v1);
SWFDEC_AS_VALUE_SET_OBJECT (&v2, o2);
swfdec_as_object_set_variable (o, s, &v2);
SWFDEC_AS_VALUE_SET_UNDEFINED (&v2);
swfdec_as_object_get_variable (o, s, &v2);
if (!SWFDEC_AS_VALUE_IS_OBJECT (&v2)) {
ERROR ("variable changed type");
} else if (o2 != SWFDEC_AS_VALUE_GET_OBJECT (&v2)) {
ERROR ("variable changed value");
}
/* step 2: gc */
swfdec_as_context_gc (context);
if (check == NULL || check2 == NULL) {
ERROR ("GC collected a used object, bailing");
g_object_unref (context);
return errors;
}
/* step 3: unset root reference and set cyclic variable */
swfdec_as_object_delete_variable (context->global, s);
swfdec_as_object_set_variable (o2, s, &v1);
SWFDEC_AS_VALUE_SET_UNDEFINED (&v1);
swfdec_as_object_get_variable (o2, s, &v1);
if (!SWFDEC_AS_VALUE_IS_OBJECT (&v1)) {
ERROR ("variable changed type");
} else if (o != SWFDEC_AS_VALUE_GET_OBJECT (&v1)) {
ERROR ("variable changed value");
}
/* step 4: gc, ensure that both objects disappears */
swfdec_as_context_gc (context);
if (check != NULL || check2 != NULL) {
ERROR ("GC didn't collect unused object");
}
g_object_unref (context);
return errors;
}
static int
swfdec_as_array_sort_compare (gconstpointer a_ptr, gconstpointer b_ptr,
gpointer user_data)
{
const SwfdecAsValue *a = &((SortEntry *)a_ptr)->value;
const SwfdecAsValue *b = &((SortEntry *)b_ptr)->value;
SortCompareData *data = user_data;
int retval;
g_return_val_if_fail (SWFDEC_IS_AS_VALUE (a), 0);
g_return_val_if_fail (SWFDEC_IS_AS_VALUE (b), 0);
g_return_val_if_fail (SWFDEC_IS_AS_CONTEXT (data->context), 0);
g_return_val_if_fail (data->options != NULL, 0);
g_return_val_if_fail (data->custom_function == NULL ||
SWFDEC_IS_AS_FUNCTION (data->custom_function), 0);
g_return_val_if_fail (data->fields == NULL || data->fields[0] != NULL, 0);
if (data->fields == NULL) {
retval = swfdec_as_array_sort_compare_values (data->context, a, b,
data->options[0], data->custom_function);
} else {
SwfdecAsValue a_comp, b_comp;
SwfdecAsObject *object;
int i;
i = 0;
do {
object = swfdec_as_value_to_object (data->context, a);
if (object) {
swfdec_as_object_get_variable (object, data->fields[i], &a_comp);
} else {
SWFDEC_AS_VALUE_SET_UNDEFINED (&a_comp);
}
object = swfdec_as_value_to_object (data->context, b);
if (object) {
swfdec_as_object_get_variable (object, data->fields[i], &b_comp);
} else {
SWFDEC_AS_VALUE_SET_UNDEFINED (&b_comp);
}
retval =
swfdec_as_array_sort_compare_values (data->context, &a_comp, &b_comp,
data->options[i], data->custom_function);
} while (retval == 0 && data->fields[++i] != NULL);
}
if (retval == 0)
data->equal_found = TRUE;
return retval;
}
void
broadcastMessage (SwfdecAsContext *cx, SwfdecAsObject *object,
guint argc, SwfdecAsValue *argv, SwfdecAsValue *ret)
{
SwfdecAsValue val;
SwfdecAsObject *listeners, *o;
gint i, length;
const char *name;
GSList *list = NULL, *walk;
if (object == NULL)
return;
if (argc < 1)
return;
name = swfdec_as_value_to_string (cx, argv[0]);
argv += 1;
argc--;
swfdec_as_object_get_variable (object, SWFDEC_AS_STR__listeners, &val);
if (!SWFDEC_AS_VALUE_IS_COMPOSITE (val))
return;
listeners = SWFDEC_AS_VALUE_GET_COMPOSITE (val);
swfdec_as_object_get_variable (listeners, SWFDEC_AS_STR_length, &val);
length = swfdec_as_value_to_integer (cx, val);
/* return undefined if we won't try to call anything */
if (length <= 0)
return;
/* FIXME: solve this wth foreach, so it gets faster for weird cases */
for (i = 0; i < length; i++) {
swfdec_as_object_get_variable (listeners, swfdec_as_integer_to_string (cx, i), &val);
o = swfdec_as_value_to_object (cx, val);
if (o == NULL)
continue;
list = g_slist_prepend (list, o);
}
if (list == NULL)
return;
list = g_slist_reverse (list);
for (walk = list; walk; walk = walk->next) {
swfdec_as_object_call (walk->data, name, argc, argv, &val);
}
g_slist_free (list);
SWFDEC_AS_VALUE_SET_BOOLEAN (ret, TRUE);
}
void
swfdec_as_function_apply (SwfdecAsContext *cx, SwfdecAsObject *object,
guint argc, SwfdecAsValue *argv, SwfdecAsValue *ret)
{
SwfdecAsValue *argv_pass = NULL;
int length = 0;
SwfdecAsFunction *fun;
SwfdecAsObject *thisp = NULL;
SWFDEC_AS_CHECK (SWFDEC_TYPE_AS_FUNCTION, &fun, "|O", &thisp);
if (thisp == NULL)
thisp = swfdec_as_object_new_empty (cx);
if (argc > 1 && SWFDEC_AS_VALUE_IS_OBJECT (&argv[1])) {
int i;
SwfdecAsObject *array;
SwfdecAsValue val;
array = SWFDEC_AS_VALUE_GET_OBJECT (&argv[1]);
swfdec_as_object_get_variable (array, SWFDEC_AS_STR_length, &val);
length = swfdec_as_value_to_integer (cx, &val);
if (length > 0) {
/* FIXME: find a smarter way to do this, like providing argv not as an array */
if (!swfdec_as_context_try_use_mem (cx, sizeof (SwfdecAsValue) * length)) {
swfdec_as_context_abort (cx, "too many arguments to Function.apply");
return;
}
argv_pass = g_malloc (sizeof (SwfdecAsValue) * length);
for (i = 0; i < length; i++) {
swfdec_as_object_get_variable (array,
swfdec_as_integer_to_string (cx, i), &argv_pass[i]);
}
} else {
length = 0;
}
}
swfdec_as_function_call (fun, thisp, length, argv_pass, ret);
if (argv_pass) {
swfdec_as_context_unuse_mem (cx, sizeof (SwfdecAsValue) * length);
g_free (argv_pass);
}
}
void
swfdec_as_array_do_pop (SwfdecAsContext *cx, SwfdecAsObject *object,
guint argc, SwfdecAsValue *argv, SwfdecAsValue *ret)
{
gint32 length;
const char *var;
if (object == NULL || SWFDEC_IS_MOVIE (object))
return;
// we allow negative indexes here, but not 0
length = swfdec_as_array_length_as_integer (object);
if (length == 0)
return;
var = swfdec_as_integer_to_string (swfdec_gc_object_get_context (object), length - 1);
swfdec_as_object_get_variable (object, var, ret);
swfdec_as_object_delete_variable (object, var);
// if Array, the length is reduced by one
// else the length is not reduced at all, but the variable is still deleted
if (SWFDEC_IS_AS_ARRAY (object))
swfdec_as_array_set_length_object (object, length - 1);
}
static void
swfdec_as_super_call (SwfdecAsFunction *function, SwfdecAsObject *thisp,
gboolean construct, SwfdecAsObject *super_reference, guint n_args,
const SwfdecAsValue *args, SwfdecAsValue *return_value)
{
SwfdecAsSuper *super = SWFDEC_AS_SUPER (function);
SwfdecAsFunction *fun;
SwfdecAsValue val;
if (super->object == NULL) {
SWFDEC_WARNING ("super () called without an object.");
return;
}
swfdec_as_object_get_variable (super->object, SWFDEC_AS_STR___constructor__, &val);
if (!SWFDEC_AS_VALUE_IS_OBJECT (&val) ||
!SWFDEC_IS_AS_FUNCTION (fun = (SwfdecAsFunction *) SWFDEC_AS_VALUE_GET_OBJECT (&val)))
return;
if (construct) {
SWFDEC_FIXME ("What happens with \"new super()\"?");
}
swfdec_as_function_call_full (fun, super->thisp, construct ||
swfdec_as_context_is_constructing (swfdec_gc_object_get_context (super)),
super->object->prototype, n_args, args, return_value);
}
static gint32
swfdec_as_array_length_as_integer (SwfdecAsObject *object)
{
SwfdecAsValue val;
gint32 length;
g_return_val_if_fail (object != NULL, 0);
swfdec_as_object_get_variable (object, SWFDEC_AS_STR_length, &val);
length = swfdec_as_value_to_integer (swfdec_gc_object_get_context (object), &val);
return length;
}
/**
* swfdec_as_array_get_value:
* @array: a #SwfdecAsArray
* @idx: index of the value to get
* @value: a pointer to #SwfdecAsValue that will be set
*
* Gets a value from given index, if the value doesn't exists an undefined
* value is set.
**/
void
swfdec_as_array_get_value (SwfdecAsArray *array, gint32 idx,
SwfdecAsValue *value)
{
const char *var;
g_assert (SWFDEC_IS_AS_ARRAY (array));
g_assert (idx >= 0);
g_assert (value != NULL);
var = swfdec_as_integer_to_string (swfdec_gc_object_get_context (array), idx);
swfdec_as_object_get_variable (SWFDEC_AS_OBJECT (array), var, value);
}
void
swfdec_as_array_join (SwfdecAsContext *cx, SwfdecAsObject *object, guint argc,
SwfdecAsValue *argv, SwfdecAsValue *ret)
{
int i;
const char *var, *str, *sep;
SwfdecAsValue val;
if (object == NULL || SWFDEC_IS_MOVIE (object))
return;
if (argc > 0) {
sep = swfdec_as_value_to_string (cx, &argv[0]);
} else {
sep = SWFDEC_AS_STR_COMMA;
}
// note: we don't cache length
if (swfdec_as_array_length (object) > 0) {
GString *string;
swfdec_as_object_get_variable (object, SWFDEC_AS_STR_0, &val);
str = swfdec_as_value_to_string (cx, &val);
string = g_string_new (str);
for (i = 1; i < swfdec_as_array_length (object); i++) {
var = swfdec_as_integer_to_string (cx, i);
swfdec_as_object_get_variable (object, var, &val);
var = swfdec_as_value_to_string (cx, &val);
g_string_append (string, sep);
g_string_append (string, var);
}
str = swfdec_as_context_give_string (cx, g_string_free (string, FALSE));
} else {
str = SWFDEC_AS_STR_EMPTY;
}
SWFDEC_AS_VALUE_SET_STRING (ret, str);
}
static gboolean
swfdec_video_movie_foreach_variable (SwfdecAsObject *object, SwfdecAsVariableForeach func, gpointer data)
{
const char *native_variables[] = { SWFDEC_AS_STR_width, SWFDEC_AS_STR_height,
SWFDEC_AS_STR_smoothing, SWFDEC_AS_STR_deblocking, NULL };
int i;
for (i = 0; native_variables[i] != NULL; i++) {
SwfdecAsValue val;
swfdec_as_object_get_variable (object, native_variables[i], &val);
if (!func (object, native_variables[i], &val, 0, data))
return FALSE;
}
return SWFDEC_AS_OBJECT_CLASS (swfdec_video_movie_parent_class)->foreach (
object, func, data);
}
