filter/source/svg/presentation_engine.js | 992 ++++++++++++++++++++++++++++++-
readlicense_oo/license/LICENSE | 38 +
readlicense_oo/license/LICENSE.fodt | 32 +
readlicense_oo/license/LICENSE.html | 278 +++-----
4 files changed, 1156 insertions(+), 184 deletions(-)
New commits:
commit d3f5800a9655ac61a5ef8d0b1b2bc0f436b32cfe
Author: Marco Cecchetti <marco.cecche...@collabora.com>
Date: Tue Jun 28 18:17:53 2016 +0200
svg-export - Removal of the SVG 1.1 path API in Chrome
On Chrome browser most of shape effects and slide transitions did not
work anymore: that was due to the fact that several animations exploit
the DOM api for handling path segments of the svg:path element.
Starting from version 48 such an api has been removed from Chrome:
https://bugs.chromium.org/p/chromium/issues/detail?id=539385 ;
Moreover Chrome does not yet provide an implementation for the new
svgpath api introduced in SVG 2.0 draft: so there is no native support
for handling path data directly.
The present patch adapts the JavaScript implementation of the old SVG
1.1 path api proposed here: https://github.com/progers/pathseg .
Change-Id: I536202291e0b8895f91d9e499a32fa57c110b2c1
Reviewed-on: https://gerrit.libreoffice.org/26839
Tested-by: Jenkins <c...@libreoffice.org>
Reviewed-by: Andras Timar <andras.ti...@collabora.com>
diff --git a/filter/source/svg/presentation_engine.js
b/filter/source/svg/presentation_engine.js
index 7dd7d14..9de750a 100644
--- a/filter/source/svg/presentation_engine.js
+++ b/filter/source/svg/presentation_engine.js
@@ -674,6 +674,984 @@ function configureDetectionTools()
* @source http://svn.dojotoolkit.org/src/dojox/trunk/_base/sniff.js
*/
+/*****
+ * @licstart
+ *
+ * The following is the license notice for the part of JavaScript code of this
+ * file included between the '@svgpathstart' and the '@svgpathend' notes.
+ */
+
+/***** **********************************************************************
+ *
+ * Copyright 2015 The Chromium Authors. All rights reserved.
+ *
+ * The Chromium Authors can be found at
+ * http://src.chromium.org/svn/trunk/src/AUTHORS
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ * * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * 'AS IS' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ ****************************************************************************/
+
+/*****
+ * @licend
+ *
+ * The above is the license notice for the part of JavaScript code of this
+ * file included between the '@svgpathstart' and the '@svgpathend' notes.
+ */
+
+
+/*****
+ * @svgpathstart
+ *
+ * The following code is a derivative work of some part of the SVGPathSeg API.
+ *
+ * This API is a drop-in replacement for the SVGPathSeg and SVGPathSegList
APIs that were removed from
+ * SVG2 (https://lists.w3.org/Archives/Public/www-svg/2015Jun/0044.html),
including the latest spec
+ * changes which were implemented in Firefox 43 and Chrome 46.
+ *
+ * @source https://github.com/progers/pathseg
+ */
+
+(function() { 'use strict';
+ if (!('SVGPathSeg' in window)) {
+ // Spec:
http://www.w3.org/TR/SVG11/single-page.html#paths-InterfaceSVGPathSeg
+ window.SVGPathSeg = function(type, typeAsLetter, owningPathSegList) {
+ this.pathSegType = type;
+ this.pathSegTypeAsLetter = typeAsLetter;
+ this._owningPathSegList = owningPathSegList;
+ };
+
+ SVGPathSeg.prototype.classname = 'SVGPathSeg';
+
+ SVGPathSeg.PATHSEG_UNKNOWN = 0;
+ SVGPathSeg.PATHSEG_CLOSEPATH = 1;
+ SVGPathSeg.PATHSEG_MOVETO_ABS = 2;
+ SVGPathSeg.PATHSEG_MOVETO_REL = 3;
+ SVGPathSeg.PATHSEG_LINETO_ABS = 4;
+ SVGPathSeg.PATHSEG_LINETO_REL = 5;
+ SVGPathSeg.PATHSEG_CURVETO_CUBIC_ABS = 6;
+ SVGPathSeg.PATHSEG_CURVETO_CUBIC_REL = 7;
+ SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_ABS = 8;
+ SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_REL = 9;
+ SVGPathSeg.PATHSEG_ARC_ABS = 10;
+ SVGPathSeg.PATHSEG_ARC_REL = 11;
+ SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_ABS = 12;
+ SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_REL = 13;
+ SVGPathSeg.PATHSEG_LINETO_VERTICAL_ABS = 14;
+ SVGPathSeg.PATHSEG_LINETO_VERTICAL_REL = 15;
+ SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_ABS = 16;
+ SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_REL = 17;
+ SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS = 18;
+ SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL = 19;
+
+ // Notify owning PathSegList on any changes so they can be
synchronized back to the path element.
+ SVGPathSeg.prototype._segmentChanged = function() {
+ if (this._owningPathSegList)
+ this._owningPathSegList.segmentChanged(this);
+ };
+
+ window.SVGPathSegClosePath = function(owningPathSegList) {
+ SVGPathSeg.call(this, SVGPathSeg.PATHSEG_CLOSEPATH, 'z',
owningPathSegList);
+ };
+ SVGPathSegClosePath.prototype = Object.create(SVGPathSeg.prototype);
+ SVGPathSegClosePath.prototype.toString = function() { return '[object
SVGPathSegClosePath]'; };
+ SVGPathSegClosePath.prototype._asPathString = function() { return
this.pathSegTypeAsLetter; };
+ SVGPathSegClosePath.prototype.clone = function() { return new
SVGPathSegClosePath(undefined); };
+
+ window.SVGPathSegMovetoAbs = function(owningPathSegList, x, y) {
+ SVGPathSeg.call(this, SVGPathSeg.PATHSEG_MOVETO_ABS, 'M',
owningPathSegList);
+ this._x = x;
+ this._y = y;
+ };
+ SVGPathSegMovetoAbs.prototype = Object.create(SVGPathSeg.prototype);
+ SVGPathSegMovetoAbs.prototype.toString = function() { return '[object
SVGPathSegMovetoAbs]'; };
+ SVGPathSegMovetoAbs.prototype._asPathString = function() { return
this.pathSegTypeAsLetter + ' ' + this._x + ' ' + this._y; };
+ SVGPathSegMovetoAbs.prototype.clone = function() { return new
SVGPathSegMovetoAbs(undefined, this._x, this._y); };
+ Object.defineProperty(SVGPathSegMovetoAbs.prototype, 'x', { get:
function() { return this._x; }, set: function(x) { this._x = x;
this._segmentChanged(); }, enumerable: true });
+ Object.defineProperty(SVGPathSegMovetoAbs.prototype, 'y', { get:
function() { return this._y; }, set: function(y) { this._y = y;
this._segmentChanged(); }, enumerable: true });
+
+ window.SVGPathSegMovetoRel = function(owningPathSegList, x, y) {
+ SVGPathSeg.call(this, SVGPathSeg.PATHSEG_MOVETO_REL, 'm',
owningPathSegList);
+ this._x = x;
+ this._y = y;
+ };
+ SVGPathSegMovetoRel.prototype = Object.create(SVGPathSeg.prototype);
+ SVGPathSegMovetoRel.prototype.toString = function() { return '[object
SVGPathSegMovetoRel]'; };
+ SVGPathSegMovetoRel.prototype._asPathString = function() { return
this.pathSegTypeAsLetter + ' ' + this._x + ' ' + this._y; };
+ SVGPathSegMovetoRel.prototype.clone = function() { return new
SVGPathSegMovetoRel(undefined, this._x, this._y); };
+ Object.defineProperty(SVGPathSegMovetoRel.prototype, 'x', { get:
function() { return this._x; }, set: function(x) { this._x = x;
this._segmentChanged(); }, enumerable: true });
+ Object.defineProperty(SVGPathSegMovetoRel.prototype, 'y', { get:
function() { return this._y; }, set: function(y) { this._y = y;
this._segmentChanged(); }, enumerable: true });
+
+ window.SVGPathSegLinetoAbs = function(owningPathSegList, x, y) {
+ SVGPathSeg.call(this, SVGPathSeg.PATHSEG_LINETO_ABS, 'L',
owningPathSegList);
+ this._x = x;
+ this._y = y;
+ };
+ SVGPathSegLinetoAbs.prototype = Object.create(SVGPathSeg.prototype);
+ SVGPathSegLinetoAbs.prototype.toString = function() { return '[object
SVGPathSegLinetoAbs]'; };
+ SVGPathSegLinetoAbs.prototype._asPathString = function() { return
this.pathSegTypeAsLetter + ' ' + this._x + ' ' + this._y; };
+ SVGPathSegLinetoAbs.prototype.clone = function() { return new
SVGPathSegLinetoAbs(undefined, this._x, this._y); };
+ Object.defineProperty(SVGPathSegLinetoAbs.prototype, 'x', { get:
function() { return this._x; }, set: function(x) { this._x = x;
this._segmentChanged(); }, enumerable: true });
+ Object.defineProperty(SVGPathSegLinetoAbs.prototype, 'y', { get:
function() { return this._y; }, set: function(y) { this._y = y;
this._segmentChanged(); }, enumerable: true });
+
+ window.SVGPathSegLinetoRel = function(owningPathSegList, x, y) {
+ SVGPathSeg.call(this, SVGPathSeg.PATHSEG_LINETO_REL, 'l',
owningPathSegList);
+ this._x = x;
+ this._y = y;
+ };
+ SVGPathSegLinetoRel.prototype = Object.create(SVGPathSeg.prototype);
+ SVGPathSegLinetoRel.prototype.toString = function() { return '[object
SVGPathSegLinetoRel]'; };
+ SVGPathSegLinetoRel.prototype._asPathString = function() { return
this.pathSegTypeAsLetter + ' ' + this._x + ' ' + this._y; };
+ SVGPathSegLinetoRel.prototype.clone = function() { return new
SVGPathSegLinetoRel(undefined, this._x, this._y); };
+ Object.defineProperty(SVGPathSegLinetoRel.prototype, 'x', { get:
function() { return this._x; }, set: function(x) { this._x = x;
this._segmentChanged(); }, enumerable: true });
+ Object.defineProperty(SVGPathSegLinetoRel.prototype, 'y', { get:
function() { return this._y; }, set: function(y) { this._y = y;
this._segmentChanged(); }, enumerable: true });
+
+ window.SVGPathSegCurvetoCubicAbs = function(owningPathSegList, x, y,
x1, y1, x2, y2) {
+ SVGPathSeg.call(this, SVGPathSeg.PATHSEG_CURVETO_CUBIC_ABS, 'C',
owningPathSegList);
+ this._x = x;
+ this._y = y;
+ this._x1 = x1;
+ this._y1 = y1;
+ this._x2 = x2;
+ this._y2 = y2;
+ };
+ SVGPathSegCurvetoCubicAbs.prototype =
Object.create(SVGPathSeg.prototype);
+ SVGPathSegCurvetoCubicAbs.prototype.toString = function() { return
'[object SVGPathSegCurvetoCubicAbs]'; };
+ SVGPathSegCurvetoCubicAbs.prototype._asPathString = function() {
return this.pathSegTypeAsLetter + ' ' + this._x1 + ' ' + this._y1 + ' ' +
this._x2 + ' ' + this._y2 + ' ' + this._x + ' ' + this._y; };
+ SVGPathSegCurvetoCubicAbs.prototype.clone = function() { return new
SVGPathSegCurvetoCubicAbs(undefined, this._x, this._y, this._x1, this._y1,
this._x2, this._y2); };
+ Object.defineProperty(SVGPathSegCurvetoCubicAbs.prototype, 'x', { get:
function() { return this._x; }, set: function(x) { this._x = x;
this._segmentChanged(); }, enumerable: true });
+ Object.defineProperty(SVGPathSegCurvetoCubicAbs.prototype, 'y', { get:
function() { return this._y; }, set: function(y) { this._y = y;
this._segmentChanged(); }, enumerable: true });
+ Object.defineProperty(SVGPathSegCurvetoCubicAbs.prototype, 'x1', {
get: function() { return this._x1; }, set: function(x1) { this._x1 = x1;
this._segmentChanged(); }, enumerable: true });
+ Object.defineProperty(SVGPathSegCurvetoCubicAbs.prototype, 'y1', {
get: function() { return this._y1; }, set: function(y1) { this._y1 = y1;
this._segmentChanged(); }, enumerable: true });
+ Object.defineProperty(SVGPathSegCurvetoCubicAbs.prototype, 'x2', {
get: function() { return this._x2; }, set: function(x2) { this._x2 = x2;
this._segmentChanged(); }, enumerable: true });
+ Object.defineProperty(SVGPathSegCurvetoCubicAbs.prototype, 'y2', {
get: function() { return this._y2; }, set: function(y2) { this._y2 = y2;
this._segmentChanged(); }, enumerable: true });
+
+ window.SVGPathSegCurvetoCubicRel = function(owningPathSegList, x, y,
x1, y1, x2, y2) {
+ SVGPathSeg.call(this, SVGPathSeg.PATHSEG_CURVETO_CUBIC_REL, 'c',
owningPathSegList);
+ this._x = x;
+ this._y = y;
+ this._x1 = x1;
+ this._y1 = y1;
+ this._x2 = x2;
+ this._y2 = y2;
+ };
+ SVGPathSegCurvetoCubicRel.prototype =
Object.create(SVGPathSeg.prototype);
+ SVGPathSegCurvetoCubicRel.prototype.toString = function() { return
'[object SVGPathSegCurvetoCubicRel]'; };
+ SVGPathSegCurvetoCubicRel.prototype._asPathString = function() {
return this.pathSegTypeAsLetter + ' ' + this._x1 + ' ' + this._y1 + ' ' +
this._x2 + ' ' + this._y2 + ' ' + this._x + ' ' + this._y; };
+ SVGPathSegCurvetoCubicRel.prototype.clone = function() { return new
SVGPathSegCurvetoCubicRel(undefined, this._x, this._y, this._x1, this._y1,
this._x2, this._y2); };
+ Object.defineProperty(SVGPathSegCurvetoCubicRel.prototype, 'x', { get:
function() { return this._x; }, set: function(x) { this._x = x;
this._segmentChanged(); }, enumerable: true });
+ Object.defineProperty(SVGPathSegCurvetoCubicRel.prototype, 'y', { get:
function() { return this._y; }, set: function(y) { this._y = y;
this._segmentChanged(); }, enumerable: true });
+ Object.defineProperty(SVGPathSegCurvetoCubicRel.prototype, 'x1', {
get: function() { return this._x1; }, set: function(x1) { this._x1 = x1;
this._segmentChanged(); }, enumerable: true });
+ Object.defineProperty(SVGPathSegCurvetoCubicRel.prototype, 'y1', {
get: function() { return this._y1; }, set: function(y1) { this._y1 = y1;
this._segmentChanged(); }, enumerable: true });
+ Object.defineProperty(SVGPathSegCurvetoCubicRel.prototype, 'x2', {
get: function() { return this._x2; }, set: function(x2) { this._x2 = x2;
this._segmentChanged(); }, enumerable: true });
+ Object.defineProperty(SVGPathSegCurvetoCubicRel.prototype, 'y2', {
get: function() { return this._y2; }, set: function(y2) { this._y2 = y2;
this._segmentChanged(); }, enumerable: true });
+
+ window.SVGPathSegCurvetoQuadraticAbs = function(owningPathSegList, x,
y, x1, y1) {
+ SVGPathSeg.call(this, SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_ABS,
'Q', owningPathSegList);
+ this._x = x;
+ this._y = y;
+ this._x1 = x1;
+ this._y1 = y1;
+ };
+ SVGPathSegCurvetoQuadraticAbs.prototype =
Object.create(SVGPathSeg.prototype);
+ SVGPathSegCurvetoQuadraticAbs.prototype.toString = function() { return
'[object SVGPathSegCurvetoQuadraticAbs]'; };
+ SVGPathSegCurvetoQuadraticAbs.prototype._asPathString = function() {
return this.pathSegTypeAsLetter + ' ' + this._x1 + ' ' + this._y1 + ' ' +
this._x + ' ' + this._y; };
+ SVGPathSegCurvetoQuadraticAbs.prototype.clone = function() { return
new SVGPathSegCurvetoQuadraticAbs(undefined, this._x, this._y, this._x1,
this._y1); };
+ Object.defineProperty(SVGPathSegCurvetoQuadraticAbs.prototype, 'x', {
get: function() { return this._x; }, set: function(x) { this._x = x;
this._segmentChanged(); }, enumerable: true });
+ Object.defineProperty(SVGPathSegCurvetoQuadraticAbs.prototype, 'y', {
get: function() { return this._y; }, set: function(y) { this._y = y;
this._segmentChanged(); }, enumerable: true });
+ Object.defineProperty(SVGPathSegCurvetoQuadraticAbs.prototype, 'x1', {
get: function() { return this._x1; }, set: function(x1) { this._x1 = x1;
this._segmentChanged(); }, enumerable: true });
+ Object.defineProperty(SVGPathSegCurvetoQuadraticAbs.prototype, 'y1', {
get: function() { return this._y1; }, set: function(y1) { this._y1 = y1;
this._segmentChanged(); }, enumerable: true });
+
+ window.SVGPathSegCurvetoQuadraticRel = function(owningPathSegList, x,
y, x1, y1) {
+ SVGPathSeg.call(this, SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_REL,
'q', owningPathSegList);
+ this._x = x;
+ this._y = y;
+ this._x1 = x1;
+ this._y1 = y1;
+ };
+ SVGPathSegCurvetoQuadraticRel.prototype =
Object.create(SVGPathSeg.prototype);
+ SVGPathSegCurvetoQuadraticRel.prototype.toString = function() { return
'[object SVGPathSegCurvetoQuadraticRel]'; };
+ SVGPathSegCurvetoQuadraticRel.prototype._asPathString = function() {
return this.pathSegTypeAsLetter + ' ' + this._x1 + ' ' + this._y1 + ' ' +
this._x + ' ' + this._y; };
+ SVGPathSegCurvetoQuadraticRel.prototype.clone = function() { return
new SVGPathSegCurvetoQuadraticRel(undefined, this._x, this._y, this._x1,
this._y1); };
+ Object.defineProperty(SVGPathSegCurvetoQuadraticRel.prototype, 'x', {
get: function() { return this._x; }, set: function(x) { this._x = x;
this._segmentChanged(); }, enumerable: true });
+ Object.defineProperty(SVGPathSegCurvetoQuadraticRel.prototype, 'y', {
get: function() { return this._y; }, set: function(y) { this._y = y;
this._segmentChanged(); }, enumerable: true });
+ Object.defineProperty(SVGPathSegCurvetoQuadraticRel.prototype, 'x1', {
get: function() { return this._x1; }, set: function(x1) { this._x1 = x1;
this._segmentChanged(); }, enumerable: true });
+ Object.defineProperty(SVGPathSegCurvetoQuadraticRel.prototype, 'y1', {
get: function() { return this._y1; }, set: function(y1) { this._y1 = y1;
this._segmentChanged(); }, enumerable: true });
+
+ window.SVGPathSegArcAbs = function(owningPathSegList, x, y, r1, r2,
angle, largeArcFlag, sweepFlag) {
+ SVGPathSeg.call(this, SVGPathSeg.PATHSEG_ARC_ABS, 'A',
owningPathSegList);
+ this._x = x;
+ this._y = y;
+ this._r1 = r1;
+ this._r2 = r2;
+ this._angle = angle;
+ this._largeArcFlag = largeArcFlag;
+ this._sweepFlag = sweepFlag;
+ };
+ SVGPathSegArcAbs.prototype = Object.create(SVGPathSeg.prototype);
+ SVGPathSegArcAbs.prototype.toString = function() { return '[object
SVGPathSegArcAbs]'; };
+ SVGPathSegArcAbs.prototype._asPathString = function() { return
this.pathSegTypeAsLetter + ' ' + this._r1 + ' ' + this._r2 + ' ' + this._angle
+ ' ' + (this._largeArcFlag ? '1' : '0') + ' ' + (this._sweepFlag ? '1' : '0')
+ ' ' + this._x + ' ' + this._y; };
+ SVGPathSegArcAbs.prototype.clone = function() { return new
SVGPathSegArcAbs(undefined, this._x, this._y, this._r1, this._r2, this._angle,
this._largeArcFlag, this._sweepFlag); };
+ Object.defineProperty(SVGPathSegArcAbs.prototype, 'x', { get:
function() { return this._x; }, set: function(x) { this._x = x;
this._segmentChanged(); }, enumerable: true });
+ Object.defineProperty(SVGPathSegArcAbs.prototype, 'y', { get:
function() { return this._y; }, set: function(y) { this._y = y;
this._segmentChanged(); }, enumerable: true });
+ Object.defineProperty(SVGPathSegArcAbs.prototype, 'r1', { get:
function() { return this._r1; }, set: function(r1) { this._r1 = r1;
this._segmentChanged(); }, enumerable: true });
+ Object.defineProperty(SVGPathSegArcAbs.prototype, 'r2', { get:
function() { return this._r2; }, set: function(r2) { this._r2 = r2;
this._segmentChanged(); }, enumerable: true });
+ Object.defineProperty(SVGPathSegArcAbs.prototype, 'angle', { get:
function() { return this._angle; }, set: function(angle) { this._angle = angle;
this._segmentChanged(); }, enumerable: true });
+ Object.defineProperty(SVGPathSegArcAbs.prototype, 'largeArcFlag', {
get: function() { return this._largeArcFlag; }, set: function(largeArcFlag) {
this._largeArcFlag = largeArcFlag; this._segmentChanged(); }, enumerable: true
});
+ Object.defineProperty(SVGPathSegArcAbs.prototype, 'sweepFlag', { get:
function() { return this._sweepFlag; }, set: function(sweepFlag) {
this._sweepFlag = sweepFlag; this._segmentChanged(); }, enumerable: true });
+
+ window.SVGPathSegArcRel = function(owningPathSegList, x, y, r1, r2,
angle, largeArcFlag, sweepFlag) {
+ SVGPathSeg.call(this, SVGPathSeg.PATHSEG_ARC_REL, 'a',
owningPathSegList);
+ this._x = x;
+ this._y = y;
+ this._r1 = r1;
+ this._r2 = r2;
+ this._angle = angle;
+ this._largeArcFlag = largeArcFlag;
+ this._sweepFlag = sweepFlag;
+ };
+ SVGPathSegArcRel.prototype = Object.create(SVGPathSeg.prototype);
+ SVGPathSegArcRel.prototype.toString = function() { return '[object
SVGPathSegArcRel]'; };
+ SVGPathSegArcRel.prototype._asPathString = function() { return
this.pathSegTypeAsLetter + ' ' + this._r1 + ' ' + this._r2 + ' ' + this._angle
+ ' ' + (this._largeArcFlag ? '1' : '0') + ' ' + (this._sweepFlag ? '1' : '0')
+ ' ' + this._x + ' ' + this._y; };
+ SVGPathSegArcRel.prototype.clone = function() { return new
SVGPathSegArcRel(undefined, this._x, this._y, this._r1, this._r2, this._angle,
this._largeArcFlag, this._sweepFlag); };
+ Object.defineProperty(SVGPathSegArcRel.prototype, 'x', { get:
function() { return this._x; }, set: function(x) { this._x = x;
this._segmentChanged(); }, enumerable: true });
+ Object.defineProperty(SVGPathSegArcRel.prototype, 'y', { get:
function() { return this._y; }, set: function(y) { this._y = y;
this._segmentChanged(); }, enumerable: true });
+ Object.defineProperty(SVGPathSegArcRel.prototype, 'r1', { get:
function() { return this._r1; }, set: function(r1) { this._r1 = r1;
this._segmentChanged(); }, enumerable: true });
+ Object.defineProperty(SVGPathSegArcRel.prototype, 'r2', { get:
function() { return this._r2; }, set: function(r2) { this._r2 = r2;
this._segmentChanged(); }, enumerable: true });
+ Object.defineProperty(SVGPathSegArcRel.prototype, 'angle', { get:
function() { return this._angle; }, set: function(angle) { this._angle = angle;
this._segmentChanged(); }, enumerable: true });
+ Object.defineProperty(SVGPathSegArcRel.prototype, 'largeArcFlag', {
get: function() { return this._largeArcFlag; }, set: function(largeArcFlag) {
this._largeArcFlag = largeArcFlag; this._segmentChanged(); }, enumerable: true
});
+ Object.defineProperty(SVGPathSegArcRel.prototype, 'sweepFlag', { get:
function() { return this._sweepFlag; }, set: function(sweepFlag) {
this._sweepFlag = sweepFlag; this._segmentChanged(); }, enumerable: true });
+
+ window.SVGPathSegLinetoHorizontalAbs = function(owningPathSegList, x) {
+ SVGPathSeg.call(this, SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_ABS,
'H', owningPathSegList);
+ this._x = x;
+ };
+ SVGPathSegLinetoHorizontalAbs.prototype =
Object.create(SVGPathSeg.prototype);
+ SVGPathSegLinetoHorizontalAbs.prototype.toString = function() { return
'[object SVGPathSegLinetoHorizontalAbs]'; };
+ SVGPathSegLinetoHorizontalAbs.prototype._asPathString = function() {
return this.pathSegTypeAsLetter + ' ' + this._x; };
+ SVGPathSegLinetoHorizontalAbs.prototype.clone = function() { return
new SVGPathSegLinetoHorizontalAbs(undefined, this._x); };
+ Object.defineProperty(SVGPathSegLinetoHorizontalAbs.prototype, 'x', {
get: function() { return this._x; }, set: function(x) { this._x = x;
this._segmentChanged(); }, enumerable: true });
+
+ window.SVGPathSegLinetoHorizontalRel = function(owningPathSegList, x) {
+ SVGPathSeg.call(this, SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_REL,
'h', owningPathSegList);
+ this._x = x;
+ };
+ SVGPathSegLinetoHorizontalRel.prototype =
Object.create(SVGPathSeg.prototype);
+ SVGPathSegLinetoHorizontalRel.prototype.toString = function() { return
'[object SVGPathSegLinetoHorizontalRel]'; };
+ SVGPathSegLinetoHorizontalRel.prototype._asPathString = function() {
return this.pathSegTypeAsLetter + ' ' + this._x; };
+ SVGPathSegLinetoHorizontalRel.prototype.clone = function() { return
new SVGPathSegLinetoHorizontalRel(undefined, this._x); };
+ Object.defineProperty(SVGPathSegLinetoHorizontalRel.prototype, 'x', {
get: function() { return this._x; }, set: function(x) { this._x = x;
this._segmentChanged(); }, enumerable: true });
+
+ window.SVGPathSegLinetoVerticalAbs = function(owningPathSegList, y) {
+ SVGPathSeg.call(this, SVGPathSeg.PATHSEG_LINETO_VERTICAL_ABS, 'V',
owningPathSegList);
+ this._y = y;
+ };
+ SVGPathSegLinetoVerticalAbs.prototype =
Object.create(SVGPathSeg.prototype);
+ SVGPathSegLinetoVerticalAbs.prototype.toString = function() { return
'[object SVGPathSegLinetoVerticalAbs]'; };
+ SVGPathSegLinetoVerticalAbs.prototype._asPathString = function() {
return this.pathSegTypeAsLetter + ' ' + this._y; };
+ SVGPathSegLinetoVerticalAbs.prototype.clone = function() { return new
SVGPathSegLinetoVerticalAbs(undefined, this._y); };
+ Object.defineProperty(SVGPathSegLinetoVerticalAbs.prototype, 'y', {
get: function() { return this._y; }, set: function(y) { this._y = y;
this._segmentChanged(); }, enumerable: true });
+
+ window.SVGPathSegLinetoVerticalRel = function(owningPathSegList, y) {
+ SVGPathSeg.call(this, SVGPathSeg.PATHSEG_LINETO_VERTICAL_REL, 'v',
owningPathSegList);
+ this._y = y;
+ };
+ SVGPathSegLinetoVerticalRel.prototype =
Object.create(SVGPathSeg.prototype);
+ SVGPathSegLinetoVerticalRel.prototype.toString = function() { return
'[object SVGPathSegLinetoVerticalRel]'; };
+ SVGPathSegLinetoVerticalRel.prototype._asPathString = function() {
return this.pathSegTypeAsLetter + ' ' + this._y; };
+ SVGPathSegLinetoVerticalRel.prototype.clone = function() { return new
SVGPathSegLinetoVerticalRel(undefined, this._y); };
+ Object.defineProperty(SVGPathSegLinetoVerticalRel.prototype, 'y', {
get: function() { return this._y; }, set: function(y) { this._y = y;
this._segmentChanged(); }, enumerable: true });
+
+ window.SVGPathSegCurvetoCubicSmoothAbs = function(owningPathSegList,
x, y, x2, y2) {
+ SVGPathSeg.call(this, SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_ABS,
'S', owningPathSegList);
+ this._x = x;
+ this._y = y;
+ this._x2 = x2;
+ this._y2 = y2;
+ };
+ SVGPathSegCurvetoCubicSmoothAbs.prototype =
Object.create(SVGPathSeg.prototype);
+ SVGPathSegCurvetoCubicSmoothAbs.prototype.toString = function() {
return '[object SVGPathSegCurvetoCubicSmoothAbs]'; };
+ SVGPathSegCurvetoCubicSmoothAbs.prototype._asPathString = function() {
return this.pathSegTypeAsLetter + ' ' + this._x2 + ' ' + this._y2 + ' ' +
this._x + ' ' + this._y; };
+ SVGPathSegCurvetoCubicSmoothAbs.prototype.clone = function() { return
new SVGPathSegCurvetoCubicSmoothAbs(undefined, this._x, this._y, this._x2,
this._y2); };
+ Object.defineProperty(SVGPathSegCurvetoCubicSmoothAbs.prototype, 'x',
{ get: function() { return this._x; }, set: function(x) { this._x = x;
this._segmentChanged(); }, enumerable: true });
+ Object.defineProperty(SVGPathSegCurvetoCubicSmoothAbs.prototype, 'y',
{ get: function() { return this._y; }, set: function(y) { this._y = y;
this._segmentChanged(); }, enumerable: true });
+ Object.defineProperty(SVGPathSegCurvetoCubicSmoothAbs.prototype, 'x2',
{ get: function() { return this._x2; }, set: function(x2) { this._x2 = x2;
this._segmentChanged(); }, enumerable: true });
+ Object.defineProperty(SVGPathSegCurvetoCubicSmoothAbs.prototype, 'y2',
{ get: function() { return this._y2; }, set: function(y2) { this._y2 = y2;
this._segmentChanged(); }, enumerable: true });
+
+ window.SVGPathSegCurvetoCubicSmoothRel = function(owningPathSegList,
x, y, x2, y2) {
+ SVGPathSeg.call(this, SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_REL,
's', owningPathSegList);
+ this._x = x;
+ this._y = y;
+ this._x2 = x2;
+ this._y2 = y2;
+ };
+ SVGPathSegCurvetoCubicSmoothRel.prototype =
Object.create(SVGPathSeg.prototype);
+ SVGPathSegCurvetoCubicSmoothRel.prototype.toString = function() {
return '[object SVGPathSegCurvetoCubicSmoothRel]'; };
+ SVGPathSegCurvetoCubicSmoothRel.prototype._asPathString = function() {
return this.pathSegTypeAsLetter + ' ' + this._x2 + ' ' + this._y2 + ' ' +
this._x + ' ' + this._y; };
+ SVGPathSegCurvetoCubicSmoothRel.prototype.clone = function() { return
new SVGPathSegCurvetoCubicSmoothRel(undefined, this._x, this._y, this._x2,
this._y2); };
+ Object.defineProperty(SVGPathSegCurvetoCubicSmoothRel.prototype, 'x',
{ get: function() { return this._x; }, set: function(x) { this._x = x;
this._segmentChanged(); }, enumerable: true });
+ Object.defineProperty(SVGPathSegCurvetoCubicSmoothRel.prototype, 'y',
{ get: function() { return this._y; }, set: function(y) { this._y = y;
this._segmentChanged(); }, enumerable: true });
+ Object.defineProperty(SVGPathSegCurvetoCubicSmoothRel.prototype, 'x2',
{ get: function() { return this._x2; }, set: function(x2) { this._x2 = x2;
this._segmentChanged(); }, enumerable: true });
+ Object.defineProperty(SVGPathSegCurvetoCubicSmoothRel.prototype, 'y2',
{ get: function() { return this._y2; }, set: function(y2) { this._y2 = y2;
this._segmentChanged(); }, enumerable: true });
+
+ window.SVGPathSegCurvetoQuadraticSmoothAbs =
function(owningPathSegList, x, y) {
+ SVGPathSeg.call(this,
SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS, 'T', owningPathSegList);
+ this._x = x;
+ this._y = y;
+ };
+ SVGPathSegCurvetoQuadraticSmoothAbs.prototype =
Object.create(SVGPathSeg.prototype);
+ SVGPathSegCurvetoQuadraticSmoothAbs.prototype.toString = function() {
return '[object SVGPathSegCurvetoQuadraticSmoothAbs]'; };
+ SVGPathSegCurvetoQuadraticSmoothAbs.prototype._asPathString =
function() { return this.pathSegTypeAsLetter + ' ' + this._x + ' ' + this._y; };
+ SVGPathSegCurvetoQuadraticSmoothAbs.prototype.clone = function() {
return new SVGPathSegCurvetoQuadraticSmoothAbs(undefined, this._x, this._y); };
+ Object.defineProperty(SVGPathSegCurvetoQuadraticSmoothAbs.prototype,
'x', { get: function() { return this._x; }, set: function(x) { this._x = x;
this._segmentChanged(); }, enumerable: true });
+ Object.defineProperty(SVGPathSegCurvetoQuadraticSmoothAbs.prototype,
'y', { get: function() { return this._y; }, set: function(y) { this._y = y;
this._segmentChanged(); }, enumerable: true });
+
+ window.SVGPathSegCurvetoQuadraticSmoothRel =
function(owningPathSegList, x, y) {
+ SVGPathSeg.call(this,
SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL, 't', owningPathSegList);
+ this._x = x;
+ this._y = y;
+ };
+ SVGPathSegCurvetoQuadraticSmoothRel.prototype =
Object.create(SVGPathSeg.prototype);
+ SVGPathSegCurvetoQuadraticSmoothRel.prototype.toString = function() {
return '[object SVGPathSegCurvetoQuadraticSmoothRel]'; };
+ SVGPathSegCurvetoQuadraticSmoothRel.prototype._asPathString =
function() { return this.pathSegTypeAsLetter + ' ' + this._x + ' ' + this._y; };
+ SVGPathSegCurvetoQuadraticSmoothRel.prototype.clone = function() {
return new SVGPathSegCurvetoQuadraticSmoothRel(undefined, this._x, this._y); };
+ Object.defineProperty(SVGPathSegCurvetoQuadraticSmoothRel.prototype,
'x', { get: function() { return this._x; }, set: function(x) { this._x = x;
this._segmentChanged(); }, enumerable: true });
+ Object.defineProperty(SVGPathSegCurvetoQuadraticSmoothRel.prototype,
'y', { get: function() { return this._y; }, set: function(y) { this._y = y;
this._segmentChanged(); }, enumerable: true });
+
+ // Add createSVGPathSeg* functions to SVGPathElement.
+ // Spec:
http://www.w3.org/TR/SVG11/single-page.html#paths-InterfaceSVGPathElement.
+ SVGPathElement.prototype.createSVGPathSegClosePath = function() {
return new SVGPathSegClosePath(undefined); };
+ SVGPathElement.prototype.createSVGPathSegMovetoAbs = function(x, y) {
return new SVGPathSegMovetoAbs(undefined, x, y); };
+ SVGPathElement.prototype.createSVGPathSegMovetoRel = function(x, y) {
return new SVGPathSegMovetoRel(undefined, x, y); };
+ SVGPathElement.prototype.createSVGPathSegLinetoAbs = function(x, y) {
return new SVGPathSegLinetoAbs(undefined, x, y); };
+ SVGPathElement.prototype.createSVGPathSegLinetoRel = function(x, y) {
return new SVGPathSegLinetoRel(undefined, x, y); };
+ SVGPathElement.prototype.createSVGPathSegCurvetoCubicAbs = function(x,
y, x1, y1, x2, y2) { return new SVGPathSegCurvetoCubicAbs(undefined, x, y, x1,
y1, x2, y2); };
+ SVGPathElement.prototype.createSVGPathSegCurvetoCubicRel = function(x,
y, x1, y1, x2, y2) { return new SVGPathSegCurvetoCubicRel(undefined, x, y, x1,
y1, x2, y2); };
+ SVGPathElement.prototype.createSVGPathSegCurvetoQuadraticAbs =
function(x, y, x1, y1) { return new SVGPathSegCurvetoQuadraticAbs(undefined, x,
y, x1, y1); };
+ SVGPathElement.prototype.createSVGPathSegCurvetoQuadraticRel =
function(x, y, x1, y1) { return new SVGPathSegCurvetoQuadraticRel(undefined, x,
y, x1, y1); };
+ SVGPathElement.prototype.createSVGPathSegArcAbs = function(x, y, r1,
r2, angle, largeArcFlag, sweepFlag) { return new SVGPathSegArcAbs(undefined, x,
y, r1, r2, angle, largeArcFlag, sweepFlag); }
+ SVGPathElement.prototype.createSVGPathSegArcRel = function(x, y, r1,
r2, angle, largeArcFlag, sweepFlag) { return new SVGPathSegArcRel(undefined, x,
y, r1, r2, angle, largeArcFlag, sweepFlag); }
+ SVGPathElement.prototype.createSVGPathSegLinetoHorizontalAbs =
function(x) { return new SVGPathSegLinetoHorizontalAbs(undefined, x); };
+ SVGPathElement.prototype.createSVGPathSegLinetoHorizontalRel =
function(x) { return new SVGPathSegLinetoHorizontalRel(undefined, x); };
+ SVGPathElement.prototype.createSVGPathSegLinetoVerticalAbs =
function(y) { return new SVGPathSegLinetoVerticalAbs(undefined, y); };
+ SVGPathElement.prototype.createSVGPathSegLinetoVerticalRel =
function(y) { return new SVGPathSegLinetoVerticalRel(undefined, y); };
+ SVGPathElement.prototype.createSVGPathSegCurvetoCubicSmoothAbs =
function(x, y, x2, y2) { return new SVGPathSegCurvetoCubicSmoothAbs(undefined,
x, y, x2, y2); };
+ SVGPathElement.prototype.createSVGPathSegCurvetoCubicSmoothRel =
function(x, y, x2, y2) { return new SVGPathSegCurvetoCubicSmoothRel(undefined,
x, y, x2, y2); };
+ SVGPathElement.prototype.createSVGPathSegCurvetoQuadraticSmoothAbs =
function(x, y) { return new SVGPathSegCurvetoQuadraticSmoothAbs(undefined, x,
y); };
+ SVGPathElement.prototype.createSVGPathSegCurvetoQuadraticSmoothRel =
function(x, y) { return new SVGPathSegCurvetoQuadraticSmoothRel(undefined, x,
y); };
+ }
+
+ if (!('SVGPathSegList' in window)) {
+ // Spec:
http://www.w3.org/TR/SVG11/single-page.html#paths-InterfaceSVGPathSegList
+ window.SVGPathSegList = function(pathElement) {
+ this._pathElement = pathElement;
+ this._list = this._parsePath(this._pathElement.getAttribute('d'));
+
+ // Use a MutationObserver to catch changes to the path's 'd'
attribute.
+ this._mutationObserverConfig = { 'attributes': true,
'attributeFilter': ['d'] };
+ this._pathElementMutationObserver = new
MutationObserver(this._updateListFromPathMutations.bind(this));
+ this._pathElementMutationObserver.observe(this._pathElement,
this._mutationObserverConfig);
+ };
+
+ SVGPathSegList.prototype.classname = 'SVGPathSegList';
+
+ Object.defineProperty(SVGPathSegList.prototype, 'numberOfItems', {
+ get: function() {
+ this._checkPathSynchronizedToList();
+ return this._list.length;
+ },
+ enumerable: true
+ });
+
+ // Add the pathSegList accessors to SVGPathElement.
+ // Spec:
http://www.w3.org/TR/SVG11/single-page.html#paths-InterfaceSVGAnimatedPathData
+ Object.defineProperty(SVGPathElement.prototype, 'pathSegList', {
+ get: function() {
+ if (!this._pathSegList)
+ this._pathSegList = new SVGPathSegList(this);
+ return this._pathSegList;
+ },
+ enumerable: true
+ });
+ // FIXME: The following are not implemented and simply return
SVGPathElement.pathSegList.
+ Object.defineProperty(SVGPathElement.prototype,
'normalizedPathSegList', { get: function() { return this.pathSegList; },
enumerable: true });
+ Object.defineProperty(SVGPathElement.prototype, 'animatedPathSegList',
{ get: function() { return this.pathSegList; }, enumerable: true });
+ Object.defineProperty(SVGPathElement.prototype,
'animatedNormalizedPathSegList', { get: function() { return this.pathSegList;
}, enumerable: true });
+
+ // Process any pending mutations to the path element and update the
list as needed.
+ // This should be the first call of all public functions and is needed
because
+ // MutationObservers are not synchronous so we can have pending
asynchronous mutations.
+ SVGPathSegList.prototype._checkPathSynchronizedToList = function() {
+
this._updateListFromPathMutations(this._pathElementMutationObserver.takeRecords());
+ };
+
+ SVGPathSegList.prototype._updateListFromPathMutations =
function(mutationRecords) {
+ if (!this._pathElement)
+ return;
+ var hasPathMutations = false;
+ mutationRecords.forEach(function(record) {
+ if (record.attributeName == 'd')
+ hasPathMutations = true;
+ });
+ if (hasPathMutations)
+ this._list =
this._parsePath(this._pathElement.getAttribute('d'));
+ };
+
+ // Serialize the list and update the path's 'd' attribute.
+ SVGPathSegList.prototype._writeListToPath = function() {
+ this._pathElementMutationObserver.disconnect();
+ this._pathElement.setAttribute('d',
SVGPathSegList._pathSegArrayAsString(this._list));
+ this._pathElementMutationObserver.observe(this._pathElement,
this._mutationObserverConfig);
+ };
+
+ // When a path segment changes the list needs to be synchronized back
to the path element.
+ SVGPathSegList.prototype.segmentChanged = function(pathSeg) {
+ this._writeListToPath();
+ };
+
+ SVGPathSegList.prototype.clear = function() {
+ this._checkPathSynchronizedToList();
+
+ this._list.forEach(function(pathSeg) {
+ pathSeg._owningPathSegList = null;
+ });
+ this._list = [];
+ this._writeListToPath();
+ };
+
+ SVGPathSegList.prototype.initialize = function(newItem) {
+ this._checkPathSynchronizedToList();
+
+ this._list = [newItem];
+ newItem._owningPathSegList = this;
+ this._writeListToPath();
+ return newItem;
+ };
+
+ SVGPathSegList.prototype._checkValidIndex = function(index) {
+ if (isNaN(index) || index < 0 || index >= this.numberOfItems)
+ throw 'INDEX_SIZE_ERR';
+ };
+
+ SVGPathSegList.prototype.getItem = function(index) {
+ this._checkPathSynchronizedToList();
+
+ this._checkValidIndex(index);
+ return this._list[index];
+ };
+
+ SVGPathSegList.prototype.insertItemBefore = function(newItem, index) {
+ this._checkPathSynchronizedToList();
+
+ // Spec: If the index is greater than or equal to numberOfItems,
then the new item is appended to the end of the list.
+ if (index > this.numberOfItems)
+ index = this.numberOfItems;
+ if (newItem._owningPathSegList) {
+ // SVG2 spec says to make a copy.
+ newItem = newItem.clone();
+ }
+ this._list.splice(index, 0, newItem);
+ newItem._owningPathSegList = this;
+ this._writeListToPath();
+ return newItem;
+ };
+
+ SVGPathSegList.prototype.replaceItem = function(newItem, index) {
+ this._checkPathSynchronizedToList();
+
+ if (newItem._owningPathSegList) {
+ // SVG2 spec says to make a copy.
+ newItem = newItem.clone();
+ }
+ this._checkValidIndex(index);
+ this._list[index] = newItem;
+ newItem._owningPathSegList = this;
+ this._writeListToPath();
+ return newItem;
+ };
+
+ SVGPathSegList.prototype.removeItem = function(index) {
+ this._checkPathSynchronizedToList();
+
+ this._checkValidIndex(index);
+ var item = this._list[index];
+ this._list.splice(index, 1);
+ this._writeListToPath();
+ return item;
+ };
+
+ SVGPathSegList.prototype.appendItem = function(newItem) {
+ this._checkPathSynchronizedToList();
+
+ if (newItem._owningPathSegList) {
+ // SVG2 spec says to make a copy.
+ newItem = newItem.clone();
+ }
+ this._list.push(newItem);
+ newItem._owningPathSegList = this;
+ // TODO: Optimize this to just append to the existing attribute.
+ this._writeListToPath();
+ return newItem;
+ };
+
+ SVGPathSegList.prototype.matrixTransform = function(aSVGMatrix) {
+ this._checkPathSynchronizedToList();
+
+ var nLength = this._list.length;
+ for( var i = 0; i < nLength; ++i )
+ {
+ var nX;
+ var aPathSeg = this._list[i];
+ switch( aPathSeg.pathSegTypeAsLetter )
+ {
+ case 'C':
+ nX = aPathSeg._x2;
+ aPathSeg._x2 = aSVGMatrix.a * nX + aSVGMatrix.c *
aPathSeg._y2 + aSVGMatrix.e;
+ aPathSeg._y2 = aSVGMatrix.b * nX + aSVGMatrix.d *
aPathSeg._y2 + aSVGMatrix.f;
+ // fall through intended
+ case 'Q':
+ nX = aPathSeg._x1;
+ aPathSeg._x1 = aSVGMatrix.a * nX + aSVGMatrix.c *
aPathSeg._y1 + aSVGMatrix.e;
+ aPathSeg._y1 = aSVGMatrix.b * nX + aSVGMatrix.d *
aPathSeg._y1 + aSVGMatrix.f;
+ // fall through intended
+ case 'M':
+ case 'L':
+ nX = aPathSeg._x;
+ aPathSeg._x = aSVGMatrix.a * nX + aSVGMatrix.c *
aPathSeg._y + aSVGMatrix.e;
+ aPathSeg._y = aSVGMatrix.b * nX + aSVGMatrix.d *
aPathSeg._y + aSVGMatrix.f;
+ break;
+ default:
+ log( 'SVGPathSeg.matrixTransform: unexpected path
segment type: '
+ + aPathSeg.pathSegTypeAsLetter );
+ }
+ }
+
+ this._writeListToPath();
+ };
+
+ SVGPathSegList.prototype.changeOrientation = function() {
+ this._checkPathSynchronizedToList();
+
+ var aPathSegList = this._list;
+ var nLength = aPathSegList.length;
+ if( nLength == 0 ) return;
+
+ var nCurrentX = 0;
+ var nCurrentY = 0;
+
+ var aPathSeg = aPathSegList[0];
+ if( aPathSeg.pathSegTypeAsLetter == 'M' )
+ {
+ nCurrentX = aPathSeg.x;
+ nCurrentY = aPathSeg.y;
+ aPathSegList.shift();
+ --nLength;
+ }
+
+ var i;
+ for( i = 0; i < nLength; ++i )
+ {
+ aPathSeg = aPathSegList[i];
+ switch( aPathSeg.pathSegTypeAsLetter )
+ {
+ case 'C':
+ var nX = aPathSeg._x1;
+ aPathSeg._x1 = aPathSeg._x2;
+ aPathSeg._x2 = nX;
+ var nY = aPathSeg._y1;
+ aPathSeg._y1 = aPathSeg._y2;
+ aPathSeg._y2 = nY;
+ // fall through intended
+ case 'M':
+ case 'L':
+ case 'Q':
+ var aPoint = { x: aPathSeg._x, y: aPathSeg._y };
+ aPathSeg._x = nCurrentX;
+ aPathSeg._y = nCurrentY;
+ nCurrentX = aPoint.x;
+ nCurrentY = aPoint.y;
+ break;
+ default:
+ log( 'SVGPathSegList.changeOrientation: unexpected
path segment type: '
+ + aPathSeg.pathSegTypeAsLetter );
+ }
+
+ }
+
+ aPathSegList.reverse();
+
+ var aMovePathSeg = new SVGPathSegMovetoAbs( this, nCurrentX,
nCurrentY );
+ aPathSegList.unshift( aMovePathSeg );
+
+ this._writeListToPath();
+ };
+
+ SVGPathSegList._pathSegArrayAsString = function(pathSegArray) {
+ var string = '';
+ var first = true;
+ pathSegArray.forEach(function(pathSeg) {
+ if (first) {
+ first = false;
+ string += pathSeg._asPathString();
+ } else {
+ string += ' ' + pathSeg._asPathString();
+ }
+ });
+ return string;
+ };
+
+ // This closely follows SVGPathParser::parsePath from
Source/core/svg/SVGPathParser.cpp.
+ SVGPathSegList.prototype._parsePath = function(string) {
+ if (!string || string.length == 0)
+ return [];
+
+ var owningPathSegList = this;
+
+ var Builder = function() {
+ this.pathSegList = [];
+ };
+
+ Builder.prototype.appendSegment = function(pathSeg) {
+ this.pathSegList.push(pathSeg);
+ };
+
+ var Source = function(string) {
+ this._string = string;
+ this._currentIndex = 0;
+ this._endIndex = this._string.length;
+ this._previousCommand = SVGPathSeg.PATHSEG_UNKNOWN;
+
+ this._skipOptionalSpaces();
+ };
+
+ Source.prototype._isCurrentSpace = function() {
+ var character = this._string[this._currentIndex];
+ return character <= ' ' && (character == ' ' || character ==
'\n' || character == '\t' || character == '\r' || character == '\f');
+ };
+
+ Source.prototype._skipOptionalSpaces = function() {
+ while (this._currentIndex < this._endIndex &&
this._isCurrentSpace())
+ this._currentIndex++;
+ return this._currentIndex < this._endIndex;
+ };
+
+ Source.prototype._skipOptionalSpacesOrDelimiter = function() {
+ if (this._currentIndex < this._endIndex &&
!this._isCurrentSpace() && this._string.charAt(this._currentIndex) != ',')
+ return false;
+ if (this._skipOptionalSpaces()) {
+ if (this._currentIndex < this._endIndex &&
this._string.charAt(this._currentIndex) == ',') {
+ this._currentIndex++;
+ this._skipOptionalSpaces();
+ }
+ }
+ return this._currentIndex < this._endIndex;
+ };
+
+ Source.prototype.hasMoreData = function() {
+ return this._currentIndex < this._endIndex;
+ };
+
+ Source.prototype.peekSegmentType = function() {
+ var lookahead = this._string[this._currentIndex];
+ return this._pathSegTypeFromChar(lookahead);
+ };
+
+ Source.prototype._pathSegTypeFromChar = function(lookahead) {
+ switch (lookahead) {
+ case 'Z':
+ case 'z':
+ return SVGPathSeg.PATHSEG_CLOSEPATH;
+ case 'M':
+ return SVGPathSeg.PATHSEG_MOVETO_ABS;
+ case 'm':
+ return SVGPathSeg.PATHSEG_MOVETO_REL;
+ case 'L':
+ return SVGPathSeg.PATHSEG_LINETO_ABS;
+ case 'l':
+ return SVGPathSeg.PATHSEG_LINETO_REL;
+ case 'C':
+ return SVGPathSeg.PATHSEG_CURVETO_CUBIC_ABS;
+ case 'c':
+ return SVGPathSeg.PATHSEG_CURVETO_CUBIC_REL;
+ case 'Q':
+ return SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_ABS;
+ case 'q':
+ return SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_REL;
+ case 'A':
+ return SVGPathSeg.PATHSEG_ARC_ABS;
+ case 'a':
+ return SVGPathSeg.PATHSEG_ARC_REL;
+ case 'H':
+ return SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_ABS;
+ case 'h':
+ return SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_REL;
+ case 'V':
+ return SVGPathSeg.PATHSEG_LINETO_VERTICAL_ABS;
+ case 'v':
+ return SVGPathSeg.PATHSEG_LINETO_VERTICAL_REL;
+ case 'S':
+ return SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_ABS;
+ case 's':
+ return SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_REL;
+ case 'T':
+ return SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS;
+ case 't':
+ return SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL;
+ default:
+ return SVGPathSeg.PATHSEG_UNKNOWN;
+ }
+ };
+
+ Source.prototype._nextCommandHelper = function(lookahead,
previousCommand) {
+ // Check for remaining coordinates in the current command.
+ if ((lookahead == '+' || lookahead == '-' || lookahead == '.'
|| (lookahead >= '0' && lookahead <= '9')) && previousCommand !=
SVGPathSeg.PATHSEG_CLOSEPATH) {
+ if (previousCommand == SVGPathSeg.PATHSEG_MOVETO_ABS)
+ return SVGPathSeg.PATHSEG_LINETO_ABS;
+ if (previousCommand == SVGPathSeg.PATHSEG_MOVETO_REL)
+ return SVGPathSeg.PATHSEG_LINETO_REL;
+ return previousCommand;
+ }
+ return SVGPathSeg.PATHSEG_UNKNOWN;
+ };
+
+ Source.prototype.initialCommandIsMoveTo = function() {
+ // If the path is empty it is still valid, so return true.
+ if (!this.hasMoreData())
+ return true;
+ var command = this.peekSegmentType();
+ // Path must start with moveTo.
+ return command == SVGPathSeg.PATHSEG_MOVETO_ABS || command ==
SVGPathSeg.PATHSEG_MOVETO_REL;
+ };
+
+ // Parse a number from an SVG path. This very closely follows
genericParseNumber(...) from Source/core/svg/SVGParserUtilities.cpp.
+ // Spec:
http://www.w3.org/TR/SVG11/single-page.html#paths-PathDataBNF
+ Source.prototype._parseNumber = function() {
+ var exponent = 0;
+ var integer = 0;
+ var frac = 1;
+ var decimal = 0;
+ var sign = 1;
+ var expsign = 1;
+
+ var startIndex = this._currentIndex;
+
+ this._skipOptionalSpaces();
+
+ // Read the sign.
+ if (this._currentIndex < this._endIndex &&
this._string.charAt(this._currentIndex) == '+')
+ this._currentIndex++;
+ else if (this._currentIndex < this._endIndex &&
this._string.charAt(this._currentIndex) == '-') {
+ this._currentIndex++;
+ sign = -1;
+ }
+
+ if (this._currentIndex == this._endIndex ||
((this._string.charAt(this._currentIndex) < '0' ||
this._string.charAt(this._currentIndex) > '9') &&
this._string.charAt(this._currentIndex) != '.'))
+ // The first character of a number must be one of [0-9+-.].
+ return undefined;
+
+ // Read the integer part, build right-to-left.
+ var startIntPartIndex = this._currentIndex;
+ while (this._currentIndex < this._endIndex &&
this._string.charAt(this._currentIndex) >= '0' &&
this._string.charAt(this._currentIndex) <= '9')
+ this._currentIndex++; // Advance to first non-digit.
+
+ if (this._currentIndex != startIntPartIndex) {
+ var scanIntPartIndex = this._currentIndex - 1;
+ var multiplier = 1;
+ while (scanIntPartIndex >= startIntPartIndex) {
+ integer += multiplier *
(this._string.charAt(scanIntPartIndex--) - '0');
+ multiplier *= 10;
+ }
+ }
+
+ // Read the decimals.
+ if (this._currentIndex < this._endIndex &&
this._string.charAt(this._currentIndex) == '.') {
+ this._currentIndex++;
+
+ // There must be a least one digit following the .
+ if (this._currentIndex >= this._endIndex ||
this._string.charAt(this._currentIndex) < '0' ||
this._string.charAt(this._currentIndex) > '9')
+ return undefined;
+ while (this._currentIndex < this._endIndex &&
this._string.charAt(this._currentIndex) >= '0' &&
this._string.charAt(this._currentIndex) <= '9') {
+ frac *= 10;
+ decimal += (this._string.charAt(this._currentIndex) -
'0') / frac;
+ this._currentIndex += 1;
+ }
+ }
+
+ // Read the exponent part.
+ if (this._currentIndex != startIndex && this._currentIndex + 1
< this._endIndex && (this._string.charAt(this._currentIndex) == 'e' ||
this._string.charAt(this._currentIndex) == 'E') &&
(this._string.charAt(this._currentIndex + 1) != 'x' &&
this._string.charAt(this._currentIndex + 1) != 'm')) {
+ this._currentIndex++;
+
+ // Read the sign of the exponent.
+ if (this._string.charAt(this._currentIndex) == '+') {
+ this._currentIndex++;
+ } else if (this._string.charAt(this._currentIndex) == '-')
{
+ this._currentIndex++;
+ expsign = -1;
+ }
+
+ // There must be an exponent.
+ if (this._currentIndex >= this._endIndex ||
this._string.charAt(this._currentIndex) < '0' ||
this._string.charAt(this._currentIndex) > '9')
+ return undefined;
+
+ while (this._currentIndex < this._endIndex &&
this._string.charAt(this._currentIndex) >= '0' &&
this._string.charAt(this._currentIndex) <= '9') {
+ exponent *= 10;
+ exponent += (this._string.charAt(this._currentIndex) -
'0');
+ this._currentIndex++;
+ }
+ }
+
+ var number = integer + decimal;
+ number *= sign;
+
+ if (exponent)
+ number *= Math.pow(10, expsign * exponent);
+
+ if (startIndex == this._currentIndex)
+ return undefined;
+
+ this._skipOptionalSpacesOrDelimiter();
+
+ return number;
+ };
+
+ Source.prototype._parseArcFlag = function() {
+ if (this._currentIndex >= this._endIndex)
+ return undefined;
+ var flag = false;
+ var flagChar = this._string.charAt(this._currentIndex++);
+ if (flagChar == '0')
+ flag = false;
+ else if (flagChar == '1')
+ flag = true;
+ else
+ return undefined;
+
+ this._skipOptionalSpacesOrDelimiter();
+ return flag;
+ };
+
+ Source.prototype.parseSegment = function() {
+ var lookahead = this._string[this._currentIndex];
+ var command = this._pathSegTypeFromChar(lookahead);
+ if (command == SVGPathSeg.PATHSEG_UNKNOWN) {
+ // Possibly an implicit command. Not allowed if this is
the first command.
+ if (this._previousCommand == SVGPathSeg.PATHSEG_UNKNOWN)
+ return null;
+ command = this._nextCommandHelper(lookahead,
this._previousCommand);
+ if (command == SVGPathSeg.PATHSEG_UNKNOWN)
+ return null;
+ } else {
+ this._currentIndex++;
+ }
+
+ this._previousCommand = command;
+
+ switch (command) {
+ case SVGPathSeg.PATHSEG_MOVETO_REL:
+ return new SVGPathSegMovetoRel(owningPathSegList,
this._parseNumber(), this._parseNumber());
+ case SVGPathSeg.PATHSEG_MOVETO_ABS:
+ return new SVGPathSegMovetoAbs(owningPathSegList,
this._parseNumber(), this._parseNumber());
+ case SVGPathSeg.PATHSEG_LINETO_REL:
+ return new SVGPathSegLinetoRel(owningPathSegList,
this._parseNumber(), this._parseNumber());
+ case SVGPathSeg.PATHSEG_LINETO_ABS:
+ return new SVGPathSegLinetoAbs(owningPathSegList,
this._parseNumber(), this._parseNumber());
+ case SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_REL:
+ return new
SVGPathSegLinetoHorizontalRel(owningPathSegList, this._parseNumber());
+ case SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_ABS:
+ return new
SVGPathSegLinetoHorizontalAbs(owningPathSegList, this._parseNumber());
+ case SVGPathSeg.PATHSEG_LINETO_VERTICAL_REL:
+ return new
SVGPathSegLinetoVerticalRel(owningPathSegList, this._parseNumber());
+ case SVGPathSeg.PATHSEG_LINETO_VERTICAL_ABS:
+ return new
SVGPathSegLinetoVerticalAbs(owningPathSegList, this._parseNumber());
+ case SVGPathSeg.PATHSEG_CLOSEPATH:
+ this._skipOptionalSpaces();
+ return new SVGPathSegClosePath(owningPathSegList);
+ case SVGPathSeg.PATHSEG_CURVETO_CUBIC_REL:
+ var points = {x1: this._parseNumber(), y1:
this._parseNumber(), x2: this._parseNumber(), y2: this._parseNumber(), x:
this._parseNumber(), y: this._parseNumber()};
+ return new
SVGPathSegCurvetoCubicRel(owningPathSegList, points.x, points.y, points.x1,
points.y1, points.x2, points.y2);
+ case SVGPathSeg.PATHSEG_CURVETO_CUBIC_ABS:
+ var points = {x1: this._parseNumber(), y1:
this._parseNumber(), x2: this._parseNumber(), y2: this._parseNumber(), x:
this._parseNumber(), y: this._parseNumber()};
+ return new
SVGPathSegCurvetoCubicAbs(owningPathSegList, points.x, points.y, points.x1,
points.y1, points.x2, points.y2);
+ case SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_REL:
+ var points = {x2: this._parseNumber(), y2:
this._parseNumber(), x: this._parseNumber(), y: this._parseNumber()};
+ return new
SVGPathSegCurvetoCubicSmoothRel(owningPathSegList, points.x, points.y,
points.x2, points.y2);
+ case SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_ABS:
+ var points = {x2: this._parseNumber(), y2:
this._parseNumber(), x: this._parseNumber(), y: this._parseNumber()};
+ return new
SVGPathSegCurvetoCubicSmoothAbs(owningPathSegList, points.x, points.y,
points.x2, points.y2);
+ case SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_REL:
+ var points = {x1: this._parseNumber(), y1:
this._parseNumber(), x: this._parseNumber(), y: this._parseNumber()};
+ return new
SVGPathSegCurvetoQuadraticRel(owningPathSegList, points.x, points.y, points.x1,
points.y1);
+ case SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_ABS:
+ var points = {x1: this._parseNumber(), y1:
this._parseNumber(), x: this._parseNumber(), y: this._parseNumber()};
+ return new
SVGPathSegCurvetoQuadraticAbs(owningPathSegList, points.x, points.y, points.x1,
points.y1);
+ case SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL:
+ return new
SVGPathSegCurvetoQuadraticSmoothRel(owningPathSegList, this._parseNumber(),
this._parseNumber());
+ case SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS:
+ return new
SVGPathSegCurvetoQuadraticSmoothAbs(owningPathSegList, this._parseNumber(),
this._parseNumber());
+ case SVGPathSeg.PATHSEG_ARC_REL:
+ var points = {x1: this._parseNumber(), y1:
this._parseNumber(), arcAngle: this._parseNumber(), arcLarge:
this._parseArcFlag(), arcSweep: this._parseArcFlag(), x: this._parseNumber(),
y: this._parseNumber()};
+ return new SVGPathSegArcRel(owningPathSegList,
points.x, points.y, points.x1, points.y1, points.arcAngle, points.arcLarge,
points.arcSweep);
+ case SVGPathSeg.PATHSEG_ARC_ABS:
+ var points = {x1: this._parseNumber(), y1:
this._parseNumber(), arcAngle: this._parseNumber(), arcLarge:
this._parseArcFlag(), arcSweep: this._parseArcFlag(), x: this._parseNumber(),
y: this._parseNumber()};
+ return new SVGPathSegArcAbs(owningPathSegList,
points.x, points.y, points.x1, points.y1, points.arcAngle, points.arcLarge,
points.arcSweep);
+ default:
+ throw 'Unknown path seg type.'
+ }
+ };
+
+ var builder = new Builder();
+ var source = new Source(string);
+
+ if (!source.initialCommandIsMoveTo())
+ return [];
+ while (source.hasMoreData()) {
+ var pathSeg = source.parseSegment();
+ if (!pathSeg)
+ return [];
+ builder.appendSegment(pathSeg);
+ }
+
+ return builder.pathSegList;
+ }
+ }
+}());
+
+/*****
+ * @svgpathend
+ *
+ * The above code is a derivative work of some part of the SVGPathSeg API.
+ *
+ * This API is a drop-in replacement for the SVGPathSeg and SVGPathSegList
APIs that were removed from
+ * SVG2 (https://lists.w3.org/Archives/Public/www-svg/2015Jun/0044.html),
including the latest spec
+ * changes which were implemented in Firefox 43 and Chrome 46.
+ *
+ * @source https://github.com/progers/pathseg
+ */
+
/*****
* @licstart
@@ -712,7 +1690,6 @@ function configureDetectionTools()
*/
-
/*****
* @libreofficestart
*
@@ -3592,6 +4569,12 @@ SVGPathElement.prototype.appendPath = function( aPath )
*/
SVGPathElement.prototype.matrixTransform = function( aSVGMatrix )
{
+ if( SVGPathSegList.prototype.matrixTransform )
+ {
+ this.pathSegList.matrixTransform( aSVGMatrix );
+ return;
+ }
+
var aPathSegList = this.pathSegList;
var nLength = aPathSegList.numberOfItems;
var i;
@@ -3611,6 +4594,12 @@ SVGPathElement.prototype.changeOrientation = function()
var nLength = aPathSegList.numberOfItems;
if( nLength == 0 ) return;
+ if( SVGPathSegList.prototype.changeOrientation )
+ {
+ aPathSegList.changeOrientation();
+ return;
+ }
+
var nCurrentX = 0;
var nCurrentY = 0;
@@ -3652,7 +4641,6 @@ SVGPathElement.prototype.changeOrientation = function()
* We exploit this fact for providing a different implementation.
*/
-var SVGPathSeg = typeof SVGPathSeg === 'undefined' ? function() {} :
SVGPathSeg;
try
{ // Firefox, Google Chrome, Internet Explorer, Safari.
diff --git a/readlicense_oo/license/LICENSE b/readlicense_oo/license/LICENSE
index 328b7d3..b840d4b 100644
--- a/readlicense_oo/license/LICENSE
+++ b/readlicense_oo/license/LICENSE
@@ -2369,6 +2369,44 @@ STLPort
no representations about the suitability of this software for any
purpose. It is provided "as is" without express or implied warranty.
+SVGPathSeg polyfill
+
+ The following software may be included in this product: SVGPathSeg
+ polyfill. Use of any of this software is governed by the terms of
+ the license below:
+
+ Copyright 2015 The Chromium Authors. All rights reserved.
+
+ The Chromium Authors can be found at
+ http://src.chromium.org/svn/trunk/src/AUTHORS
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are
+ met:
+
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the following disclaimer
+ in the documentation and/or other materials provided with the
+ distribution.
+ * Neither the name of Google Inc. nor the names of its
+ contributors may be used to endorse or promote products derived from
+ this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
TWAIN
The following software may be included in this product: TWAIN. Use of
diff --git a/readlicense_oo/license/LICENSE.fodt
b/readlicense_oo/license/LICENSE.fodt
index 3f7f435..a90fd71 100644
--- a/readlicense_oo/license/LICENSE.fodt
+++ b/readlicense_oo/license/LICENSE.fodt
@@ -4020,6 +4020,38 @@
<text:p text:style-name="P67">Permission to use, copy, modify, distribute
and sell this software and its documentation for any purpose is hereby granted
without fee, provided that the above copyright notice appear in all copies and
that both that copyright notice and this permission notice appear in supporting
documentation. Hewlett-Packard Company makes no representations about the
suitability of this software for any purpose. It is provided "as is"
without express or implied warranty.</text:p>
<text:p text:style-name="P67">Permission to use, copy, modify, distribute
and sell this software and its documentation for any purpose is hereby granted
without fee, provided that the above copyright notice appear in all copies and
that both that copyright notice and this permission notice appear in supporting
documentation. Silicon Graphics makes no representations about the suitability
of this software for any purpose. It is provided "as is" without
express or implied warranty.</text:p>
<text:p text:style-name="P67">Permission to use, copy, modify, distribute
and sell this software and its documentation for any purpose is hereby granted
without fee, provided that the above copyright notice appear in all copies and
that both that copyright notice and this permission notice appear in supporting
documentation. Moscow Center for SPARC Technology makes no representations
about the suitability of this software for any purpose. It is provided "as
is" without express or implied warranty.</text:p>
+ <text:h text:style-name="Heading_20_2" text:outline-level="2">SVGPathSeg
polyfill</text:h>
+ <text:p text:style-name="Standard">The following software may be included
in this product: SVGPathSeg polyfill. Use of any of this software is governed
by the terms of the license below:</text:p>
+ <text:p text:style-name="Preformatted_20_Text">Copyright 2015 The Chromium
Authors. All rights reserved.</text:p>
+ <text:p
text:style-name="Preformatted_20_Text"><text:soft-page-break/></text:p>
+ <text:p text:style-name="Preformatted_20_Text">The Chromium Authors can be
found at</text:p>
+ <text:p
text:style-name="Preformatted_20_Text">http://src.chromium.org/svn/trunk/src/AUTHORS</text:p>
+ <text:p text:style-name="Preformatted_20_Text"/>
+ <text:p text:style-name="Preformatted_20_Text">Redistribution and use in
source and binary forms, with or without</text:p>
+ <text:p text:style-name="Preformatted_20_Text">modification, are permitted
provided that the following conditions are</text:p>
+ <text:p text:style-name="Preformatted_20_Text">met:</text:p>
+ <text:p text:style-name="Preformatted_20_Text"/>
+ <text:p text:style-name="Preformatted_20_Text"><text:s text:c="3"/>*
Redistributions of source code must retain the above copyright</text:p>
+ <text:p text:style-name="Preformatted_20_Text">notice, this list of
conditions and the following disclaimer.</text:p>
+ <text:p text:style-name="Preformatted_20_Text"><text:s text:c="3"/>*
Redistributions in binary form must reproduce the above</text:p>
+ <text:p text:style-name="Preformatted_20_Text">copyright notice, this list
of conditions and the following disclaimer</text:p>
+ <text:p text:style-name="Preformatted_20_Text">in the documentation and/or
other materials provided with the</text:p>
+ <text:p text:style-name="Preformatted_20_Text">distribution.</text:p>
+ <text:p text:style-name="Preformatted_20_Text"><text:s text:c="3"/>*
Neither the name of Google Inc. nor the names of its</text:p>
+ <text:p text:style-name="Preformatted_20_Text">contributors may be used to
endorse or promote products derived from</text:p>
+ <text:p text:style-name="Preformatted_20_Text">this software without
specific prior written permission.</text:p>
+ <text:p text:style-name="Preformatted_20_Text"/>
+ <text:p text:style-name="Preformatted_20_Text">THIS SOFTWARE IS PROVIDED BY
THE COPYRIGHT HOLDERS AND CONTRIBUTORS</text:p>
+ <text:p text:style-name="Preformatted_20_Text">"AS IS" AND ANY
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT</text:p>
+ <text:p text:style-name="Preformatted_20_Text">LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR</text:p>
+ <text:p text:style-name="Preformatted_20_Text">A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT</text:p>
+ <text:p text:style-name="Preformatted_20_Text">OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,</text:p>
+ <text:p text:style-name="Preformatted_20_Text">SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT</text:p>
+ <text:p text:style-name="Preformatted_20_Text">LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,</text:p>
+ <text:p text:style-name="Preformatted_20_Text">DATA, OR PROFITS; OR
BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY</text:p>
+ <text:p text:style-name="Preformatted_20_Text">THEORY OF LIABILITY, WHETHER
IN CONTRACT, STRICT LIABILITY, OR TORT</text:p>
+ <text:p text:style-name="Preformatted_20_Text">(INCLUDING NEGLIGENCE OR
OTHERWISE) ARISING IN ANY WAY OUT OF THE USE</text:p>
+ <text:p text:style-name="P8">OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.</text:p>
<text:h text:style-name="Heading_20_2" text:outline-level="2">TWAIN</text:h>
<text:p text:style-name="Standard">The following software may be included
in this product: TWAIN. Use of any of this software is governed by the terms of
the license below:</text:p>
<text:h text:style-name="Heading_20_3"
text:outline-level="3"><text:soft-page-break/>The TWAIN License</text:h>
diff --git a/readlicense_oo/license/LICENSE.html
b/readlicense_oo/license/LICENSE.html
index 493ed6c..47b12ea 100644
--- a/readlicense_oo/license/LICENSE.html
+++ b/readlicense_oo/license/LICENSE.html
@@ -1,5 +1,5 @@
<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1 plus MathML 2.0//EN"
"http://www.w3.org/Math/DTD/mathml2/xhtml-math11-f.dtd";><html
xmlns="http://www.w3.org/1999/xhtml";><!--This file was converted to xhtml by
LibreOffice - see
http://cgit.freedesktop.org/libreoffice/core/tree/filter/source/xslt for the
code.--><head profile="http://dublincore.org/documents/dcmi-terms/";><meta
http-equiv="Content-Type" content="application/xhtml+xml;
charset=utf-8"/><title xml:lang="en-US">Licensing and Legal
information</title><meta name="DCTERMS.title" content="Licensing and Legal
information" xml:lang="en-US"/><meta name="DCTERMS.language" content="en-US"
scheme="DCTERMS.RFC4646"/><meta name="DCTERMS.source"
content="http://xml.openoffice.org/odf2xhtml"/><meta name="DCTERMS.issued"
content="2011-05-11T11:39:17.79" scheme="DCTERMS.W3CDTF"/><meta
name="DCTERMS.contributor" content="Tor Lillqvist"/><meta
name="DCTERMS.modified" content="2015-01-12T14:53:31.375949809"
scheme="DCTERMS.W3CDTF"/><meta name="D
CTERMS.provenance" content="" xml:lang="en-US"/><meta name="DCTERMS.subject"
content="LibreOffice Licensing and Legal information, License, GPL, LGPL, MPL,
Apache, CC" xml:lang="en-US"/><link rel="schema.DC"
href="http://purl.org/dc/elements/1.1/"; hreflang="en"/><link
rel="schema.DCTERMS" href="http://purl.org/dc/terms/"; hreflang="en"/><link
rel="schema.DCTYPE" href="http://purl.org/dc/dcmitype/"; hreflang="en"/><link
rel="schema.DCAM" href="http://purl.org/dc/dcam/"; hreflang="en"/><style
type="text/css">
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1 plus MathML 2.0//EN"
"http://www.w3.org/Math/DTD/mathml2/xhtml-math11-f.dtd";><html
xmlns="http://www.w3.org/1999/xhtml";><!--This file was converted to xhtml by
LibreOffice - see
http://cgit.freedesktop.org/libreoffice/core/tree/filter/source/xslt for the
code.--><head profile="http://dublincore.org/documents/dcmi-terms/";><meta
http-equiv="Content-Type" content="application/xhtml+xml;
charset=utf-8"/><title xml:lang="en-US">Licensing and Legal
information</title><meta name="DCTERMS.title" content="Licensing and Legal
information" xml:lang="en-US"/><meta name="DCTERMS.language" content="en-US"
scheme="DCTERMS.RFC4646"/><meta name="DCTERMS.source"
content="http://xml.openoffice.org/odf2xhtml"/><meta name="DCTERMS.issued"
content="2011-05-11T11:39:17.79" scheme="DCTERMS.W3CDTF"/><meta
name="DCTERMS.modified" content="2015-05-22T10:18:42.401712240"
scheme="DCTERMS.W3CDTF"/><meta name="DCTERMS.provenance" content=""
xml:lang="en-US"/><meta name
="DCTERMS.subject" content="LibreOffice Licensing and Legal information,
License, GPL, LGPL, MPL, Apache, CC" xml:lang="en-US"/><link rel="schema.DC"
href="http://purl.org/dc/elements/1.1/"; hreflang="en"/><link
rel="schema.DCTERMS" href="http://purl.org/dc/terms/"; hreflang="en"/><link
rel="schema.DCTYPE" href="http://purl.org/dc/dcmitype/"; hreflang="en"/><link
rel="schema.DCAM" href="http://purl.org/dc/dcam/"; hreflang="en"/><style
type="text/css">
@page { }
table { border-collapse:collapse; border-spacing:0; empty-cells:show }
td, th { vertical-align:top; font-size:12pt;}
@@ -11,184 +11,98 @@
span.footnodeNumber { padding-right:1em; }
span.annotation_style_by_filter { font-size:95%; font-family:Arial;
background-color:#fff000; margin:0; border:0; padding:0; }
* { margin:0;}
- .Contents_20_1 { font-size:12pt; margin-bottom:0cm; margin-top:0cm;
font-family:DejaVu Serif; writing-mode:page; margin-left:0cm; margin-right:0cm;
text-indent:0cm; }
- .Contents_20_2 { font-size:12pt; margin-bottom:0cm; margin-top:0cm;
font-family:DejaVu Serif; writing-mode:page; margin-left:0.499cm;
margin-right:0cm; text-indent:0cm; }
- .Contents_20_3 { font-size:12pt; margin-bottom:0cm; margin-top:0cm;
font-family:DejaVu Serif; writing-mode:page; margin-left:0.998cm;
margin-right:0cm; text-indent:0cm; }
- .Contents_20_Heading { font-size:16pt; margin-bottom:0cm;
margin-top:0cm; font-family:DejaVu Sans; writing-mode:page; margin-left:0cm;
margin-right:0cm; text-indent:0cm; font-weight:bold; }
- .Heading_20_1 { font-size:115%; margin-bottom:0.212cm;
margin-top:0.423cm; font-family:DejaVu Sans; writing-mode:page;
font-weight:bold; }
- .Heading_20_2 { font-size:14pt; margin-bottom:0cm; margin-top:0.3cm;
font-family:DejaVu Sans; writing-mode:page; margin-left:0cm; margin-right:0cm;
text-indent:0cm; font-style:italic; font-weight:bold; }
- .Heading_20_3 { font-size:12pt; margin-bottom:0.212cm;
margin-top:0.423cm; font-family:DejaVu Sans; writing-mode:page;
font-weight:bold; }
- .Heading_20_4 { font-size:12pt; margin-bottom:0.212cm;
margin-top:0.423cm; font-family:DejaVu Sans Condensed; writing-mode:page;
font-weight:bold; }
- .List_20_Contents { font-size:12pt; margin-bottom:0cm; margin-top:0cm;
font-family:DejaVu Serif; writing-mode:page; margin-left:1cm; margin-right:0cm;
text-indent:0cm; }
- .List_20_Heading { font-size:12pt; margin-bottom:0cm; margin-top:0cm;
font-family:DejaVu Serif; writing-mode:page; margin-left:0cm; margin-right:0cm;
text-indent:0cm; }
- .P1 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; text-decoration:none ! important; }
- .P10 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P100 { font-size:14pt; font-style:italic; font-weight:bold;
margin-bottom:0cm; margin-left:0cm; margin-right:0cm; margin-top:0.3cm;
text-indent:0cm; font-family:DejaVu Sans; writing-mode:page; }
- .P101 { font-size:14pt; font-style:italic; font-weight:bold;
margin-bottom:0cm; margin-left:0cm; margin-right:0cm; margin-top:0.3cm;
text-indent:0cm; font-family:DejaVu Sans; writing-mode:page; }
- .P102 { font-size:12pt; font-weight:bold; margin-bottom:0.212cm;
margin-top:0.423cm; font-family:DejaVu Sans; writing-mode:page; }
- .P104 { font-size:12pt; font-weight:bold; margin-bottom:0.212cm;
margin-top:0.423cm; font-family:DejaVu Sans; writing-mode:page; }
- .P105 { font-size:12pt; font-weight:bold; margin-bottom:0.212cm;
margin-top:0.423cm; font-family:DejaVu Sans; writing-mode:page; }
- .P106 { font-size:12pt; font-weight:bold; margin-bottom:0.212cm;
margin-top:0.423cm; font-family:DejaVu Sans; writing-mode:page; }
- .P107 { font-size:12pt; font-weight:bold; margin-bottom:0.212cm;
margin-top:0.423cm; font-family:DejaVu Sans; writing-mode:page; }
- .P108 { font-size:12pt; font-weight:bold; margin-bottom:0.212cm;
margin-top:0.423cm; font-family:DejaVu Sans; writing-mode:page; }
- .P109 { font-size:12pt; font-weight:bold; margin-bottom:0.212cm;
margin-top:0.423cm; font-family:DejaVu Sans; writing-mode:page; }
- .P11 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P110 { font-size:12pt; font-weight:bold; margin-bottom:0.212cm;
margin-top:0.423cm; font-family:DejaVu Sans; writing-mode:page; }
- .P112 { font-size:12pt; margin-bottom:0.212cm; margin-top:0cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P113 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P114 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P115 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P116 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P117 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P118 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P119 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P12 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P120 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P121 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P122 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; font-weight:bold; }
- .P123 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P124 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P125 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P126 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P127 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P128 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P129 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P13 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P130 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P131 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P132 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P133 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P134 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P135 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P136 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P137 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P138 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P139 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P14 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P140 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P141 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P142 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P143 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P144 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P145 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P146 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P147 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P148 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P149 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P15 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P150 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P151 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P152 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P153 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P154 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P155 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P156 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P157 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; margin-left:2.501cm;
margin-right:0cm; text-indent:-0.635cm; }
- .P158 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; margin-left:2.501cm;
margin-right:0cm; text-indent:-0.635cm; }
- .P159 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; margin-left:1.402cm;
margin-right:0cm; text-indent:-0.767cm; font-weight:bold; }
- .P16 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P160 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; margin-left:1.429cm;
margin-right:0cm; text-indent:-0.794cm; font-weight:bold; }
- .P161 { font-size:12pt; margin-bottom:0.212cm; margin-top:0cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P162 { font-size:12pt; margin-bottom:0.212cm; margin-top:0cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P163 { font-size:12pt; margin-bottom:0.212cm; margin-top:0cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P164 { font-size:12pt; margin-bottom:0.212cm; margin-top:0cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P165 { font-size:12pt; margin-bottom:0.212cm; margin-top:0cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P166 { font-size:12pt; margin-bottom:0.212cm; margin-top:0cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P17 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P176 { font-size:115%; font-weight:bold; margin-bottom:0.212cm;
margin-top:0.423cm; font-family:DejaVu Sans; writing-mode:page; }
- .P18 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P19 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P2 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; font-weight:bold; }
- .P20 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P206 { font-size:12pt; margin-bottom:0cm; margin-left:1cm;
margin-right:0cm; margin-top:0.3cm; text-indent:0cm; font-family:DejaVu Serif;
writing-mode:page; }
- .P207 { font-size:12pt; margin-bottom:0.499cm; margin-left:1cm;
margin-right:0cm; margin-top:0cm; text-indent:0cm; font-family:DejaVu Serif;
writing-mode:page; }
- .P208 { font-size:12pt; margin-bottom:0.499cm; margin-left:1cm;
margin-right:0cm; margin-top:0cm; text-indent:0cm; font-family:DejaVu Serif;
writing-mode:page; }
- .P21 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P22 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P23 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P24 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P25 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P26 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P27 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P28 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P29 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P3 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; font-weight:bold; }
- .P30 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P31 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P32 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P33 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P34 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P35 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P36 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P37 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P38 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P39 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P4 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; font-weight:bold; }
- .P40 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P41 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P42 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P43 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P44 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P45 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P46 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P47 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P48 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P49 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P5 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P50 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P51 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P52 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P53 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P54 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P55 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P56 { font-size:10pt; margin-bottom:0.499cm; margin-top:0.3cm;
font-family:DejaVu Sans Mono; writing-mode:lr-tb; }
- .P57 { font-size:10pt; margin-bottom:0.499cm; margin-top:0.3cm;
font-family:DejaVu Sans Mono; writing-mode:page; }
- .P58 { font-size:10pt; margin-bottom:0cm; margin-top:0cm;
font-family:DejaVu Sans Mono; writing-mode:lr-tb; }
- .P59 { font-size:10pt; margin-bottom:0.499cm; margin-top:0cm;
font-family:DejaVu Sans Mono; writing-mode:page; }
- .P6 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P60 { font-size:12pt; margin-bottom:0.499cm; margin-left:0cm;
margin-right:0cm; margin-top:0cm; text-indent:0cm; font-family:DejaVu Serif;
writing-mode:page; }
- .P61 { font-size:12pt; margin-bottom:0.499cm; margin-left:1cm;
margin-right:0cm; margin-top:0cm; text-indent:0cm; font-family:DejaVu Serif;
writing-mode:page; }
- .P62 { font-size:14pt; font-style:italic; font-weight:bold;
margin-bottom:0.499cm; margin-left:0cm; margin-right:0cm; margin-top:0cm;
text-indent:0cm; font-family:DejaVu Sans; writing-mode:page; }
- .P63 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; margin-left:1.251cm;
margin-right:0cm; text-indent:0cm; }
- .P64 { font-size:18pt; font-weight:bold; margin-bottom:0.212cm;
margin-top:0.423cm; text-align:center ! important; font-family:DejaVu Sans;
writing-mode:page; }
- .P65 { font-size:16pt; font-weight:bold; margin-bottom:0cm;
margin-left:0cm; margin-right:0cm; margin-top:0cm; text-indent:0cm;
font-family:DejaVu Sans; writing-mode:page; }
- .P66 { font-size:115%; font-weight:bold; margin-bottom:0.212cm;
margin-top:0.423cm; font-family:DejaVu Sans; writing-mode:page; }
- .P67 { font-size:10pt; margin-bottom:0.499cm; margin-left:1cm;
margin-right:1cm; margin-top:0cm; text-indent:0cm; font-family:DejaVu Serif;
writing-mode:page; font-style:italic; }
- .P68 { font-size:12pt; margin-bottom:0cm; margin-left:0cm;
margin-right:0cm; margin-top:0cm; text-indent:0cm; font-family:DejaVu Serif;
writing-mode:page; }
- .P7 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P72 { font-size:14pt; font-style:italic; font-weight:bold;
margin-bottom:0cm; margin-left:0cm; margin-right:0cm; margin-top:0.3cm;
text-indent:0cm; font-family:DejaVu Sans; writing-mode:page; }
- .P73 { font-size:14pt; font-style:italic; font-weight:bold;
margin-bottom:0cm; margin-left:0cm; margin-right:0cm; margin-top:0.3cm;
text-indent:0cm; font-family:DejaVu Sans; writing-mode:page; }
- .P74 { font-size:14pt; font-style:italic; font-weight:bold;
margin-bottom:0cm; margin-left:0cm; margin-right:0cm; margin-top:0.3cm;
text-indent:0cm; font-family:DejaVu Sans; writing-mode:page; }
- .P76 { font-size:14pt; font-style:italic; font-weight:bold;
margin-bottom:0cm; margin-left:0cm; margin-right:0cm; margin-top:0.3cm;
text-indent:0cm; font-family:DejaVu Sans; writing-mode:page; }
- .P77 { font-size:14pt; font-style:italic; font-weight:bold;
margin-bottom:0cm; margin-left:0cm; margin-right:0cm; margin-top:0.3cm;
text-indent:0cm; font-family:DejaVu Sans; writing-mode:page; }
- .P78 { font-size:14pt; font-style:italic; font-weight:bold;
margin-bottom:0cm; margin-left:0cm; margin-right:0cm; margin-top:0.3cm;
text-indent:0cm; font-family:DejaVu Sans; writing-mode:page; }
- .P79 { font-size:14pt; font-style:italic; font-weight:bold;
margin-bottom:0cm; margin-left:0cm; margin-right:0cm; margin-top:0.3cm;
text-indent:0cm; font-family:DejaVu Sans; writing-mode:page; }
- .P8 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P80 { font-size:14pt; font-style:italic; font-weight:bold;
margin-bottom:0cm; margin-left:0cm; margin-right:0cm; margin-top:0.3cm;
text-indent:0cm; font-family:DejaVu Sans; writing-mode:page; }
- .P81 { font-size:14pt; font-style:italic; font-weight:bold;
margin-bottom:0cm; margin-left:0cm; margin-right:0cm; margin-top:0.3cm;
text-indent:0cm; font-family:DejaVu Sans; writing-mode:page; }
- .P82 { font-size:14pt; font-style:italic; font-weight:bold;
margin-bottom:0cm; margin-left:0cm; margin-right:0cm; margin-top:0.3cm;
text-indent:0cm; font-family:DejaVu Sans; writing-mode:page; }
- .P83 { font-size:14pt; font-style:italic; font-weight:bold;
margin-bottom:0cm; margin-left:0cm; margin-right:0cm; margin-top:0.3cm;
text-indent:0cm; font-family:DejaVu Sans; writing-mode:page;
text-decoration:none ! important; }
- .P84 { font-size:14pt; font-style:italic; font-weight:bold;
margin-bottom:0cm; margin-left:0cm; margin-right:0cm; margin-top:0.3cm;
text-indent:0cm; font-family:DejaVu Sans; writing-mode:page; }
- .P85 { font-size:14pt; font-style:italic; font-weight:bold;
margin-bottom:0cm; margin-left:0cm; margin-right:0cm; margin-top:0.3cm;
text-indent:0cm; font-family:DejaVu Sans; writing-mode:page; }
- .P86 { font-size:14pt; font-style:italic; font-weight:bold;
margin-bottom:0cm; margin-left:0cm; margin-right:0cm; margin-top:0.3cm;
text-indent:0cm; font-family:DejaVu Sans; writing-mode:page; }
- .P87 { font-size:14pt; font-style:italic; font-weight:bold;
margin-bottom:0cm; margin-left:0cm; margin-right:0cm; margin-top:0.3cm;
text-indent:0cm; font-family:DejaVu Sans; writing-mode:page; }
- .P88 { font-size:14pt; font-style:italic; font-weight:bold;
margin-bottom:0cm; margin-left:0cm; margin-right:0cm; margin-top:0.3cm;
text-indent:0cm; font-family:DejaVu Sans; writing-mode:page; }
- .P89 { font-size:14pt; font-style:italic; font-weight:bold;
margin-bottom:0cm; margin-left:0cm; margin-right:0cm; margin-top:0.3cm;
text-indent:0cm; font-family:DejaVu Sans; writing-mode:page; }
- .P9 { font-size:12pt; margin-bottom:0.3cm; margin-top:0.3cm;
font-family:DejaVu Serif; writing-mode:page; }
- .P90 { font-size:14pt; font-style:italic; font-weight:bold;
margin-bottom:0cm; margin-left:0cm; margin-right:0cm; margin-top:0.3cm;
text-indent:0cm; font-family:DejaVu Sans; writing-mode:page; }
- .P92 { font-size:14pt; font-style:italic; font-weight:bold;
margin-bottom:0cm; margin-left:0cm; margin-right:0cm; margin-top:0.3cm;
text-indent:0cm; font-family:DejaVu Sans; writing-mode:page; }
- .P93 { font-size:14pt; font-style:italic; font-weight:bold;
margin-bottom:0cm; margin-left:0cm; margin-right:0cm; margin-top:0.3cm;
text-indent:0cm; font-family:DejaVu Sans; writing-mode:page; }
... etc. - the rest is truncated
_______________________________________________
Libreoffice-commits mailing list
libreoffice-comm...@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/libreoffice-commits
