← Back to branch summary

~ubuntu-branches/ubuntu/saucy/gnash/saucy-proposed

« back to all changes in this revision

Viewing changes to librender/openvg/OpenVGRenderer.cpp

  • Committer: Package Import Robot
  • Author(s): Micah Gersten
  • Date: 2012-03-04 03:19:06 UTC
  • mfrom: (1.1.18) (3.1.24 sid)
  • Revision ID: package-import@ubuntu.com-20120304031906-p6q5rnb0xhgpof7o
Tags: 0.8.10-3ubuntu1
https://launchpad.net/bugs/940876
* Merge from Debian testing (FFe: LP: #940876), remaining changes:
  - Use mozilla-flashplugin as the alternative for now
  - Change xulrunner-dev build dep to firefox-dev
* Drop the plugin API porting patch, this has been fixed upstream
  - drop debian/patches*
* Drop the following change as we want Adobe's player to take priority
  if it's installed
  - Set alternative priority to 50 so that it matches Adobe Flash's priority

Show diffs side-by-side

added added

removed removed

Lines of Context:
librender/openvg/OpenVGRenderer.cpp
1
1
// 
2
 
//   Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011
 
2
//   Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
3
3
//   Free Software Foundation, Inc.
4
4
// 
5
5
// This program is free software; you can redistribute it and/or modify
272
272
    _mask_layer = vgCreateMaskLayer(x, y);
273
273
#endif
274
274
 
275
 
    log_debug("VG Vendor is %s, VG Version is %s, VG Renderer is %s",
 
275
    log_debug(_("VG Vendor is %s, VG Version is %s, VG Renderer is %s"),
276
276
              vgGetString(VG_VENDOR), vgGetString(VG_VERSION),
277
277
              vgGetString(VG_RENDERER));
278
 
    log_debug("VG Extensions are: ", vgGetString(VG_EXTENSIONS));
 
278
    log_debug(_("VG Extensions are: "), vgGetString(VG_EXTENSIONS));
279
279
    printVGParams();
280
280
    
281
281
    // vgSeti(VG_SCISSORING, VG_FALSE);
316
316
Renderer_ovg::drawVideoFrame(image::GnashImage* /* frame */, const SWFMatrix* /* m */,
317
317
                             const SWFRect* /* bounds */, bool /*smooth*/)
318
318
{
319
 
    log_unimpl("drawVideoFrame");  
 
319
    log_unimpl(_("drawVideoFrame"));
320
320
}
321
321
 
322
322
void
375
375
    SWFMatrix mat = stage_matrix;
376
376
    mat.invert().transform(p);
377
377
    return p;
378
 
};
 
378
}
379
379
 
380
380
/// Setup the renderer to display by setting the Matrix for scaling,
381
381
/// shearing, and transformations.
566
566
void
567
567
Renderer_ovg::set_antialiased(bool /* enable */)
568
568
{
569
 
    log_unimpl("set_antialiased");
 
569
    log_unimpl(_("set_antialiased"));
570
570
}
571
571
 
572
572
void
833
833
          vgSetf (VG_STROKE_JOIN_STYLE, VG_JOIN_MITER);
834
834
          break;
835
835
      default:
836
 
          log_unimpl("join style");
 
836
          log_unimpl(_("join style"));
837
837
    }
838
838
    
839
839
    switch(style.startCapStyle()) {
847
847
          vgSetf (VG_STROKE_CAP_STYLE, VG_CAP_SQUARE);
848
848
          break;
849
849
      default:
850
 
          log_unimpl("cap style");
 
850
          log_unimpl(_("cap style"));
851
851
    }
852
852
    
853
853
    vgSetf (VG_STROKE_MITER_LIMIT, style.miterLimitFactor());
1296
1296
          break;
1297
1297
#endif
1298
1298
      default:
1299
 
          log_error("unsupported VG_MATRIX_MODE!");
 
1299
          log_error(_("unsupported VG_MATRIX_MODE!"));
1300
1300
    }
1301
 
    log_debug("VG_MATRIX_MODE is %s", str);
 
1301
    log_debug(_("VG_MATRIX_MODE is %s"), str);
1302
1302
    str.clear();
1303
1303
 
1304
1304
    switch(vgGeti(VG_FILL_RULE)) {
1309
1309
          str = "VG_NON_ZERO";
1310
1310
          break;
1311
1311
      default:
1312
 
          log_error("unsupported VG_FILL_RULE!");          
 
1312
          log_error(_("unsupported VG_FILL_RULE!")); 
1313
1313
    }
1314
 
    log_debug("VG_FILL_RULE is %s", str);
 
1314
    log_debug(_("VG_FILL_RULE is %s"), str);
1315
1315
    str.clear();
1316
1316
 
1317
1317
    switch(vgGeti(VG_IMAGE_QUALITY)) {
1330
1330
          break;
1331
1331
#endif
1332
1332
      default:
1333
 
          log_error("unsupported VG_IMAGE_QUALITY!");
 
1333
          log_error(_("unsupported VG_IMAGE_QUALITY!"));
1334
1334
    }
