libswfdec/swfdec_movie_asprops.c

   1 /* Swfdec
   2  * Copyright (C) 2003-2006 David Schleef <ds@schleef.org>
   3  *               2005-2006 Eric Anholt <eric@anholt.net>
   4  *               2006-2007 Benjamin Otte <otte@gnome.org>
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor,
  19  * Boston, MA  02110-1301  USA
  20  */
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include "config.h"
  24 #endif
  25 #include <string.h>
  26 #include <math.h>
  27
  28 #include "swfdec_movie.h"
  29 #include "swfdec_as_strings.h"
  30 #include "swfdec_bits.h"
  31 #include "swfdec_debug.h"
  32 #include "swfdec_player_internal.h"
  33 #include "swfdec_sprite.h"
  34 #include "swfdec_sprite_movie.h"
  35
  36 static void
  37 mc_x_get (SwfdecMovie *movie, SwfdecAsValue *rval)
  38 {
  39   double d;
  40
  41   swfdec_movie_update (movie);
  42   d = SWFDEC_TWIPS_TO_DOUBLE (movie->matrix.x0);
  43   SWFDEC_AS_VALUE_SET_NUMBER (rval, d);
  44 }
  45
  46 static void
  47 mc_x_set (SwfdecMovie *movie, const SwfdecAsValue *val)
  48 {
  49   double d;
  50
  51   d = swfdec_as_value_to_number (SWFDEC_AS_OBJECT (movie)->context, val);
  52   if (!isfinite (d)) {
  53     SWFDEC_WARNING ("trying to move %s._x to a non-finite value, ignoring", movie->name);
  54     return;
  55   }
  56   movie->modified = TRUE;
  57   d = SWFDEC_DOUBLE_TO_TWIPS (d);
  58   if (d != movie->matrix.x0) {
  59     movie->matrix.x0 = d;
  60     swfdec_movie_queue_update (movie, SWFDEC_MOVIE_INVALID_MATRIX);
  61   }
  62 }
  63
  64 static void
  65 mc_y_get (SwfdecMovie *movie, SwfdecAsValue *rval)
  66 {
  67   double d;
  68
  69   swfdec_movie_update (movie);
  70   d = SWFDEC_TWIPS_TO_DOUBLE (movie->matrix.y0);
  71   SWFDEC_AS_VALUE_SET_NUMBER (rval, d);
  72 }
  73
  74 static void
  75 mc_y_set (SwfdecMovie *movie, const SwfdecAsValue *val)
  76 {
  77   double d;
  78
  79   d = swfdec_as_value_to_number (SWFDEC_AS_OBJECT (movie)->context, val);
  80   if (!isfinite (d)) {
  81     SWFDEC_WARNING ("trying to move %s._y to a non-finite value, ignoring", movie->name);
  82     return;
  83   }
  84   movie->modified = TRUE;
  85   d = SWFDEC_DOUBLE_TO_TWIPS (d);
  86   if (d != movie->matrix.y0) {
  87     movie->matrix.y0 = d;
  88     swfdec_movie_queue_update (movie, SWFDEC_MOVIE_INVALID_MATRIX);
  89   }
  90 }
  91
  92 static void
  93 mc_xscale_get (SwfdecMovie *movie, SwfdecAsValue *rval)
  94 {
  95   SWFDEC_AS_VALUE_SET_NUMBER (rval, movie->xscale);
  96 }
  97
  98 static void
  99 mc_xscale_set (SwfdecMovie *movie, const SwfdecAsValue *val)
 100 {
 101   double d;
 102
 103   d = swfdec_as_value_to_number (SWFDEC_AS_OBJECT (movie)->context, val);
 104   if (!isfinite (d)) {
 105     SWFDEC_WARNING ("trying to set xscale to a non-finite value, ignoring");
 106     return;
 107   }
 108   movie->modified = TRUE;
 109   movie->xscale = d;
 110   swfdec_movie_queue_update (movie, SWFDEC_MOVIE_INVALID_MATRIX);
 111 }
 112
 113 static void
 114 mc_yscale_get (SwfdecMovie *movie, SwfdecAsValue *rval)
 115 {
 116   SWFDEC_AS_VALUE_SET_NUMBER (rval, movie->yscale);
 117 }
 118
 119 static void
 120 mc_yscale_set (SwfdecMovie *movie, const SwfdecAsValue *val)
 121 {
 122   double d;
 123
 124   d = swfdec_as_value_to_number (SWFDEC_AS_OBJECT (movie)->context, val);
 125   if (!isfinite (d)) {
 126     SWFDEC_WARNING ("trying to set yscale to a non-finite value, ignoring");
 127     return;
 128   }
 129   movie->modified = TRUE;
 130   movie->yscale = d;
 131   swfdec_movie_queue_update (movie, SWFDEC_MOVIE_INVALID_MATRIX);
 132 }
 133
 134 static void
 135 mc_currentframe (SwfdecMovie *movie, SwfdecAsValue *rval)
 136 {
 137   g_assert (SWFDEC_IS_SPRITE_MOVIE (movie));
 138   SWFDEC_AS_VALUE_SET_NUMBER (rval, SWFDEC_SPRITE_MOVIE (movie)->frame);
 139 }
 140
 141 static void
 142 mc_framesloaded (SwfdecMovie *mov, SwfdecAsValue *rval)
 143 {
 144   SwfdecSpriteMovie *movie = SWFDEC_SPRITE_MOVIE (mov);
 145   if (movie->sprite) {
 146     SWFDEC_AS_VALUE_SET_NUMBER (rval, movie->sprite->parse_frame);
 147     return;
 148   }
 149   SWFDEC_AS_VALUE_SET_INT (rval, movie->n_frames);
 150 }
 151
 152 static void
 153 mc_name_get (SwfdecMovie *movie, SwfdecAsValue *rval)
 154 {
 155   SWFDEC_AS_VALUE_SET_STRING (rval, movie->name);
 156 }
 157
 158 static void
 159 mc_name_set (SwfdecMovie *movie, const SwfdecAsValue *val)
 160 {
 161   movie->name = swfdec_as_value_to_string (SWFDEC_AS_OBJECT (movie)->context, val);
 162 }
 163
 164 static void
 165 mc_totalframes (SwfdecMovie *movie, SwfdecAsValue *rval)
 166 {
 167   g_assert (SWFDEC_IS_SPRITE_MOVIE (movie));
 168   SWFDEC_AS_VALUE_SET_INT (rval, SWFDEC_SPRITE_MOVIE (movie)->n_frames);
 169 }
 170
 171 static void
 172 mc_alpha_get (SwfdecMovie *movie, SwfdecAsValue *rval)
 173 {
 174   SWFDEC_AS_VALUE_SET_NUMBER (rval,
 175       movie->color_transform.aa * 100.0 / 256.0);
 176 }
 177
 178 static void
 179 mc_alpha_set (SwfdecMovie *movie, const SwfdecAsValue *val)
 180 {
 181   double d;
 182   int alpha;
 183
 184   d = swfdec_as_value_to_number (SWFDEC_AS_OBJECT (movie)->context, val);
 185   if (!isfinite (d)) {
 186     SWFDEC_WARNING ("trying to set alpha to a non-finite value, ignoring");
 187     return;
 188   }
 189   alpha = d * 256.0 / 100.0;
 190   if (alpha != movie->color_transform.aa) {
 191     movie->color_transform.aa = alpha;
 192     swfdec_movie_invalidate (movie);
 193   }
 194 }
 195
 196 static void
 197 mc_visible_get (SwfdecMovie *movie, SwfdecAsValue *rval)
 198 {
 199   SWFDEC_AS_VALUE_SET_BOOLEAN (rval, movie->visible);
 200 }
 201
 202 static void
 203 mc_visible_set (SwfdecMovie *movie, const SwfdecAsValue *val)
 204 {
 205   gboolean b;
 206
 207   b = swfdec_as_value_to_boolean (SWFDEC_AS_OBJECT (movie)->context, val);
 208   if (b != movie->visible) {
 209     movie->visible = b;
 210     swfdec_movie_invalidate (movie);
 211   }
 212 }
 213
 214 static void
 215 mc_width_get (SwfdecMovie *movie, SwfdecAsValue *rval)
 216 {
 217   double d;
 218
 219   swfdec_movie_update (movie);
 220   d = rint (movie->extents.x1 - movie->extents.x0);
 221   d = SWFDEC_TWIPS_TO_DOUBLE ((SwfdecTwips) d);
 222   SWFDEC_AS_VALUE_SET_NUMBER (rval, d);
 223 }
 224
 225 static void
 226 mc_width_set (SwfdecMovie *movie, const SwfdecAsValue *val)
 227 {
 228   double d, cur;
 229
 230   /* property was readonly in Flash 4 and before */
 231   if (SWFDEC_AS_OBJECT (movie)->context->version < 5)
 232     return;
 233   d = swfdec_as_value_to_number (SWFDEC_AS_OBJECT (movie)->context, val);
 234   if (!isfinite (d)) {
 235     SWFDEC_WARNING ("trying to set width to a non-finite value, ignoring");
 236     return;
 237   }
 238   swfdec_movie_update (movie);
 239   movie->modified = TRUE;
 240   cur = rint (movie->original_extents.x1 - movie->original_extents.x0);
 241   cur = SWFDEC_TWIPS_TO_DOUBLE ((SwfdecTwips) cur);
 242   if (cur != 0) {
 243     movie->xscale = 100 * d / cur;
 244   } else {
 245     movie->xscale = 0;
 246     movie->yscale = 0;
 247   }
 248   swfdec_movie_queue_update (movie, SWFDEC_MOVIE_INVALID_MATRIX);
 249 }
 250
 251 static void
 252 mc_height_get (SwfdecMovie *movie, SwfdecAsValue *rval)
 253 {
 254   double d;
 255
 256   swfdec_movie_update (movie);
 257   d = rint (movie->extents.y1 - movie->extents.y0);
 258   d = SWFDEC_TWIPS_TO_DOUBLE ((SwfdecTwips) d);
 259   SWFDEC_AS_VALUE_SET_NUMBER (rval, d);
 260 }
 261
 262 static void
 263 mc_height_set (SwfdecMovie *movie, const SwfdecAsValue *val)
 264 {
 265   double d, cur;
 266
 267   /* property was readonly in Flash 4 and before */
 268   if (SWFDEC_AS_OBJECT (movie)->context->version < 5)
 269     return;
 270   d = swfdec_as_value_to_number (SWFDEC_AS_OBJECT (movie)->context, val);
 271   if (!isfinite (d)) {
 272     SWFDEC_WARNING ("trying to set height to a non-finite value, ignoring");
 273     return;
 274   }
 275   swfdec_movie_update (movie);
 276   movie->modified = TRUE;
 277   cur = rint (movie->original_extents.y1 - movie->original_extents.y0);
 278   cur = SWFDEC_TWIPS_TO_DOUBLE ((SwfdecTwips) cur);
 279   if (cur != 0) {
 280     movie->yscale = 100 * d / cur;
 281   } else {
 282     movie->xscale = 0;
 283     movie->yscale = 0;
 284   }
 285   swfdec_movie_queue_update (movie, SWFDEC_MOVIE_INVALID_MATRIX);
 286 }
 287
 288 static void
 289 mc_rotation_get (SwfdecMovie *movie, SwfdecAsValue *rval)
 290 {
 291   SWFDEC_AS_VALUE_SET_NUMBER (rval, movie->rotation);
 292 }
 293
 294 static void
 295 mc_rotation_set (SwfdecMovie *movie, const SwfdecAsValue *val)
 296 {
 297   double d;
 298
 299   /* FIXME: Flash 4 handles this differently */
 300   d = swfdec_as_value_to_number (SWFDEC_AS_OBJECT (movie)->context, val);
 301   if (isnan (d)) {
 302     SWFDEC_WARNING ("setting rotation to NaN - not allowed");
 303     return;
 304   }
 305   d = fmod (d, 360.0);
 306   if (d > 180.0)
 307     d -= 360.0;
 308   if (d < -180.0)
 309     d += 360.0;
 310   if (SWFDEC_AS_OBJECT (movie)->context->version < 5) {
 311     if (!isfinite (d))
 312       return;
 313     SWFDEC_ERROR ("FIXME: implement correct rounding errors here");
 314   }
 315   movie->modified = TRUE;
 316   movie->rotation = d;
 317   swfdec_movie_queue_update (movie, SWFDEC_MOVIE_INVALID_MATRIX);
 318 }
 319
 320 static void
 321 mc_xmouse_get (SwfdecMovie *movie, SwfdecAsValue *rval)
 322 {
 323   double x, y;
 324
 325   swfdec_movie_get_mouse (movie, &x, &y);
 326   x = SWFDEC_TWIPS_TO_DOUBLE (rint (x));
 327   SWFDEC_AS_VALUE_SET_NUMBER (rval, x);
 328 }
 329
 330 static void
 331 mc_ymouse_get (SwfdecMovie *movie, SwfdecAsValue *rval)
 332 {
 333   double x, y;
 334
 335   swfdec_movie_get_mouse (movie, &x, &y);
 336   y = SWFDEC_TWIPS_TO_DOUBLE (rint (y));
 337   SWFDEC_AS_VALUE_SET_NUMBER (rval, y);
 338 }
 339
 340 static void
 341 mc_parent (SwfdecMovie *movie, SwfdecAsValue *rval)
 342 {
 343   if (movie->parent) {
 344     SWFDEC_AS_VALUE_SET_OBJECT (rval, SWFDEC_AS_OBJECT (movie->parent));
 345   } else {
 346     SWFDEC_AS_VALUE_SET_UNDEFINED (rval);
 347   }
 348 }
 349
 350 static void
 351 mc_root (SwfdecMovie *movie, SwfdecAsValue *rval)
 352 {
 353   while (movie->parent)
 354     movie = movie->parent;
 355   SWFDEC_AS_VALUE_SET_OBJECT (rval, SWFDEC_AS_OBJECT (movie));
 356 }
 357
 358 struct {
 359   gboolean needs_movie;
 360   const char *name;
 361   void (* get) (SwfdecMovie *movie, SwfdecAsValue *ret);
 362   void (* set) (SwfdecMovie *movie, const SwfdecAsValue *val);
 363 } swfdec_movieclip_props[] = {
 364   { 0, SWFDEC_AS_STR__x,                mc_x_get,           mc_x_set },
 365   { 0, SWFDEC_AS_STR__y,                mc_y_get,           mc_y_set },
 366   { 0, SWFDEC_AS_STR__xscale,   mc_xscale_get,      mc_xscale_set },
 367   { 0, SWFDEC_AS_STR__yscale,   mc_yscale_get,      mc_yscale_set },
 368   { 1, SWFDEC_AS_STR__currentframe,mc_currentframe,    NULL },
 369   { 1, SWFDEC_AS_STR__totalframes,      mc_totalframes,     NULL },
 370   { 0, SWFDEC_AS_STR__alpha,    mc_alpha_get,       mc_alpha_set },
 371   { 0, SWFDEC_AS_STR__visible,  mc_visible_get,     mc_visible_set },
 372   { 0, SWFDEC_AS_STR__width,    mc_width_get,       mc_width_set },
 373   { 0, SWFDEC_AS_STR__height,   mc_height_get,      mc_height_set },
 374   { 0, SWFDEC_AS_STR__rotation, mc_rotation_get,    mc_rotation_set },
 375   { 1, SWFDEC_AS_STR__target,   NULL,  NULL }, //"_target"
 376   { 1, SWFDEC_AS_STR__framesloaded,mc_framesloaded,    NULL},
 377   { 0, SWFDEC_AS_STR__name,     mc_name_get,        mc_name_set },
 378   { 1, SWFDEC_AS_STR__droptarget,       NULL,  NULL }, //"_droptarget"
 379   { 0, SWFDEC_AS_STR__url,              NULL,  NULL }, //"_url"
 380   { 0, SWFDEC_AS_STR__highquality,      NULL,  NULL }, //"_highquality"
 381   { 0, SWFDEC_AS_STR__focusrect,        NULL,  NULL }, //"_focusrect"
 382   { 0, SWFDEC_AS_STR__soundbuftime,NULL,  NULL }, //"_soundbuftime"
 383   { 0, SWFDEC_AS_STR__quality,  NULL,  NULL }, //"_quality"
 384   { 0, SWFDEC_AS_STR__xmouse,   mc_xmouse_get,      NULL },
 385   { 0, SWFDEC_AS_STR__ymouse,   mc_ymouse_get,      NULL },
 386   { 0, SWFDEC_AS_STR__parent,   mc_parent,          NULL },
 387   { 0, SWFDEC_AS_STR__root,     mc_root,            NULL },
 388 };
 389
 390 static inline int
 391 swfdec_movie_get_asprop_index (SwfdecMovie *movie, const char *name)
 392 {
 393   guint i;
 394
 395   if (name < SWFDEC_AS_STR__x || name > SWFDEC_AS_STR__root)
 396     return -1;
 397
 398   for (i = 0; i < G_N_ELEMENTS (swfdec_movieclip_props); i++) {
 399     if (swfdec_movieclip_props[i].name == name) {
 400       if (swfdec_movieclip_props[i].needs_movie && !SWFDEC_IS_SPRITE_MOVIE (movie))
 401         return -1;
 402       if (swfdec_movieclip_props[i].get == NULL) {
 403         SWFDEC_ERROR ("property %s not implemented", name);
 404       }
 405       return i;
 406     }
 407   }
 408   g_assert_not_reached ();
 409   return -1;
 410 }
 411
 412 gboolean
 413 swfdec_movie_set_asprop (SwfdecMovie *movie, const char *name, const SwfdecAsValue *val)
 414 {
 415   int i;
 416
 417   i = swfdec_movie_get_asprop_index (movie, name);
 418   if (i == -1)
 419     return FALSE;
 420   if (swfdec_movieclip_props[i].set != NULL) {
 421     swfdec_movieclip_props[i].set (movie, val);
 422   }
 423   return TRUE;
 424 }
 425
 426 gboolean
 427 swfdec_movie_get_asprop (SwfdecMovie *movie, const char *name, SwfdecAsValue *val)
 428 {
 429   int i;
 430
 431   i = swfdec_movie_get_asprop_index (movie, name);
 432   if (i == -1)
 433     return FALSE;
 434   if (swfdec_movieclip_props[i].get != NULL) {
 435     swfdec_movieclip_props[i].get (movie, val);
 436   } else {
 437     SWFDEC_AS_VALUE_SET_UNDEFINED (val);
 438   }
 439   return TRUE;
 440 }
 441