testsuite/actionscript.all/BitmapData.as

   1 //
   2 //   Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc.
   3 //
   4 // This program is free software; you can redistribute it and/or modify
   5 // it under the terms of the GNU General Public License as published by
   6 // the Free Software Foundation; either version 2 of the License, or
   7 // (at your option) any later version.
   8 //
   9 // This program is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU General Public License
  15 //
  16 // along with this program; if not, write to the Free Software
  17 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  18 //
  19 // Test case for BitmapData ActionScript class
  20 // compile this test case with Ming makeswf, and then
  21 // execute it like this gnash -1 -r 0 -v out.swf
  22
  23 rcsid="$Id: BitmapData.as,v 1.3 2008/06/20 13:28:56 bwy Exp $";
  24
  25
  26 #include "check.as"
  27
  28 #if OUTPUT_VERSION < 8
  29
  30 check_equals(typeof(flash), 'undefined');
  31
  32 check_totals(1);
  33
  34 #else
  35
  36 Bitmap = flash.display.BitmapData;
  37 check_equals(typeof(Bitmap), 'function');
  38 check_equals(typeof(Bitmap.prototype), 'object');
  39 check(Bitmap.prototype.hasOwnProperty('applyFilter'));
  40 check(Bitmap.prototype.hasOwnProperty('clone'));
  41 check(Bitmap.prototype.hasOwnProperty('colorTransform'));
  42 check(Bitmap.prototype.hasOwnProperty('copyChannel'));
  43 check(Bitmap.prototype.hasOwnProperty('copyPixels'));
  44 check(Bitmap.prototype.hasOwnProperty('dispose'));
  45 check(Bitmap.prototype.hasOwnProperty('draw'));
  46 check(Bitmap.prototype.hasOwnProperty('fillRect'));
  47 check(Bitmap.prototype.hasOwnProperty('floodFill'));
  48 check(Bitmap.prototype.hasOwnProperty('generateFilterRect'));
  49 check(Bitmap.prototype.hasOwnProperty('getColorBoundsRect'));
  50 check(Bitmap.prototype.hasOwnProperty('getPixel'));
  51 check(Bitmap.prototype.hasOwnProperty('getPixel32'));
  52 check(Bitmap.prototype.hasOwnProperty('hitTest'));
  53 check(Bitmap.prototype.hasOwnProperty('merge'));
  54 check(Bitmap.prototype.hasOwnProperty('noise'));
  55 check(Bitmap.prototype.hasOwnProperty('paletteMap'));
  56 check(Bitmap.prototype.hasOwnProperty('perlinNoise'));
  57 check(Bitmap.prototype.hasOwnProperty('pixelDissolve'));
  58 check(Bitmap.prototype.hasOwnProperty('scroll'));
  59 check(Bitmap.prototype.hasOwnProperty('setPixel'));
  60 check(Bitmap.prototype.hasOwnProperty('setPixel32'));
  61 check(Bitmap.prototype.hasOwnProperty('threshold'));
  62 check(Bitmap.prototype.hasOwnProperty("height"));
  63 check(Bitmap.prototype.hasOwnProperty("width"));
  64 check(Bitmap.prototype.hasOwnProperty("rectangle"));
  65 check(Bitmap.prototype.hasOwnProperty("transparent"));
  66
  67 check(Bitmap.hasOwnProperty("RED_CHANNEL"));
  68 check(Bitmap.hasOwnProperty("GREEN_CHANNEL"));
  69 check(Bitmap.hasOwnProperty("BLUE_CHANNEL"));
  70 check(Bitmap.hasOwnProperty("ALPHA_CHANNEL"));
  71
  72 check(!Bitmap.prototype.hasOwnProperty('loadBitmap'));
  73 check(Bitmap.hasOwnProperty('loadBitmap'));
  74
  75 Rectangle = flash.geom.Rectangle;
  76
  77 //-------------------------------------------------------------
  78 // Test constructor
  79 //-------------------------------------------------------------
  80
  81 bmp = new Bitmap();
  82 check_equals(typeof(bmp), "undefined");
  83
  84 bmp = new Bitmap(10, 10);
  85 check_equals(typeof(bmp), 'object');
  86 check(bmp instanceof Bitmap);
  87 check(!bmp.hasOwnProperty("height"));
  88 check(!bmp.hasOwnProperty("width"));
  89 check(!bmp.hasOwnProperty("rectangle"));
  90 check(!bmp.hasOwnProperty("transparent"));
  91 check_equals(bmp.height, 10);
  92 check_equals(bmp.width, 10);
  93 check_equals(bmp.transparent, true);
  94 check_equals(bmp.rectangle.toString(), "(x=0, y=0, w=10, h=10)");
  95 check(bmp.rectangle instanceOf flash.geom.Rectangle);
  96 check_equals(bmp.getPixel(1, 1), 16777215);
  97 check_equals(bmp.getPixel(9, 9), 16777215);
  98 check_equals(bmp.getPixel32(1, 1), -1);
  99
 100 bmp = new Bitmap(10, 10, true);
 101 check_equals(bmp.getPixel32(1, 1), -1);
 102 bmp = new Bitmap(10, 10, false);
 103 check_equals(bmp.getPixel32(1, 1), -1);
 104
 105
 106 bmp = new Bitmap(20, 30, false, 0xeeddee);
 107 check_equals(bmp.height, 30);
 108 check_equals(bmp.width, 20);
 109 check_equals(bmp.transparent, false);
 110 check_equals(bmp.rectangle.toString(), "(x=0, y=0, w=20, h=30)");
 111 check_equals(bmp.getPixel(1, 1), 0xeeddee);
 112 check_equals(bmp.getPixel32(1, 1), -1122834);
 113
 114 // limits
 115
 116 check_equals(bmp.getPixel(50, 1), 0);
 117 check_equals(bmp.getPixel(0, 0), 15654382);
 118 check_equals(bmp.getPixel(-2, -5), 0);
 119
 120 // 0,0 is inside, 20, 30 outside a 20x30 bitmap.
 121 check_equals(bmp.getPixel(20, 30), 0);
 122
 123
 124 // 2880 is the maximum, 1 the minimum. Returns
 125 // undefined if the dimensions are invalid.
 126 bmp = new Bitmap(10000, 3);
 127 check_equals(typeof(bmp), "undefined");
 128 check_equals(bmp.height, undefined);
 129
 130 bmp = new Bitmap(0, 10000);
 131 check_equals(bmp, undefined);
 132 check_equals(bmp.height, undefined);
 133
 134 bmp = new Bitmap(2880, 2880);
 135 check_equals(typeof(bmp), "object");
 136 check_equals(bmp.height, 2880);
 137
 138 bmp = new Bitmap(2880, 2881);
 139 check_equals(typeof(bmp), "undefined");
 140 check_equals(bmp.height, undefined);
 141
 142 bmp = new Bitmap(0, 2880);
 143 check_equals(bmp, undefined);
 144 check_equals(bmp.height, undefined);
 145
 146 bmp = new Bitmap(2879, 2879);
 147 check_equals(typeof(bmp), "object");
 148 check_equals(bmp.height, 2879);
 149
 150 bmp = new Bitmap(0, 2879);
 151 check_equals(bmp, undefined);
 152 check_equals(bmp.height, undefined);
 153
 154 bmp = new Bitmap(-1, 10, false, 0xff);
 155 check_equals(bmp, undefined);
 156 check_equals(bmp.height, undefined);
 157
 158 // --------------------
 159 // setPixel, setPixel32
 160 // --------------------
 161
 162 tr = new Bitmap(30, 30, true);
 163 ntr = new Bitmap(30, 30, false);
 164
 165 // Premultiplication?
 166 tr.setPixel32(2, 2, 0x44);
 167 xcheck_equals(tr.getPixel(2, 2), 0x00);
 168 xcheck_equals(tr.getPixel32(2, 2), 0);
 169
 170 // Premultiplication?
 171 tr.setPixel32(2, 2, 0x220000aa);
 172 xcheck_equals(tr.getPixel(2, 2), 0xac);
 173 xcheck_equals(tr.getPixel32(2, 2), 0x220000ac);
 174
 175 tr.setPixel32(2, 2, 0xff0000aa);
 176 check_equals(tr.getPixel(2, 2), 0xaa);
 177 check_equals(tr.getPixel32(2, 2), -16777046);
 178
 179 tr.setPixel(3, 3, 0xff);
 180 check_equals(tr.getPixel(3, 3), 0xff);
 181 check_equals(tr.getPixel32(3, 3), -16776961);
 182
 183 // Premultiplication?
 184 tr.setPixel32(4, 4, 0x44444444);
 185 xcheck_equals(tr.getPixel(4, 4), 0x434343);
 186 xcheck_equals(tr.getPixel32(4, 4), 0x44434343);
 187
 188 tr.setPixel32(4, 4, 0x10101010);
 189 check_equals(tr.getPixel(4, 4), 0x101010);
 190 check_equals(tr.getPixel32(4, 4), 0x10101010);
 191
 192 // Premultiplication?
 193 tr.setPixel32(4, 4, 0x43434343);
 194 xcheck_equals(tr.getPixel(4, 4), 0x444444);
 195 xcheck_equals(tr.getPixel32(4, 4), 0x43444444);
 196
 197 ntr.setPixel(5, 5, 0xff);
 198 check_equals(ntr.getPixel(5, 5), 0xff);
 199 check_equals(ntr.getPixel32(5, 5), -16776961);
 200
 201 ntr.setPixel32(6, 6, 0x44444444);
 202 check_equals(ntr.getPixel(6, 6), 0x444444);
 203 check_equals(ntr.getPixel32(6, 6), -12303292);
 204
 205 // ---------
 206 // floodFill
 207 // ---------
 208
 209 bmp = new Bitmap(20, 20, false);
 210 bmp.floodFill(10, 10, 0x0000ff00);
 211
 212 check_equals(bmp.getPixel(10, 10), 0x0000ff00);
 213 bmp.floodFill(5, 5, 0x000000ff);
 214 check_equals(bmp.getPixel(10, 0), 0x000000ff);
 215
 216 mc = this.createEmptyMovieClip("mc", this.getNextHighestDepth());
 217 mc.attachBitmap(bmp, this.getNextHighestDepth());
 218
 219 b = new Bitmap(200, 200, false, 0xffffff);
 220 b.fillRect(new Rectangle(10, 10, 10, 10), 0x00ff00);
 221 b.fillRect(new Rectangle(50, 20, 10, 10), 0x00ff00);
 222 b.fillRect(new Rectangle(50, 70, 20, 20), 0x00ff00);
 223 b.fillRect(new Rectangle(50, 70, 20, 20), 0x00ff00);
 224
 225 b.fillRect(new Rectangle(120, 100, 10, 10), 0x0000ff);
 226 b.fillRect(new Rectangle(130, 90, 10, 10), 0xffff00);
 227 b.fillRect(new Rectangle(140, 100, 10, 10), 0x00ffff);
 228 b.fillRect(new Rectangle(130, 110, 10, 10), 0xff00ff);
 229
 230 check_equals(b.getPixel(1, 1), 0xffffff);
 231 check_equals(b.getPixel(135, 105), 0xffffff);
 232
 233 // This is done twice deliberately to make sure Gnash doesn't hang!
 234 b.floodFill(0, 0, 0);
 235 b.floodFill(0, 0, 0);
 236 check_equals(b.getPixel(1, 1), 0x0);
 237 check_equals(b.getPixel(190, 190), 0x0);
 238 check_equals(b.getPixel(135, 105), 0xffffff);
 239
 240 b.floodFill(135, 105, 0xee1111);
 241 check_equals(b.getPixel(1, 1), 0x0);
 242 check_equals(b.getPixel(190, 190), 0x0);
 243 check_equals(b.getPixel(135, 105), 0xee1111);
 244
 245 mc2 = this.createEmptyMovieClip("mc2", this.getNextHighestDepth());
 246 mc2.attachBitmap(b, this.getNextHighestDepth());
 247 mc2._x = 300;
 248 mc2._y = 300;
 249
 250 // fillRect
 251
 252 bmp = new Bitmap(20, 20, false);
 253 r = new Rectangle(2, 2, 5, 5);
 254 bmp.fillRect(r, 0xff1100);
 255 check_equals(bmp.getPixel(1, 1), 0xffffff);
 256 check_equals(bmp.getPixel(2, 2), 0xff1100);
 257 check_equals(bmp.getPixel(2, 5), 0xff1100);
 258 check_equals(bmp.getPixel(5, 2), 0xff1100);
 259 check_equals(bmp.getPixel(2, 6), 0xff1100);
 260 check_equals(bmp.getPixel(6, 6), 0xff1100);
 261 check_equals(bmp.getPixel(6, 7), 0xffffff);
 262 check_equals(bmp.getPixel(7, 6), 0xffffff);
 263
 264 r = new Rectangle(-2, -2, 8, 8);
 265 bmp.fillRect(r, 0x00ff00);
 266 check_equals(bmp.getPixel(1, 1), 0x00ff00);
 267
 268 // Fails.
 269 r = new Rectangle(18, 18, -4, -4);
 270 bmp.fillRect(r, 0x0000ff);
 271 check_equals(bmp.getPixel(7, 6), 0xffffff);
 272
 273 r = new Rectangle(18, 18, 200, 200);
 274 bmp.fillRect(r, 0x0000ff);
 275 check_equals(bmp.getPixel(19,19), 0x0000ff);
 276
 277 // Doesn't have to be a rectangle
 278 g = {x: 15, y: 15, width: 2, height: 2};
 279 bmp.fillRect(g, 0xff00ff);
 280 check_equals(bmp.getPixel(16, 16), 0xff00ff);
 281
 282 // Transparency (this bitmap is not transparent).
 283 g = {x: 18, y: 2, width: 7, height: 7};
 284 bmp.fillRect(g, 0xddff00ff);
 285 check_equals(bmp.getPixel32(18, 2), -65281);
 286
 287 mc.attachBitmap(bmp, this.getNextHighestDepth());
 288
 289 // Transparency (transparent bitmap). Fill just obliterates
 290 // what was there, even if it's transparent.
 291 bmp = new Bitmap(20, 20, true);
 292 r = new Rectangle(1, 1, 10, 10);
 293 bmp.fillRect(r, 0xff00ff00);
 294 r = new Rectangle(2, 2, 9, 9);
 295 bmp.fillRect(r, 0x99ff1100);
 296 check_equals(bmp.getPixel32(3, 3), -1711337216);
 297
 298 mc.attachBitmap(bmp, this.getNextHighestDepth());
 299
 300 bmp.dispose();
 301 check_equals(bmp.height, -1);
 302 check_equals(bmp.width, -1);
 303 check_equals(bmp.transparent, -1);
 304 check_equals(typeof(bmp.rectangle), "number");
 305 check_equals(bmp.rectangle, -1);
 306 check_equals(bmp.rectangle.toString(), "-1");
 307
 308 check(bmp instanceOf Bitmap);
 309 bmp.height = 2;
 310 check_equals(bmp.height, -1);
 311
 312 bmp = new Bitmap(20, 10, true);
 313 backup = flash.geom.Rectangle;
 314 flash.geom.Rectangle = 2;
 315 check_equals(bmp.rectangle, -1);
 316
 317 flash.geom.Rectangle = function (x, y, w, h)
 318 {
 319     this.y = x + 5;
 320     this.x = 10.5;
 321     this.width = h;
 322     this.height = w;
 323 };
 324 check_equals(bmp.rectangle.toString(), "[object Object]");
 325
 326 flash.geom.Rectangle = function (x, y, w, h)
 327 {
 328 };
 329 check_equals(bmp.rectangle.toString(), "[object Object]");
 330
 331 flash.geom.Rectangle = function ()
 332 {
 333 };
 334 check_equals(bmp.rectangle.toString(), "[object Object]");
 335
 336 flash.geom.Rectangle = backup;
 337 check_equals(bmp.rectangle.toString(), "(x=0, y=0, w=20, h=10)");
 338
 339 ////////////////////
 340 // BitmapData.draw
 341 ////////////////////
 342
 343 // First we check that all user-defined transformations are ignored.
 344
 345 // Note: at the corners of these tests antialiasing makes a difference. The
 346 // value can vary according to the transformation of the clip. We're not
 347 // really interested in the exact values of anti-aliased pixels.
 348
 349 d = _root.createEmptyMovieClip("tar", 600);
 350 d.beginFill(0x00ff00);
 351 d.moveTo(20, 20);
 352 d.lineTo(20, 80);
 353 d.lineTo(80, 80);
 354 d.lineTo(80, 40);
 355 d.lineTo(20, 20);
 356
 357 d.moveTo(50, 50);
 358 d.beginFill(0xff0000);
 359 d.lineTo(60, 50);
 360 d.lineTo(60, 60);
 361 d.lineTo(50, 60);
 362 d.lineTo(50, 50);
 363
 364
 365 // 100x100, no transparency
 366 b = new Bitmap(100, 100, false);
 367 b.draw(d);
 368 check_equals(b.getPixel(1, 1), 0xffffff);
 369 check_equals(b.getPixel(21, 21), 0x00ff00);
 370 check_equals(b.getPixel(19, 20), 0xffffff);
 371 check_equals(b.getPixel(79, 79), 0x00ff00);
 372 check_equals(b.getPixel(50, 25), 0xffffff);
 373 check_equals(b.getPixel(55, 55), 0xff0000);
 374
 375 // Hard ref
 376 b.draw(_level0.tar);
 377 check_equals(b.getPixel(1, 1), 0xffffff);
 378 check_equals(b.getPixel(21, 21), 0x00ff00);
 379 check_equals(b.getPixel(19, 20), 0xffffff);
 380 check_equals(b.getPixel(79, 79), 0x00ff00);
 381 check_equals(b.getPixel(50, 25), 0xffffff);
 382 check_equals(b.getPixel(55, 55), 0xff0000);
 383
 384 // User-defined translation makes no difference.
 385 d._x = 500;
 386 b.draw(d);
 387 check_equals(b.getPixel(1, 1), 0xffffff);
 388 check_equals(b.getPixel(21, 21), 0x00ff00);
 389 check_equals(b.getPixel(19, 20), 0xffffff);
 390 check_equals(b.getPixel(79, 79), 0x00ff00);
 391 check_equals(b.getPixel(50, 25), 0xffffff);
 392 check_equals(b.getPixel(55, 55), 0xff0000);
 393
 394 // User defined transform makes no difference.
 395 d._height = 30;
 396 b.draw(d);
 397 check_equals(b.getPixel(1, 1), 0xffffff);
 398 check_equals(b.getPixel(21, 21), 0x00ff00);
 399 check_equals(b.getPixel(19, 20), 0xffffff);
 400 check_equals(b.getPixel(79, 79), 0x00ff00);
 401 check_equals(b.getPixel(50, 25), 0xffffff);
 402 check_equals(b.getPixel(55, 55), 0xff0000);
 403
 404 // User defined transform makes no difference.
 405 d._width = 30;
 406 b.draw(d);
 407 check_equals(b.getPixel(1, 1), 0xffffff);
 408 check_equals(b.getPixel(21, 21), 0x00ff00);
 409 check_equals(b.getPixel(19, 20), 0xffffff);
 410 check_equals(b.getPixel(79, 79), 0x00ff00);
 411 check_equals(b.getPixel(50, 25), 0xffffff);
 412 check_equals(b.getPixel(55, 55), 0xff0000);
 413
 414 // Color transform the old way (no difference).
 415 c = new Color("_level0.tar");
 416 c.setRGB(0xff5500);
 417 check_equals(b.getPixel(1, 1), 0xffffff);
 418 check_equals(b.getPixel(21, 21), 0x00ff00);
 419 check_equals(b.getPixel(19, 20), 0xffffff);
 420 check_equals(b.getPixel(79, 79), 0x00ff00);
 421 check_equals(b.getPixel(50, 25), 0xffffff);
 422 check_equals(b.getPixel(55, 55), 0xff0000);
 423
 424 // Color transform the new way.
 425 var tr = d.transform;
 426 tr.colorTransform = new flash.geom.ColorTransform(0.5, 0.5, 0.5, 0.5, 34, 34, 34, 34);
 427 d.transform = tr;
 428 check_equals(b.getPixel(1, 1), 0xffffff);
 429 check_equals(b.getPixel(21, 21), 0x00ff00);
 430 check_equals(b.getPixel(19, 20), 0xffffff);
 431 check_equals(b.getPixel(79, 79), 0x00ff00);
 432 check_equals(b.getPixel(50, 25), 0xffffff);
 433 check_equals(b.getPixel(55, 55), 0xff0000);
 434
 435 dom = new flash.geom.Matrix();
 436 dom.rotate(Math.PI / 4);
 437 tr.matrix = dom;
 438 d.transform = tr;
 439 check_equals(b.getPixel(1, 1), 0xffffff);
 440 check_equals(b.getPixel(21, 21), 0x00ff00);
 441 check_equals(b.getPixel(19, 20), 0xffffff);
 442 check_equals(b.getPixel(79, 79), 0x00ff00);
 443 check_equals(b.getPixel(50, 25), 0xffffff);
 444 check_equals(b.getPixel(55, 55), 0xff0000);
 445
 446 // Test behaviour of BitmapData.draw with masks.
 447
 448 // 1. The MovieClip is drawn with the custom transform
 449 // 2. The mask is drawn with its current transform
 450 near = function(bitmap, x, y, val) {
 451    tol = 2;
 452    col = bitmap.getPixel(x, y);
 453    col_r = (col & 0xff0000) >> 16;
 454    col_g = (col & 0xff00) >> 8;
 455    col_b = (col & 0xff);
 456    val_r = (val & 0xff0000) >> 16;
 457    val_g = (val & 0xff00) >> 8;
 458    val_b = (val & 0xff);
 459    if (Math.abs(col_r - val_r) > tol) return false;
 460    if (Math.abs(col_b - val_b) > tol) return false;
 461    if (Math.abs(col_g - val_g) > tol) return false;
 462    return true;
 463 };
 464
 465 mc = _root.createEmptyMovieClip("mc", 1009);
 466 a = mc.createEmptyMovieClip("a", 1090);
 467 b = mc.createEmptyMovieClip("b", 1091);
 468
 469 mask = _root.createEmptyMovieClip("mask", 1150);
 470
 471 with(a) {
 472     beginFill(0xff0000);
 473     moveTo(0, 0);
 474     lineTo(10, 0);
 475     lineTo(10, 40);
 476     lineTo(0, 40);
 477     lineTo(0, 0);
 478
 479     beginFill(0x00ff00);
 480     moveTo(10, 0);
 481     lineTo(20, 0);
 482     lineTo(20, 40);
 483     lineTo(10, 40);
 484     lineTo(10, 0);
 485
 486     beginFill(0x0000ff);
 487     moveTo(20, 0);
 488     lineTo(30, 0);
 489     lineTo(30, 40);
 490     lineTo(20, 40);
 491     lineTo(20, 0);
 492
 493 };
 494
 495 with(mask) {
 496     beginFill(0x000000);
 497     moveTo(10, 10);
 498     lineTo(20, 10);
 499     lineTo(20, 20);
 500     lineTo(10, 20);
 501     lineTo(10, 10);
 502 };
 503
 504 // Only for visual checking.
 505 disp = _root.createEmptyMovieClip("disp", 1300);
 506 disp._x = 200;
 507 disp._y = 200;
 508
 509 mc.setMask(mask);
 510
 511 // Mask and MovieClip with neutral transform
 512 bm = new flash.display.BitmapData(50, 50, false);
 513 bm.draw(mc);
 514
 515 // A square of the green stripe is visible.
 516 check(near(bm, 5, 5, 0xffffff));
 517 check(near(bm, 5, 15, 0xffffff));
 518 check(near(bm, 5, 25, 0xffffff));
 519 check(near(bm, 15, 5, 0xffffff));
 520 check(near(bm, 15, 15, 0x00ff00));
 521 check(near(bm, 15, 25, 0xffffff));
 522 check(near(bm, 25, 5, 0xffffff));
 523 check(near(bm, 25, 15, 0xffffff));
 524 check(near(bm, 25, 25, 0xffffff));
 525
 526 // Mask with neutral transform, MovieClip with different transform
 527 mc._width = 30;
 528 mc._height = 200;
 529 mc._x = -39;
 530 bm = new flash.display.BitmapData(50, 50, false);
 531 bm.draw(mc);
 532
 533 // A square of the green stripe is visible.
 534 check(near(bm, 5, 5, 0xffffff));
 535 check(near(bm, 5, 15, 0xffffff));
 536 check(near(bm, 5, 25, 0xffffff));
 537 check(near(bm, 15, 5, 0xffffff));
 538 xcheck(near(bm, 15, 15, 0x00ff00));
 539 check(near(bm, 15, 25, 0xffffff));
 540 check(near(bm, 25, 5, 0xffffff));
 541 check(near(bm, 25, 15, 0xffffff));
 542 check(near(bm, 25, 25, 0xffffff));
 543
 544 disp.attachBitmap(bm, 400);
 545
 546 // Mask with different transform, MovieClip with different transform
 547 mask._x = 10;
 548 bm = new flash.display.BitmapData(50, 50, false);
 549 bm.draw(mc);
 550
 551 // A square of the blue stripe is visible.
 552 check(near(bm, 5, 5, 0xffffff));
 553 check(near(bm, 5, 15, 0xffffff));
 554 check(near(bm, 5, 25, 0xffffff));
 555 check(near(bm, 15, 5, 0xffffff));
 556 check(near(bm, 15, 15, 0xffffff));
 557 check(near(bm, 15, 25, 0xffffff));
 558 check(near(bm, 25, 5, 0xffffff));
 559 xcheck(near(bm, 25, 15, 0x0000ff));
 560 check(near(bm, 25, 25, 0xffffff));
 561
 562 bm = new flash.display.BitmapData(50, 50, false);
 563 bm.draw(mc, new flash.geom.Matrix(1, 0, 0, 1, 5, 5));
 564
 565 // A bit of the blue and green blue stripe is visible.
 566 check(near(bm, 5, 5, 0xffffff));
 567 check(near(bm, 5, 15, 0xffffff));
 568 check(near(bm, 5, 25, 0xffffff));
 569 check(near(bm, 15, 5, 0xffffff));
 570 check(near(bm, 15, 15, 0xffffff));
 571 check(near(bm, 15, 25, 0xffffff));
 572 check(near(bm, 25, 5, 0xffffff));
 573 xcheck(near(bm, 23, 15, 0x00ff00));
 574 xcheck(near(bm, 25, 15, 0x0000ff));
 575 check(near(bm, 25, 25, 0xffffff));
 576
 577 bm = new flash.display.BitmapData(10, 10, true, 0x5010eeff);
 578 xcheck_equals(bm.getPixel32(5, 5), 0x5010efff);
 579
 580 bm = new flash.display.BitmapData(10, 10, true, 0xee11efff);
 581 check_equals(bm.getPixel32(5, 5), -300814337);
 582
 583 bm = new flash.display.BitmapData(10, 10, true, 0x00011010);
 584 check_equals(bm.getPixel32(5, 5), 0x00000000);
 585
 586 bm = new flash.display.BitmapData(10, 10, true, 0x0000ffff);
 587 check_equals(bm.getPixel32(5, 5), 0x00000000);
 588
 589 bm = new flash.display.BitmapData(10, 10, true, 0x000000ff);
 590 check_equals(bm.getPixel32(5, 5), 0x00000000);
 591
 592 bm = new flash.display.BitmapData(10, 10, true, 0x010000ff);
 593 check_equals(bm.getPixel32(5, 5), 0x010000ff);
 594
 595 bm = new flash.display.BitmapData(10, 10, true, 0x300000ff);
 596 check_equals(bm.getPixel32(5, 5), 0x300000ff);
 597
 598 bm = new flash.display.BitmapData(10, 10, true, 0x30ffffff);
 599 check_equals(bm.getPixel32(5, 5), 0x30ffffff);
 600
 601 // clone();
 602
 603 orig = new flash.display.BitmapData(10, 10, false, 0x00ff10);
 604 orig.a = 7;
 605 orig.setPixel(5, 5, 0x0000ff);
 606
 607 // Cloning doesn't clone non-native properties.
 608 cl = orig.clone();
 609 check_equals(cl.a, undefined);
 610 check_equals(cl.width, 10);
 611 check_equals(cl.height, 10);
 612 check_equals(cl.getPixel(2, 2), 0x00ff10);
 613 check_equals(cl.getPixel(5, 5), 0x0000ff);
 614 check_equals(typeof(cl.__proto__), "object");
 615 check_equals(cl.__proto__, orig.__proto__);
 616 check_equals(typeof(cl.constructor), "function");
 617 check_equals(cl.constructor, orig.constructor);
 618
 619 // The constructor is irrelevant.
 620 orig.constructor = 10;
 621 check_equals(orig.constructor, 10);
 622 cl = orig.clone();
 623 check_equals(typeof(cl.__proto__), "object");
 624 check_equals(typeof(cl.constructor), "function");
 625
 626 // The prototype is important.
 627 orig.__proto__ = 8;
 628 check_equals(orig.__proto__, 8);
 629 cl = orig.clone();
 630 check_equals(cl.__proto__, undefined);
 631 check_equals(cl.constructor, undefined);
 632
 633 // What kind of prototype makes this work?
 634 o = {};
 635 o.constructor = 25;
 636 o.clone = flash.display.BitmapData.prototype.clone;
 637 orig.__proto__ = o;
 638 o.width = 20;
 639 o.height = 21;
 640 o.getPixel = flash.display.BitmapData.prototype.getPixel;
 641
 642 cl = orig.clone();
 643 check_equals(cl.__proto__, o);
 644 check_equals(cl.constructor, 25);
 645 check_equals(cl.width, 20);
 646 check_equals(cl.height, 21);
 647 cl.__proto__ = flash.display.BitmapData.prototype;
 648 check_equals(cl.width, 10);
 649 check_equals(cl.height, 10);
 650
 651 e = flash.display.BitmapData.prototype;
 652 orig.__proto__ = e;
 653 flash.display.BitmapData.prototype = 8;
 654 check_equals(flash.display.BitmapData.prototype, 8);
 655 cl = orig.clone();
 656 check_equals(typeof(cl.__proto__), "object");
 657 check_equals(typeof(cl.constructor), "function");
 658
 659 // The constructor property comes from the original __proto__.
 660 cb = e.constructor;
 661 e.constructor = 98;
 662 cl = orig.clone();
 663 check_equals(typeof(cl.__proto__), "object");
 664 check_equals(cl.constructor, 98);
 665
 666 // Restore to original state!
 667 e.constructor = cb;
 668 flash.display.BitmapData.prototype = e;
 669
 670 //-------------------------------------------------------------
 671 // END OF TEST
 672 //-------------------------------------------------------------
 673
 674 totals(252);
 675
 676 #endif // OUTPUT_VERSION >= 8