1335
 
    log_debug("VG_IMAGE_QUALITY is %s", str);
 
1335
    log_debug(_("VG_IMAGE_QUALITY is %s"), str);
1336
1336
    str.clear();
1337
1337
    
1338
1338
    switch(vgGeti(VG_RENDERING_QUALITY)) {
1351
1351
          break;
1352
1352
#endif
1353
1353
      default:
1354
 
          log_error("unsupported VG_RENDERING_QUALITY!");
 
1354
          log_error(_("unsupported VG_RENDERING_QUALITY!"));
1355
1355
    }
1356
 
    log_debug("VG_RENDERING_QUALITY is %s", str);
 
1356
    log_debug(_("VG_RENDERING_QUALITY is %s"), str);
1357
1357
    str.clear();
1358
1358
    
1359
1359
    switch(vgGeti(VG_BLEND_MODE)) {
1388
1388
          str = "VG_BLEND_ADDITIVE";
1389
1389
          break;
1390
1390
      default:
1391
 
          log_error("unsupported VG_BLEND_MODE!");
 
1391
          log_error(_("unsupported VG_BLEND_MODE!"));
1392
1392
    }
1393
 
    log_debug("VG_BLEND_MODE is %s", str);    
 
1393
    log_debug(_("VG_BLEND_MODE is %s"), str);    
1394
1394
    str.clear();
1395
1395
    
1396
1396
    switch(vgGeti(VG_IMAGE_MODE)) {
1409
1409
          break;
1410
1410
#endif
1411
1411
      default:
1412
 
          log_error("unsupported VG_IMAGE_MODE!");
 
1412
          log_error(_("unsupported VG_IMAGE_MODE!"));
1413
1413
    }
1414
 
    log_debug("VG_IMAGE_MODE is %s", str);
 
1414
    log_debug(_("VG_IMAGE_MODE is %s"), str);
1415
1415
    str.clear();
1416
1416
    
1417
 
    log_debug("VG_STROKE_LINE_WIDTH is %d", vgGeti(VG_STROKE_LINE_WIDTH));    
 
1417
    log_debug(_("VG_STROKE_LINE_WIDTH is %d"), vgGeti(VG_STROKE_LINE_WIDTH));
1418
1418
    str.clear();
1419
1419
    
1420
1420
    switch(vgGeti(VG_STROKE_CAP_STYLE)) {
1433
1433
          break;
1434
1434
#endif
1435
1435
      default:
1436
 
          log_error("unsupported VG_STROKE_CAP_STYLE!");
 
1436
          log_error(_("unsupported VG_STROKE_CAP_STYLE!"));
1437
1437
    }
1438
 
    log_debug("VG_STROKE_CAP_STYLE is %s", str);
 
1438
    log_debug(_("VG_STROKE_CAP_STYLE is %s"), str);
1439
1439
    str.clear();
1440
1440
    
1441
1441
    switch(vgGeti(VG_STROKE_JOIN_STYLE)) {
1454
1454
          break;
1455
1455
#endif
1456
1456
      default:
1457
 
          log_error("unsupported VG_STROKE_JOIN_STYLE!");
 
1457
          log_error(_("unsupported VG_STROKE_JOIN_STYLE!"));
1458
1458
    }
1459
 
    log_debug("VG_STROKE_JOIN_STYLE is %s", str);
 
1459
    log_debug(_("VG_STROKE_JOIN_STYLE is %s"), str);
1460
1460
    str.clear();
1461
1461
    
1462
 
    log_debug("VG_STROKE_MITER_LIMIT is %d", vgGeti(VG_STROKE_MITER_LIMIT));
1463
 
    log_debug("VG_MASKING is %d", vgGeti(VG_MASKING));
1464
 
    log_debug("VG_SCISSORING is %d", vgGeti(VG_SCISSORING));    
 
1462
    log_debug(_("VG_STROKE_MITER_LIMIT is %d"), vgGeti(VG_STROKE_MITER_LIMIT));
 
1463
    log_debug(_("VG_MASKING is %d"), vgGeti(VG_MASKING));
 
1464
    log_debug(_("VG_SCISSORING is %d"), vgGeti(VG_SCISSORING));    
1465
1465
    str.clear();
1466
1466
    
1467
1467
    switch(vgGeti(VG_PIXEL_LAYOUT)) {
1486
1486
          break;
1487
1487
#endif
1488
1488
      default:
1489
 
          log_error("unsupported VG_PIXEL_LAYOUT!");
 
1489
          log_error(_("unsupported VG_PIXEL_LAYOUT!"));
1490
1490
    }
1491
 
    log_debug("VG_PIXEL_LAYOUT is %s", str);
 
1491
    log_debug(_("VG_PIXEL_LAYOUT is %s"), str);
1492
1492
    
1493
 
    log_debug("VG_STROKE_DASH_PHASE_RESET is %s",
 
1493
    log_debug(_("VG_STROKE_DASH_PHASE_RESET is %s"),
1494
1494
              (vgGeti(VG_STROKE_DASH_PHASE_RESET) == true) ? "true" : "false");
1495
 
    log_debug("VG_FILTER_FORMAT_LINEAR is %s",
 
1495
    log_debug(_("VG_FILTER_FORMAT_LINEAR is %s"),
1496
1496
              (vgGeti(VG_FILTER_FORMAT_LINEAR) == true) ? "true" : "false");
1497
 
    log_debug("VG_FILTER_FORMAT_PREMULTIPLIED is %s",
 
1497
    log_debug(_("VG_FILTER_FORMAT_PREMULTIPLIED is %s"),
1498
1498
              (vgGeti(VG_FILTER_FORMAT_PREMULTIPLIED) == true) ? "true" : "false");
1499
1499
    str.clear();
1500
1500
    
1511
1511
    if (value & VG_ALPHA) {
1512
1512
        str += " VG_ALPHA";
1513
1513
    }
1514
 
    log_debug("VG_FILTER_CHANNEL_MASK is %s", str);
 
1514
    log_debug(_("VG_FILTER_CHANNEL_MASK is %s"), str);
1515
1515
    
1516
 
    log_debug("VG_MAX_IMAGE_WIDTH is %d", vgGeti(VG_MAX_IMAGE_WIDTH));
1517
 
    log_debug("VG_MAX_IMAGE_HEIGHT is %d", vgGeti(VG_MAX_IMAGE_HEIGHT));
1518
 
    log_debug("VG_MAX_IMAGE_PIXELS is %d", vgGeti(VG_MAX_IMAGE_PIXELS));
1519
 
    log_debug("VG_MAX_IMAGE_BYTES is %d", vgGeti(VG_MAX_IMAGE_BYTES));
 
1516
    log_debug(_("VG_MAX_IMAGE_WIDTH is %d"), vgGeti(VG_MAX_IMAGE_WIDTH));
 
1517
    log_debug(_("VG_MAX_IMAGE_HEIGHT is %d"), vgGeti(VG_MAX_IMAGE_HEIGHT));
 
1518
    log_debug(_("VG_MAX_IMAGE_PIXELS is %d"), vgGeti(VG_MAX_IMAGE_PIXELS));
 
1519
    log_debug(_("VG_MAX_IMAGE_BYTES is %d"), vgGeti(VG_MAX_IMAGE_BYTES));
1520
1520
 
1521
1521
}
1522
1522
 
1523
1523
void
1524
1524
Renderer_ovg::printVGPath(VGPath path)
1525
1525
{
1526
 
    log_debug("VG_PATH_FORMAT is %d", vgGetParameteri(path, VG_PATH_FORMAT));
1527
 
    log_debug("VG_PATH_DATATYPE is %d", vgGetParameteri(path, VG_PATH_DATATYPE));
1528
 
    log_debug("VG_PATH_CAPABILITY_APPEND_TO is %d", vgGetParameteri(path, VG_PATH_CAPABILITY_APPEND_TO));
1529
 
    log_debug("VG_PATH_SCALE is %g", vgGetParameteri(path, VG_PATH_SCALE));
1530
 
    log_debug("VG_PATH_BIA is %g", vgGetParameteri(path, VG_PATH_BIAS));
 
1526
    log_debug(_("VG_PATH_FORMAT is %d"), vgGetParameteri(path, VG_PATH_FORMAT));
 
1527
    log_debug(_("VG_PATH_DATATYPE is %d"), vgGetParameteri(path, VG_PATH_DATATYPE));
 
1528
    log_debug(_("VG_PATH_CAPABILITY_APPEND_TO is %d"), vgGetParameteri(path, VG_PATH_CAPABILITY_APPEND_TO));
 
1529
    log_debug(_("VG_PATH_SCALE is %g"), vgGetParameteri(path, VG_PATH_SCALE));
 
1530
    log_debug(_("VG_PATH_BIA is %g"), vgGetParameteri(path, VG_PATH_BIAS));
1531
1531
 
1532
 
    log_debug("VG_PATH_NUM_SEGMENTS is %d", vgGetParameteri(path, VG_PATH_NUM_SEGMENTS));
1533
 
    log_debug("VG_PATH_NUM_COORDS is %d", vgGetParameteri(path, VG_PATH_NUM_COORDS));
 
1532
    log_debug(_("VG_PATH_NUM_SEGMENTS is %d"), vgGetParameteri(path, VG_PATH_NUM_SEGMENTS));
 
1533
    log_debug(_("VG_PATH_NUM_COORDS is %d"), vgGetParameteri(path, VG_PATH_NUM_COORDS));
1534
1534
}
1535
1535
 
1536
1536
// Print an OpenVG matric, which is 3 x 3. Elements 2 and 5 are