+
+Why?
+----
+
+Writing `JSON.stringify()` and then `fs.writeFile()` and `JSON.parse()` with `fs.readFile()` enclosed in `try/catch` blocks became annoying.
+
+
+
+Installation
+------------
+
+ npm install --save jsonfile
+
+
+
+API
+---
+
+### readFile(filename, [options], callback)
+
+`options` (`object`, default `undefined`): Pass in any `fs.readFile` options or set `reviver` for a [JSON reviver](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse).
+ - `throws` (`boolean`, default: `true`). If `JSON.parse` throws an error, pass this error to the callback.
+ If `false`, returns `null` for the object.
+
+
+```js
+var jsonfile = require('jsonfile')
+var file = '/tmp/data.json'
+jsonfile.readFile(file, function(err, obj) {
+ console.dir(obj)
+})
+```
+
+
+### readFileSync(filename, [options])
+
+`options` (`object`, default `undefined`): Pass in any `fs.readFileSync` options or set `reviver` for a [JSON reviver](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse).
+- `throws` (`boolean`, default: `true`). If `JSON.parse` throws an error, throw the error.
+If `false`, returns `null` for the object.
+
+```js
+var jsonfile = require('jsonfile')
+var file = '/tmp/data.json'
+
+console.dir(jsonfile.readFileSync(file))
+```
+
+
+### writeFile(filename, obj, [options], callback)
+
+`options`: Pass in any `fs.writeFile` options or set `replacer` for a [JSON replacer](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify). Can also pass in `spaces`.
+
+
+```js
+var jsonfile = require('jsonfile')
+
+var file = '/tmp/data.json'
+var obj = {name: 'JP'}
+
+jsonfile.writeFile(file, obj, function (err) {
+ console.error(err)
+})
+```
+
+**formatting with spaces:**
+
+```js
+var jsonfile = require('jsonfile')
+
+var file = '/tmp/data.json'
+var obj = {name: 'JP'}
+
+jsonfile.writeFile(file, obj, {spaces: 2}, function(err) {
+ console.error(err)
+})
+```
+
+
+### writeFileSync(filename, obj, [options])
+
+`options`: Pass in any `fs.writeFileSync` options or set `replacer` for a [JSON replacer](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify). Can also pass in `spaces`.
+
+```js
+var jsonfile = require('jsonfile')
+
+var file = '/tmp/data.json'
+var obj = {name: 'JP'}
+
+jsonfile.writeFileSync(file, obj)
+```
+
+**formatting with spaces:**
+
+```js
+var jsonfile = require('jsonfile')
+
+var file = '/tmp/data.json'
+var obj = {name: 'JP'}
+
+jsonfile.writeFileSync(file, obj, {spaces: 2})
+```
+
+
+
+### spaces
+
+Global configuration to set spaces to indent JSON files.
+
+**default:** `null`
+
+```js
+var jsonfile = require('jsonfile')
+
+jsonfile.spaces = 4
+
+var file = '/tmp/data.json'
+var obj = {name: 'JP'}
+
+// json file has four space indenting now
+jsonfile.writeFile(file, obj, function (err) {
+ console.error(err)
+})
+```
+
+Note, it's bound to `this.spaces`. So, if you do this:
+
+```js
+var myObj = {}
+myObj.writeJsonSync = jsonfile.writeFileSync
+// => this.spaces = null
+```
+
+Could do the following:
+
+```js
+var jsonfile = require('jsonfile')
+jsonfile.spaces = 4
+jsonfile.writeFileSync(file, obj) // will have 4 spaces indentation
+
+var myCrazyObj = {spaces: 32}
+myCrazyObj.writeJsonSync = jsonfile.writeFileSync
+myCrazyObj.writeJsonSync(file, obj) // will have 32 space indentation
+myCrazyObj.writeJsonSync(file, obj, {spaces: 2}) // will have only 2
+```
+
+
+License
+-------
+
+(MIT License)
+
+Copyright 2012-2016, JP Richardson Basic
+
grayscale+
color+
paletted+
grayscale + alpha+
color + alpha+ +
Image filtering
+
grayscale, filter 0+
color, filter 0+
grayscale, filter 1+
color, filter 1+
grayscale, filter 2+
color, filter 2+
grayscale, filter 3+
color, filter 3+
grayscale, filter 4+
color, filter 4+ +
Transparency
+
grayscale, not transparent+
color, not transparent+
paletted, not transparent+
color, transparent+
paletted, transparent+ + diff --git a/pype/premiere/extensions/com.pype.avalon/node_modules/node-png/examples/test/out/.npmignore b/pype/premiere/extensions/com.pype.avalon/node_modules/node-png/examples/test/out/.npmignore new file mode 100644 index 0000000000..e33609d251 --- /dev/null +++ b/pype/premiere/extensions/com.pype.avalon/node_modules/node-png/examples/test/out/.npmignore @@ -0,0 +1 @@ +*.png diff --git a/pype/premiere/extensions/com.pype.avalon/node_modules/node-png/examples/test/test.js b/pype/premiere/extensions/com.pype.avalon/node_modules/node-png/examples/test/test.js new file mode 100644 index 0000000000..1a9f6a1531 --- /dev/null +++ b/pype/premiere/extensions/com.pype.avalon/node_modules/node-png/examples/test/test.js @@ -0,0 +1,38 @@ + +var fs = require('fs'), + PNG = require('pngjs').PNG; + + +fs.readdir(__dirname + '/img/', function(err, files) { + if (err) throw err; + + files.forEach(function(file) { + + if (!file.match(/\.png$/i)) + return; + + fs.createReadStream(__dirname + '/img/' + file) + .pipe(new PNG()) + .on('parsed', function() { + + if (this.gamma) { + for (var y = 0; y < this.height; y++) { + for (var x = 0; x < this.width; x++) { + var idx = (this.width * y + x) << 2; + + for (var i = 0; i < 3; i++) { + var sample = this.data[idx + i] / 255; + sample = Math.pow(sample, 1 / 2.2 / this.gamma); + this.data[idx + i] = Math.round(sample * 255); + } + } + } + } + + this.pack() + .pipe(fs.createWriteStream(__dirname + '/out/' + file)); + + }); + + }); +}); diff --git a/pype/premiere/extensions/com.pype.avalon/node_modules/node-png/lib/chunkstream.js b/pype/premiere/extensions/com.pype.avalon/node_modules/node-png/lib/chunkstream.js new file mode 100644 index 0000000000..e57c1e7680 --- /dev/null +++ b/pype/premiere/extensions/com.pype.avalon/node_modules/node-png/lib/chunkstream.js @@ -0,0 +1,200 @@ +// Copyright (c) 2012 Kuba Niegowski +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +'use strict'; + + +var util = require('util'), + Stream = require('stream'); + + +var ChunkStream = module.exports = function() { + Stream.call(this); + + this._buffers = []; + this._buffered = 0; + + this._reads = []; + this._paused = false; + + this._encoding = 'utf8'; + this.writable = true; +}; +util.inherits(ChunkStream, Stream); + + +ChunkStream.prototype.read = function(length, callback) { + + this._reads.push({ + length: Math.abs(length), // if length < 0 then at most this length + allowLess: length < 0, + func: callback + }); + + process.nextTick(function() { + this._process(); + + // its paused and there is not enought data then ask for more + if (this._paused && this._reads.length > 0) { + this._paused = false; + + this.emit('drain'); + } + }.bind(this)); +}; + +ChunkStream.prototype.write = function(data, encoding) { + + if (!this.writable) { + this.emit('error', new Error('Stream not writable')); + return false; + } + + if (!Buffer.isBuffer(data)) + data = new Buffer(data, encoding || this._encoding); + + this._buffers.push(data); + this._buffered += data.length; + + this._process(); + + // ok if there are no more read requests + if (this._reads && this._reads.length == 0) + this._paused = true; + + return this.writable && !this._paused; +}; + +ChunkStream.prototype.end = function(data, encoding) { + + if (data) this.write(data, encoding); + + this.writable = false; + + // already destroyed + if (!this._buffers) return; + + // enqueue or handle end + if (this._buffers.length == 0) { + this._end(); + } else { + this._buffers.push(null); + this._process(); + } +}; + +ChunkStream.prototype.destroySoon = ChunkStream.prototype.end; + +ChunkStream.prototype._end = function() { + + if (this._reads.length > 0) { + this.emit('error', + new Error('There are some read requests waitng on finished stream') + ); + } + + this.destroy(); +}; + +ChunkStream.prototype.destroy = function() { + + if (!this._buffers) return; + + this.writable = false; + this._reads = null; + this._buffers = null; + + this.emit('close'); +}; + +ChunkStream.prototype._process = function() { + + // as long as there is any data and read requests + while (this._buffered > 0 && this._reads && this._reads.length > 0) { + + var read = this._reads[0]; + + // read any data (but no more than length) + if (read.allowLess) { + + // ok there is any data so that we can satisfy this request + this._reads.shift(); // == read + + // first we need to peek into first buffer + var buf = this._buffers[0]; + + // ok there is more data than we need + if (buf.length > read.length) { + + this._buffered -= read.length; + this._buffers[0] = buf.slice(read.length); + + read.func.call(this, buf.slice(0, read.length)); + + } else { + // ok this is less than maximum length so use it all + this._buffered -= buf.length; + this._buffers.shift(); // == buf + + read.func.call(this, buf); + } + + } else if (this._buffered >= read.length) { + // ok we can meet some expectations + + this._reads.shift(); // == read + + var pos = 0, + count = 0, + data = new Buffer(read.length); + + // create buffer for all data + while (pos < read.length) { + + var buf = this._buffers[count++], + len = Math.min(buf.length, read.length - pos); + + buf.copy(data, pos, 0, len); + pos += len; + + // last buffer wasn't used all so just slice it and leave + if (len != buf.length) + this._buffers[--count] = buf.slice(len); + } + + // remove all used buffers + if (count > 0) + this._buffers.splice(0, count); + + this._buffered -= read.length; + + read.func.call(this, data); + + } else { + // not enought data to satisfy first request in queue + // so we need to wait for more + break; + } + } + + if (this._buffers && this._buffers.length > 0 && this._buffers[0] == null) { + this._end(); + } +}; diff --git a/pype/premiere/extensions/com.pype.avalon/node_modules/node-png/lib/constants.js b/pype/premiere/extensions/com.pype.avalon/node_modules/node-png/lib/constants.js new file mode 100644 index 0000000000..1e74b790a2 --- /dev/null +++ b/pype/premiere/extensions/com.pype.avalon/node_modules/node-png/lib/constants.js @@ -0,0 +1,38 @@ +// Copyright (c) 2012 Kuba Niegowski +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +'use strict'; + + +module.exports = { + + PNG_SIGNATURE: [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a], + + TYPE_IHDR: 0x49484452, + TYPE_IEND: 0x49454e44, + TYPE_IDAT: 0x49444154, + TYPE_PLTE: 0x504c5445, + TYPE_tRNS: 0x74524e53, + TYPE_gAMA: 0x67414d41, + + COLOR_PALETTE: 1, + COLOR_COLOR: 2, + COLOR_ALPHA: 4 +}; diff --git a/pype/premiere/extensions/com.pype.avalon/node_modules/node-png/lib/crc.js b/pype/premiere/extensions/com.pype.avalon/node_modules/node-png/lib/crc.js new file mode 100644 index 0000000000..a3ac042313 --- /dev/null +++ b/pype/premiere/extensions/com.pype.avalon/node_modules/node-png/lib/crc.js @@ -0,0 +1,79 @@ +// Copyright (c) 2012 Kuba Niegowski +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +'use strict'; + +var util = require('util'), + Stream = require('stream'); + + +var CrcStream = module.exports = function() { + Stream.call(this); + + this._crc = -1; + + this.writable = true; +}; +util.inherits(CrcStream, Stream); + + +CrcStream.prototype.write = function(data) { + + for (var i = 0; i < data.length; i++) { + this._crc = crcTable[(this._crc ^ data[i]) & 0xff] ^ (this._crc >>> 8); + } + return true; +}; + +CrcStream.prototype.end = function(data) { + if (data) this.write(data); + + this.emit('crc', this.crc32()); +}; + +CrcStream.prototype.crc32 = function() { + return this._crc ^ -1; +}; + + +CrcStream.crc32 = function(buf) { + + var crc = -1; + for (var i = 0; i < buf.length; i++) { + crc = crcTable[(crc ^ buf[i]) & 0xff] ^ (crc >>> 8); + } + return crc ^ -1; +}; + + + +var crcTable = []; + +for (var i = 0; i < 256; i++) { + var c = i; + for (var j = 0; j < 8; j++) { + if (c & 1) { + c = 0xedb88320 ^ (c >>> 1); + } else { + c = c >>> 1; + } + } + crcTable[i] = c; +} diff --git a/pype/premiere/extensions/com.pype.avalon/node_modules/node-png/lib/filter.js b/pype/premiere/extensions/com.pype.avalon/node_modules/node-png/lib/filter.js new file mode 100644 index 0000000000..fbe60d22cc --- /dev/null +++ b/pype/premiere/extensions/com.pype.avalon/node_modules/node-png/lib/filter.js @@ -0,0 +1,314 @@ +// Copyright (c) 2012 Kuba Niegowski +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +'use strict'; + +var util = require('util'), + zlib = require('zlib'), + ChunkStream = require('./chunkstream'); + + +var Filter = module.exports = function(width, height, Bpp, data, options) { + ChunkStream.call(this); + + this._width = width; + this._height = height; + this._Bpp = Bpp; + this._data = data; + this._options = options; + + this._line = 0; + + if (!('filterType' in options) || options.filterType == -1) { + options.filterType = [0, 1, 2, 3, 4]; + } else if (typeof options.filterType == 'number') { + options.filterType = [options.filterType]; + } + + this._filters = { + 0: this._filterNone.bind(this), + 1: this._filterSub.bind(this), + 2: this._filterUp.bind(this), + 3: this._filterAvg.bind(this), + 4: this._filterPaeth.bind(this) + }; + + this.read(this._width * Bpp + 1, this._reverseFilterLine.bind(this)); +}; +util.inherits(Filter, ChunkStream); + + +var pixelBppMap = { + 1: { // L + 0: 0, + 1: 0, + 2: 0, + 3: 0xff + }, + 2: { // LA + 0: 0, + 1: 0, + 2: 0, + 3: 1 + }, + 3: { // RGB + 0: 0, + 1: 1, + 2: 2, + 3: 0xff + }, + 4: { // RGBA + 0: 0, + 1: 1, + 2: 2, + 3: 3 + } +}; + +Filter.prototype._reverseFilterLine = function(rawData) { + + var pxData = this._data, + pxLineLength = this._width << 2, + pxRowPos = this._line * pxLineLength, + filter = rawData[0]; + + if (filter == 0) { + for (var x = 0; x < this._width; x++) { + var pxPos = pxRowPos + (x << 2), + rawPos = 1 + x * this._Bpp; + + for (var i = 0; i < 4; i++) { + var idx = pixelBppMap[this._Bpp][i]; + pxData[pxPos + i] = idx != 0xff ? rawData[rawPos + idx] : 0xff; + } + } + + } else if (filter == 1) { + for (var x = 0; x < this._width; x++) { + var pxPos = pxRowPos + (x << 2), + rawPos = 1 + x * this._Bpp; + + for (var i = 0; i < 4; i++) { + var idx = pixelBppMap[this._Bpp][i], + left = x > 0 ? pxData[pxPos + i - 4] : 0; + + pxData[pxPos + i] = idx != 0xff ? rawData[rawPos + idx] + left : 0xff; + } + } + + } else if (filter == 2) { + for (var x = 0; x < this._width; x++) { + var pxPos = pxRowPos + (x << 2), + rawPos = 1 + x * this._Bpp; + + for (var i = 0; i < 4; i++) { + var idx = pixelBppMap[this._Bpp][i], + up = this._line > 0 ? pxData[pxPos - pxLineLength + i] : 0; + + pxData[pxPos + i] = idx != 0xff ? rawData[rawPos + idx] + up : 0xff; + } + + } + + } else if (filter == 3) { + for (var x = 0; x < this._width; x++) { + var pxPos = pxRowPos + (x << 2), + rawPos = 1 + x * this._Bpp; + + for (var i = 0; i < 4; i++) { + var idx = pixelBppMap[this._Bpp][i], + left = x > 0 ? pxData[pxPos + i - 4] : 0, + up = this._line > 0 ? pxData[pxPos - pxLineLength + i] : 0, + add = Math.floor((left + up) / 2); + + pxData[pxPos + i] = idx != 0xff ? rawData[rawPos + idx] + add : 0xff; + } + + } + + } else if (filter == 4) { + for (var x = 0; x < this._width; x++) { + var pxPos = pxRowPos + (x << 2), + rawPos = 1 + x * this._Bpp; + + for (var i = 0; i < 4; i++) { + var idx = pixelBppMap[this._Bpp][i], + left = x > 0 ? pxData[pxPos + i - 4] : 0, + up = this._line > 0 ? pxData[pxPos - pxLineLength + i] : 0, + upLeft = x > 0 && this._line > 0 + ? pxData[pxPos - pxLineLength + i - 4] : 0, + add = PaethPredictor(left, up, upLeft); + + pxData[pxPos + i] = idx != 0xff ? rawData[rawPos + idx] + add : 0xff; + } + } + } + + + this._line++; + + if (this._line < this._height) + this.read(this._width * this._Bpp + 1, this._reverseFilterLine.bind(this)); + else + this.emit('complete', this._data, this._width, this._height); +}; + + + + +Filter.prototype.filter = function() { + + var pxData = this._data, + rawData = new Buffer(((this._width << 2) + 1) * this._height); + + for (var y = 0; y < this._height; y++) { + + // find best filter for this line (with lowest sum of values) + var filterTypes = this._options.filterType, + min = Infinity, + sel = 0; + + for (var i = 0; i < filterTypes.length; i++) { + var sum = this._filters[filterTypes[i]](pxData, y, null); + if (sum < min) { + sel = filterTypes[i]; + min = sum; + } + } + + this._filters[sel](pxData, y, rawData); + } + return rawData; +}; + +Filter.prototype._filterNone = function(pxData, y, rawData) { + + var pxRowLength = this._width << 2, + rawRowLength = pxRowLength + 1, + sum = 0; + + if (!rawData) { + for (var x = 0; x < pxRowLength; x++) + sum += Math.abs(pxData[y * pxRowLength + x]); + + } else { + rawData[y * rawRowLength] = 0; + pxData.copy(rawData, rawRowLength * y + 1, pxRowLength * y, pxRowLength * (y + 1)); + } + + return sum; +}; + +Filter.prototype._filterSub = function(pxData, y, rawData) { + + var pxRowLength = this._width << 2, + rawRowLength = pxRowLength + 1, + sum = 0; + + if (rawData) + rawData[y * rawRowLength] = 1; + + for (var x = 0; x < pxRowLength; x++) { + + var left = x >= 4 ? pxData[y * pxRowLength + x - 4] : 0, + val = pxData[y * pxRowLength + x] - left; + + if (!rawData) sum += Math.abs(val); + else rawData[y * rawRowLength + 1 + x] = val; + } + return sum; +}; + +Filter.prototype._filterUp = function(pxData, y, rawData) { + + var pxRowLength = this._width << 2, + rawRowLength = pxRowLength + 1, + sum = 0; + + if (rawData) + rawData[y * rawRowLength] = 2; + + for (var x = 0; x < pxRowLength; x++) { + + var up = y > 0 ? pxData[(y - 1) * pxRowLength + x] : 0, + val = pxData[y * pxRowLength + x] - up; + + if (!rawData) sum += Math.abs(val); + else rawData[y * rawRowLength + 1 + x] = val; + } + return sum; +}; + +Filter.prototype._filterAvg = function(pxData, y, rawData) { + + var pxRowLength = this._width << 2, + rawRowLength = pxRowLength + 1, + sum = 0; + + if (rawData) + rawData[y * rawRowLength] = 3; + + for (var x = 0; x < pxRowLength; x++) { + + var left = x >= 4 ? pxData[y * pxRowLength + x - 4] : 0, + up = y > 0 ? pxData[(y - 1) * pxRowLength + x] : 0, + val = pxData[y * pxRowLength + x] - ((left + up) >> 1); + + if (!rawData) sum += Math.abs(val); + else rawData[y * rawRowLength + 1 + x] = val; + } + return sum; +}; + +Filter.prototype._filterPaeth = function(pxData, y, rawData) { + + var pxRowLength = this._width << 2, + rawRowLength = pxRowLength + 1, + sum = 0; + + if (rawData) + rawData[y * rawRowLength] = 4; + + for (var x = 0; x < pxRowLength; x++) { + + var left = x >= 4 ? pxData[y * pxRowLength + x - 4] : 0, + up = y > 0 ? pxData[(y - 1) * pxRowLength + x] : 0, + upLeft = x >= 4 && y > 0 ? pxData[(y - 1) * pxRowLength + x - 4] : 0, + val = pxData[y * pxRowLength + x] - PaethPredictor(left, up, upLeft); + + if (!rawData) sum += Math.abs(val); + else rawData[y * rawRowLength + 1 + x] = val; + } + return sum; +}; + + + +var PaethPredictor = function(left, above, upLeft) { + + var p = left + above - upLeft, + pLeft = Math.abs(p - left), + pAbove = Math.abs(p - above), + pUpLeft = Math.abs(p - upLeft); + + if (pLeft <= pAbove && pLeft <= pUpLeft) return left; + else if (pAbove <= pUpLeft) return above; + else return upLeft; +}; diff --git a/pype/premiere/extensions/com.pype.avalon/node_modules/node-png/lib/packer.js b/pype/premiere/extensions/com.pype.avalon/node_modules/node-png/lib/packer.js new file mode 100644 index 0000000000..d069448f5e --- /dev/null +++ b/pype/premiere/extensions/com.pype.avalon/node_modules/node-png/lib/packer.js @@ -0,0 +1,110 @@ +// Copyright (c) 2012 Kuba Niegowski +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +'use strict'; + + +var util = require('util'), + Stream = require('stream'), + zlib = require('zlib'), + Filter = require('./filter'), + CrcStream = require('./crc'), + constants = require('./constants'); + + +var Packer = module.exports = function(options) { + Stream.call(this); + + this._options = options; + + options.deflateChunkSize = options.deflateChunkSize || 32 * 1024; + options.deflateLevel = options.deflateLevel || 9; + options.deflateStrategy = options.deflateStrategy || 3; + + this.readable = true; +}; +util.inherits(Packer, Stream); + + +Packer.prototype.pack = function(data, width, height) { + + // Signature + this.emit('data', new Buffer(constants.PNG_SIGNATURE)); + this.emit('data', this._packIHDR(width, height)); + + // filter pixel data + var filter = new Filter(width, height, 4, data, this._options); + var data = filter.filter(); + + // compress it + var deflate = zlib.createDeflate({ + chunkSize: this._options.deflateChunkSize, + level: this._options.deflateLevel, + strategy: this._options.deflateStrategy + }); + deflate.on('error', this.emit.bind(this, 'error')); + + deflate.on('data', function(data) { + this.emit('data', this._packIDAT(data)); + }.bind(this)); + + deflate.on('end', function() { + this.emit('data', this._packIEND()); + this.emit('end'); + }.bind(this)); + + deflate.end(data); +}; + +Packer.prototype._packChunk = function(type, data) { + + var len = (data ? data.length : 0), + buf = new Buffer(len + 12); + + buf.writeUInt32BE(len, 0); + buf.writeUInt32BE(type, 4); + + if (data) data.copy(buf, 8); + + buf.writeInt32BE(CrcStream.crc32(buf.slice(4, buf.length - 4)), buf.length - 4); + return buf; +}; + +Packer.prototype._packIHDR = function(width, height) { + + var buf = new Buffer(13); + buf.writeUInt32BE(width, 0); + buf.writeUInt32BE(height, 4); + buf[8] = 8; + buf[9] = 6; // colorType + buf[10] = 0; // compression + buf[11] = 0; // filter + buf[12] = 0; // interlace + + return this._packChunk(constants.TYPE_IHDR, buf); +}; + +Packer.prototype._packIDAT = function(data) { + return this._packChunk(constants.TYPE_IDAT, data); +}; + +Packer.prototype._packIEND = function() { + return this._packChunk(constants.TYPE_IEND, null); +}; diff --git a/pype/premiere/extensions/com.pype.avalon/node_modules/node-png/lib/parser.js b/pype/premiere/extensions/com.pype.avalon/node_modules/node-png/lib/parser.js new file mode 100644 index 0000000000..f4eef7b279 --- /dev/null +++ b/pype/premiere/extensions/com.pype.avalon/node_modules/node-png/lib/parser.js @@ -0,0 +1,359 @@ +// Copyright (c) 2012 Kuba Niegowski +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +'use strict'; + + +var util = require('util'), + zlib = require('zlib'), + CrcStream = require('./crc'), + ChunkStream = require('./chunkstream'), + constants = require('./constants'), + Filter = require('./filter'); + + +var Parser = module.exports = function(options) { + ChunkStream.call(this); + + this._options = options; + options.checkCRC = options.checkCRC !== false; + + this._hasIHDR = false; + this._hasIEND = false; + + this._inflate = null; + this._filter = null; + this._crc = null; + + // input flags/metadata + this._palette = []; + this._colorType = 0; + + this._chunks = {}; + this._chunks[constants.TYPE_IHDR] = this._handleIHDR.bind(this); + this._chunks[constants.TYPE_IEND] = this._handleIEND.bind(this); + this._chunks[constants.TYPE_IDAT] = this._handleIDAT.bind(this); + this._chunks[constants.TYPE_PLTE] = this._handlePLTE.bind(this); + this._chunks[constants.TYPE_tRNS] = this._handleTRNS.bind(this); + this._chunks[constants.TYPE_gAMA] = this._handleGAMA.bind(this); + + this.writable = true; + + this.on('error', this._handleError.bind(this)); + this._handleSignature(); +}; +util.inherits(Parser, ChunkStream); + + +Parser.prototype._handleError = function() { + + this.writable = false; + + this.destroy(); + + if (this._inflate) + this._inflate.destroy(); +}; + +Parser.prototype._handleSignature = function() { + this.read(constants.PNG_SIGNATURE.length, + this._parseSignature.bind(this) + ); +}; + +Parser.prototype._parseSignature = function(data) { + + var signature = constants.PNG_SIGNATURE; + + for (var i = 0; i < signature.length; i++) { + if (data[i] != signature[i]) { + this.emit('error', new Error('Invalid file signature')); + return; + } + } + this.read(8, this._parseChunkBegin.bind(this)); +}; + +Parser.prototype._parseChunkBegin = function(data) { + + // chunk content length + var length = data.readUInt32BE(0); + + // chunk type + var type = data.readUInt32BE(4), + name = ''; + for (var i = 4; i < 8; i++) + name += String.fromCharCode(data[i]); + + // console.log('chunk ', name, length); + + // chunk flags + var ancillary = !!(data[4] & 0x20), // or critical + priv = !!(data[5] & 0x20), // or public + safeToCopy = !!(data[7] & 0x20); // or unsafe + + if (!this._hasIHDR && type != constants.TYPE_IHDR) { + this.emit('error', new Error('Expected IHDR on beggining')); + return; + } + + this._crc = new CrcStream(); + this._crc.write(new Buffer(name)); + + if (this._chunks[type]) { + return this._chunks[type](length); + + } else if (!ancillary) { + this.emit('error', new Error('Unsupported critical chunk type ' + name)); + return; + } else { + this.read(length + 4, this._skipChunk.bind(this)); + } +}; + +Parser.prototype._skipChunk = function(data) { + this.read(8, this._parseChunkBegin.bind(this)); +}; + +Parser.prototype._handleChunkEnd = function() { + this.read(4, this._parseChunkEnd.bind(this)); +}; + +Parser.prototype._parseChunkEnd = function(data) { + + var fileCrc = data.readInt32BE(0), + calcCrc = this._crc.crc32(); + + // check CRC + if (this._options.checkCRC && calcCrc != fileCrc) { + this.emit('error', new Error('Crc error')); + return; + } + + if (this._hasIEND) { + this.destroySoon(); + + } else { + this.read(8, this._parseChunkBegin.bind(this)); + } +}; + + +Parser.prototype._handleIHDR = function(length) { + this.read(length, this._parseIHDR.bind(this)); +}; +Parser.prototype._parseIHDR = function(data) { + + this._crc.write(data); + + var width = data.readUInt32BE(0), + height = data.readUInt32BE(4), + depth = data[8], + colorType = data[9], // bits: 1 palette, 2 color, 4 alpha + compr = data[10], + filter = data[11], + interlace = data[12]; + + // console.log(' width', width, 'height', height, + // 'depth', depth, 'colorType', colorType, + // 'compr', compr, 'filter', filter, 'interlace', interlace + // ); + + if (depth != 8) { + this.emit('error', new Error('Unsupported bit depth ' + depth)); + return; + } + if (!(colorType in colorTypeToBppMap)) { + this.emit('error', new Error('Unsupported color type')); + return; + } + if (compr != 0) { + this.emit('error', new Error('Unsupported compression method')); + return; + } + if (filter != 0) { + this.emit('error', new Error('Unsupported filter method')); + return; + } + if (interlace != 0) { + this.emit('error', new Error('Unsupported interlace method')); + return; + } + + this._colorType = colorType; + + this._data = new Buffer(width * height * 4); + this._filter = new Filter( + width, height, + colorTypeToBppMap[this._colorType], + this._data, + this._options + ); + + this._hasIHDR = true; + + this.emit('metadata', { + width: width, + height: height, + palette: !!(colorType & constants.COLOR_PALETTE), + color: !!(colorType & constants.COLOR_COLOR), + alpha: !!(colorType & constants.COLOR_ALPHA), + data: this._data + }); + + this._handleChunkEnd(); +}; + + +Parser.prototype._handlePLTE = function(length) { + this.read(length, this._parsePLTE.bind(this)); +}; +Parser.prototype._parsePLTE = function(data) { + + this._crc.write(data); + + var entries = Math.floor(data.length / 3); + // console.log('Palette:', entries); + + for (var i = 0; i < entries; i++) { + this._palette.push([ + data.readUInt8(i * 3), + data.readUInt8(i * 3 + 1), + data.readUInt8(i * 3 + 2 ), + 0xff + ]); + } + + this._handleChunkEnd(); +}; + +Parser.prototype._handleTRNS = function(length) { + this.read(length, this._parseTRNS.bind(this)); +}; +Parser.prototype._parseTRNS = function(data) { + + this._crc.write(data); + + // palette + if (this._colorType == 3) { + if (this._palette.length == 0) { + this.emit('error', new Error('Transparency chunk must be after palette')); + return; + } + if (data.length > this._palette.length) { + this.emit('error', new Error('More transparent colors than palette size')); + return; + } + for (var i = 0; i < this._palette.length; i++) { + this._palette[i][3] = i < data.length ? data.readUInt8(i) : 0xff; + } + } + + // for colorType 0 (grayscale) and 2 (rgb) + // there might be one gray/color defined as transparent + + this._handleChunkEnd(); +}; + +Parser.prototype._handleGAMA = function(length) { + this.read(length, this._parseGAMA.bind(this)); +}; +Parser.prototype._parseGAMA = function(data) { + + this._crc.write(data); + this.emit('gamma', data.readUInt32BE(0) / 100000); + + this._handleChunkEnd(); +}; + +Parser.prototype._handleIDAT = function(length) { + this.read(-length, this._parseIDAT.bind(this, length)); +}; +Parser.prototype._parseIDAT = function(length, data) { + + this._crc.write(data); + + if (this._colorType == 3 && this._palette.length == 0) + throw new Error('Expected palette not found'); + + if (!this._inflate) { + this._inflate = zlib.createInflate(); + + this._inflate.on('error', this.emit.bind(this, 'error')); + this._filter.on('complete', this._reverseFiltered.bind(this)); + + this._inflate.pipe(this._filter); + } + + this._inflate.write(data); + length -= data.length; + + if (length > 0) + this._handleIDAT(length); + else + this._handleChunkEnd(); +}; + + +Parser.prototype._handleIEND = function(length) { + this.read(length, this._parseIEND.bind(this)); +}; +Parser.prototype._parseIEND = function(data) { + + this._crc.write(data); + + // no more data to inflate + this._inflate.end(); + + this._hasIEND = true; + this._handleChunkEnd(); +}; + + +var colorTypeToBppMap = { + 0: 1, + 2: 3, + 3: 1, + 4: 2, + 6: 4 +}; + +Parser.prototype._reverseFiltered = function(data, width, height) { + + if (this._colorType == 3) { // paletted + + // use values from palette + var pxLineLength = width << 2; + + for (var y = 0; y < height; y++) { + var pxRowPos = y * pxLineLength; + + for (var x = 0; x < width; x++) { + var pxPos = pxRowPos + (x << 2), + color = this._palette[data[pxPos]]; + + for (var i = 0; i < 4; i++) + data[pxPos + i] = color[i]; + } + } + } + + this.emit('parsed', data); +}; diff --git a/pype/premiere/extensions/com.pype.avalon/node_modules/node-png/lib/png.js b/pype/premiere/extensions/com.pype.avalon/node_modules/node-png/lib/png.js new file mode 100644 index 0000000000..c2c56c9fbd --- /dev/null +++ b/pype/premiere/extensions/com.pype.avalon/node_modules/node-png/lib/png.js @@ -0,0 +1,149 @@ +// Copyright (c) 2012 Kuba Niegowski +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +'use strict'; + + +var util = require('util'), + Stream = require('stream'), + Parser = require('./parser'), + Packer = require('./packer'); + + +var PNG = exports.PNG = function(options) { + Stream.call(this); + + options = options || {}; + + this.width = options.width || 0; + this.height = options.height || 0; + + this.data = this.width > 0 && this.height > 0 + ? new Buffer(4 * this.width * this.height) : null; + + if(options.fill && this.data){this.data.fill(0)}; + + this.gamma = 0; + this.readable = this.writable = true; + + this._parser = new Parser(options || {}); + + this._parser.on('error', this.emit.bind(this, 'error')); + this._parser.on('close', this._handleClose.bind(this)); + this._parser.on('metadata', this._metadata.bind(this)); + this._parser.on('gamma', this._gamma.bind(this)); + this._parser.on('parsed', function(data) { + this.data = data; + this.emit('parsed', data); + }.bind(this)); + + this._packer = new Packer(options); + this._packer.on('data', this.emit.bind(this, 'data')); + this._packer.on('end', this.emit.bind(this, 'end')); + this._parser.on('close', this._handleClose.bind(this)); + this._packer.on('error', this.emit.bind(this, 'error')); + +}; +util.inherits(PNG, Stream); + + +PNG.prototype.pack = function() { + + process.nextTick(function() { + this._packer.pack(this.data, this.width, this.height); + }.bind(this)); + + return this; +}; + + +PNG.prototype.parse = function(data, callback) { + + if (callback) { + var onParsed = null, onError = null; + + this.once('parsed', onParsed = function(data) { + this.removeListener('error', onError); + + this.data = data; + callback(null, this); + + }.bind(this)); + + this.once('error', onError = function(err) { + this.removeListener('parsed', onParsed); + + callback(err, null); + }.bind(this)); + } + + this.end(data); + return this; +}; + +PNG.prototype.write = function(data) { + this._parser.write(data); + return true; +}; + +PNG.prototype.end = function(data) { + this._parser.end(data); +}; + +PNG.prototype._metadata = function(metadata) { + this.width = metadata.width; + this.height = metadata.height; + this.data = metadata.data; + + delete metadata.data; + this.emit('metadata', metadata); +}; + +PNG.prototype._gamma = function(gamma) { + this.gamma = gamma; +}; + +PNG.prototype._handleClose = function() { + if (!this._parser.writable && !this._packer.readable) + this.emit('close'); +}; + + +PNG.prototype.bitblt = function(dst, sx, sy, w, h, dx, dy) { + + var src = this; + + if (sx > src.width || sy > src.height + || sx + w > src.width || sy + h > src.height) + throw new Error('bitblt reading outside image'); + if (dx > dst.width || dy > dst.height + || dx + w > dst.width || dy + h > dst.height) + throw new Error('bitblt writing outside image'); + + for (var y = 0; y < h; y++) { + src.data.copy(dst.data, + ((dy + y) * dst.width + dx) << 2, + ((sy + y) * src.width + sx) << 2, + ((sy + y) * src.width + sx + w) << 2 + ); + } + + return this; +}; diff --git a/pype/premiere/extensions/com.pype.avalon/node_modules/node-png/package.json b/pype/premiere/extensions/com.pype.avalon/node_modules/node-png/package.json new file mode 100644 index 0000000000..c359bea33c --- /dev/null +++ b/pype/premiere/extensions/com.pype.avalon/node_modules/node-png/package.json @@ -0,0 +1,59 @@ +{ + "_args": [ + [ + "node-png@0.4.3", + "/private/var/lib/jenkins/workspace/iconik_panel/src" + ] + ], + "_from": "node-png@0.4.3", + "_id": "node-png@0.4.3", + "_inBundle": false, + "_integrity": "sha1-RQIjeWuC08yg/+Sl1cf6l0hZdOc=", + "_location": "/node-png", + "_phantomChildren": {}, + "_requested": { + "type": "version", + "registry": true, + "raw": "node-png@0.4.3", + "name": "node-png", + "escapedName": "node-png", + "rawSpec": "0.4.3", + "saveSpec": null, + "fetchSpec": "0.4.3" + }, + "_requiredBy": [ + "/imagejs" + ], + "_resolved": "https://registry.npmjs.org/node-png/-/node-png-0.4.3.tgz", + "_spec": "0.4.3", + "_where": "/private/var/lib/jenkins/workspace/iconik_panel/src", + "author": { + "name": "Kuba Niegowski" + }, + "bugs": { + "url": "https://github.com/brighthas/node-pngjs/issues" + }, + "contributors": [], + "description": "Simple PNG encoder/decoder", + "directories": { + "example": "examples" + }, + "engines": { + "node": "0.8.x" + }, + "homepage": "https://github.com/niegowski/node-pngjs/", + "keywords": [ + "png" + ], + "license": "MIT", + "main": "./lib/png.js", + "name": "node-png", + "repository": { + "type": "git", + "url": "git://github.com/brighthas/node-pngjs.git" + }, + "scripts": { + "test": "echo \"Error: no test specified\" && exit 1" + }, + "version": "0.4.3" +} diff --git a/pype/premiere/extensions/com.pype.avalon/node_modules/open/.jshintignore b/pype/premiere/extensions/com.pype.avalon/node_modules/open/.jshintignore new file mode 100644 index 0000000000..651665bbd9 --- /dev/null +++ b/pype/premiere/extensions/com.pype.avalon/node_modules/open/.jshintignore @@ -0,0 +1,2 @@ +node_modules +.git diff --git a/pype/premiere/extensions/com.pype.avalon/node_modules/open/.jshintrc b/pype/premiere/extensions/com.pype.avalon/node_modules/open/.jshintrc new file mode 100644 index 0000000000..765fb34a1e --- /dev/null +++ b/pype/premiere/extensions/com.pype.avalon/node_modules/open/.jshintrc @@ -0,0 +1,27 @@ +{ + "bitwise": true, + "curly": true, + "eqeqeq": true, + "forin": true, + "immed": true, + "latedef": false, + "newcap": true, + "noarg": true, + "noempty": false, + "nonew": true, + "plusplus": false, + "regexp": false, + "undef": true, + "strict": false, + "trailing": true, + + "eqnull": true, + "laxcomma": true, + + "node": true, + + "onevar": true, + "white": true, + + "indent": 2 +} diff --git a/pype/premiere/extensions/com.pype.avalon/node_modules/open/.npmignore b/pype/premiere/extensions/com.pype.avalon/node_modules/open/.npmignore new file mode 100644 index 0000000000..9daeafb986 --- /dev/null +++ b/pype/premiere/extensions/com.pype.avalon/node_modules/open/.npmignore @@ -0,0 +1 @@ +test diff --git a/pype/premiere/extensions/com.pype.avalon/node_modules/open/LICENSE b/pype/premiere/extensions/com.pype.avalon/node_modules/open/LICENSE new file mode 100644 index 0000000000..58b5cd2414 --- /dev/null +++ b/pype/premiere/extensions/com.pype.avalon/node_modules/open/LICENSE @@ -0,0 +1,22 @@ +Copyright (c) 2012 Jay Jordan + +Permission is hereby granted, free of charge, to any person +obtaining a copy of this software and associated documentation +files (the "Software"), to deal in the Software without +restriction, including without limitation the rights to use, +copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the +Software is furnished to do so, subject to the following +conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +OTHER DEALINGS IN THE SOFTWARE. diff --git a/pype/premiere/extensions/com.pype.avalon/node_modules/open/README.md b/pype/premiere/extensions/com.pype.avalon/node_modules/open/README.md new file mode 100644 index 0000000000..4fc0d54ece --- /dev/null +++ b/pype/premiere/extensions/com.pype.avalon/node_modules/open/README.md @@ -0,0 +1,33 @@ +# open + +Open a file or url in the user's preferred application. + +# Usage + +```javascript +var open = require("open"); +open("http://www.google.com"); +``` + +`open` taks an optional argument specifying the program to be used to open the +file or URL. + +```javascript +open("http://www.google.com", "firefox"); +``` + +# Installation + + npm install open + +# How it works + +- on `win32` uses `start` +- on `darwin` uses `open` +- otherwise uses the `xdg-open` script from [freedesktop.org](http://portland.freedesktop.org/xdg-utils-1.0/xdg-open.html) + +# Warning + +The same care should be taken when calling open as if you were calling +[child_process.exec](http://nodejs.org/api/child_process.html#child_process_child_process_exec_command_options_callback) +directly. If it is an executable it will run in a new shell. diff --git a/pype/premiere/extensions/com.pype.avalon/node_modules/open/lib/open.js b/pype/premiere/extensions/com.pype.avalon/node_modules/open/lib/open.js new file mode 100644 index 0000000000..667bc175d7 --- /dev/null +++ b/pype/premiere/extensions/com.pype.avalon/node_modules/open/lib/open.js @@ -0,0 +1,63 @@ +var exec = require('child_process').exec + , path = require('path') + ; + + +/** + * open a file or uri using the default application for the file type. + * + * @return {ChildProcess} - the child process object. + * @param {string} target - the file/uri to open. + * @param {string} appName - (optional) the application to be used to open the + * file (for example, "chrome", "firefox") + * @param {function(Error)} callback - called with null on success, or + * an error object that contains a property 'code' with the exit + * code of the process. + */ + +module.exports = open; + +function open(target, appName, callback) { + var opener; + + if (typeof(appName) === 'function') { + callback = appName; + appName = null; + } + + switch (process.platform) { + case 'darwin': + if (appName) { + opener = 'open -a "' + escape(appName) + '"'; + } else { + opener = 'open'; + } + break; + case 'win32': + // if the first parameter to start is quoted, it uses that as the title + // so we pass a blank title so we can quote the file we are opening + if (appName) { + opener = 'start "" "' + escape(appName) + '"'; + } else { + opener = 'start ""'; + } + break; + default: + if (appName) { + opener = escape(appName); + } else { + // use Portlands xdg-open everywhere else + opener = path.join(__dirname, '../vendor/xdg-open'); + } + break; + } + + if (process.env.SUDO_USER) { + opener = 'sudo -u ' + process.env.SUDO_USER + ' ' + opener; + } + return exec(opener + ' "' + escape(target) + '"', callback); +} + +function escape(s) { + return s.replace(/"/g, '\\\"'); +} diff --git a/pype/premiere/extensions/com.pype.avalon/node_modules/open/package.json b/pype/premiere/extensions/com.pype.avalon/node_modules/open/package.json new file mode 100644 index 0000000000..9dec20a1ea --- /dev/null +++ b/pype/premiere/extensions/com.pype.avalon/node_modules/open/package.json @@ -0,0 +1,101 @@ +{ + "_args": [ + [ + { + "raw": "open", + "scope": null, + "escapedName": "open", + "name": "open", + "rawSpec": "", + "spec": "latest", + "type": "tag" + }, + "/Library/Application Support/Adobe/CEP/extensions/aeft/node_modules" + ] + ], + "_from": "open@latest", + "_id": "open@0.0.5", + "_inCache": true, + "_location": "/open", + "_npmUser": { + "name": "pwnall", + "email": "costan@gmail.com" + }, + "_npmVersion": "1.4.3", + "_phantomChildren": {}, + "_requested": { + "raw": "open", + "scope": null, + "escapedName": "open", + "name": "open", + "rawSpec": "", + "spec": "latest", + "type": "tag" + }, + "_requiredBy": [ + "#USER" + ], + "_resolved": "https://registry.npmjs.org/open/-/open-0.0.5.tgz", + "_shasum": "42c3e18ec95466b6bf0dc42f3a2945c3f0cad8fc", + "_shrinkwrap": null, + "_spec": "open", + "_where": "/Library/Application Support/Adobe/CEP/extensions/aeft/node_modules", + "author": { + "name": "J Jordan", + "email": "jjrdn@styosis.com" + }, + "bugs": { + "url": "https://github.com/pwnall/node-open/issues" + }, + "contributors": [ + { + "name": "Victor Costan", + "email": "victor@costan.us", + "url": "http://www.costan.us" + } + ], + "dependencies": {}, + "description": "open a file or url in the user's preferred application", + "devDependencies": { + "mocha": "*" + }, + "directories": {}, + "dist": { + "shasum": "42c3e18ec95466b6bf0dc42f3a2945c3f0cad8fc", + "tarball": "https://registry.npmjs.org/open/-/open-0.0.5.tgz" + }, + "engines": { + "node": ">= 0.6.0" + }, + "homepage": "https://github.com/jjrdn/node-open", + "keywords": [ + "start", + "open", + "browser", + "editor", + "default" + ], + "license": "MIT", + "main": "lib/open.js", + "maintainers": [ + { + "name": "jjrdn", + "email": "jjrdn@styosis.com" + }, + { + "name": "pwnall", + "email": "costan@gmail.com" + } + ], + "name": "open", + "optionalDependencies": {}, + "readme": "ERROR: No README data found!", + "repository": { + "type": "git", + "url": "git+https://github.com/pwnall/node-open.git" + }, + "scripts": { + "test": "node_modules/mocha/bin/mocha" + }, + "version": "0.0.5" +} diff --git a/pype/premiere/extensions/com.pype.avalon/node_modules/open/vendor/xdg-open b/pype/premiere/extensions/com.pype.avalon/node_modules/open/vendor/xdg-open new file mode 100644 index 0000000000..13caac1a43 --- /dev/null +++ b/pype/premiere/extensions/com.pype.avalon/node_modules/open/vendor/xdg-open @@ -0,0 +1,767 @@ +#!/bin/sh +#--------------------------------------------- +# xdg-open +# +# Utility script to open a URL in the registered default application. +# +# Refer to the usage() function below for usage. +# +# Copyright 2009-2010, Fathi Boudra
[uninitialized]
+[uninitialized]
+[uninitialized]
+Proxies enabled for sequence:
+ +
+
+ New in 13.0!
+
+
+ +
+
+ + + + + + + + + + + + +
+
+
+ >>', 'Sequence Naming Prompt');
+ app.project.createNewSequence(seqName, someID);
+ },
+
+ createSequenceFromPreset : function(presetPath) {
+ app.enableQE();
+ var seqName = prompt('Name of sequence?', '<<>>', 'Sequence Naming Prompt');
+ if (seqName) {
+ qe.project.newSequence(seqName, presetPath);
+ }
+ },
+
+ transcode : function(outputPresetPath) {
+ app.encoder.bind('onEncoderJobComplete', $._PPP_.onEncoderJobComplete);
+ app.encoder.bind('onEncoderJobError', $._PPP_.onEncoderJobError);
+ app.encoder.bind('onEncoderJobProgress', $._PPP_.onEncoderJobProgress);
+ app.encoder.bind('onEncoderJobQueued', $._PPP_.onEncoderJobQueued);
+ app.encoder.bind('onEncoderJobCanceled', $._PPP_.onEncoderJobCanceled);
+
+ var projRoot = app.project.rootItem.children;
+
+ if (projRoot.numItems){
+ var firstProjectItem = app.project.rootItem.children[0];
+ if (firstProjectItem){
+
+ app.encoder.launchEncoder(); // This can take a while; let's get the ball rolling.
+
+ var fileOutputPath = Folder.selectDialog("Choose the output directory");
+ if (fileOutputPath){
+ var outputName = firstProjectItem.name.search('[.]');
+ if (outputName == -1){
+ outputName = firstProjectItem.name.length;
+ }
+ outFileName = firstProjectItem.name.substr(0, outputName);
+ outFileName = outFileName.replace('/', '-');
+ var completeOutputPath = fileOutputPath.fsName + $._PPP_.getSep() + outFileName + '.mxf';
+ var removeFromQueue = true;
+ var rangeToEncode = app.encoder.ENCODE_IN_TO_OUT;
+ app.encoder.encodeProjectItem( firstProjectItem,
+ completeOutputPath,
+ outputPresetPath,
+ rangeToEncode,
+ removeFromQueue);
+ app.encoder.startBatch();
+ }
+ } else {
+ $._PPP_.updateEventPanel("No project items found.");
+ }
+ } else {
+ $._PPP_.updateEventPanel("Project is empty.");
+ }
+ },
+
+ transcodeExternal : function (outputPresetPath){
+ app.encoder.launchEncoder();
+ var filterString = "";
+ if (Folder.fs === 'Windows'){
+ filterString = "All files:*.*";
+ }
+ var fileToTranscode = File.openDialog ( "Choose file to open.",
+ filterString,
+ false);
+ if (fileToTranscode) {
+ var fileOutputPath = Folder.selectDialog("Choose the output directory");
+ if (fileOutputPath){
+
+ var srcInPoint = 1.0; // encode start time at 1s (optional--if omitted, encode entire file)
+ var srcOutPoint = 3.0; // encode stop time at 3s (optional--if omitted, encode entire file)
+ var removeFromQueue = false;
+
+ var result = app.encoder.encodeFile(fileToTranscode.fsName,
+ fileOutputPath.fsName,
+ outputPresetPath,
+ removeFromQueue,
+ srcInPoint,
+ srcOutPoint);
+ }
+ }
+ },
+
+ render : function(outputPresetPath) {
+ app.enableQE();
+ var activeSequence = qe.project.getActiveSequence(); // we use a QE DOM function, to determine the output extension.
+ if (activeSequence) {
+ app.encoder.launchEncoder(); // This can take a while; let's get the ball rolling.
+
+ var timeSecs = activeSequence.CTI.secs; // Just for reference, here's how to access the CTI
+ var timeFrames = activeSequence.CTI.frames; // (Current Time Indicator), for the active sequence.
+ var timeTicks = activeSequence.CTI.ticks;
+ var timeString = activeSequence.CTI.timecode;
+
+ var seqInPoint = app.project.activeSequence.getInPoint(); // new in 9.0
+ var seqOutPoint = app.project.activeSequence.getOutPoint(); // new in 9.0
+
+ var seqInPointAsTime = app.project.activeSequence.getInPointAsTime(); // new in 12.0
+ var seqOutPointAsTime = app.project.activeSequence.getOutPointAsTime(); // new in 12.0
+
+ var projPath = new File(app.project.path);
+ var outputPath = Folder.selectDialog("Choose the output directory");
+
+ if ((outputPath) && projPath.exists){
+ var outPreset = new File(outputPresetPath);
+ if (outPreset.exists === true){
+ var outputFormatExtension = activeSequence.getExportFileExtension(outPreset.fsName);
+ if (outputFormatExtension){
+ var outputFilename = activeSequence.name + '.' + outputFormatExtension;
+
+ var fullPathToFile = outputPath.fsName +
+ $._PPP_.getSep() +
+ activeSequence.name +
+ "." +
+ outputFormatExtension;
+
+ var outFileTest = new File(fullPathToFile);
+
+ if (outFileTest.exists){
+ var destroyExisting = confirm("A file with that name already exists; overwrite?", false, "Are you sure...?");
+ if (destroyExisting){
+ outFileTest.remove();
+ outFileTest.close();
+ }
+ }
+
+ app.encoder.bind('onEncoderJobComplete', $._PPP_.onEncoderJobComplete);
+ app.encoder.bind('onEncoderJobError', $._PPP_.onEncoderJobError);
+ app.encoder.bind('onEncoderJobProgress', $._PPP_.onEncoderJobProgress);
+ app.encoder.bind('onEncoderJobQueued', $._PPP_.onEncoderJobQueued);
+ app.encoder.bind('onEncoderJobCanceled', $._PPP_.onEncoderJobCanceled);
+
+
+ // use these 0 or 1 settings to disable some/all metadata creation.
+
+ app.encoder.setSidecarXMPEnabled(0);
+ app.encoder.setEmbeddedXMPEnabled(0);
+
+ /*
+
+ For reference, here's how to export from within PPro (blocking further user interaction).
+
+ var seq = app.project.activeSequence;
+
+ if (seq) {
+ seq.exportAsMediaDirect(fullPathToFile,
+ outPreset.fsName,
+ app.encoder.ENCODE_WORKAREA);
+
+ Bonus: Here's how to compute a sequence's duration, in ticks. 254016000000 ticks/second.
+ var sequenceDuration = app.project.activeSequence.end - app.project.activeSequence.zeroPoint;
+ }
+
+ */
+
+ var jobID = app.encoder.encodeSequence( app.project.activeSequence,
+ fullPathToFile,
+ outPreset.fsName,
+ app.encoder.ENCODE_WORKAREA,
+ 1); // Remove from queue upon successful completion?
+ $._PPP_.updateEventPanel('jobID = ' + jobID);
+ outPreset.close();
+ }
+ } else {
+ $._PPP_.updateEventPanel("Could not find output preset.");
+ }
+ } else {
+ $._PPP_.updateEventPanel("Could not find/create output path.");
+ }
+ projPath.close();
+ } else {
+ $._PPP_.updateEventPanel("No active sequence.");
+ }
+ },
+
+ saveProjectCopy : function() {
+ var sessionCounter = 1;
+ var originalPath = app.project.path;
+ var outputPath = Folder.selectDialog("Choose the output directory");
+
+ if (outputPath) {
+ var absPath = outputPath.fsName;
+ var outputName = String(app.project.name);
+ var array = outputName.split('.', 2);
+
+ outputName = array[0]+ sessionCounter + '.' + array[1];
+ sessionCounter++;
+
+ var fullOutPath = absPath + $._PPP_.getSep() + outputName;
+
+ app.project.saveAs(fullOutPath);
+
+ for (var a = 0; a < app.projects.numProjects; a++){
+ var currentProject = app.projects[a];
+ if (currentProject.path === fullOutPath){
+ app.openDocument(originalPath); // Why first? So we don't frighten the user by making PPro's window disappear. :)
+ currentProject.closeDocument();
+ }
+ }
+ } else {
+ $._PPP_.updateEventPanel("No output path chosen.");
+ }
+ },
+
+ mungeXMP : function(){
+ var projectItem = app.project.rootItem.children[0]; // assumes first item is footage.
+ if (projectItem) {
+ if (ExternalObject.AdobeXMPScript === undefined) {
+ ExternalObject.AdobeXMPScript = new ExternalObject('lib:AdobeXMPScript');
+ }
+ if (ExternalObject.AdobeXMPScript !== undefined) { // safety-conscious!
+
+ var xmpBlob = projectItem.getXMPMetadata();
+ var xmp = new XMPMeta(xmpBlob);
+ var oldSceneVal = "";
+ var oldDMCreatorVal = "";
+
+ if (xmp.doesPropertyExist(XMPConst.NS_DM, "scene") === true){
+ var myScene = xmp.getProperty(XMPConst.NS_DM, "scene");
+ oldSceneVal = myScene.value;
+ }
+
+ if (xmp.doesPropertyExist(XMPConst.NS_DM, "creator") === true){
+ var myCreator = xmp.getProperty(XMPConst.NS_DM, "creator");
+ oldCreatorVal = myCreator.value;
+ }
+
+ // Regardless of whether there WAS scene or creator data, set scene and creator data.
+
+ xmp.setProperty(XMPConst.NS_DM, "scene", oldSceneVal + " Added by PProPanel sample!");
+ xmp.setProperty(XMPConst.NS_DM, "creator", oldDMCreatorVal + " Added by PProPanel sample!");
+
+ // That was the NS_DM creator; here's the NS_DC creator.
+
+ var creatorProp = "creator";
+ var containsDMCreatorValue = xmp.doesPropertyExist(XMPConst.NS_DC, creatorProp);
+ var numCreatorValuesPresent = xmp.countArrayItems(XMPConst.NS_DC, creatorProp);
+ var CreatorsSeparatedBy4PoundSigns = "";
+
+ if(numCreatorValuesPresent > 0) {
+ for (var z = 0; z < numCreatorValuesPresent; z++){
+ CreatorsSeparatedBy4PoundSigns = CreatorsSeparatedBy4PoundSigns + xmp.getArrayItem(XMPConst.NS_DC, creatorProp, z + 1);
+ CreatorsSeparatedBy4PoundSigns = CreatorsSeparatedBy4PoundSigns + "####";
+ }
+ $._PPP_.updateEventPanel(CreatorsSeparatedBy4PoundSigns);
+
+ if (confirm("Replace previous?", false, "Replace existing Creator?")) {
+ xmp.deleteProperty(XMPConst.NS_DC, "creator");
+ }
+ xmp.appendArrayItem(XMPConst.NS_DC, // If no values exist, appendArrayItem will create a value.
+ creatorProp,
+ numCreatorValuesPresent + " creator values were already present.",
+ null,
+ XMPConst.ARRAY_IS_ORDERED);
+
+ } else {
+
+ xmp.appendArrayItem(XMPConst.NS_DC,
+ creatorProp,
+ "PProPanel wrote the first value into NS_DC creator field.",
+ null,
+ XMPConst.ARRAY_IS_ORDERED);
+ }
+ var xmpAsString = xmp.serialize(); // either way, serialize and write XMP.
+ projectItem.setXMPMetadata(xmpAsString);
+ }
+ } else {
+ $._PPP_.updateEventPanel("Project item required.");
+ }
+ },
+
+ getProductionByName : function(nameToGet) {
+ var production;
+ for (var i = 0; i < productionList.numProductions; i++) {
+ var currentProduction = productionList[i];
+
+ if (currentProduction.name == nameToGet) {
+ production = currentProduction;
+ }
+ }
+ return production;
+ },
+
+ pokeAnywhere : function() {
+ var token = app.anywhere.getAuthenticationToken();
+ var productionList = app.anywhere.listProductions();
+ var isProductionOpen = app.anywhere.isProductionOpen();
+ if (isProductionOpen === true) {
+ var sessionURL = app.anywhere.getCurrentEditingSessionURL();
+ var selectionURL = app.anywhere.getCurrentEditingSessionSelectionURL();
+ var activeSequenceURL = app.anywhere.getCurrentEditingSessionActiveSequenceURL();
+
+ var theOneIAskedFor = $._PPP_.getProductionByName("test");
+
+ if (theOneIAskedFor) {
+ var out = theOneIAskedFor.name + ", " + theOneIAskedFor.description;
+ $._PPP_.updateEventPanel("Found: " + out); // todo: put useful code here.
+ }
+ } else {
+ $._PPP_.updateEventPanel("No Production open.");
+ }
+ },
+
+ dumpOMF : function() {
+ var activeSequence = app.project.activeSequence;
+ if (activeSequence) {
+ var outputPath = Folder.selectDialog("Choose the output directory");
+ if (outputPath){
+ var absPath = outputPath.fsName;
+ var outputName = String(activeSequence.name) + '.omf';
+ var fullOutPathWithName = absPath + $._PPP_.getSep() + outputName;
+
+ app.project.exportOMF( app.project.activeSequence, // sequence
+ fullOutPathWithName, // output file path
+ 'OMFTitle', // OMF title
+ 48000, // sample rate (48000 or 96000)
+ 16, // bits per sample (16 or 24)
+ 1, // audio encapsulated flag (1 : yes or 0 : no)
+ 0, // audio file format (0 : AIFF or 1 : WAV)
+ 0, // trim audio files (0 : no or 1 : yes)
+ 0, // handle frames (if trim is 1, handle frames from 0 to 1000)
+ 0); // include pan flag (0 : no or 1 : yes)
+ }
+ } else {
+ $._PPP_.updateEventPanel("No active sequence.");
+ }
+ },
+
+ addClipMarkers : function () {
+ if (app.project.rootItem.children.numItems > 0){
+ var projectItem = app.project.rootItem.children[0]; // assumes first item is footage.
+ if (projectItem) {
+ if (projectItem.type == ProjectItemType.CLIP || projectItem.type == ProjectItemType.FILE) {
+
+ markers = projectItem.getMarkers();
+
+ if (markers) {
+ var num_markers = markers.numMarkers;
+ var new_marker = markers.createMarker(12.345);
+ var guid = new_marker.guid; // new in 11.1
+
+ new_marker.name = 'Marker created by PProPanel.';
+ new_marker.comments = 'Here are some comments, inserted by PProPanel.';
+ new_marker.end = 15.6789;
+
+ //default marker type == comment. To change marker type, call one of these:
+
+ // new_marker.setTypeAsChapter();
+ // new_marker.setTypeAsWebLink();
+ // new_marker.setTypeAsSegmentation();
+ // new_marker.setTypeAsComment();
+ }
+ } else {
+ $._PPP_.updateEventPanel("Can only add markers to footage items.");
+ }
+ } else {
+ $._PPP_.updateEventPanel("Could not find first projectItem.");
+ }
+ } else {
+ $._PPP_.updateEventPanel("Project is empty.");
+ }
+ },
+
+ modifyProjectMetadata : function () {
+ var kPProPrivateProjectMetadataURI = "http://ns.adobe.com/premierePrivateProjectMetaData/1.0/";
+
+ var namefield = "Column.Intrinsic.Name";
+ var tapename = "Column.Intrinsic.TapeName";
+ var desc = "Column.PropertyText.Description";
+ var logNote = "Column.Intrinsic.LogNote";
+ var newField = "ExampleFieldName";
+
+ if (app.isDocumentOpen()) {
+ var projectItem = app.project.rootItem.children[0]; // just grabs first projectItem.
+ if (projectItem) {
+ if (ExternalObject.AdobeXMPScript === undefined) {
+ ExternalObject.AdobeXMPScript = new ExternalObject('lib:AdobeXMPScript');
+ }
+ if (ExternalObject.AdobeXMPScript !== undefined) { // safety-conscious!
+ var projectMetadata = projectItem.getProjectMetadata();
+ var successfullyAdded = app.project.addPropertyToProjectMetadataSchema(newField, "ExampleFieldLabel", 2);
+
+ var xmp = new XMPMeta(projectMetadata);
+ var obj = xmp.dumpObject();
+
+ // var aliases = xmp.dumpAliases();
+
+ var namespaces = XMPMeta.dumpNamespaces();
+ var found_name = xmp.doesPropertyExist(kPProPrivateProjectMetadataURI, namefield);
+ var found_tapename = xmp.doesPropertyExist(kPProPrivateProjectMetadataURI, tapename);
+ var found_desc = xmp.doesPropertyExist(kPProPrivateProjectMetadataURI, desc);
+ var found_custom = xmp.doesPropertyExist(kPProPrivateProjectMetadataURI, newField);
+ var foundLogNote = xmp.doesPropertyExist(kPProPrivateProjectMetadataURI, logNote);
+ var oldLogValue = "";
+ var appendThis = "This log note inserted by PProPanel.";
+ var appendTextWasActuallyNew = false;
+
+ if(foundLogNote){
+ var oldLogNote = xmp.getProperty(kPProPrivateProjectMetadataURI, logNote);
+ if (oldLogNote){
+ oldLogValue = oldLogNote.value;
+ }
+ }
+
+ xmp.setProperty(kPProPrivateProjectMetadataURI, tapename, "***TAPENAME***");
+ xmp.setProperty(kPProPrivateProjectMetadataURI, desc, "***DESCRIPTION***");
+ xmp.setProperty(kPProPrivateProjectMetadataURI, namefield, "***NEWNAME***");
+ xmp.setProperty(kPProPrivateProjectMetadataURI, newField, "PProPanel set this, using addPropertyToProjectMetadataSchema().");
+
+
+ var array = [];
+ array[0] = tapename;
+ array[1] = desc;
+ array[2] = namefield;
+ array[3] = newField;
+
+ var concatenatedLogNotes = "";
+
+ if (oldLogValue != appendThis){ // if that value is not exactly what we were going to add
+ if (oldLogValue.length > 0){ // if we have a valid value
+ concatenatedLogNotes += "Previous log notes: " + oldLogValue + " |||| ";
+ }
+ concatenatedLogNotes += appendThis;
+ xmp.setProperty(kPProPrivateProjectMetadataURI, logNote, concatenatedLogNotes);
+ array[4] = logNote;
+ }
+
+ var str = xmp.serialize();
+ projectItem.setProjectMetadata(str, array);
+
+ // test: is it in there?
+
+ var newblob = projectItem.getProjectMetadata();
+ var newXMP = new XMPMeta(newblob);
+ var foundYet = newXMP.doesPropertyExist(kPProPrivateProjectMetadataURI, newField);
+
+ if (foundYet){
+ $._PPP_.updateEventPanel("PProPanel successfully added a field to the project metadata schema, and set a value for it.");
+ }
+ }
+ } else {
+ $._PPP_.updateEventPanel("No project items found.");
+ }
+ }
+ },
+
+ updatePAR : function() {
+ var item = app.project.rootItem.children[0];
+ if (item) {
+ if ((item.type == ProjectItemType.FILE) || (item.type == ProjectItemType.CLIP)){
+ // If there is an item, and it's either a clip or file...
+ item.setOverridePixelAspectRatio(185, 100); // anamorphic is BACK! ;)
+ } else {
+ $._PPP_.updateEventPanel('You cannot override the PAR of bins or sequences.');
+ }
+ } else {
+ $._PPP_.updateEventPanel("No project items found.");
+ }
+ },
+
+ getnumAEProjectItems : function() {
+ var bt = new BridgeTalk();
+ bt.target = 'aftereffects';
+ bt.body = //'$._PPP_.updateEventPanel("Items in AE project: " + app.project.rootFolder.numItems);app.quit();';
+ 'alert("Items in AE project: " + app.project.rootFolder.numItems);app.quit();';
+ bt.send();
+ },
+
+ updateEventPanel : function(message) {
+ app.setSDKEventMessage(message, 'info');
+ //app.setSDKEventMessage('Here is some information.', 'info');
+ //app.setSDKEventMessage('Here is a warning.', 'warning');
+ //app.setSDKEventMessage('Here is an error.', 'error'); // Very annoying; use sparingly.
+ },
+
+ walkAllBinsForFootage : function(parentItem, outPath){
+ for (var j = 0; j < parentItem.children.numItems; j++){
+ var currentChild = parentItem.children[j];
+ if (currentChild){
+ if (currentChild.type == ProjectItemType.BIN){
+ $._PPP_.walkAllBinsForFootage(currentChild, outPath); // warning; recursion!
+ } else {
+ $._PPP_.dumpProjectItemXMP(currentChild, outPath);
+ }
+ }
+ }
+ },
+
+ searchBinForProjItemByName : function(i, containingBin, nameToFind){
+ for (var j = i; j < containingBin.children.numItems; j++){
+ var currentChild = containingBin.children[j];
+ if (currentChild){
+ if (currentChild.type == ProjectItemType.BIN){
+ return $._PPP_.searchBinForProjItemByName(j, currentChild, nameToFind); // warning; recursion!
+ } else {
+ if (currentChild.name == nameToFind){
+ return currentChild;
+ } else {
+ currentChild = currentItem.children[j+1];
+ if (currentChild){
+ return $._PPP_.searchBinForProjItemByName(0, currentChild, nameToFind);
+ }
+ }
+ }
+ }
+ }
+ },
+
+ dumpProjectItemXMP : function (projectItem, outPath) {
+ var xmpBlob = projectItem.getXMPMetadata();
+ var outFileName = projectItem.name + '.xmp';
+ var completeOutputPath = outPath + $._PPP_.getSep() + outFileName;
+ var outFile = new File(completeOutputPath);
+
+ var isThisASequence = projectItem.isSequence();
+
+ if (outFile){
+ outFile.encoding = "UTF8";
+ outFile.open("w", "TEXT", "????");
+ outFile.write(xmpBlob.toString());
+ outFile.close();
+ }
+ },
+
+ addSubClip : function() {
+ var startTime = new Time;
+ startTime.seconds = 0.0;
+ var endTime = new Time;
+ endTime.seconds = 3.21;
+ var hasHardBoundaries = 0;
+ var sessionCounter = 1;
+ var takeVideo = 1; // optional, defaults to 1
+ var takeAudio = 1; // optional, defaults to 1
+ var projectItem = app.project.rootItem.children[0]; // just grabs the first item
+ if (projectItem) {
+ if ((projectItem.type == ProjectItemType.CLIP) || (projectItem.type == ProjectItemType.FILE)) {
+ var newSubClipName = prompt('Name of subclip?', projectItem.name + '_' + sessionCounter, 'Name your subclip');
+
+ var newSubClip = projectItem.createSubClip(newSubClipName,
+ startTime,
+ endTime,
+ hasHardBoundaries,
+ takeVideo,
+ takeAudio);
+
+ if (newSubClip){
+ newSubClip.setStartTime(12.345);
+ }
+ } else {
+ $._PPP_.updateEventPanel("Could not sub-clip " + projectItem.name + ".");
+ }
+ } else {
+ $._PPP_.updateEventPanel("No project item found.");
+ }
+ },
+
+ dumpXMPFromAllProjectItems : function() {
+ var numItemsInRoot = app.project.rootItem.children.numItems;
+ if (numItemsInRoot > 0) {
+ var outPath = Folder.selectDialog("Choose the output directory");
+ if (outPath) {
+ for (var i = 0; i < numItemsInRoot; i++){
+ var currentItem = app.project.rootItem.children[i];
+ if (currentItem){
+ if (currentItem.type == ProjectItemType.BIN){
+ $._PPP_.walkAllBinsForFootage(currentItem, outPath.fsName);
+ } else {
+ $._PPP_.dumpProjectItemXMP(currentItem, outPath.fsName);
+ }
+ }
+ }
+ }
+ } else {
+ $._PPP_.updateEventPanel("No project items found.");
+ }
+ },
+
+ exportAAF : function() {
+ var sessionCounter = 1;
+ if (app.project.activeSequence){
+ var outputPath = Folder.selectDialog("Choose the output directory");
+ if (outputPath) {
+ var absPath = outputPath.fsName;
+ var outputName = String(app.project.name);
+ var array = outputName.split('.', 2);
+ outputName = array[0]+ sessionCounter + '.' + array[1];
+
+ sessionCounter++;
+ var fullOutPath = absPath + $._PPP_.getSep() + outputName + '.aaf';
+ //var optionalPathToOutputPreset = null; New in 11.0.0, you can specify an output preset.
+
+ app.project.exportAAF( app.project.activeSequence, // which sequence
+ fullOutPath, // output path
+ 1, // mix down video?
+ 0, // explode to mono?
+ 96000, // sample rate
+ 16, // bits per sample
+ 0, // embed audio?
+ 0, // audio file format? 0 = aiff, 1 = wav
+ 0, // trim sources?
+ 0/*, // number of 'handle' frames
+ optionalPathToOutputPreset*/); // optional; .epr file to use
+ } else {
+ $._PPP_.updateEventPanel("Couldn't create AAF output.");
+ }
+ } else {
+ $._PPP_.updateEventPanel("No active sequence.");
+ }
+ },
+
+ setScratchDisk : function (){
+ var scratchPath = Folder.selectDialog("Choose new scratch disk directory");
+ if ((scratchPath) && scratchPath.exists) {
+ app.setScratchDiskPath(scratchPath.fsName, ScratchDiskType.FirstAutoSaveFolder); // see ScratchDiskType object, in ESTK.
+ }
+ },
+
+ getProjectProxySetting : function() {
+ var returnVal = "";
+ if (app.project){
+ var returnVal = "No sequence detected in " + app.project.name + ".";
+ if (app.getEnableProxies()) {
+ returnVal = 'true';
+ } else {
+ returnVal = 'false';
+ }
+ } else {
+ returnVal = "No project available.";
+ }
+ return returnVal;
+ },
+
+ toggleProxyState : function() {
+ var update = "Proxies for " + app.project.name + " turned ";
+ if (app.getEnableProxies()) {
+ app.setEnableProxies(0);
+ update = update + "OFF.";
+ app.setSDKEventMessage(update, 'info');
+ } else {
+ app.setEnableProxies(1);
+ update = update + "ON.";
+ app.setSDKEventMessage(update, 'info');
+ }
+ },
+
+ setProxiesON : function () {
+ var firstProjectItem = app.project.rootItem.children[0];
+ if (firstProjectItem) {
+ if (firstProjectItem.canProxy()){
+ var shouldAttachProxy = true;
+ if (firstProjectItem.hasProxy()) {
+ shouldAttachProxy = confirm(firstProjectItem.name + " already has an assigned proxy. Re-assign anyway?", false, "Are you sure...?");
+ }
+ if (shouldAttachProxy) {
+ var filterString = "";
+ if (Folder.fs === 'Windows'){
+ filterString = "All files:*.*";
+ }
+ var proxyPath = File.openDialog( "Choose proxy for " + firstProjectItem.name + ":",
+ filterString,
+ false);
+ if (proxyPath.exists){
+ firstProjectItem.attachProxy(proxyPath.fsName, 0);
+ } else {
+ $._PPP_.updateEventPanel("Could not attach proxy from " + proxyPath + ".");
+ }
+ }
+ } else {
+ $._PPP_.updateEventPanel("Cannot attach a proxy to " + firstProjectItem.name + ".");
+ }
+ } else {
+ $._PPP_.updateEventPanel("No project item available.");
+ }
+ },
+
+ clearCache : function () {
+ app.enableQE();
+ MediaType = {};
+
+ // Magical constants from Premiere Pro's internal automation.
+
+ MediaType.VIDEO = "228CDA18-3625-4d2d-951E-348879E4ED93";
+ MediaType.AUDIO = "80B8E3D5-6DCA-4195-AEFB-CB5F407AB009";
+ MediaType.ANY = "FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFF";
+ qe.project.deletePreviewFiles(MediaType.ANY);
+ $._PPP_.updateEventPanel("All video and audio preview files deleted.");
+ },
+
+ randomizeSequenceSelection : function (){
+ var sequence = app.project.activeSequence;
+
+ if (sequence){
+ var trackGroups = [ sequence.audioTracks, sequence.videoTracks ];
+ var trackGroupNames = [ "audioTracks", "videoTracks" ];
+ var updateUI = true;
+ var before;
+
+ for(var gi = 0; gi<2; gi++) {
+ $._PPP_.updateEventPanel(trackGroupNames[gi]);
+ group = trackGroups[gi];
+ for(var ti=0; ti" : clip.projectItem.name);
+ before = clip.isSelected();
+
+ // randomly select clips
+ clip.setSelected((Math.random() > 0.5), updateUI);
+
+ if (clip.isAdjustmentLayer()){ // new in 13.0
+ $._PPP_.updateEventPanel("Clip named \"" + clip.name + "\" is an adjustment layer.");
+ }
+
+ // Note; there's no good place to exercise this code yet, but
+ // I wanted to provide example usage.
+
+ var allClipsInThisSequenceFromSameSource = clip.getLinkedItems();
+
+ if (allClipsInThisSequenceFromSameSource){
+ $._PPP_.updateEventPanel("Found " + allClipsInThisSequenceFromSameSource.numItems + " clips from " + clip.projectItem.name + ", in this sequence.");
+ }
+ beforeSelected = before ? "Y" : "N";
+ afterSelected = clip.selected ? "Y" : "N";
+ $._PPP_.updateEventPanel("clip : " + ci + " " + name + " " + beforeSelected + " -> " + afterSelected);
+ }
+
+ for(var tni=0; tni 0.5), updateUI);
+
+ beforeSelected = before ? "Y" : "N";
+ afterSelected = transition.selected ? "Y" : "N";
+
+ $._PPP_.updateEventPanel('transition: ' + tni + " " + beforeSelected + " -> " + afterSelected);
+ }
+ }
+ }
+ } else {
+ $._PPP_.updateEventPanel("no active sequence.");
+ }
+ },
+
+ // Define a couple of callback functions, for AME to use during render.
+
+ onEncoderJobComplete : function (jobID, outputFilePath) {
+ var eoName;
+
+ if (Folder.fs == 'Macintosh') {
+ eoName = "PlugPlugExternalObject";
+ } else {
+ eoName = "PlugPlugExternalObject.dll";
+ }
+
+ var suffixAddedByPPro = '_1'; // You should really test for any suffix.
+ var withoutExtension = outputFilePath.slice(0,-4); // trusting 3 char extension
+ var lastIndex = outputFilePath.lastIndexOf(".");
+ var extension = outputFilePath.substr(lastIndex + 1);
+
+ if (outputFilePath.indexOf(suffixAddedByPPro)){
+ $._PPP_.updateEventPanel(" Output filename was changed: the output preset name may have been added, or there may have been an existing file with that name. This would be a good place to deal with such occurrences.");
+ }
+
+ var mylib = new ExternalObject('lib:' + eoName);
+ var eventObj = new CSXSEvent();
+
+ eventObj.type = "com.adobe.csxs.events.PProPanelRenderEvent";
+ eventObj.data = "Rendered Job " + jobID + ", to " + outputFilePath + ".";
+
+ eventObj.dispatch();
+ },
+
+ onEncoderJobError : function (jobID, errorMessage) {
+ var eoName;
+
+ if (Folder.fs === 'Macintosh') {
+ eoName = "PlugPlugExternalObject";
+ } else {
+ eoName = "PlugPlugExternalObject.dll";
+ }
+
+ var mylib = new ExternalObject('lib:' + eoName);
+ var eventObj = new CSXSEvent();
+
+ eventObj.type = "com.adobe.csxs.events.PProPanelRenderEvent";
+ eventObj.data = "Job " + jobID + " failed, due to " + errorMessage + ".";
+ eventObj.dispatch();
+ },
+
+ onEncoderJobProgress : function (jobID, progress) {
+ $._PPP_.updateEventPanel('onEncoderJobProgress called. jobID = ' + jobID + '. progress = ' + progress + '.');
+ },
+
+ onEncoderJobQueued : function (jobID) {
+ app.encoder.startBatch();
+ },
+
+ onEncoderJobCanceled : function (jobID) {
+ $._PPP_.updateEventPanel('OnEncoderJobCanceled called. jobID = ' + jobID + '.');
+ },
+
+ onPlayWithKeyframes : function () {
+ var seq = app.project.activeSequence;
+ if (seq) {
+ var firstVideoTrack = seq.videoTracks[0];
+ if (firstVideoTrack){
+ var firstClip = firstVideoTrack.clips[0];
+ if (firstClip){
+ var clipComponents = firstClip.components;
+ if (clipComponents){
+ for (var i = 0; i < clipComponents.numItems; ++i){
+ $._PPP_.updateEventPanel('component ' + i + ' = ' + clipComponents[i].matchName + ' : ' + clipComponents[i].displayName);
+ }
+ if (clipComponents.numItems > 2){
+
+ // 0 = clip
+ // 1 = Opacity
+ // N effects, then...
+ // Shape layer (new in 12.0)
+
+ var blur = clipComponents[2]; // Assume Gaussian Blur is the first effect applied to the clip.
+ if (blur){
+ var blurProps = blur.properties;
+ if (blurProps){
+ for( var j = 0; j < blurProps.numItems; ++j){
+ $._PPP_.updateEventPanel('param ' + j + ' = ' + blurProps[j].displayName);
+ }
+ var blurriness = blurProps[0];
+ if (blurriness){
+ if (!blurriness.isTimeVarying()){
+ blurriness.setTimeVarying(true);
+ }
+ for(var k = 0; k < 20; ++k){
+ updateUI = (k==9); // Decide how often to update PPro's UI
+ blurriness.addKey(k);
+ var blurVal = Math.sin(3.14159*i/5)*20+25;
+ blurriness.setValueAtKey(k, blurVal, updateUI);
+ }
+ }
+ var repeatEdgePixels = blurProps[2];
+ if (repeatEdgePixels){
+ if (!repeatEdgePixels.getValue()){
+ updateUI = true;
+ repeatEdgePixels.setValue(true, updateUI);
+ }
+ }
+ // look for keyframe nearest to 4s with 1/10 second tolerance
+ var keyFrameTime = blurriness.findNearestKey(4.0, 0.1);
+ if (keyFrameTime !== undefined){
+ $._PPP_.updateEventPanel('Found keyframe = ' + keyFrameTime.seconds);
+ } else {
+ $._PPP_.updateEventPanel('Keyframe not found.');
+ }
+
+ // scan keyframes, forward
+
+ keyFrameTime = blurriness.findNearestKey(0.0, 0.1);
+ var lastKeyFrameTime = keyFrameTime;
+ while(keyFrameTime !== undefined){
+ $._PPP_.updateEventPanel('keyframe @ ' + keyFrameTime.seconds);
+ lastKeyFrameTime = keyFrameTime;
+ keyFrameTime = blurriness.findNextKey(keyFrameTime);
+ }
+
+ // scan keyframes, backward
+ keyFrameTime = lastKeyFrameTime;
+ while(keyFrameTime !== undefined){
+ $._PPP_.updateEventPanel('keyframe @ ' + keyFrameTime.seconds);
+ lastKeyFrameTime = keyFrameTime;
+ keyFrameTime = blurriness.findPreviousKey(keyFrameTime);
+ }
+
+ // get all keyframes
+
+ var blurKeyframesArray = blurriness.getKeys();
+ if (blurKeyframesArray){
+ $._PPP_.updateEventPanel(blurKeyframesArray.length + ' keyframes found');
+ }
+
+ // remove keyframe at 19s
+ blurriness.removeKey(19);
+
+ // remove keyframes in range from 0s to 5s
+ var shouldUpdateUI = true;
+ blurriness.removeKeyRange(0,5, shouldUpdateUI);
+ }
+
+ } else {
+ $._PPP_.updateEventPanel("Please apply the Gaussian Blur effect to the first clip in the first video track of the active sequence.");
+ }
+ }
+ }
+ }
+ }
+ } else {
+ $._PPP_.updateEventPanel("no active sequence.");
+ }
+ },
+
+ extractFileNameFromPath : function (fullPath){
+ var lastDot = fullPath.lastIndexOf(".");
+ var lastSep = fullPath.lastIndexOf("/");
+
+ if (lastDot > -1){
+ return fullPath.substr( (lastSep +1), (fullPath.length - (lastDot + 1)));
+ } else {
+ return fullPath;
+ }
+ },
+
+ onProxyTranscodeJobComplete : function (jobID, outputFilePath) {
+ var suffixAddedByPPro = '_1'; // You should really test for any suffix.
+ var withoutExtension = outputFilePath.slice(0,-4); // trusting 3 char extension
+ var lastIndex = outputFilePath.lastIndexOf(".");
+ var extension = outputFilePath.substr(lastIndex + 1);
+
+ var wrapper = [];
+ wrapper[0] = outputFilePath;
+
+ var nameToFind = 'Proxies generated by PProPanel';
+ var targetBin = $._PPP_.getPPPInsertionBin();
+ if (targetBin){
+ app.project.importFiles(wrapper);
+ }
+ },
+
+ onProxyTranscodeJobError : function (jobID, errorMessage) {
+ $._PPP_.updateEventPanel(errorMessage);
+ },
+
+ onProxyTranscodeJobQueued : function (jobID) {
+ app.encoder.startBatch();
+ },
+
+ ingestFiles : function(outputPresetPath) {
+ app.encoder.bind('onEncoderJobComplete', $._PPP_.onProxyTranscodeJobComplete);
+ app.encoder.bind('onEncoderJobError', $._PPP_.onProxyTranscodeJobError);
+ app.encoder.bind('onEncoderJobQueued', $._PPP_.onProxyTranscodeJobQueued);
+ app.encoder.bind('onEncoderJobCanceled', $._PPP_.onEncoderJobCanceled);
+
+ if (app.project) {
+ var filterString = "";
+ if (Folder.fs === 'Windows'){
+ filterString = "All files:*.*";
+ }
+ var fileOrFilesToImport = File.openDialog( "Choose full resolution files to import", // title
+ filterString, // filter available files?
+ true); // allow multiple?
+ if (fileOrFilesToImport) {
+ var nameToFind = 'Proxies generated by PProPanel';
+ var targetBin = $._PPP_.searchForBinWithName(nameToFind);
+ if (targetBin === 0) {
+ // If panel can't find the target bin, it creates it.
+ app.project.rootItem.createBin(nameToFind);
+ targetBin = $._PPP_.searchForBinWithName(nameToFind);
+ }
+ if (targetBin){
+ targetBin.select();
+ var importThese = []; // We have an array of File objects; importFiles() takes an array of paths.
+ if (importThese){
+ for (var i = 0; i < fileOrFilesToImport.length; i++) {
+ importThese[i] = fileOrFilesToImport[i].fsName;
+ var justFileName = extractFileNameFromPath(importThese[i]);
+ var suffix = '_PROXY.mp4';
+ var containingPath = fileOrFilesToImport[i].parent.fsName;
+ var completeProxyPath = containingPath + $._PPP_.getSep() + justFileName + suffix;
+
+ var jobID = app.encoder.encodeFile(fileOrFilesToImport[i].fsName,
+ completeProxyPath,
+ outputPresetPath,
+ 0);
+ }
+
+ app.project.importFiles(importThese,
+ 1, // suppress warnings
+ targetBin,
+ 0); // import as numbered stills
+ }
+ } else {
+ $._PPP_.updateEventPanel("Could not find or create target bin.");
+ }
+ } else {
+ $._PPP_.updateEventPanel("No files to import.");
+ }
+ } else {
+ $._PPP_.updateEventPanel("No project found.");
+ }
+ },
+
+ insertOrAppend : function() {
+ var seq = app.project.activeSequence;
+ if (seq){
+ var first = app.project.rootItem.children[0];
+ if (first){
+ var numVTracks = seq.videoTracks.numTracks;
+ var targetVTrack = seq.videoTracks[(numVTracks - 1)];
+ if (targetVTrack){
+ // If there are already clips in this track,
+ // append this one to the end. Otherwise,
+ // insert at start time.
+
+ if (targetVTrack.clips.numItems > 0){
+ var lastClip = targetVTrack.clips[(targetVTrack.clips.numItems - 1)];
+ if (lastClip){
+ targetVTrack.insertClip(first, lastClip.end.seconds);
+ }
+ }else {
+ targetVTrack.insertClip(first, '00;00;00;00');
+ }
+ } else {
+ $._PPP_.updateEventPanel("Could not find first video track.");
+ }
+ } else {
+ $._PPP_.updateEventPanel("Couldn't locate first projectItem.");
+ }
+ } else {
+ $._PPP_.updateEventPanel("no active sequence.");
+ }
+ },
+
+ overWrite : function() {
+ var seq = app.project.activeSequence;
+ if (seq){
+ var first = app.project.rootItem.children[0];
+ if (first) {
+ var vTrack1 = seq.videoTracks[0];
+ if (vTrack1){
+ var now = seq.getPlayerPosition();
+ vTrack1.overwriteClip(first, now.seconds);
+ } else {
+ $._PPP_.updateEventPanel("Could not find first video track.");
+ }
+ } else {
+ $._PPP_.updateEventPanel("Couldn't locate first projectItem.");
+ }
+ } else {
+ $._PPP_.updateEventPanel("no active sequence.");
+ }
+ },
+
+ closeFrontSourceClip : function() {
+ app.sourceMonitor.closeClip();
+ },
+
+ closeAllClipsInSourceMonitor : function() {
+ app.sourceMonitor.closeAllClips();
+ },
+
+ changeLabel : function () {
+ var first = app.project.rootItem.children[0];
+ if (first){
+ var currentLabel = first.getColorLabel();
+ var newLabel = currentLabel + 1; // 4 = Cerulean. 0 = Violet, 15 = Yellow.
+ if (newLabel > 15){
+ newLabel = newLabel - 16;
+ }
+ app.setSDKEventMessage("Previous Label color = " + currentLabel + ".", 'info');
+ first.setColorLabel(newLabel);
+ app.setSDKEventMessage("New Label color = " + newLabel + ".", 'info');
+ } else {
+ $._PPP_.updateEventPanel("Couldn't locate first projectItem.");
+ }
+ },
+
+ getPPPInsertionBin : function () {
+ var nameToFind = "Here's where PProPanel puts things.";
+
+ var targetBin = $._PPP_.searchForBinWithName(nameToFind);
+
+ if (targetBin === undefined) {
+ // If panel can't find the target bin, it creates it.
+ app.project.rootItem.createBin(nameToFind);
+ targetBin = $._PPP_.searchForBinWithName(nameToFind);
+ }
+ if (targetBin) {
+ targetBin.select();
+ return targetBin;
+ }
+ },
+
+ importComps : function () {
+ var targetBin = $._PPP_.getPPPInsertionBin();
+ if (targetBin){
+ var filterString = "";
+ if (Folder.fs === 'Windows'){
+ filterString = "All files:*.*";
+ }
+ compNamesToImport = [];
+
+ var aepToImport = File.openDialog ( "Choose After Effects project", // title
+ filterString, // filter available files?
+ false); // allow multiple?
+ if (aepToImport) {
+ var importAll = confirm("Import all compositions in project?", false, "Import all?");
+ if (importAll){
+ var result = app.project.importAllAEComps(aepToImport.fsName, targetBin);
+ } else {
+ var compName = prompt( 'Name of composition to import?',
+ '',
+ 'Which Comp to import');
+ if (compName){
+ compNamesToImport[0] = compName;
+ var importAECompResult = app.project.importAEComps(aepToImport.fsName, compNamesToImport, targetBin);
+ } else {
+ $._PPP_.updateEventPanel("Could not find Composition.");
+ }
+ }
+ } else {
+ $._PPP_.updateEventPanel("Could not open project.");
+ }
+ } else {
+ $._PPP_.updateEventPanel("Could not find or create target bin.");
+ }
+ },
+
+ consolidateProject : function () {
+ var pmo = app.projectManager.options;
+
+ if (app.project.sequences.length){
+ if (pmo) {
+ var filterString = "";
+ if (Folder.fs === 'Windows'){
+ filterString = "Output Presets:*.epr";
+ }
+
+ var outFolder = Folder.selectDialog("Choose output directory.");
+ if (outFolder) {
+
+ var presetPath = "";
+ var useSpecificPreset = confirm("Would you like to select an output preset?", false, "Are you sure...?");
+ if (useSpecificPreset){
+ var useThisEPR = File.openDialog ( "Choose output preset (.epr file)", // title
+ filterString, // filter available files?
+ false); // allow multiple?
+
+ if (useThisEPR){
+ pmo.clipTranscoderOption = pmo.CLIP_TRANSCODE_MATCH_PRESET;
+ pmo.encoderPresetFilePath = useThisEPR.fsName;
+ }
+ } else {
+ pmo.clipTranscoderOption = pmo.CLIP_TRANSCODE_MATCH_SEQUENCE;
+ }
+
+ var processAllSequences = confirm("Process all sequences? No = just the first sequence found.", true, "Process all?");
+
+ if (processAllSequences){
+ pmo.includeAllSequences = true;
+ } else {
+ pmo.includeAllSequences = false;
+ pmo.affectedSequences = [app.project.sequences[0]];
+ }
+
+ pmo.clipTransferOption = pmo.CLIP_TRANSFER_TRANSCODE;
+ pmo.convertAECompsToClips = false;
+ pmo.convertSyntheticsToClips = false;
+ pmo.copyToPreventAlphaLoss = false;
+ pmo.destinationPath = outFolder.fsName;
+ pmo.excludeUnused = false;
+ pmo.handleFrameCount = 0;
+ pmo.includeConformedAudio = true;
+ pmo.includePreviews = true;
+ pmo.renameMedia = false;
+
+ var result = app.projectManager.process(app.project);
+ var errorList = app.projectManager.errors;
+
+ if(errorList.length){
+ for (var k = 0; k < errorList.length; k++){
+ $._PPP_.updateEventPanel(errorList[k][1]);
+ }
+ } else {
+ $._PPP_.updateEventPanel(app.project.name + " successfully processed to " + outFolder.fsName + ".");
+ }
+ return result;
+ }
+ }
+
+
+ }
+ if (pmo) {
+ var filterString = "";
+ if (Folder.fs === 'Windows'){
+ filterString = "Output Presets:*.epr";
+ }
+
+ var outFolder = Folder.selectDialog("Choose output directory.");
+ if (outFolder) {
+
+ var presetPath = "";
+ var useSpecificPreset = confirm("Would you like to select an output preset?", false, "Are you sure...?");
+ if (useSpecificPreset){
+ var useThisEPR = File.openDialog ( "Choose output preset (.epr file)", // title
+ filterString, // filter available files?
+ false); // allow multiple?
+
+ if (useThisEPR){
+ pmo.clipTranscoderOption = pmo.CLIP_TRANSCODE_MATCH_PRESET;
+ pmo.encoderPresetFilePath = useThisEPR.fsName;
+ }
+ } else {
+ pmo.clipTranscoderOption = pmo.CLIP_TRANSCODE_MATCH_SEQUENCE;
+ }
+
+ var processAllSequences = confirm("Process all sequences? No = just the first sequence found.", true, "Process all?");
+
+ if (processAllSequences){
+ pmo.includeAllSequences = true;
+ } else {
+ pmo.includeAllSequences = false;
+ pmo.affectedSequences = [app.project.sequences[0]];
+ }
+
+ pmo.clipTransferOption = pmo.CLIP_TRANSFER_TRANSCODE;
+ pmo.convertAECompsToClips = false;
+ pmo.convertSyntheticsToClips = false;
+ pmo.copyToPreventAlphaLoss = false;
+ pmo.destinationPath = outFolder.fsName;
+ pmo.excludeUnused = false;
+ pmo.handleFrameCount = 0;
+ pmo.includeConformedAudio = true;
+ pmo.includePreviews = true;
+ pmo.renameMedia = false;
+
+ var result = app.projectManager.process(app.project);
+ var errorList = app.projectManager.errors;
+
+ if(errorList.length){
+ for (var k = 0; k < errorList.length; k++){
+ $._PPP_.updateEventPanel(errorList[k][1]);
+ }
+ } else {
+ $._PPP_.updateEventPanel(app.project.name + " successfully processed to " + outFolder.fsName + ".");
+ }
+ return result;
+ }
+ }
+ },
+
+ importMoGRT : function () {
+ var activeSeq = app.project.activeSequence;
+ if (activeSeq) {
+ var filterString = "";
+ if (Folder.fs === 'Windows'){
+ filterString = "Motion Graphics Templates:*.mogrt";
+ }
+ var mogrtToImport = File.openDialog ( "Choose MoGRT", // title
+ filterString, // filter available files?
+ false); // allow multiple?
+ if (mogrtToImport){
+ var targetTime = activeSeq.getPlayerPosition();
+ var vidTrackOffset = 0;
+ var audTrackOffset = 0;
+ var newTrackItem = activeSeq.importMGT( mogrtToImport.fsName,
+ targetTime.ticks,
+ vidTrackOffset,
+ audTrackOffset);
+ if (newTrackItem){
+ var moComp = newTrackItem.getMGTComponent();
+ if (moComp){
+ var params = moComp.properties;
+ for (var z = 0; z < params.numItems; z++){
+ var thisParam = params[0];
+ }
+ var srcTextParam = params.getParamForDisplayName("Main Title");
+ if (srcTextParam){
+ var val = srcTextParam.getValue();
+ srcTextParam.setValue("New value set by PProPanel!");
+ }
+ }
+ }
+ } else {
+ app.setSDKEventMessage('Unable to import ' + mogrtToImport.fsName + '.', 'error');
+ }
+ } else {
+ app.setSDKEventMessage('No active sequence.');
+ }
+ },
+
+ reportCurrentProjectSelection : function() {
+ var viewIDs = app.getProjectViewIDs(); // sample code optimized for a single open project
+ viewSelection = app.getProjectViewSelection(viewIDs[0]);
+ $._PPP_.projectPanelSelectionChanged(viewSelection, viewIDs[0]);
+ },
+
+ randomizeProjectSelection : function() {
+ var viewIDs = app.getProjectViewIDs();
+ var firstProject = app.getProjectFromViewID(viewIDs[0]);
+ var arrayOfRandomProjectItems = [];
+
+ for (var b = 0; b < app.project.rootItem.children.numItems; b++){
+ var currentProjectItem = app.project.rootItem.children[b];
+ if (Math.random() > 0.5){
+ arrayOfRandomProjectItems.push(currentProjectItem);
+ }
+ }
+ if (arrayOfRandomProjectItems.length > 0){
+ app.setProjectViewSelection(arrayOfRandomProjectItems, viewIDs[0]);
+ }
+ },
+
+ setAllProjectItemsOnline : function(startingBin){
+ for (var k = 0; k < startingBin.children.numItems; k++){
+ var currentChild = startingBin.children[k];
+ if (currentChild){
+ if (currentChild.type === ProjectItemType.BIN){
+ $._PPP_.setAllProjectItemsOnline(currentChild); // warning; recursion!
+ } else if (currentChild.isOffline()){
+ currentChild.changeMediaPath(currentChild.getMediaPath(), true);
+ if (currentChild.isOffline()){
+ $._PPP_.updateEventPanel("Failed to bring \'" + currentChild.name + "\' online.");
+ } else {
+ $._PPP_.updateEventPanel("\'" + currentChild.name + "\' is once again online.");
+ }
+ }
+ }
+ }
+ },
+
+ setAllOnline : function(){
+ var startingBin = app.project.rootItem;
+ $._PPP_.setAllProjectItemsOnline(startingBin);
+ },
+
+ setOffline : function() {
+ var viewIDs = app.getProjectViewIDs();
+ for (var a = 0; a < app.projects.numProjects; a++){
+ var currentProject = app.getProjectFromViewID(viewIDs[a]);
+ if (currentProject){
+ if (currentProject.documentID === app.project.documentID){ // We're in the right project!
+ var selectedItems = app.getProjectViewSelection(viewIDs[a]);
+ for (var b = 0; b < selectedItems.length; b++){
+ var currentItem = selectedItems[b];
+ if (currentItem){
+ if ((!currentItem.isSequence()) && (currentItem.type !== ProjectItemType.BIN)){ // For every selected item which isn't a bin or sequence...
+ if (currentItem.isOffline()){
+ $._PPP_.updateEventPanel("\'" + currentItem.name + "\'was already offline.");
+ } else {
+ var result = currentItem.setOffline();
+ $._PPP_.updateEventPanel("\'" + currentItem.name + "\' is now offline.");
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ },
+
+ updateFrameRate : function() {
+ var item = app.project.rootItem.children[0];
+ if (item) {
+ if ((item.type == ProjectItemType.FILE) || (item.type == ProjectItemType.CLIP)){
+ // If there is an item, and it's either a clip or file...
+ item.setOverrideFrameRate(23.976);
+ } else {
+ $._PPP_.updateEventPanel('You cannot override the frame rate of bins or sequences.');
+ }
+ } else {
+ $._PPP_.updateEventPanel("No project items found.");
+ }
+ },
+
+ onItemAddedToProject : function(whichProject, addedProjectItem) {
+ var msg = addedProjectItem.name + " was added to " + whichProject + "."
+ $._PPP_.updateEventPanel(msg);
+ },
+
+ registerItemAddedFxn : function() {
+ app.onItemAddedToProjectSuccess = $._PPP_.onItemAddedToProject;
+ },
+
+ myOnProjectChanged : function(documentID){
+ var msg = 'Project with ID ' + documentID + ' Changed.';
+ // Commented out, as this happens a LOT.
+ // $._PPP_.updateEventPanel(msg);
+ },
+
+ registerProjectChangedFxn : function() {
+ app.bind('onProjectChanged', $._PPP_.myOnProjectChanged);
+ },
+
+ confirmPProHostVersion : function() {
+ var version = parseFloat(app.version);
+ if (version < 12.1){
+ $._PPP_.updateEventPanel("Note: PProPanel relies on features added in 12.1, but is currently running in " + version + ".");
+ }
+ },
+
+ changeMarkerColors : function() {
+ if (app.project.rootItem.children.numItems > 0){
+ var projectItem = app.project.rootItem.children[0]; // assumes first item is footage.
+ if (projectItem) {
+ if (projectItem.type == ProjectItemType.CLIP ||
+ projectItem.type == ProjectItemType.FILE) {
+
+ markers = projectItem.getMarkers();
+
+ if (markers) {
+ var markerCount = markers.numMarkers;
+
+ if (markerCount){
+ for(var thisMarker = markers.getFirstMarker(); thisMarker !== undefined; thisMarker = markers.getNextMarker(thisMarker)){
+ var oldColor = thisMarker.getColorByIndex();
+ var newColor = oldColor + 1;
+ if (newColor > 7){
+ newColor = 0;
+ }
+ thisMarker.setColorByIndex(newColor);
+ $._PPP_.updateEventPanel("Changed color of marker named \'" + thisMarker.name + "\' from " + oldColor + " to " + newColor + ".");
+ }
+ }
+ }
+ } else {
+ $._PPP_.updateEventPanel("Can only add markers to footage items.");
+ }
+ } else {
+ $._PPP_.updateEventPanel("Could not find first projectItem.");
+ }
+ } else {
+ $._PPP_.updateEventPanel("Project is empty.");
+ }
+ },
+
+ changeSeqTimeCodeDisplay : function() {
+ if (app.project.activeSequence){
+ var currentSeqSettings = app.project.activeSequence.getSettings();
+ if (currentSeqSettings){
+ var oldVidSetting = currentSeqSettings.videoDisplayFormat;
+ currentSeqSettings.videoDisplayFormat = oldVidSetting + 1;
+ if (currentSeqSettings.videoDisplayFormat > TIMEDISPLAY_48Timecode){
+ currentSeqSettings.videoDisplayFormat = TIMEDISPLAY_24Timecode;
+ }
+ app.project.activeSequence.setSettings(currentSeqSettings);
+ $._PPP_.updateEventPanel("Changed timecode display format for \'" + app.project.activeSequence.name + "\'.");
+ }
+ } else {
+ $._PPP_.updateEventPanel("No active sequence.");
+ }
+ },
+
+ myActiveSequenceChangedFxn : function() {
+ $._PPP_.updateEventPanel("Active sequence is now " + app.project.activeSequence.name + ".");
+ },
+
+ myActiveSequenceSelectionChangedFxn : function() {
+ var sel = app.project.activeSequence.getSelection();
+ $._PPP_.updateEventPanel('Current active sequence = ' + app.project.activeSequence.name + '.');
+ $._PPP_.updateEventPanel( sel.length + ' track items selected.');
+ for(var i = 0; i < sel.length; i++){
+ if (sel[i].name !== 'anonymous'){
+ $._PPP_.updateEventPanel('Selected item ' + (i+1) + ' == ' + sel[i].name + '.');
+ }
+ }
+ },
+
+ registerActiveSequenceChangedFxn : function() {
+ var success = app.bind("onActiveSequenceChanged", $._PPP_.myActiveSequenceChangedFxn);
+ },
+
+ registerSequenceSelectionChangedFxn : function() {
+ var success = app.bind('onActiveSequenceSelectionChanged', $._PPP_.myActiveSequenceSelectionChangedFxn);
+ },
+
+ enableNewWorldScripting : function(){
+ app.enableQE();
+
+ var previousNWValue = qe.getDebugDatabaseEntry("ScriptLayerPPro.EnableNewWorld");
+ var previousInternalDOMValue = qe.getDebugDatabaseEntry("dvascripting.EnabledInternalDOM");
+ if ((previousNWValue === 'true') && (previousInternalDOMValue === 'true')){
+ qe.setDebugDatabaseEntry("ScriptLayerPPro.EnableNewWorld", "false");
+ qe.setDebugDatabaseEntry("dvascripting.EnabledInternalDOM", "false");
+ $._PPP_.updateEventPanel("ScriptLayerPPro.EnableNewWorld and dvascripting.EnabledInternalDOM are now OFF.");
+ } else {
+ qe.setDebugDatabaseEntry("ScriptLayerPPro.EnableNewWorld", "true");
+ qe.setDebugDatabaseEntry("dvascripting.EnabledInternalDOM", "true");
+ $._PPP_.updateEventPanel("ScriptLayerPPro.EnableNewWorld and dvascripting.EnabledInternalDOM are now ON.");
+ }
+ },
+
+ insertOrAppendToTopTracks : function() {
+ var seq = app.project.activeSequence;
+ if (seq){
+ var first = app.project.rootItem.children[0];
+ if (first){
+ var time = seq.getPlayerPosition();
+ var newClip = seq.insertClip(first, time, (seq.videoTracks.numTracks - 1), (seq.audioTracks.numTracks - 1));
+ if (newClip){
+ $._PPP_.updateEventPanel("Inserted " + newClip.name + ", into " + seq.name + ".");
+ }
+ } else {
+ $._PPP_.updateEventPanel("Couldn't locate first projectItem.");
+ }
+ } else {
+ $._PPP_.updateEventPanel("no active sequence.");
+ }
+ },
+
+ closeAllProjectsOtherThanActiveProject : function() {
+ var viewIDs = app.getProjectViewIDs();
+ var closeTheseProjects = [];
+ for (var a = 0; a < viewIDs.length; a++){
+ var thisProj = app.getProjectFromViewID(viewIDs[a]);
+ if (thisProj.documentID !== app.project.documentID){
+ closeTheseProjects[a] = thisProj;
+ }
+ }
+ // Why do this afterward? Because if we close projects in that loop, we change the active project. :)
+ for (var b = 0; b < closeTheseProjects.length; b++){
+ $._PPP_.updateEventPanel("Closed " + closeTheseProjects[b].name);
+ closeTheseProjects[b].closeDocument();
+ }
+ },
+
+ countAdjustmentLayersInBin : function(parentItem, arrayOfAdjustmentLayerNames, foundSoFar){
+ for (var j = 0; j < parentItem.children.numItems; j++){
+ var currentChild = parentItem.children[j];
+ if (currentChild){
+ if (currentChild.type == ProjectItemType.BIN){
+ $._PPP_.countAdjustmentLayersInBin(currentChild, arrayOfAdjustmentLayerNames, foundSoFar); // warning; recursion!
+ } else {
+ if (currentChild.isAdjustmentLayer()){
+ arrayOfAdjustmentLayerNames[foundSoFar] = currentChild.name;
+ foundSoFar++;
+ }
+ }
+ }
+ }
+ },
+
+ findAllAdjustmentLayersInProject : function() {
+ var arrayOfAdjustmentLayerNames = [];
+ var foundSoFar = 0;
+ var startingBin = app.project.rootItem;
+
+ $._PPP_.countAdjustmentLayersInBin(startingBin, arrayOfAdjustmentLayerNames, foundSoFar);
+ if (arrayOfAdjustmentLayerNames.length){
+ var remainingArgs = arrayOfAdjustmentLayerNames.length;
+ var message = remainingArgs + " adjustment layers found: ";
+
+ for (var i = 0; i < arrayOfAdjustmentLayerNames.length; i++) {
+ message += arrayOfAdjustmentLayerNames[i];
+ remainingArgs--;
+ if (remainingArgs > 1) {
+ message += ', ';
+ }
+ if (remainingArgs === 1){
+ message += ", and ";
+ }
+ if (remainingArgs === 0) {
+ message += ".";
+ }
+ }
+ $._PPP_.updateEventPanel(message);
+ } else {
+ $._PPP_.updateEventPanel("No adjustment layers found in " + app.project.name + ".");
+ }
+ },
+
+ consolidateDuplicates : function() {
+ result = app.project.consolidateDuplicates();
+ $._PPP_.updateEventPanel("Duplicates consolidated in " + app.project.name + ".");
+ },
+
+ closeAllSequences : function() {
+ var seqList = app.project.sequences;
+ for (var a = 0; a < seqList.numSequences; a++){
+ var currentSeq = seqList[a];
+ if (currentSeq){
+ currentSeq.close();
+ } else {
+ $._PPP_.updateEventPanel("No sequences from " + app.project.name + " were open.");
+ }
+ }
+ },
+
+ dumpAllPresets : function() {
+ var desktopPath = new File("~/Desktop");
+ var outputFileName = desktopPath.fsName + $._PPP_.getSep() + 'available_presets.txt';
+ var selectedPreset = undefined;
+ var selectedExporter = undefined;
+ var exporters = app.encoder.getExporters();
+
+ var outFile = new File(outputFileName);
+
+ outFile.encoding = "UTF8";
+ outFile.open("w", "TEXT", "????");
+
+ for(var i = 0; i < exporters.length; i++){
+ var exporter = exporters[i];
+ if (exporter){
+ outFile.writeln('-----------------------------------------------');
+ outFile.writeln(i + ':' + exporter.name + ' : ' + exporter.classID + ' : ' + exporter.fileType);
+ var presets = exporter.getPresets();
+ if (presets){
+ outFile.writeln(presets.length + ' presets found');
+ for(var j = 0; j < presets.length; j++){
+ var preset = presets[j];
+ if (preset){
+ outFile.writeln('matchName: ' + preset.matchName + '(' + preset.name+')');
+ if (preset.name.indexOf('TQM') > -1){
+ selectedPreset = preset;
+ selectedExporter = exporter;
+ outFile.writeln('selected preset = ' + selectedExporter.name + ' : ' + selectedPreset.name);
+ selectedPreset.writeToFile(desktopPath.fsName + $._PPP_.getSep() + preset.name + ".epr");
+ $._PPP_.updateEventPanel("List of available presets saved to desktop as \'available_presets.txt\'");
+ }
+ }
+ }
+ }
+ }
+ }
+ desktopPath.close();
+ outFile.close();
+ },
+
+ reportSequenceVRSettings : function() {
+ var seq = app.project.activeSequence;
+ if (seq){
+ var settings = seq.getSettings();
+ if (settings){
+ $._PPP_.updateEventPanel("====================================================");
+ $._PPP_.updateEventPanel("VR Settings for \'" + seq.name + "\':");
+ $._PPP_.updateEventPanel("");
+ $._PPP_.updateEventPanel(" Horizontal captured view: " + settings.vrHorzCapturedView);
+ $._PPP_.updateEventPanel(" Vertical captured view: " + settings.vrVertCapturedView);
+ $._PPP_.updateEventPanel(" Layout: " + settings.Layout);
+ $._PPP_.updateEventPanel(" Projection: " + settings.vrProjection);
+ $._PPP_.updateEventPanel("");
+ $._PPP_.updateEventPanel("====================================================");
+ }
+ }
+ },
+
+ openProjectItemInSource : function() {
+ var viewIDs = app.getProjectViewIDs();
+ if (viewIDs){
+ for (var a = 0; a < app.projects.numProjects; a++){
+ var currentProject = app.getProjectFromViewID(viewIDs[a]);
+ if (currentProject){
+ if (currentProject.documentID === app.project.documentID){ // We're in the right project!
+ var selectedItems = app.getProjectViewSelection(viewIDs[a]);
+ for (var b = 0; b < selectedItems.length; b++){
+ var currentItem = selectedItems[b];
+ if (currentItem){
+ if (currentItem.type !== ProjectItemType.BIN){ // For every selected item which isn't a bin or sequence...
+ app.sourceMonitor.openProjectItem(currentItem);
+ }
+ } else {
+ $._PPP_.updateEventPanel("No item available.");
+ }
+ }
+ }
+ } else {
+ $._PPP_.updateEventPanel("No project available.");
+ }
+ }
+ } else {
+ $._PPP_.updateEventPanel("No view IDs available.");
+ }
+ },
+
+ reinterpretFootage : function() {
+ var viewIDs = app.getProjectViewIDs();
+ if (viewIDs){
+ for (var a = 0; a < app.projects.numProjects; a++){
+ var currentProject = app.getProjectFromViewID(viewIDs[a]);
+ if (currentProject){
+ if (currentProject.documentID === app.project.documentID){ // We're in the right project!
+ var selectedItems = app.getProjectViewSelection(viewIDs[a]);
+ if (selectedItems){
+ for (var b = 0; b < selectedItems.length; b++){
+ var currentItem = selectedItems[b];
+ if (currentItem){
+ if ((currentItem.type !== ProjectItemType.BIN) &&
+ (currentItem.isSequence() === false)){
+ var interp = currentItem.getFootageInterpretation();
+ if (interp) {
+ // Note: I made this something terrible, so the change is apparent.
+ interp.frameRate = 17.868;
+ interp.pixelAspectRatio = 1.2121;
+ currentItem.setFootageInterpretation(interp);
+ } else {
+ $._PPP_.updateEventPanel("Unable to get interpretation for " + currentItem.name + ".");
+ }
+ var mapping = currentItem.getAudioChannelMapping;
+ if (mapping){
+ mapping.audioChannelsType = AUDIOCHANNELTYPE_Stereo;
+ mapping.audioClipsNumber = 1;
+ mapping.setMappingForChannel(0, 4); // 1st param = channel index, 2nd param = source index
+ mapping.setMappingForChannel(1, 5);
+ currentItem.setAudioChannelMapping(mapping); // submit changed mapping object
+ }
+ }
+ } else {
+ $._PPP_.updateEventPanel("No project item available.");
+ }
+ }
+ } else {
+ $._PPP_.updateEventPanel("No items selected.");
+ }
+ }
+ } else {
+ $._PPP_.updateEventPanel("No project available.");
+ }
+ }
+ } else {
+ $._PPP_.updateEventPanel("No view IDs available.");
+ }
+ },
+
+ createSubSequence : function() {
+
+ /* Behavioral Note
+
+ createSubSequence() uses track targeting to select clips when there is
+ no current clip selection, in the sequence. To create a subsequence with
+ clips on tracks that are currently NOT targeted, either select some clips
+ (on any track), or temporarily target all desired tracks.
+
+ */
+
+ var activeSequence = app.project.activeSequence;
+ if (activeSequence) {
+ var foundTarget = false;
+ for (var a = 0; (a < activeSequence.videoTracks.numTracks) && (foundTarget === false); a++){
+ var vTrack = activeSequence.videoTracks[a];
+ if (vTrack){
+ if (vTrack.isTargeted()){
+ foundTarget = true;
+ }
+ }
+ }
+ // If no targeted track was found, just target the zero-th track, for demo purposes
+ if (foundTarget === false){
+ activeSequence.videotracks[0].setTargeted(true, true);
+ }
+
+ var cloneAnyway = true;
+ if ((activeSequence.getInPoint() == NOT_SET) && (activeSequence.getOutPoint() == NOT_SET)){
+ cloneAnyway = confirm("No in or out points set; clone entire sequence?", false, "Clone the whole thing?");
+ }
+ if (cloneAnyway){
+ var ignoreMapping = confirm("Ignore track mapping?", false, "Ignore track mapping?");
+ var newSeq = activeSequence.createSubsequence(ignoreMapping);
+ // rename newSeq here, as desired.
+ }
+ } else {
+ $._PPP_.updateEventPanel("No active sequence.");
+ }
+ },
+
+ selectAllRetimedClips : function() {
+ var activeSeq = app.project.activeSequence;
+ var numRetimedClips = 0;
+ if (activeSeq){
+ var trackGroups = [ activeSeq.audioTracks, activeSeq.videoTracks ];
+ var trackGroupNames = [ "audioTracks", "videoTracks" ];
+ var updateUI = true;
+
+ for(var gi = 0; gi<2; gi++) {
+ group = trackGroups[gi];
+ for(var ti=0; ti} The file extensions (without the dot) for the types
+ * of files that can be selected. Ignored when chooseDirectory=true.
+ *
+ * @return An object with these properties:
+ * } The file extensions (without the dot) for the types
+ * of files that can be selected. Ignored when chooseDirectory=true.
+ * @param friendlyFilePrefix {string} String to put in front of the extensions
+ * of files that can be selected. Ignored when chooseDirectory=true. (win only)
+ * For example:
+ * fileTypes = ["gif", "jpg", "jpeg", "png", "bmp", "webp", "svg"];
+ * friendlyFilePrefix = "Images (*.gif;*.jpg;*.jpeg;*.png;*.bmp;*.webp;*.svg)";
+ * @param prompt {string} String for OK button (mac only, default is "Open" on mac, "Open" or "Select Folder" on win).
+ *
+ * @return An object with these properties:
+ * } The file extensions (without the dot) for the types
+ * of files that can be selected.
+ * @param defaultName {string} String to start with for the file name.
+ * @param friendlyFilePrefix {string} String to put in front of the extensions of files that can be selected. (win only)
+ * For example:
+ * fileTypes = ["gif", "jpg", "jpeg", "png", "bmp", "webp", "svg"];
+ * friendlyFilePrefix = "Images (*.gif;*.jpg;*.jpeg;*.png;*.bmp;*.webp;*.svg)";
+ * @param prompt {string} String for Save button (mac only, default is "Save" on mac and win).
+ * @param nameFieldLabel {string} String displayed in front of the file name text field (mac only, "File name:" on win).
+ *
+ * @return An object with these properties:
+ *
+ * PHXS
+ * 16.1.0
+ *
+ */
+Vulcan.prototype.getEndPoints = function()
+{
+ var params = {};
+ return JSON.parse(window.__adobe_cep__.invokeSync("vulcanGetEndPoints", JSON.stringify(params)));
+};
+
+/**
+ * Gets the endpoint for itself.
+ *
+ * Since 7.0.0
+ *
+ * @return The endpoint string for itself.
+ */
+Vulcan.prototype.getSelfEndPoint = function()
+{
+ var params = {};
+ return window.__adobe_cep__.invokeSync("vulcanGetSelfEndPoint", JSON.stringify(params));
+};
+
+/** Singleton instance of Vulcan **/
+var VulcanInterface = new Vulcan();
+
+//--------------------------------- Vulcan Message ------------------------------
+
+/**
+ * @class VulcanMessage
+ * Message type for sending messages between host applications.
+ * A message of this type can be sent to the designated destination
+ * when appId and appVersion are provided and valid. Otherwise,
+ * the message is broadcast to all running Vulcan-enabled applications.
+ *
+ * To send a message between extensions running within one
+ * application, use the {0} ";
+
+/**
+ * Initializes this message instance.
+ *
+ * @param message A \c message instance to use for initialization.
+ */
+VulcanMessage.prototype.initialize = function(message)
+{
+ this.type = message.type;
+ this.scope = message.scope;
+ this.appId = message.appId;
+ this.appVersion = message.appVersion;
+ this.data = message.data;
+};
+
+/**
+ * Retrieves the message data.
+ *
+ * @return A data string in XML format.
+ */
+VulcanMessage.prototype.xmlData = function()
+{
+ if(this.data === undefined)
+ {
+ var str = "";
+ str = String.format(VulcanMessage.payloadTemplate, str);
+ this.data = String.format(VulcanMessage.dataTemplate, str);
+ }
+ return this.data;
+};
+
+/**
+ * Sets the message payload of this message.
+ *
+ * @param payload A string containing the message payload.
+ */
+VulcanMessage.prototype.setPayload = function(payload)
+{
+ var str = cep.encoding.convertion.utf8_to_b64(payload);
+ str = String.format(VulcanMessage.payloadTemplate, str);
+ this.data = String.format(VulcanMessage.dataTemplate, str);
+};
+
+/**
+ * Retrieves the message payload of this message.
+ *
+ * @return A string containing the message payload.
+ */
+VulcanMessage.prototype.getPayload = function()
+{
+ var str = GetValueByKey(this.data, "payload");
+ if(str !== null)
+ {
+ return cep.encoding.convertion.b64_to_utf8(str);
+ }
+ return null;
+};
+
+/**
+ * Converts the properties of this instance to a string.
+ *
+ * @return The string version of this instance.
+ */
+VulcanMessage.prototype.toString = function()
+{
+ var str = "type=" + this.type;
+ str += ", scope=" + this.scope;
+ str += ", appId=" + this.appId;
+ str += ", appVersion=" + this.appVersion;
+ str += ", data=" + this.xmlData();
+ return str;
+};
+
+//--------------------------------------- Util --------------------------------
+
+/**
+ * Formats a string based on a template.
+ *
+ * @param src The format template.
+ *
+ * @return The formatted string
+ */
+String.format = function(src)
+{
+ if (arguments.length === 0)
+ {
+ return null;
+ }
+
+ var args = Array.prototype.slice.call(arguments, 1);
+ return src.replace(/\{(\d+)\}/g, function(m, i){
+ return args[i];
+ });
+};
+
+/**
+ * Retrieves the content of an XML element.
+ *
+ * @param xmlStr The XML string.
+ * @param key The name of the tag.
+ *
+ * @return The content of the tag, or the empty string
+ * if such tag is not found or the tag has no content.
+ */
+function GetValueByKey(xmlStr, key)
+{
+ if(window.DOMParser)
+ {
+ var parser = new window.DOMParser();
+ try
+ {
+ var xmlDoc = parser.parseFromString(xmlStr, "text/xml");
+ var node = xmlDoc.getElementsByTagName(key)[0];
+ if(node && node.childNodes[0])
+ {
+ return node.childNodes[0].nodeValue;
+ }
+ }
+ catch(e)
+ {
+ //log the error
+ }
+ }
+ return "";
+}
+
+/**
+ * Reports whether required parameters are valid.
+ *
+ * @return True if all required parameters are valid,
+ * false if any of the required parameters are invalid.
+ */
+function requiredParamsValid()
+{
+ for(var i = 0; i < arguments.length; i++)
+ {
+ var argument = arguments[i];
+ if(argument === undefined || argument === null)
+ {
+ return false;
+ }
+ }
+ return true;
+}
+
+/**
+ * Reports whether a string has a given prefix.
+ *
+ * @param str The target string.
+ * @param prefix The specific prefix string.
+ *
+ * @return True if the string has the prefix, false if not.
+ */
+function strStartsWith(str, prefix)
+{
+ if(typeof str != "string")
+ {
+ return false;
+ }
+ return str.indexOf(prefix) === 0;
+}
diff --git a/pype/premiere/extensions/com.pype.rename/lib/jquery-1.9.1.js b/pype/premiere/extensions/com.pype.rename/lib/jquery-1.9.1.js
new file mode 100644
index 0000000000..e2c203fe97
--- /dev/null
+++ b/pype/premiere/extensions/com.pype.rename/lib/jquery-1.9.1.js
@@ -0,0 +1,9597 @@
+/*!
+ * jQuery JavaScript Library v1.9.1
+ * http://jquery.com/
+ *
+ * Includes Sizzle.js
+ * http://sizzlejs.com/
+ *
+ * Copyright 2005, 2012 jQuery Foundation, Inc. and other contributors
+ * Released under the MIT license
+ * http://jquery.org/license
+ *
+ * Date: 2013-2-4
+ */
+(function( window, undefined ) {
+
+// Can't do this because several apps including ASP.NET trace
+// the stack via arguments.caller.callee and Firefox dies if
+// you try to trace through "use strict" call chains. (#13335)
+// Support: Firefox 18+
+//"use strict";
+var
+ // The deferred used on DOM ready
+ readyList,
+
+ // A central reference to the root jQuery(document)
+ rootjQuery,
+
+ // Support: IE<9
+ // For `typeof node.method` instead of `node.method !== undefined`
+ core_strundefined = typeof undefined,
+
+ // Use the correct document accordingly with window argument (sandbox)
+ document = window.document,
+ location = window.location,
+
+ // Map over jQuery in case of overwrite
+ _jQuery = window.jQuery,
+
+ // Map over the $ in case of overwrite
+ _$ = window.$,
+
+ // [[Class]] -> type pairs
+ class2type = {},
+
+ // List of deleted data cache ids, so we can reuse them
+ core_deletedIds = [],
+
+ core_version = "1.9.1",
+
+ // Save a reference to some core methods
+ core_concat = core_deletedIds.concat,
+ core_push = core_deletedIds.push,
+ core_slice = core_deletedIds.slice,
+ core_indexOf = core_deletedIds.indexOf,
+ core_toString = class2type.toString,
+ core_hasOwn = class2type.hasOwnProperty,
+ core_trim = core_version.trim,
+
+ // Define a local copy of jQuery
+ jQuery = function( selector, context ) {
+ // The jQuery object is actually just the init constructor 'enhanced'
+ return new jQuery.fn.init( selector, context, rootjQuery );
+ },
+
+ // Used for matching numbers
+ core_pnum = /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source,
+
+ // Used for splitting on whitespace
+ core_rnotwhite = /\S+/g,
+
+ // Make sure we trim BOM and NBSP (here's looking at you, Safari 5.0 and IE)
+ rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,
+
+ // A simple way to check for HTML strings
+ // Prioritize #id over to avoid XSS via location.hash (#9521)
+ // Strict HTML recognition (#11290: must start with <)
+ rquickExpr = /^(?:(<[\w\W]+>)[^>]*|#([\w-]*))$/,
+
+ // Match a standalone tag
+ rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>|)$/,
+
+ // JSON RegExp
+ rvalidchars = /^[\],:{}\s]*$/,
+ rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,
+ rvalidescape = /\\(?:["\\\/bfnrt]|u[\da-fA-F]{4})/g,
+ rvalidtokens = /"[^"\\\r\n]*"|true|false|null|-?(?:\d+\.|)\d+(?:[eE][+-]?\d+|)/g,
+
+ // Matches dashed string for camelizing
+ rmsPrefix = /^-ms-/,
+ rdashAlpha = /-([\da-z])/gi,
+
+ // Used by jQuery.camelCase as callback to replace()
+ fcamelCase = function( all, letter ) {
+ return letter.toUpperCase();
+ },
+
+ // The ready event handler
+ completed = function( event ) {
+
+ // readyState === "complete" is good enough for us to call the dom ready in oldIE
+ if ( document.addEventListener || event.type === "load" || document.readyState === "complete" ) {
+ detach();
+ jQuery.ready();
+ }
+ },
+ // Clean-up method for dom ready events
+ detach = function() {
+ if ( document.addEventListener ) {
+ document.removeEventListener( "DOMContentLoaded", completed, false );
+ window.removeEventListener( "load", completed, false );
+
+ } else {
+ document.detachEvent( "onreadystatechange", completed );
+ window.detachEvent( "onload", completed );
+ }
+ };
+
+jQuery.fn = jQuery.prototype = {
+ // The current version of jQuery being used
+ jquery: core_version,
+
+ constructor: jQuery,
+ init: function( selector, context, rootjQuery ) {
+ var match, elem;
+
+ // HANDLE: $(""), $(null), $(undefined), $(false)
+ if ( !selector ) {
+ return this;
+ }
+
+ // Handle HTML strings
+ if ( typeof selector === "string" ) {
+ if ( selector.charAt(0) === "<" && selector.charAt( selector.length - 1 ) === ">" && selector.length >= 3 ) {
+ // Assume that strings that start and end with <> are HTML and skip the regex check
+ match = [ null, selector, null ];
+
+ } else {
+ match = rquickExpr.exec( selector );
+ }
+
+ // Match html or make sure no context is specified for #id
+ if ( match && (match[1] || !context) ) {
+
+ // HANDLE: $(html) -> $(array)
+ if ( match[1] ) {
+ context = context instanceof jQuery ? context[0] : context;
+
+ // scripts is true for back-compat
+ jQuery.merge( this, jQuery.parseHTML(
+ match[1],
+ context && context.nodeType ? context.ownerDocument || context : document,
+ true
+ ) );
+
+ // HANDLE: $(html, props)
+ if ( rsingleTag.test( match[1] ) && jQuery.isPlainObject( context ) ) {
+ for ( match in context ) {
+ // Properties of context are called as methods if possible
+ if ( jQuery.isFunction( this[ match ] ) ) {
+ this[ match ]( context[ match ] );
+
+ // ...and otherwise set as attributes
+ } else {
+ this.attr( match, context[ match ] );
+ }
+ }
+ }
+
+ return this;
+
+ // HANDLE: $(#id)
+ } else {
+ elem = document.getElementById( match[2] );
+
+ // Check parentNode to catch when Blackberry 4.6 returns
+ // nodes that are no longer in the document #6963
+ if ( elem && elem.parentNode ) {
+ // Handle the case where IE and Opera return items
+ // by name instead of ID
+ if ( elem.id !== match[2] ) {
+ return rootjQuery.find( selector );
+ }
+
+ // Otherwise, we inject the element directly into the jQuery object
+ this.length = 1;
+ this[0] = elem;
+ }
+
+ this.context = document;
+ this.selector = selector;
+ return this;
+ }
+
+ // HANDLE: $(expr, $(...))
+ } else if ( !context || context.jquery ) {
+ return ( context || rootjQuery ).find( selector );
+
+ // HANDLE: $(expr, context)
+ // (which is just equivalent to: $(context).find(expr)
+ } else {
+ return this.constructor( context ).find( selector );
+ }
+
+ // HANDLE: $(DOMElement)
+ } else if ( selector.nodeType ) {
+ this.context = this[0] = selector;
+ this.length = 1;
+ return this;
+
+ // HANDLE: $(function)
+ // Shortcut for document ready
+ } else if ( jQuery.isFunction( selector ) ) {
+ return rootjQuery.ready( selector );
+ }
+
+ if ( selector.selector !== undefined ) {
+ this.selector = selector.selector;
+ this.context = selector.context;
+ }
+
+ return jQuery.makeArray( selector, this );
+ },
+
+ // Start with an empty selector
+ selector: "",
+
+ // The default length of a jQuery object is 0
+ length: 0,
+
+ // The number of elements contained in the matched element set
+ size: function() {
+ return this.length;
+ },
+
+ toArray: function() {
+ return core_slice.call( this );
+ },
+
+ // Get the Nth element in the matched element set OR
+ // Get the whole matched element set as a clean array
+ get: function( num ) {
+ return num == null ?
+
+ // Return a 'clean' array
+ this.toArray() :
+
+ // Return just the object
+ ( num < 0 ? this[ this.length + num ] : this[ num ] );
+ },
+
+ // Take an array of elements and push it onto the stack
+ // (returning the new matched element set)
+ pushStack: function( elems ) {
+
+ // Build a new jQuery matched element set
+ var ret = jQuery.merge( this.constructor(), elems );
+
+ // Add the old object onto the stack (as a reference)
+ ret.prevObject = this;
+ ret.context = this.context;
+
+ // Return the newly-formed element set
+ return ret;
+ },
+
+ // Execute a callback for every element in the matched set.
+ // (You can seed the arguments with an array of args, but this is
+ // only used internally.)
+ each: function( callback, args ) {
+ return jQuery.each( this, callback, args );
+ },
+
+ ready: function( fn ) {
+ // Add the callback
+ jQuery.ready.promise().done( fn );
+
+ return this;
+ },
+
+ slice: function() {
+ return this.pushStack( core_slice.apply( this, arguments ) );
+ },
+
+ first: function() {
+ return this.eq( 0 );
+ },
+
+ last: function() {
+ return this.eq( -1 );
+ },
+
+ eq: function( i ) {
+ var len = this.length,
+ j = +i + ( i < 0 ? len : 0 );
+ return this.pushStack( j >= 0 && j < len ? [ this[j] ] : [] );
+ },
+
+ map: function( callback ) {
+ return this.pushStack( jQuery.map(this, function( elem, i ) {
+ return callback.call( elem, i, elem );
+ }));
+ },
+
+ end: function() {
+ return this.prevObject || this.constructor(null);
+ },
+
+ // For internal use only.
+ // Behaves like an Array's method, not like a jQuery method.
+ push: core_push,
+ sort: [].sort,
+ splice: [].splice
+};
+
+// Give the init function the jQuery prototype for later instantiation
+jQuery.fn.init.prototype = jQuery.fn;
+
+jQuery.extend = jQuery.fn.extend = function() {
+ var src, copyIsArray, copy, name, options, clone,
+ target = arguments[0] || {},
+ i = 1,
+ length = arguments.length,
+ deep = false;
+
+ // Handle a deep copy situation
+ if ( typeof target === "boolean" ) {
+ deep = target;
+ target = arguments[1] || {};
+ // skip the boolean and the target
+ i = 2;
+ }
+
+ // Handle case when target is a string or something (possible in deep copy)
+ if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
+ target = {};
+ }
+
+ // extend jQuery itself if only one argument is passed
+ if ( length === i ) {
+ target = this;
+ --i;
+ }
+
+ for ( ; i < length; i++ ) {
+ // Only deal with non-null/undefined values
+ if ( (options = arguments[ i ]) != null ) {
+ // Extend the base object
+ for ( name in options ) {
+ src = target[ name ];
+ copy = options[ name ];
+
+ // Prevent never-ending loop
+ if ( target === copy ) {
+ continue;
+ }
+
+ // Recurse if we're merging plain objects or arrays
+ if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
+ if ( copyIsArray ) {
+ copyIsArray = false;
+ clone = src && jQuery.isArray(src) ? src : [];
+
+ } else {
+ clone = src && jQuery.isPlainObject(src) ? src : {};
+ }
+
+ // Never move original objects, clone them
+ target[ name ] = jQuery.extend( deep, clone, copy );
+
+ // Don't bring in undefined values
+ } else if ( copy !== undefined ) {
+ target[ name ] = copy;
+ }
+ }
+ }
+ }
+
+ // Return the modified object
+ return target;
+};
+
+jQuery.extend({
+ noConflict: function( deep ) {
+ if ( window.$ === jQuery ) {
+ window.$ = _$;
+ }
+
+ if ( deep && window.jQuery === jQuery ) {
+ window.jQuery = _jQuery;
+ }
+
+ return jQuery;
+ },
+
+ // Is the DOM ready to be used? Set to true once it occurs.
+ isReady: false,
+
+ // A counter to track how many items to wait for before
+ // the ready event fires. See #6781
+ readyWait: 1,
+
+ // Hold (or release) the ready event
+ holdReady: function( hold ) {
+ if ( hold ) {
+ jQuery.readyWait++;
+ } else {
+ jQuery.ready( true );
+ }
+ },
+
+ // Handle when the DOM is ready
+ ready: function( wait ) {
+
+ // Abort if there are pending holds or we're already ready
+ if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {
+ return;
+ }
+
+ // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
+ if ( !document.body ) {
+ return setTimeout( jQuery.ready );
+ }
+
+ // Remember that the DOM is ready
+ jQuery.isReady = true;
+
+ // If a normal DOM Ready event fired, decrement, and wait if need be
+ if ( wait !== true && --jQuery.readyWait > 0 ) {
+ return;
+ }
+
+ // If there are functions bound, to execute
+ readyList.resolveWith( document, [ jQuery ] );
+
+ // Trigger any bound ready events
+ if ( jQuery.fn.trigger ) {
+ jQuery( document ).trigger("ready").off("ready");
+ }
+ },
+
+ // See test/unit/core.js for details concerning isFunction.
+ // Since version 1.3, DOM methods and functions like alert
+ // aren't supported. They return false on IE (#2968).
+ isFunction: function( obj ) {
+ return jQuery.type(obj) === "function";
+ },
+
+ isArray: Array.isArray || function( obj ) {
+ return jQuery.type(obj) === "array";
+ },
+
+ isWindow: function( obj ) {
+ return obj != null && obj == obj.window;
+ },
+
+ isNumeric: function( obj ) {
+ return !isNaN( parseFloat(obj) ) && isFinite( obj );
+ },
+
+ type: function( obj ) {
+ if ( obj == null ) {
+ return String( obj );
+ }
+ return typeof obj === "object" || typeof obj === "function" ?
+ class2type[ core_toString.call(obj) ] || "object" :
+ typeof obj;
+ },
+
+ isPlainObject: function( obj ) {
+ // Must be an Object.
+ // Because of IE, we also have to check the presence of the constructor property.
+ // Make sure that DOM nodes and window objects don't pass through, as well
+ if ( !obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
+ return false;
+ }
+
+ try {
+ // Not own constructor property must be Object
+ if ( obj.constructor &&
+ !core_hasOwn.call(obj, "constructor") &&
+ !core_hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) {
+ return false;
+ }
+ } catch ( e ) {
+ // IE8,9 Will throw exceptions on certain host objects #9897
+ return false;
+ }
+
+ // Own properties are enumerated firstly, so to speed up,
+ // if last one is own, then all properties are own.
+
+ var key;
+ for ( key in obj ) {}
+
+ return key === undefined || core_hasOwn.call( obj, key );
+ },
+
+ isEmptyObject: function( obj ) {
+ var name;
+ for ( name in obj ) {
+ return false;
+ }
+ return true;
+ },
+
+ error: function( msg ) {
+ throw new Error( msg );
+ },
+
+ // data: string of html
+ // context (optional): If specified, the fragment will be created in this context, defaults to document
+ // keepScripts (optional): If true, will include scripts passed in the html string
+ parseHTML: function( data, context, keepScripts ) {
+ if ( !data || typeof data !== "string" ) {
+ return null;
+ }
+ if ( typeof context === "boolean" ) {
+ keepScripts = context;
+ context = false;
+ }
+ context = context || document;
+
+ var parsed = rsingleTag.exec( data ),
+ scripts = !keepScripts && [];
+
+ // Single tag
+ if ( parsed ) {
+ return [ context.createElement( parsed[1] ) ];
+ }
+
+ parsed = jQuery.buildFragment( [ data ], context, scripts );
+ if ( scripts ) {
+ jQuery( scripts ).remove();
+ }
+ return jQuery.merge( [], parsed.childNodes );
+ },
+
+ parseJSON: function( data ) {
+ // Attempt to parse using the native JSON parser first
+ if ( window.JSON && window.JSON.parse ) {
+ return window.JSON.parse( data );
+ }
+
+ if ( data === null ) {
+ return data;
+ }
+
+ if ( typeof data === "string" ) {
+
+ // Make sure leading/trailing whitespace is removed (IE can't handle it)
+ data = jQuery.trim( data );
+
+ if ( data ) {
+ // Make sure the incoming data is actual JSON
+ // Logic borrowed from http://json.org/json2.js
+ if ( rvalidchars.test( data.replace( rvalidescape, "@" )
+ .replace( rvalidtokens, "]" )
+ .replace( rvalidbraces, "")) ) {
+
+ return ( new Function( "return " + data ) )();
+ }
+ }
+ }
+
+ jQuery.error( "Invalid JSON: " + data );
+ },
+
+ // Cross-browser xml parsing
+ parseXML: function( data ) {
+ var xml, tmp;
+ if ( !data || typeof data !== "string" ) {
+ return null;
+ }
+ try {
+ if ( window.DOMParser ) { // Standard
+ tmp = new DOMParser();
+ xml = tmp.parseFromString( data , "text/xml" );
+ } else { // IE
+ xml = new ActiveXObject( "Microsoft.XMLDOM" );
+ xml.async = "false";
+ xml.loadXML( data );
+ }
+ } catch( e ) {
+ xml = undefined;
+ }
+ if ( !xml || !xml.documentElement || xml.getElementsByTagName( "parsererror" ).length ) {
+ jQuery.error( "Invalid XML: " + data );
+ }
+ return xml;
+ },
+
+ noop: function() {},
+
+ // Evaluates a script in a global context
+ // Workarounds based on findings by Jim Driscoll
+ // http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context
+ globalEval: function( data ) {
+ if ( data && jQuery.trim( data ) ) {
+ // We use execScript on Internet Explorer
+ // We use an anonymous function so that context is window
+ // rather than jQuery in Firefox
+ ( window.execScript || function( data ) {
+ window[ "eval" ].call( window, data );
+ } )( data );
+ }
+ },
+
+ // Convert dashed to camelCase; used by the css and data modules
+ // Microsoft forgot to hump their vendor prefix (#9572)
+ camelCase: function( string ) {
+ return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
+ },
+
+ nodeName: function( elem, name ) {
+ return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
+ },
+
+ // args is for internal usage only
+ each: function( obj, callback, args ) {
+ var value,
+ i = 0,
+ length = obj.length,
+ isArray = isArraylike( obj );
+
+ if ( args ) {
+ if ( isArray ) {
+ for ( ; i < length; i++ ) {
+ value = callback.apply( obj[ i ], args );
+
+ if ( value === false ) {
+ break;
+ }
+ }
+ } else {
+ for ( i in obj ) {
+ value = callback.apply( obj[ i ], args );
+
+ if ( value === false ) {
+ break;
+ }
+ }
+ }
+
+ // A special, fast, case for the most common use of each
+ } else {
+ if ( isArray ) {
+ for ( ; i < length; i++ ) {
+ value = callback.call( obj[ i ], i, obj[ i ] );
+
+ if ( value === false ) {
+ break;
+ }
+ }
+ } else {
+ for ( i in obj ) {
+ value = callback.call( obj[ i ], i, obj[ i ] );
+
+ if ( value === false ) {
+ break;
+ }
+ }
+ }
+ }
+
+ return obj;
+ },
+
+ // Use native String.trim function wherever possible
+ trim: core_trim && !core_trim.call("\uFEFF\xA0") ?
+ function( text ) {
+ return text == null ?
+ "" :
+ core_trim.call( text );
+ } :
+
+ // Otherwise use our own trimming functionality
+ function( text ) {
+ return text == null ?
+ "" :
+ ( text + "" ).replace( rtrim, "" );
+ },
+
+ // results is for internal usage only
+ makeArray: function( arr, results ) {
+ var ret = results || [];
+
+ if ( arr != null ) {
+ if ( isArraylike( Object(arr) ) ) {
+ jQuery.merge( ret,
+ typeof arr === "string" ?
+ [ arr ] : arr
+ );
+ } else {
+ core_push.call( ret, arr );
+ }
+ }
+
+ return ret;
+ },
+
+ inArray: function( elem, arr, i ) {
+ var len;
+
+ if ( arr ) {
+ if ( core_indexOf ) {
+ return core_indexOf.call( arr, elem, i );
+ }
+
+ len = arr.length;
+ i = i ? i < 0 ? Math.max( 0, len + i ) : i : 0;
+
+ for ( ; i < len; i++ ) {
+ // Skip accessing in sparse arrays
+ if ( i in arr && arr[ i ] === elem ) {
+ return i;
+ }
+ }
+ }
+
+ return -1;
+ },
+
+ merge: function( first, second ) {
+ var l = second.length,
+ i = first.length,
+ j = 0;
+
+ if ( typeof l === "number" ) {
+ for ( ; j < l; j++ ) {
+ first[ i++ ] = second[ j ];
+ }
+ } else {
+ while ( second[j] !== undefined ) {
+ first[ i++ ] = second[ j++ ];
+ }
+ }
+
+ first.length = i;
+
+ return first;
+ },
+
+ grep: function( elems, callback, inv ) {
+ var retVal,
+ ret = [],
+ i = 0,
+ length = elems.length;
+ inv = !!inv;
+
+ // Go through the array, only saving the items
+ // that pass the validator function
+ for ( ; i < length; i++ ) {
+ retVal = !!callback( elems[ i ], i );
+ if ( inv !== retVal ) {
+ ret.push( elems[ i ] );
+ }
+ }
+
+ return ret;
+ },
+
+ // arg is for internal usage only
+ map: function( elems, callback, arg ) {
+ var value,
+ i = 0,
+ length = elems.length,
+ isArray = isArraylike( elems ),
+ ret = [];
+
+ // Go through the array, translating each of the items to their
+ if ( isArray ) {
+ for ( ; i < length; i++ ) {
+ value = callback( elems[ i ], i, arg );
+
+ if ( value != null ) {
+ ret[ ret.length ] = value;
+ }
+ }
+
+ // Go through every key on the object,
+ } else {
+ for ( i in elems ) {
+ value = callback( elems[ i ], i, arg );
+
+ if ( value != null ) {
+ ret[ ret.length ] = value;
+ }
+ }
+ }
+
+ // Flatten any nested arrays
+ return core_concat.apply( [], ret );
+ },
+
+ // A global GUID counter for objects
+ guid: 1,
+
+ // Bind a function to a context, optionally partially applying any
+ // arguments.
+ proxy: function( fn, context ) {
+ var args, proxy, tmp;
+
+ if ( typeof context === "string" ) {
+ tmp = fn[ context ];
+ context = fn;
+ fn = tmp;
+ }
+
+ // Quick check to determine if target is callable, in the spec
+ // this throws a TypeError, but we will just return undefined.
+ if ( !jQuery.isFunction( fn ) ) {
+ return undefined;
+ }
+
+ // Simulated bind
+ args = core_slice.call( arguments, 2 );
+ proxy = function() {
+ return fn.apply( context || this, args.concat( core_slice.call( arguments ) ) );
+ };
+
+ // Set the guid of unique handler to the same of original handler, so it can be removed
+ proxy.guid = fn.guid = fn.guid || jQuery.guid++;
+
+ return proxy;
+ },
+
+ // Multifunctional method to get and set values of a collection
+ // The value/s can optionally be executed if it's a function
+ access: function( elems, fn, key, value, chainable, emptyGet, raw ) {
+ var i = 0,
+ length = elems.length,
+ bulk = key == null;
+
+ // Sets many values
+ if ( jQuery.type( key ) === "object" ) {
+ chainable = true;
+ for ( i in key ) {
+ jQuery.access( elems, fn, i, key[i], true, emptyGet, raw );
+ }
+
+ // Sets one value
+ } else if ( value !== undefined ) {
+ chainable = true;
+
+ if ( !jQuery.isFunction( value ) ) {
+ raw = true;
+ }
+
+ if ( bulk ) {
+ // Bulk operations run against the entire set
+ if ( raw ) {
+ fn.call( elems, value );
+ fn = null;
+
+ // ...except when executing function values
+ } else {
+ bulk = fn;
+ fn = function( elem, key, value ) {
+ return bulk.call( jQuery( elem ), value );
+ };
+ }
+ }
+
+ if ( fn ) {
+ for ( ; i < length; i++ ) {
+ fn( elems[i], key, raw ? value : value.call( elems[i], i, fn( elems[i], key ) ) );
+ }
+ }
+ }
+
+ return chainable ?
+ elems :
+
+ // Gets
+ bulk ?
+ fn.call( elems ) :
+ length ? fn( elems[0], key ) : emptyGet;
+ },
+
+ now: function() {
+ return ( new Date() ).getTime();
+ }
+});
+
+jQuery.ready.promise = function( obj ) {
+ if ( !readyList ) {
+
+ readyList = jQuery.Deferred();
+
+ // Catch cases where $(document).ready() is called after the browser event has already occurred.
+ // we once tried to use readyState "interactive" here, but it caused issues like the one
+ // discovered by ChrisS here: http://bugs.jquery.com/ticket/12282#comment:15
+ if ( document.readyState === "complete" ) {
+ // Handle it asynchronously to allow scripts the opportunity to delay ready
+ setTimeout( jQuery.ready );
+
+ // Standards-based browsers support DOMContentLoaded
+ } else if ( document.addEventListener ) {
+ // Use the handy event callback
+ document.addEventListener( "DOMContentLoaded", completed, false );
+
+ // A fallback to window.onload, that will always work
+ window.addEventListener( "load", completed, false );
+
+ // If IE event model is used
+ } else {
+ // Ensure firing before onload, maybe late but safe also for iframes
+ document.attachEvent( "onreadystatechange", completed );
+
+ // A fallback to window.onload, that will always work
+ window.attachEvent( "onload", completed );
+
+ // If IE and not a frame
+ // continually check to see if the document is ready
+ var top = false;
+
+ try {
+ top = window.frameElement == null && document.documentElement;
+ } catch(e) {}
+
+ if ( top && top.doScroll ) {
+ (function doScrollCheck() {
+ if ( !jQuery.isReady ) {
+
+ try {
+ // Use the trick by Diego Perini
+ // http://javascript.nwbox.com/IEContentLoaded/
+ top.doScroll("left");
+ } catch(e) {
+ return setTimeout( doScrollCheck, 50 );
+ }
+
+ // detach all dom ready events
+ detach();
+
+ // and execute any waiting functions
+ jQuery.ready();
+ }
+ })();
+ }
+ }
+ }
+ return readyList.promise( obj );
+};
+
+// Populate the class2type map
+jQuery.each("Boolean Number String Function Array Date RegExp Object Error".split(" "), function(i, name) {
+ class2type[ "[object " + name + "]" ] = name.toLowerCase();
+});
+
+function isArraylike( obj ) {
+ var length = obj.length,
+ type = jQuery.type( obj );
+
+ if ( jQuery.isWindow( obj ) ) {
+ return false;
+ }
+
+ if ( obj.nodeType === 1 && length ) {
+ return true;
+ }
+
+ return type === "array" || type !== "function" &&
+ ( length === 0 ||
+ typeof length === "number" && length > 0 && ( length - 1 ) in obj );
+}
+
+// All jQuery objects should point back to these
+rootjQuery = jQuery(document);
+// String to Object options format cache
+var optionsCache = {};
+
+// Convert String-formatted options into Object-formatted ones and store in cache
+function createOptions( options ) {
+ var object = optionsCache[ options ] = {};
+ jQuery.each( options.match( core_rnotwhite ) || [], function( _, flag ) {
+ object[ flag ] = true;
+ });
+ return object;
+}
+
+/*
+ * Create a callback list using the following parameters:
+ *
+ * options: an optional list of space-separated options that will change how
+ * the callback list behaves or a more traditional option object
+ *
+ * By default a callback list will act like an event callback list and can be
+ * "fired" multiple times.
+ *
+ * Possible options:
+ *
+ * once: will ensure the callback list can only be fired once (like a Deferred)
+ *
+ * memory: will keep track of previous values and will call any callback added
+ * after the list has been fired right away with the latest "memorized"
+ * values (like a Deferred)
+ *
+ * unique: will ensure a callback can only be added once (no duplicate in the list)
+ *
+ * stopOnFalse: interrupt callings when a callback returns false
+ *
+ */
+jQuery.Callbacks = function( options ) {
+
+ // Convert options from String-formatted to Object-formatted if needed
+ // (we check in cache first)
+ options = typeof options === "string" ?
+ ( optionsCache[ options ] || createOptions( options ) ) :
+ jQuery.extend( {}, options );
+
+ var // Flag to know if list is currently firing
+ firing,
+ // Last fire value (for non-forgettable lists)
+ memory,
+ // Flag to know if list was already fired
+ fired,
+ // End of the loop when firing
+ firingLength,
+ // Index of currently firing callback (modified by remove if needed)
+ firingIndex,
+ // First callback to fire (used internally by add and fireWith)
+ firingStart,
+ // Actual callback list
+ list = [],
+ // Stack of fire calls for repeatable lists
+ stack = !options.once && [],
+ // Fire callbacks
+ fire = function( data ) {
+ memory = options.memory && data;
+ fired = true;
+ firingIndex = firingStart || 0;
+ firingStart = 0;
+ firingLength = list.length;
+ firing = true;
+ for ( ; list && firingIndex < firingLength; firingIndex++ ) {
+ if ( list[ firingIndex ].apply( data[ 0 ], data[ 1 ] ) === false && options.stopOnFalse ) {
+ memory = false; // To prevent further calls using add
+ break;
+ }
+ }
+ firing = false;
+ if ( list ) {
+ if ( stack ) {
+ if ( stack.length ) {
+ fire( stack.shift() );
+ }
+ } else if ( memory ) {
+ list = [];
+ } else {
+ self.disable();
+ }
+ }
+ },
+ // Actual Callbacks object
+ self = {
+ // Add a callback or a collection of callbacks to the list
+ add: function() {
+ if ( list ) {
+ // First, we save the current length
+ var start = list.length;
+ (function add( args ) {
+ jQuery.each( args, function( _, arg ) {
+ var type = jQuery.type( arg );
+ if ( type === "function" ) {
+ if ( !options.unique || !self.has( arg ) ) {
+ list.push( arg );
+ }
+ } else if ( arg && arg.length && type !== "string" ) {
+ // Inspect recursively
+ add( arg );
+ }
+ });
+ })( arguments );
+ // Do we need to add the callbacks to the
+ // current firing batch?
+ if ( firing ) {
+ firingLength = list.length;
+ // With memory, if we're not firing then
+ // we should call right away
+ } else if ( memory ) {
+ firingStart = start;
+ fire( memory );
+ }
+ }
+ return this;
+ },
+ // Remove a callback from the list
+ remove: function() {
+ if ( list ) {
+ jQuery.each( arguments, function( _, arg ) {
+ var index;
+ while( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {
+ list.splice( index, 1 );
+ // Handle firing indexes
+ if ( firing ) {
+ if ( index <= firingLength ) {
+ firingLength--;
+ }
+ if ( index <= firingIndex ) {
+ firingIndex--;
+ }
+ }
+ }
+ });
+ }
+ return this;
+ },
+ // Check if a given callback is in the list.
+ // If no argument is given, return whether or not list has callbacks attached.
+ has: function( fn ) {
+ return fn ? jQuery.inArray( fn, list ) > -1 : !!( list && list.length );
+ },
+ // Remove all callbacks from the list
+ empty: function() {
+ list = [];
+ return this;
+ },
+ // Have the list do nothing anymore
+ disable: function() {
+ list = stack = memory = undefined;
+ return this;
+ },
+ // Is it disabled?
+ disabled: function() {
+ return !list;
+ },
+ // Lock the list in its current state
+ lock: function() {
+ stack = undefined;
+ if ( !memory ) {
+ self.disable();
+ }
+ return this;
+ },
+ // Is it locked?
+ locked: function() {
+ return !stack;
+ },
+ // Call all callbacks with the given context and arguments
+ fireWith: function( context, args ) {
+ args = args || [];
+ args = [ context, args.slice ? args.slice() : args ];
+ if ( list && ( !fired || stack ) ) {
+ if ( firing ) {
+ stack.push( args );
+ } else {
+ fire( args );
+ }
+ }
+ return this;
+ },
+ // Call all the callbacks with the given arguments
+ fire: function() {
+ self.fireWith( this, arguments );
+ return this;
+ },
+ // To know if the callbacks have already been called at least once
+ fired: function() {
+ return !!fired;
+ }
+ };
+
+ return self;
+};
+jQuery.extend({
+
+ Deferred: function( func ) {
+ var tuples = [
+ // action, add listener, listener list, final state
+ [ "resolve", "done", jQuery.Callbacks("once memory"), "resolved" ],
+ [ "reject", "fail", jQuery.Callbacks("once memory"), "rejected" ],
+ [ "notify", "progress", jQuery.Callbacks("memory") ]
+ ],
+ state = "pending",
+ promise = {
+ state: function() {
+ return state;
+ },
+ always: function() {
+ deferred.done( arguments ).fail( arguments );
+ return this;
+ },
+ then: function( /* fnDone, fnFail, fnProgress */ ) {
+ var fns = arguments;
+ return jQuery.Deferred(function( newDefer ) {
+ jQuery.each( tuples, function( i, tuple ) {
+ var action = tuple[ 0 ],
+ fn = jQuery.isFunction( fns[ i ] ) && fns[ i ];
+ // deferred[ done | fail | progress ] for forwarding actions to newDefer
+ deferred[ tuple[1] ](function() {
+ var returned = fn && fn.apply( this, arguments );
+ if ( returned && jQuery.isFunction( returned.promise ) ) {
+ returned.promise()
+ .done( newDefer.resolve )
+ .fail( newDefer.reject )
+ .progress( newDefer.notify );
+ } else {
+ newDefer[ action + "With" ]( this === promise ? newDefer.promise() : this, fn ? [ returned ] : arguments );
+ }
+ });
+ });
+ fns = null;
+ }).promise();
+ },
+ // Get a promise for this deferred
+ // If obj is provided, the promise aspect is added to the object
+ promise: function( obj ) {
+ return obj != null ? jQuery.extend( obj, promise ) : promise;
+ }
+ },
+ deferred = {};
+
+ // Keep pipe for back-compat
+ promise.pipe = promise.then;
+
+ // Add list-specific methods
+ jQuery.each( tuples, function( i, tuple ) {
+ var list = tuple[ 2 ],
+ stateString = tuple[ 3 ];
+
+ // promise[ done | fail | progress ] = list.add
+ promise[ tuple[1] ] = list.add;
+
+ // Handle state
+ if ( stateString ) {
+ list.add(function() {
+ // state = [ resolved | rejected ]
+ state = stateString;
+
+ // [ reject_list | resolve_list ].disable; progress_list.lock
+ }, tuples[ i ^ 1 ][ 2 ].disable, tuples[ 2 ][ 2 ].lock );
+ }
+
+ // deferred[ resolve | reject | notify ]
+ deferred[ tuple[0] ] = function() {
+ deferred[ tuple[0] + "With" ]( this === deferred ? promise : this, arguments );
+ return this;
+ };
+ deferred[ tuple[0] + "With" ] = list.fireWith;
+ });
+
+ // Make the deferred a promise
+ promise.promise( deferred );
+
+ // Call given func if any
+ if ( func ) {
+ func.call( deferred, deferred );
+ }
+
+ // All done!
+ return deferred;
+ },
+
+ // Deferred helper
+ when: function( subordinate /* , ..., subordinateN */ ) {
+ var i = 0,
+ resolveValues = core_slice.call( arguments ),
+ length = resolveValues.length,
+
+ // the count of uncompleted subordinates
+ remaining = length !== 1 || ( subordinate && jQuery.isFunction( subordinate.promise ) ) ? length : 0,
+
+ // the master Deferred. If resolveValues consist of only a single Deferred, just use that.
+ deferred = remaining === 1 ? subordinate : jQuery.Deferred(),
+
+ // Update function for both resolve and progress values
+ updateFunc = function( i, contexts, values ) {
+ return function( value ) {
+ contexts[ i ] = this;
+ values[ i ] = arguments.length > 1 ? core_slice.call( arguments ) : value;
+ if( values === progressValues ) {
+ deferred.notifyWith( contexts, values );
+ } else if ( !( --remaining ) ) {
+ deferred.resolveWith( contexts, values );
+ }
+ };
+ },
+
+ progressValues, progressContexts, resolveContexts;
+
+ // add listeners to Deferred subordinates; treat others as resolved
+ if ( length > 1 ) {
+ progressValues = new Array( length );
+ progressContexts = new Array( length );
+ resolveContexts = new Array( length );
+ for ( ; i < length; i++ ) {
+ if ( resolveValues[ i ] && jQuery.isFunction( resolveValues[ i ].promise ) ) {
+ resolveValues[ i ].promise()
+ .done( updateFunc( i, resolveContexts, resolveValues ) )
+ .fail( deferred.reject )
+ .progress( updateFunc( i, progressContexts, progressValues ) );
+ } else {
+ --remaining;
+ }
+ }
+ }
+
+ // if we're not waiting on anything, resolve the master
+ if ( !remaining ) {
+ deferred.resolveWith( resolveContexts, resolveValues );
+ }
+
+ return deferred.promise();
+ }
+});
+jQuery.support = (function() {
+
+ var support, all, a,
+ input, select, fragment,
+ opt, eventName, isSupported, i,
+ div = document.createElement("div");
+
+ // Setup
+ div.setAttribute( "className", "t" );
+ div.innerHTML = "
a";
+
+ // Support tests won't run in some limited or non-browser environments
+ all = div.getElementsByTagName("*");
+ a = div.getElementsByTagName("a")[ 0 ];
+ if ( !all || !a || !all.length ) {
+ return {};
+ }
+
+ // First batch of tests
+ select = document.createElement("select");
+ opt = select.appendChild( document.createElement("option") );
+ input = div.getElementsByTagName("input")[ 0 ];
+
+ a.style.cssText = "top:1px;float:left;opacity:.5";
+ support = {
+ // Test setAttribute on camelCase class. If it works, we need attrFixes when doing get/setAttribute (ie6/7)
+ getSetAttribute: div.className !== "t",
+
+ // IE strips leading whitespace when .innerHTML is used
+ leadingWhitespace: div.firstChild.nodeType === 3,
+
+ // Make sure that tbody elements aren't automatically inserted
+ // IE will insert them into empty tables
+ tbody: !div.getElementsByTagName("tbody").length,
+
+ // Make sure that link elements get serialized correctly by innerHTML
+ // This requires a wrapper element in IE
+ htmlSerialize: !!div.getElementsByTagName("link").length,
+
+ // Get the style information from getAttribute
+ // (IE uses .cssText instead)
+ style: /top/.test( a.getAttribute("style") ),
+
+ // Make sure that URLs aren't manipulated
+ // (IE normalizes it by default)
+ hrefNormalized: a.getAttribute("href") === "/a",
+
+ // Make sure that element opacity exists
+ // (IE uses filter instead)
+ // Use a regex to work around a WebKit issue. See #5145
+ opacity: /^0.5/.test( a.style.opacity ),
+
+ // Verify style float existence
+ // (IE uses styleFloat instead of cssFloat)
+ cssFloat: !!a.style.cssFloat,
+
+ // Check the default checkbox/radio value ("" on WebKit; "on" elsewhere)
+ checkOn: !!input.value,
+
+ // Make sure that a selected-by-default option has a working selected property.
+ // (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
+ optSelected: opt.selected,
+
+ // Tests for enctype support on a form (#6743)
+ enctype: !!document.createElement("form").enctype,
+
+ // Makes sure cloning an html5 element does not cause problems
+ // Where outerHTML is undefined, this still works
+ html5Clone: document.createElement("nav").cloneNode( true ).outerHTML !== "<:nav>",
+
+ // jQuery.support.boxModel DEPRECATED in 1.8 since we don't support Quirks Mode
+ boxModel: document.compatMode === "CSS1Compat",
+
+ // Will be defined later
+ deleteExpando: true,
+ noCloneEvent: true,
+ inlineBlockNeedsLayout: false,
+ shrinkWrapBlocks: false,
+ reliableMarginRight: true,
+ boxSizingReliable: true,
+ pixelPosition: false
+ };
+
+ // Make sure checked status is properly cloned
+ input.checked = true;
+ support.noCloneChecked = input.cloneNode( true ).checked;
+
+ // Make sure that the options inside disabled selects aren't marked as disabled
+ // (WebKit marks them as disabled)
+ select.disabled = true;
+ support.optDisabled = !opt.disabled;
+
+ // Support: IE<9
+ try {
+ delete div.test;
+ } catch( e ) {
+ support.deleteExpando = false;
+ }
+
+ // Check if we can trust getAttribute("value")
+ input = document.createElement("input");
+ input.setAttribute( "value", "" );
+ support.input = input.getAttribute( "value" ) === "";
+
+ // Check if an input maintains its value after becoming a radio
+ input.value = "t";
+ input.setAttribute( "type", "radio" );
+ support.radioValue = input.value === "t";
+
+ // #11217 - WebKit loses check when the name is after the checked attribute
+ input.setAttribute( "checked", "t" );
+ input.setAttribute( "name", "t" );
+
+ fragment = document.createDocumentFragment();
+ fragment.appendChild( input );
+
+ // Check if a disconnected checkbox will retain its checked
+ // value of true after appended to the DOM (IE6/7)
+ support.appendChecked = input.checked;
+
+ // WebKit doesn't clone checked state correctly in fragments
+ support.checkClone = fragment.cloneNode( true ).cloneNode( true ).lastChild.checked;
+
+ // Support: IE<9
+ // Opera does not clone events (and typeof div.attachEvent === undefined).
+ // IE9-10 clones events bound via attachEvent, but they don't trigger with .click()
+ if ( div.attachEvent ) {
+ div.attachEvent( "onclick", function() {
+ support.noCloneEvent = false;
+ });
+
+ div.cloneNode( true ).click();
+ }
+
+ // Support: IE<9 (lack submit/change bubble), Firefox 17+ (lack focusin event)
+ // Beware of CSP restrictions (https://developer.mozilla.org/en/Security/CSP), test/csp.php
+ for ( i in { submit: true, change: true, focusin: true }) {
+ div.setAttribute( eventName = "on" + i, "t" );
+
+ support[ i + "Bubbles" ] = eventName in window || div.attributes[ eventName ].expando === false;
+ }
+
+ div.style.backgroundClip = "content-box";
+ div.cloneNode( true ).style.backgroundClip = "";
+ support.clearCloneStyle = div.style.backgroundClip === "content-box";
+
+ // Run tests that need a body at doc ready
+ jQuery(function() {
+ var container, marginDiv, tds,
+ divReset = "padding:0;margin:0;border:0;display:block;box-sizing:content-box;-moz-box-sizing:content-box;-webkit-box-sizing:content-box;",
+ body = document.getElementsByTagName("body")[0];
+
+ if ( !body ) {
+ // Return for frameset docs that don't have a body
+ return;
+ }
+
+ container = document.createElement("div");
+ container.style.cssText = "border:0;width:0;height:0;position:absolute;top:0;left:-9999px;margin-top:1px";
+
+ body.appendChild( container ).appendChild( div );
+
+ // Support: IE8
+ // Check if table cells still have offsetWidth/Height when they are set
+ // to display:none and there are still other visible table cells in a
+ // table row; if so, offsetWidth/Height are not reliable for use when
+ // determining if an element has been hidden directly using
+ // display:none (it is still safe to use offsets if a parent element is
+ // hidden; don safety goggles and see bug #4512 for more information).
+ div.innerHTML = "
";
+ tds = div.getElementsByTagName("td");
+ tds[ 0 ].style.cssText = "padding:0;margin:0;border:0;display:none";
+ isSupported = ( tds[ 0 ].offsetHeight === 0 );
+
+ tds[ 0 ].style.display = "";
+ tds[ 1 ].style.display = "none";
+
+ // Support: IE8
+ // Check if empty table cells still have offsetWidth/Height
+ support.reliableHiddenOffsets = isSupported && ( tds[ 0 ].offsetHeight === 0 );
+
+ // Check box-sizing and margin behavior
+ div.innerHTML = "";
+ div.style.cssText = "box-sizing:border-box;-moz-box-sizing:border-box;-webkit-box-sizing:border-box;padding:1px;border:1px;display:block;width:4px;margin-top:1%;position:absolute;top:1%;";
+ support.boxSizing = ( div.offsetWidth === 4 );
+ support.doesNotIncludeMarginInBodyOffset = ( body.offsetTop !== 1 );
+
+ // Use window.getComputedStyle because jsdom on node.js will break without it.
+ if ( window.getComputedStyle ) {
+ support.pixelPosition = ( window.getComputedStyle( div, null ) || {} ).top !== "1%";
+ support.boxSizingReliable = ( window.getComputedStyle( div, null ) || { width: "4px" } ).width === "4px";
+
+ // Check if div with explicit width and no margin-right incorrectly
+ // gets computed margin-right based on width of container. (#3333)
+ // Fails in WebKit before Feb 2011 nightlies
+ // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
+ marginDiv = div.appendChild( document.createElement("div") );
+ marginDiv.style.cssText = div.style.cssText = divReset;
+ marginDiv.style.marginRight = marginDiv.style.width = "0";
+ div.style.width = "1px";
+
+ support.reliableMarginRight =
+ !parseFloat( ( window.getComputedStyle( marginDiv, null ) || {} ).marginRight );
+ }
+
+ if ( typeof div.style.zoom !== core_strundefined ) {
+ // Support: IE<8
+ // Check if natively block-level elements act like inline-block
+ // elements when setting their display to 'inline' and giving
+ // them layout
+ div.innerHTML = "";
+ div.style.cssText = divReset + "width:1px;padding:1px;display:inline;zoom:1";
+ support.inlineBlockNeedsLayout = ( div.offsetWidth === 3 );
+
+ // Support: IE6
+ // Check if elements with layout shrink-wrap their children
+ div.style.display = "block";
+ div.innerHTML = "";
+ div.firstChild.style.width = "5px";
+ support.shrinkWrapBlocks = ( div.offsetWidth !== 3 );
+
+ if ( support.inlineBlockNeedsLayout ) {
+ // Prevent IE 6 from affecting layout for positioned elements #11048
+ // Prevent IE from shrinking the body in IE 7 mode #12869
+ // Support: IE<8
+ body.style.zoom = 1;
+ }
+ }
+
+ body.removeChild( container );
+
+ // Null elements to avoid leaks in IE
+ container = div = tds = marginDiv = null;
+ });
+
+ // Null elements to avoid leaks in IE
+ all = select = fragment = opt = a = input = null;
+
+ return support;
+})();
+
+var rbrace = /(?:\{[\s\S]*\}|\[[\s\S]*\])$/,
+ rmultiDash = /([A-Z])/g;
+
+function internalData( elem, name, data, pvt /* Internal Use Only */ ){
+ if ( !jQuery.acceptData( elem ) ) {
+ return;
+ }
+
+ var thisCache, ret,
+ internalKey = jQuery.expando,
+ getByName = typeof name === "string",
+
+ // We have to handle DOM nodes and JS objects differently because IE6-7
+ // can't GC object references properly across the DOM-JS boundary
+ isNode = elem.nodeType,
+
+ // Only DOM nodes need the global jQuery cache; JS object data is
+ // attached directly to the object so GC can occur automatically
+ cache = isNode ? jQuery.cache : elem,
+
+ // Only defining an ID for JS objects if its cache already exists allows
+ // the code to shortcut on the same path as a DOM node with no cache
+ id = isNode ? elem[ internalKey ] : elem[ internalKey ] && internalKey;
+
+ // Avoid doing any more work than we need to when trying to get data on an
+ // object that has no data at all
+ if ( (!id || !cache[id] || (!pvt && !cache[id].data)) && getByName && data === undefined ) {
+ return;
+ }
+
+ if ( !id ) {
+ // Only DOM nodes need a new unique ID for each element since their data
+ // ends up in the global cache
+ if ( isNode ) {
+ elem[ internalKey ] = id = core_deletedIds.pop() || jQuery.guid++;
+ } else {
+ id = internalKey;
+ }
+ }
+
+ if ( !cache[ id ] ) {
+ cache[ id ] = {};
+
+ // Avoids exposing jQuery metadata on plain JS objects when the object
+ // is serialized using JSON.stringify
+ if ( !isNode ) {
+ cache[ id ].toJSON = jQuery.noop;
+ }
+ }
+
+ // An object can be passed to jQuery.data instead of a key/value pair; this gets
+ // shallow copied over onto the existing cache
+ if ( typeof name === "object" || typeof name === "function" ) {
+ if ( pvt ) {
+ cache[ id ] = jQuery.extend( cache[ id ], name );
+ } else {
+ cache[ id ].data = jQuery.extend( cache[ id ].data, name );
+ }
+ }
+
+ thisCache = cache[ id ];
+
+ // jQuery data() is stored in a separate object inside the object's internal data
+ // cache in order to avoid key collisions between internal data and user-defined
+ // data.
+ if ( !pvt ) {
+ if ( !thisCache.data ) {
+ thisCache.data = {};
+ }
+
+ thisCache = thisCache.data;
+ }
+
+ if ( data !== undefined ) {
+ thisCache[ jQuery.camelCase( name ) ] = data;
+ }
+
+ // Check for both converted-to-camel and non-converted data property names
+ // If a data property was specified
+ if ( getByName ) {
+
+ // First Try to find as-is property data
+ ret = thisCache[ name ];
+
+ // Test for null|undefined property data
+ if ( ret == null ) {
+
+ // Try to find the camelCased property
+ ret = thisCache[ jQuery.camelCase( name ) ];
+ }
+ } else {
+ ret = thisCache;
+ }
+
+ return ret;
+}
+
+function internalRemoveData( elem, name, pvt ) {
+ if ( !jQuery.acceptData( elem ) ) {
+ return;
+ }
+
+ var i, l, thisCache,
+ isNode = elem.nodeType,
+
+ // See jQuery.data for more information
+ cache = isNode ? jQuery.cache : elem,
+ id = isNode ? elem[ jQuery.expando ] : jQuery.expando;
+
+ // If there is already no cache entry for this object, there is no
+ // purpose in continuing
+ if ( !cache[ id ] ) {
+ return;
+ }
+
+ if ( name ) {
+
+ thisCache = pvt ? cache[ id ] : cache[ id ].data;
+
+ if ( thisCache ) {
+
+ // Support array or space separated string names for data keys
+ if ( !jQuery.isArray( name ) ) {
+
+ // try the string as a key before any manipulation
+ if ( name in thisCache ) {
+ name = [ name ];
+ } else {
+
+ // split the camel cased version by spaces unless a key with the spaces exists
+ name = jQuery.camelCase( name );
+ if ( name in thisCache ) {
+ name = [ name ];
+ } else {
+ name = name.split(" ");
+ }
+ }
+ } else {
+ // If "name" is an array of keys...
+ // When data is initially created, via ("key", "val") signature,
+ // keys will be converted to camelCase.
+ // Since there is no way to tell _how_ a key was added, remove
+ // both plain key and camelCase key. #12786
+ // This will only penalize the array argument path.
+ name = name.concat( jQuery.map( name, jQuery.camelCase ) );
+ }
+
+ for ( i = 0, l = name.length; i < l; i++ ) {
+ delete thisCache[ name[i] ];
+ }
+
+ // If there is no data left in the cache, we want to continue
+ // and let the cache object itself get destroyed
+ if ( !( pvt ? isEmptyDataObject : jQuery.isEmptyObject )( thisCache ) ) {
+ return;
+ }
+ }
+ }
+
+ // See jQuery.data for more information
+ if ( !pvt ) {
+ delete cache[ id ].data;
+
+ // Don't destroy the parent cache unless the internal data object
+ // had been the only thing left in it
+ if ( !isEmptyDataObject( cache[ id ] ) ) {
+ return;
+ }
+ }
+
+ // Destroy the cache
+ if ( isNode ) {
+ jQuery.cleanData( [ elem ], true );
+
+ // Use delete when supported for expandos or `cache` is not a window per isWindow (#10080)
+ } else if ( jQuery.support.deleteExpando || cache != cache.window ) {
+ delete cache[ id ];
+
+ // When all else fails, null
+ } else {
+ cache[ id ] = null;
+ }
+}
+
+jQuery.extend({
+ cache: {},
+
+ // Unique for each copy of jQuery on the page
+ // Non-digits removed to match rinlinejQuery
+ expando: "jQuery" + ( core_version + Math.random() ).replace( /\D/g, "" ),
+
+ // The following elements throw uncatchable exceptions if you
+ // attempt to add expando properties to them.
+ noData: {
+ "embed": true,
+ // Ban all objects except for Flash (which handle expandos)
+ "object": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",
+ "applet": true
+ },
+
+ hasData: function( elem ) {
+ elem = elem.nodeType ? jQuery.cache[ elem[jQuery.expando] ] : elem[ jQuery.expando ];
+ return !!elem && !isEmptyDataObject( elem );
+ },
+
+ data: function( elem, name, data ) {
+ return internalData( elem, name, data );
+ },
+
+ removeData: function( elem, name ) {
+ return internalRemoveData( elem, name );
+ },
+
+ // For internal use only.
+ _data: function( elem, name, data ) {
+ return internalData( elem, name, data, true );
+ },
+
+ _removeData: function( elem, name ) {
+ return internalRemoveData( elem, name, true );
+ },
+
+ // A method for determining if a DOM node can handle the data expando
+ acceptData: function( elem ) {
+ // Do not set data on non-element because it will not be cleared (#8335).
+ if ( elem.nodeType && elem.nodeType !== 1 && elem.nodeType !== 9 ) {
+ return false;
+ }
+
+ var noData = elem.nodeName && jQuery.noData[ elem.nodeName.toLowerCase() ];
+
+ // nodes accept data unless otherwise specified; rejection can be conditional
+ return !noData || noData !== true && elem.getAttribute("classid") === noData;
+ }
+});
+
+jQuery.fn.extend({
+ data: function( key, value ) {
+ var attrs, name,
+ elem = this[0],
+ i = 0,
+ data = null;
+
+ // Gets all values
+ if ( key === undefined ) {
+ if ( this.length ) {
+ data = jQuery.data( elem );
+
+ if ( elem.nodeType === 1 && !jQuery._data( elem, "parsedAttrs" ) ) {
+ attrs = elem.attributes;
+ for ( ; i < attrs.length; i++ ) {
+ name = attrs[i].name;
+
+ if ( !name.indexOf( "data-" ) ) {
+ name = jQuery.camelCase( name.slice(5) );
+
+ dataAttr( elem, name, data[ name ] );
+ }
+ }
+ jQuery._data( elem, "parsedAttrs", true );
+ }
+ }
+
+ return data;
+ }
+
+ // Sets multiple values
+ if ( typeof key === "object" ) {
+ return this.each(function() {
+ jQuery.data( this, key );
+ });
+ }
+
+ return jQuery.access( this, function( value ) {
+
+ if ( value === undefined ) {
+ // Try to fetch any internally stored data first
+ return elem ? dataAttr( elem, key, jQuery.data( elem, key ) ) : null;
+ }
+
+ this.each(function() {
+ jQuery.data( this, key, value );
+ });
+ }, null, value, arguments.length > 1, null, true );
+ },
+
+ removeData: function( key ) {
+ return this.each(function() {
+ jQuery.removeData( this, key );
+ });
+ }
+});
+
+function dataAttr( elem, key, data ) {
+ // If nothing was found internally, try to fetch any
+ // data from the HTML5 data-* attribute
+ if ( data === undefined && elem.nodeType === 1 ) {
+
+ var name = "data-" + key.replace( rmultiDash, "-$1" ).toLowerCase();
+
+ data = elem.getAttribute( name );
+
+ if ( typeof data === "string" ) {
+ try {
+ data = data === "true" ? true :
+ data === "false" ? false :
+ data === "null" ? null :
+ // Only convert to a number if it doesn't change the string
+ +data + "" === data ? +data :
+ rbrace.test( data ) ? jQuery.parseJSON( data ) :
+ data;
+ } catch( e ) {}
+
+ // Make sure we set the data so it isn't changed later
+ jQuery.data( elem, key, data );
+
+ } else {
+ data = undefined;
+ }
+ }
+
+ return data;
+}
+
+// checks a cache object for emptiness
+function isEmptyDataObject( obj ) {
+ var name;
+ for ( name in obj ) {
+
+ // if the public data object is empty, the private is still empty
+ if ( name === "data" && jQuery.isEmptyObject( obj[name] ) ) {
+ continue;
+ }
+ if ( name !== "toJSON" ) {
+ return false;
+ }
+ }
+
+ return true;
+}
+jQuery.extend({
+ queue: function( elem, type, data ) {
+ var queue;
+
+ if ( elem ) {
+ type = ( type || "fx" ) + "queue";
+ queue = jQuery._data( elem, type );
+
+ // Speed up dequeue by getting out quickly if this is just a lookup
+ if ( data ) {
+ if ( !queue || jQuery.isArray(data) ) {
+ queue = jQuery._data( elem, type, jQuery.makeArray(data) );
+ } else {
+ queue.push( data );
+ }
+ }
+ return queue || [];
+ }
+ },
+
+ dequeue: function( elem, type ) {
+ type = type || "fx";
+
+ var queue = jQuery.queue( elem, type ),
+ startLength = queue.length,
+ fn = queue.shift(),
+ hooks = jQuery._queueHooks( elem, type ),
+ next = function() {
+ jQuery.dequeue( elem, type );
+ };
+
+ // If the fx queue is dequeued, always remove the progress sentinel
+ if ( fn === "inprogress" ) {
+ fn = queue.shift();
+ startLength--;
+ }
+
+ hooks.cur = fn;
+ if ( fn ) {
+
+ // Add a progress sentinel to prevent the fx queue from being
+ // automatically dequeued
+ if ( type === "fx" ) {
+ queue.unshift( "inprogress" );
+ }
+
+ // clear up the last queue stop function
+ delete hooks.stop;
+ fn.call( elem, next, hooks );
+ }
+
+ if ( !startLength && hooks ) {
+ hooks.empty.fire();
+ }
+ },
+
+ // not intended for public consumption - generates a queueHooks object, or returns the current one
+ _queueHooks: function( elem, type ) {
+ var key = type + "queueHooks";
+ return jQuery._data( elem, key ) || jQuery._data( elem, key, {
+ empty: jQuery.Callbacks("once memory").add(function() {
+ jQuery._removeData( elem, type + "queue" );
+ jQuery._removeData( elem, key );
+ })
+ });
+ }
+});
+
+jQuery.fn.extend({
+ queue: function( type, data ) {
+ var setter = 2;
+
+ if ( typeof type !== "string" ) {
+ data = type;
+ type = "fx";
+ setter--;
+ }
+
+ if ( arguments.length < setter ) {
+ return jQuery.queue( this[0], type );
+ }
+
+ return data === undefined ?
+ this :
+ this.each(function() {
+ var queue = jQuery.queue( this, type, data );
+
+ // ensure a hooks for this queue
+ jQuery._queueHooks( this, type );
+
+ if ( type === "fx" && queue[0] !== "inprogress" ) {
+ jQuery.dequeue( this, type );
+ }
+ });
+ },
+ dequeue: function( type ) {
+ return this.each(function() {
+ jQuery.dequeue( this, type );
+ });
+ },
+ // Based off of the plugin by Clint Helfers, with permission.
+ // http://blindsignals.com/index.php/2009/07/jquery-delay/
+ delay: function( time, type ) {
+ time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;
+ type = type || "fx";
+
+ return this.queue( type, function( next, hooks ) {
+ var timeout = setTimeout( next, time );
+ hooks.stop = function() {
+ clearTimeout( timeout );
+ };
+ });
+ },
+ clearQueue: function( type ) {
+ return this.queue( type || "fx", [] );
+ },
+ // Get a promise resolved when queues of a certain type
+ // are emptied (fx is the type by default)
+ promise: function( type, obj ) {
+ var tmp,
+ count = 1,
+ defer = jQuery.Deferred(),
+ elements = this,
+ i = this.length,
+ resolve = function() {
+ if ( !( --count ) ) {
+ defer.resolveWith( elements, [ elements ] );
+ }
+ };
+
+ if ( typeof type !== "string" ) {
+ obj = type;
+ type = undefined;
+ }
+ type = type || "fx";
+
+ while( i-- ) {
+ tmp = jQuery._data( elements[ i ], type + "queueHooks" );
+ if ( tmp && tmp.empty ) {
+ count++;
+ tmp.empty.add( resolve );
+ }
+ }
+ resolve();
+ return defer.promise( obj );
+ }
+});
+var nodeHook, boolHook,
+ rclass = /[\t\r\n]/g,
+ rreturn = /\r/g,
+ rfocusable = /^(?:input|select|textarea|button|object)$/i,
+ rclickable = /^(?:a|area)$/i,
+ rboolean = /^(?:checked|selected|autofocus|autoplay|async|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped)$/i,
+ ruseDefault = /^(?:checked|selected)$/i,
+ getSetAttribute = jQuery.support.getSetAttribute,
+ getSetInput = jQuery.support.input;
+
+jQuery.fn.extend({
+ attr: function( name, value ) {
+ return jQuery.access( this, jQuery.attr, name, value, arguments.length > 1 );
+ },
+
+ removeAttr: function( name ) {
+ return this.each(function() {
+ jQuery.removeAttr( this, name );
+ });
+ },
+
+ prop: function( name, value ) {
+ return jQuery.access( this, jQuery.prop, name, value, arguments.length > 1 );
+ },
+
+ removeProp: function( name ) {
+ name = jQuery.propFix[ name ] || name;
+ return this.each(function() {
+ // try/catch handles cases where IE balks (such as removing a property on window)
+ try {
+ this[ name ] = undefined;
+ delete this[ name ];
+ } catch( e ) {}
+ });
+ },
+
+ addClass: function( value ) {
+ var classes, elem, cur, clazz, j,
+ i = 0,
+ len = this.length,
+ proceed = typeof value === "string" && value;
+
+ if ( jQuery.isFunction( value ) ) {
+ return this.each(function( j ) {
+ jQuery( this ).addClass( value.call( this, j, this.className ) );
+ });
+ }
+
+ if ( proceed ) {
+ // The disjunction here is for better compressibility (see removeClass)
+ classes = ( value || "" ).match( core_rnotwhite ) || [];
+
+ for ( ; i < len; i++ ) {
+ elem = this[ i ];
+ cur = elem.nodeType === 1 && ( elem.className ?
+ ( " " + elem.className + " " ).replace( rclass, " " ) :
+ " "
+ );
+
+ if ( cur ) {
+ j = 0;
+ while ( (clazz = classes[j++]) ) {
+ if ( cur.indexOf( " " + clazz + " " ) < 0 ) {
+ cur += clazz + " ";
+ }
+ }
+ elem.className = jQuery.trim( cur );
+
+ }
+ }
+ }
+
+ return this;
+ },
+
+ removeClass: function( value ) {
+ var classes, elem, cur, clazz, j,
+ i = 0,
+ len = this.length,
+ proceed = arguments.length === 0 || typeof value === "string" && value;
+
+ if ( jQuery.isFunction( value ) ) {
+ return this.each(function( j ) {
+ jQuery( this ).removeClass( value.call( this, j, this.className ) );
+ });
+ }
+ if ( proceed ) {
+ classes = ( value || "" ).match( core_rnotwhite ) || [];
+
+ for ( ; i < len; i++ ) {
+ elem = this[ i ];
+ // This expression is here for better compressibility (see addClass)
+ cur = elem.nodeType === 1 && ( elem.className ?
+ ( " " + elem.className + " " ).replace( rclass, " " ) :
+ ""
+ );
+
+ if ( cur ) {
+ j = 0;
+ while ( (clazz = classes[j++]) ) {
+ // Remove *all* instances
+ while ( cur.indexOf( " " + clazz + " " ) >= 0 ) {
+ cur = cur.replace( " " + clazz + " ", " " );
+ }
+ }
+ elem.className = value ? jQuery.trim( cur ) : "";
+ }
+ }
+ }
+
+ return this;
+ },
+
+ toggleClass: function( value, stateVal ) {
+ var type = typeof value,
+ isBool = typeof stateVal === "boolean";
+
+ if ( jQuery.isFunction( value ) ) {
+ return this.each(function( i ) {
+ jQuery( this ).toggleClass( value.call(this, i, this.className, stateVal), stateVal );
+ });
+ }
+
+ return this.each(function() {
+ if ( type === "string" ) {
+ // toggle individual class names
+ var className,
+ i = 0,
+ self = jQuery( this ),
+ state = stateVal,
+ classNames = value.match( core_rnotwhite ) || [];
+
+ while ( (className = classNames[ i++ ]) ) {
+ // check each className given, space separated list
+ state = isBool ? state : !self.hasClass( className );
+ self[ state ? "addClass" : "removeClass" ]( className );
+ }
+
+ // Toggle whole class name
+ } else if ( type === core_strundefined || type === "boolean" ) {
+ if ( this.className ) {
+ // store className if set
+ jQuery._data( this, "__className__", this.className );
+ }
+
+ // If the element has a class name or if we're passed "false",
+ // then remove the whole classname (if there was one, the above saved it).
+ // Otherwise bring back whatever was previously saved (if anything),
+ // falling back to the empty string if nothing was stored.
+ this.className = this.className || value === false ? "" : jQuery._data( this, "__className__" ) || "";
+ }
+ });
+ },
+
+ hasClass: function( selector ) {
+ var className = " " + selector + " ",
+ i = 0,
+ l = this.length;
+ for ( ; i < l; i++ ) {
+ if ( this[i].nodeType === 1 && (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) >= 0 ) {
+ return true;
+ }
+ }
+
+ return false;
+ },
+
+ val: function( value ) {
+ var ret, hooks, isFunction,
+ elem = this[0];
+
+ if ( !arguments.length ) {
+ if ( elem ) {
+ hooks = jQuery.valHooks[ elem.type ] || jQuery.valHooks[ elem.nodeName.toLowerCase() ];
+
+ if ( hooks && "get" in hooks && (ret = hooks.get( elem, "value" )) !== undefined ) {
+ return ret;
+ }
+
+ ret = elem.value;
+
+ return typeof ret === "string" ?
+ // handle most common string cases
+ ret.replace(rreturn, "") :
+ // handle cases where value is null/undef or number
+ ret == null ? "" : ret;
+ }
+
+ return;
+ }
+
+ isFunction = jQuery.isFunction( value );
+
+ return this.each(function( i ) {
+ var val,
+ self = jQuery(this);
+
+ if ( this.nodeType !== 1 ) {
+ return;
+ }
+
+ if ( isFunction ) {
+ val = value.call( this, i, self.val() );
+ } else {
+ val = value;
+ }
+
+ // Treat null/undefined as ""; convert numbers to string
+ if ( val == null ) {
+ val = "";
+ } else if ( typeof val === "number" ) {
+ val += "";
+ } else if ( jQuery.isArray( val ) ) {
+ val = jQuery.map(val, function ( value ) {
+ return value == null ? "" : value + "";
+ });
+ }
+
+ hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ];
+
+ // If set returns undefined, fall back to normal setting
+ if ( !hooks || !("set" in hooks) || hooks.set( this, val, "value" ) === undefined ) {
+ this.value = val;
+ }
+ });
+ }
+});
+
+jQuery.extend({
+ valHooks: {
+ option: {
+ get: function( elem ) {
+ // attributes.value is undefined in Blackberry 4.7 but
+ // uses .value. See #6932
+ var val = elem.attributes.value;
+ return !val || val.specified ? elem.value : elem.text;
+ }
+ },
+ select: {
+ get: function( elem ) {
+ var value, option,
+ options = elem.options,
+ index = elem.selectedIndex,
+ one = elem.type === "select-one" || index < 0,
+ values = one ? null : [],
+ max = one ? index + 1 : options.length,
+ i = index < 0 ?
+ max :
+ one ? index : 0;
+
+ // Loop through all the selected options
+ for ( ; i < max; i++ ) {
+ option = options[ i ];
+
+ // oldIE doesn't update selected after form reset (#2551)
+ if ( ( option.selected || i === index ) &&
+ // Don't return options that are disabled or in a disabled optgroup
+ ( jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null ) &&
+ ( !option.parentNode.disabled || !jQuery.nodeName( option.parentNode, "optgroup" ) ) ) {
+
+ // Get the specific value for the option
+ value = jQuery( option ).val();
+
+ // We don't need an array for one selects
+ if ( one ) {
+ return value;
+ }
+
+ // Multi-Selects return an array
+ values.push( value );
+ }
+ }
+
+ return values;
+ },
+
+ set: function( elem, value ) {
+ var values = jQuery.makeArray( value );
+
+ jQuery(elem).find("option").each(function() {
+ this.selected = jQuery.inArray( jQuery(this).val(), values ) >= 0;
+ });
+
+ if ( !values.length ) {
+ elem.selectedIndex = -1;
+ }
+ return values;
+ }
+ }
+ },
+
+ attr: function( elem, name, value ) {
+ var hooks, notxml, ret,
+ nType = elem.nodeType;
+
+ // don't get/set attributes on text, comment and attribute nodes
+ if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
+ return;
+ }
+
+ // Fallback to prop when attributes are not supported
+ if ( typeof elem.getAttribute === core_strundefined ) {
+ return jQuery.prop( elem, name, value );
+ }
+
+ notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
+
+ // All attributes are lowercase
+ // Grab necessary hook if one is defined
+ if ( notxml ) {
+ name = name.toLowerCase();
+ hooks = jQuery.attrHooks[ name ] || ( rboolean.test( name ) ? boolHook : nodeHook );
+ }
+
+ if ( value !== undefined ) {
+
+ if ( value === null ) {
+ jQuery.removeAttr( elem, name );
+
+ } else if ( hooks && notxml && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ) {
+ return ret;
+
+ } else {
+ elem.setAttribute( name, value + "" );
+ return value;
+ }
+
+ } else if ( hooks && notxml && "get" in hooks && (ret = hooks.get( elem, name )) !== null ) {
+ return ret;
+
+ } else {
+
+ // In IE9+, Flash objects don't have .getAttribute (#12945)
+ // Support: IE9+
+ if ( typeof elem.getAttribute !== core_strundefined ) {
+ ret = elem.getAttribute( name );
+ }
+
+ // Non-existent attributes return null, we normalize to undefined
+ return ret == null ?
+ undefined :
+ ret;
+ }
+ },
+
+ removeAttr: function( elem, value ) {
+ var name, propName,
+ i = 0,
+ attrNames = value && value.match( core_rnotwhite );
+
+ if ( attrNames && elem.nodeType === 1 ) {
+ while ( (name = attrNames[i++]) ) {
+ propName = jQuery.propFix[ name ] || name;
+
+ // Boolean attributes get special treatment (#10870)
+ if ( rboolean.test( name ) ) {
+ // Set corresponding property to false for boolean attributes
+ // Also clear defaultChecked/defaultSelected (if appropriate) for IE<8
+ if ( !getSetAttribute && ruseDefault.test( name ) ) {
+ elem[ jQuery.camelCase( "default-" + name ) ] =
+ elem[ propName ] = false;
+ } else {
+ elem[ propName ] = false;
+ }
+
+ // See #9699 for explanation of this approach (setting first, then removal)
+ } else {
+ jQuery.attr( elem, name, "" );
+ }
+
+ elem.removeAttribute( getSetAttribute ? name : propName );
+ }
+ }
+ },
+
+ attrHooks: {
+ type: {
+ set: function( elem, value ) {
+ if ( !jQuery.support.radioValue && value === "radio" && jQuery.nodeName(elem, "input") ) {
+ // Setting the type on a radio button after the value resets the value in IE6-9
+ // Reset value to default in case type is set after value during creation
+ var val = elem.value;
+ elem.setAttribute( "type", value );
+ if ( val ) {
+ elem.value = val;
+ }
+ return value;
+ }
+ }
+ }
+ },
+
+ propFix: {
+ tabindex: "tabIndex",
+ readonly: "readOnly",
+ "for": "htmlFor",
+ "class": "className",
+ maxlength: "maxLength",
+ cellspacing: "cellSpacing",
+ cellpadding: "cellPadding",
+ rowspan: "rowSpan",
+ colspan: "colSpan",
+ usemap: "useMap",
+ frameborder: "frameBorder",
+ contenteditable: "contentEditable"
+ },
+
+ prop: function( elem, name, value ) {
+ var ret, hooks, notxml,
+ nType = elem.nodeType;
+
+ // don't get/set properties on text, comment and attribute nodes
+ if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
+ return;
+ }
+
+ notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
+
+ if ( notxml ) {
+ // Fix name and attach hooks
+ name = jQuery.propFix[ name ] || name;
+ hooks = jQuery.propHooks[ name ];
+ }
+
+ if ( value !== undefined ) {
+ if ( hooks && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ) {
+ return ret;
+
+ } else {
+ return ( elem[ name ] = value );
+ }
+
+ } else {
+ if ( hooks && "get" in hooks && (ret = hooks.get( elem, name )) !== null ) {
+ return ret;
+
+ } else {
+ return elem[ name ];
+ }
+ }
+ },
+
+ propHooks: {
+ tabIndex: {
+ get: function( elem ) {
+ // elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
+ // http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
+ var attributeNode = elem.getAttributeNode("tabindex");
+
+ return attributeNode && attributeNode.specified ?
+ parseInt( attributeNode.value, 10 ) :
+ rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ?
+ 0 :
+ undefined;
+ }
+ }
+ }
+});
+
+// Hook for boolean attributes
+boolHook = {
+ get: function( elem, name ) {
+ var
+ // Use .prop to determine if this attribute is understood as boolean
+ prop = jQuery.prop( elem, name ),
+
+ // Fetch it accordingly
+ attr = typeof prop === "boolean" && elem.getAttribute( name ),
+ detail = typeof prop === "boolean" ?
+
+ getSetInput && getSetAttribute ?
+ attr != null :
+ // oldIE fabricates an empty string for missing boolean attributes
+ // and conflates checked/selected into attroperties
+ ruseDefault.test( name ) ?
+ elem[ jQuery.camelCase( "default-" + name ) ] :
+ !!attr :
+
+ // fetch an attribute node for properties not recognized as boolean
+ elem.getAttributeNode( name );
+
+ return detail && detail.value !== false ?
+ name.toLowerCase() :
+ undefined;
+ },
+ set: function( elem, value, name ) {
+ if ( value === false ) {
+ // Remove boolean attributes when set to false
+ jQuery.removeAttr( elem, name );
+ } else if ( getSetInput && getSetAttribute || !ruseDefault.test( name ) ) {
+ // IE<8 needs the *property* name
+ elem.setAttribute( !getSetAttribute && jQuery.propFix[ name ] || name, name );
+
+ // Use defaultChecked and defaultSelected for oldIE
+ } else {
+ elem[ jQuery.camelCase( "default-" + name ) ] = elem[ name ] = true;
+ }
+
+ return name;
+ }
+};
+
+// fix oldIE value attroperty
+if ( !getSetInput || !getSetAttribute ) {
+ jQuery.attrHooks.value = {
+ get: function( elem, name ) {
+ var ret = elem.getAttributeNode( name );
+ return jQuery.nodeName( elem, "input" ) ?
+
+ // Ignore the value *property* by using defaultValue
+ elem.defaultValue :
+
+ ret && ret.specified ? ret.value : undefined;
+ },
+ set: function( elem, value, name ) {
+ if ( jQuery.nodeName( elem, "input" ) ) {
+ // Does not return so that setAttribute is also used
+ elem.defaultValue = value;
+ } else {
+ // Use nodeHook if defined (#1954); otherwise setAttribute is fine
+ return nodeHook && nodeHook.set( elem, value, name );
+ }
+ }
+ };
+}
+
+// IE6/7 do not support getting/setting some attributes with get/setAttribute
+if ( !getSetAttribute ) {
+
+ // Use this for any attribute in IE6/7
+ // This fixes almost every IE6/7 issue
+ nodeHook = jQuery.valHooks.button = {
+ get: function( elem, name ) {
+ var ret = elem.getAttributeNode( name );
+ return ret && ( name === "id" || name === "name" || name === "coords" ? ret.value !== "" : ret.specified ) ?
+ ret.value :
+ undefined;
+ },
+ set: function( elem, value, name ) {
+ // Set the existing or create a new attribute node
+ var ret = elem.getAttributeNode( name );
+ if ( !ret ) {
+ elem.setAttributeNode(
+ (ret = elem.ownerDocument.createAttribute( name ))
+ );
+ }
+
+ ret.value = value += "";
+
+ // Break association with cloned elements by also using setAttribute (#9646)
+ return name === "value" || value === elem.getAttribute( name ) ?
+ value :
+ undefined;
+ }
+ };
+
+ // Set contenteditable to false on removals(#10429)
+ // Setting to empty string throws an error as an invalid value
+ jQuery.attrHooks.contenteditable = {
+ get: nodeHook.get,
+ set: function( elem, value, name ) {
+ nodeHook.set( elem, value === "" ? false : value, name );
+ }
+ };
+
+ // Set width and height to auto instead of 0 on empty string( Bug #8150 )
+ // This is for removals
+ jQuery.each([ "width", "height" ], function( i, name ) {
+ jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
+ set: function( elem, value ) {
+ if ( value === "" ) {
+ elem.setAttribute( name, "auto" );
+ return value;
+ }
+ }
+ });
+ });
+}
+
+
+// Some attributes require a special call on IE
+// http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
+if ( !jQuery.support.hrefNormalized ) {
+ jQuery.each([ "href", "src", "width", "height" ], function( i, name ) {
+ jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
+ get: function( elem ) {
+ var ret = elem.getAttribute( name, 2 );
+ return ret == null ? undefined : ret;
+ }
+ });
+ });
+
+ // href/src property should get the full normalized URL (#10299/#12915)
+ jQuery.each([ "href", "src" ], function( i, name ) {
+ jQuery.propHooks[ name ] = {
+ get: function( elem ) {
+ return elem.getAttribute( name, 4 );
+ }
+ };
+ });
+}
+
+if ( !jQuery.support.style ) {
+ jQuery.attrHooks.style = {
+ get: function( elem ) {
+ // Return undefined in the case of empty string
+ // Note: IE uppercases css property names, but if we were to .toLowerCase()
+ // .cssText, that would destroy case senstitivity in URL's, like in "background"
+ return elem.style.cssText || undefined;
+ },
+ set: function( elem, value ) {
+ return ( elem.style.cssText = value + "" );
+ }
+ };
+}
+
+// Safari mis-reports the default selected property of an option
+// Accessing the parent's selectedIndex property fixes it
+if ( !jQuery.support.optSelected ) {
+ jQuery.propHooks.selected = jQuery.extend( jQuery.propHooks.selected, {
+ get: function( elem ) {
+ var parent = elem.parentNode;
+
+ if ( parent ) {
+ parent.selectedIndex;
+
+ // Make sure that it also works with optgroups, see #5701
+ if ( parent.parentNode ) {
+ parent.parentNode.selectedIndex;
+ }
+ }
+ return null;
+ }
+ });
+}
+
+// IE6/7 call enctype encoding
+if ( !jQuery.support.enctype ) {
+ jQuery.propFix.enctype = "encoding";
+}
+
+// Radios and checkboxes getter/setter
+if ( !jQuery.support.checkOn ) {
+ jQuery.each([ "radio", "checkbox" ], function() {
+ jQuery.valHooks[ this ] = {
+ get: function( elem ) {
+ // Handle the case where in Webkit "" is returned instead of "on" if a value isn't specified
+ return elem.getAttribute("value") === null ? "on" : elem.value;
+ }
+ };
+ });
+}
+jQuery.each([ "radio", "checkbox" ], function() {
+ jQuery.valHooks[ this ] = jQuery.extend( jQuery.valHooks[ this ], {
+ set: function( elem, value ) {
+ if ( jQuery.isArray( value ) ) {
+ return ( elem.checked = jQuery.inArray( jQuery(elem).val(), value ) >= 0 );
+ }
+ }
+ });
+});
+var rformElems = /^(?:input|select|textarea)$/i,
+ rkeyEvent = /^key/,
+ rmouseEvent = /^(?:mouse|contextmenu)|click/,
+ rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,
+ rtypenamespace = /^([^.]*)(?:\.(.+)|)$/;
+
+function returnTrue() {
+ return true;
+}
+
+function returnFalse() {
+ return false;
+}
+
+/*
+ * Helper functions for managing events -- not part of the public interface.
+ * Props to Dean Edwards' addEvent library for many of the ideas.
+ */
+jQuery.event = {
+
+ global: {},
+
+ add: function( elem, types, handler, data, selector ) {
+ var tmp, events, t, handleObjIn,
+ special, eventHandle, handleObj,
+ handlers, type, namespaces, origType,
+ elemData = jQuery._data( elem );
+
+ // Don't attach events to noData or text/comment nodes (but allow plain objects)
+ if ( !elemData ) {
+ return;
+ }
+
+ // Caller can pass in an object of custom data in lieu of the handler
+ if ( handler.handler ) {
+ handleObjIn = handler;
+ handler = handleObjIn.handler;
+ selector = handleObjIn.selector;
+ }
+
+ // Make sure that the handler has a unique ID, used to find/remove it later
+ if ( !handler.guid ) {
+ handler.guid = jQuery.guid++;
+ }
+
+ // Init the element's event structure and main handler, if this is the first
+ if ( !(events = elemData.events) ) {
+ events = elemData.events = {};
+ }
+ if ( !(eventHandle = elemData.handle) ) {
+ eventHandle = elemData.handle = function( e ) {
+ // Discard the second event of a jQuery.event.trigger() and
+ // when an event is called after a page has unloaded
+ return typeof jQuery !== core_strundefined && (!e || jQuery.event.triggered !== e.type) ?
+ jQuery.event.dispatch.apply( eventHandle.elem, arguments ) :
+ undefined;
+ };
+ // Add elem as a property of the handle fn to prevent a memory leak with IE non-native events
+ eventHandle.elem = elem;
+ }
+
+ // Handle multiple events separated by a space
+ // jQuery(...).bind("mouseover mouseout", fn);
+ types = ( types || "" ).match( core_rnotwhite ) || [""];
+ t = types.length;
+ while ( t-- ) {
+ tmp = rtypenamespace.exec( types[t] ) || [];
+ type = origType = tmp[1];
+ namespaces = ( tmp[2] || "" ).split( "." ).sort();
+
+ // If event changes its type, use the special event handlers for the changed type
+ special = jQuery.event.special[ type ] || {};
+
+ // If selector defined, determine special event api type, otherwise given type
+ type = ( selector ? special.delegateType : special.bindType ) || type;
+
+ // Update special based on newly reset type
+ special = jQuery.event.special[ type ] || {};
+
+ // handleObj is passed to all event handlers
+ handleObj = jQuery.extend({
+ type: type,
+ origType: origType,
+ data: data,
+ handler: handler,
+ guid: handler.guid,
+ selector: selector,
+ needsContext: selector && jQuery.expr.match.needsContext.test( selector ),
+ namespace: namespaces.join(".")
+ }, handleObjIn );
+
+ // Init the event handler queue if we're the first
+ if ( !(handlers = events[ type ]) ) {
+ handlers = events[ type ] = [];
+ handlers.delegateCount = 0;
+
+ // Only use addEventListener/attachEvent if the special events handler returns false
+ if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
+ // Bind the global event handler to the element
+ if ( elem.addEventListener ) {
+ elem.addEventListener( type, eventHandle, false );
+
+ } else if ( elem.attachEvent ) {
+ elem.attachEvent( "on" + type, eventHandle );
+ }
+ }
+ }
+
+ if ( special.add ) {
+ special.add.call( elem, handleObj );
+
+ if ( !handleObj.handler.guid ) {
+ handleObj.handler.guid = handler.guid;
+ }
+ }
+
+ // Add to the element's handler list, delegates in front
+ if ( selector ) {
+ handlers.splice( handlers.delegateCount++, 0, handleObj );
+ } else {
+ handlers.push( handleObj );
+ }
+
+ // Keep track of which events have ever been used, for event optimization
+ jQuery.event.global[ type ] = true;
+ }
+
+ // Nullify elem to prevent memory leaks in IE
+ elem = null;
+ },
+
+ // Detach an event or set of events from an element
+ remove: function( elem, types, handler, selector, mappedTypes ) {
+ var j, handleObj, tmp,
+ origCount, t, events,
+ special, handlers, type,
+ namespaces, origType,
+ elemData = jQuery.hasData( elem ) && jQuery._data( elem );
+
+ if ( !elemData || !(events = elemData.events) ) {
+ return;
+ }
+
+ // Once for each type.namespace in types; type may be omitted
+ types = ( types || "" ).match( core_rnotwhite ) || [""];
+ t = types.length;
+ while ( t-- ) {
+ tmp = rtypenamespace.exec( types[t] ) || [];
+ type = origType = tmp[1];
+ namespaces = ( tmp[2] || "" ).split( "." ).sort();
+
+ // Unbind all events (on this namespace, if provided) for the element
+ if ( !type ) {
+ for ( type in events ) {
+ jQuery.event.remove( elem, type + types[ t ], handler, selector, true );
+ }
+ continue;
+ }
+
+ special = jQuery.event.special[ type ] || {};
+ type = ( selector ? special.delegateType : special.bindType ) || type;
+ handlers = events[ type ] || [];
+ tmp = tmp[2] && new RegExp( "(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)" );
+
+ // Remove matching events
+ origCount = j = handlers.length;
+ while ( j-- ) {
+ handleObj = handlers[ j ];
+
+ if ( ( mappedTypes || origType === handleObj.origType ) &&
+ ( !handler || handler.guid === handleObj.guid ) &&
+ ( !tmp || tmp.test( handleObj.namespace ) ) &&
+ ( !selector || selector === handleObj.selector || selector === "**" && handleObj.selector ) ) {
+ handlers.splice( j, 1 );
+
+ if ( handleObj.selector ) {
+ handlers.delegateCount--;
+ }
+ if ( special.remove ) {
+ special.remove.call( elem, handleObj );
+ }
+ }
+ }
+
+ // Remove generic event handler if we removed something and no more handlers exist
+ // (avoids potential for endless recursion during removal of special event handlers)
+ if ( origCount && !handlers.length ) {
+ if ( !special.teardown || special.teardown.call( elem, namespaces, elemData.handle ) === false ) {
+ jQuery.removeEvent( elem, type, elemData.handle );
+ }
+
+ delete events[ type ];
+ }
+ }
+
+ // Remove the expando if it's no longer used
+ if ( jQuery.isEmptyObject( events ) ) {
+ delete elemData.handle;
+
+ // removeData also checks for emptiness and clears the expando if empty
+ // so use it instead of delete
+ jQuery._removeData( elem, "events" );
+ }
+ },
+
+ trigger: function( event, data, elem, onlyHandlers ) {
+ var handle, ontype, cur,
+ bubbleType, special, tmp, i,
+ eventPath = [ elem || document ],
+ type = core_hasOwn.call( event, "type" ) ? event.type : event,
+ namespaces = core_hasOwn.call( event, "namespace" ) ? event.namespace.split(".") : [];
+
+ cur = tmp = elem = elem || document;
+
+ // Don't do events on text and comment nodes
+ if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
+ return;
+ }
+
+ // focus/blur morphs to focusin/out; ensure we're not firing them right now
+ if ( rfocusMorph.test( type + jQuery.event.triggered ) ) {
+ return;
+ }
+
+ if ( type.indexOf(".") >= 0 ) {
+ // Namespaced trigger; create a regexp to match event type in handle()
+ namespaces = type.split(".");
+ type = namespaces.shift();
+ namespaces.sort();
+ }
+ ontype = type.indexOf(":") < 0 && "on" + type;
+
+ // Caller can pass in a jQuery.Event object, Object, or just an event type string
+ event = event[ jQuery.expando ] ?
+ event :
+ new jQuery.Event( type, typeof event === "object" && event );
+
+ event.isTrigger = true;
+ event.namespace = namespaces.join(".");
+ event.namespace_re = event.namespace ?
+ new RegExp( "(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)" ) :
+ null;
+
+ // Clean up the event in case it is being reused
+ event.result = undefined;
+ if ( !event.target ) {
+ event.target = elem;
+ }
+
+ // Clone any incoming data and prepend the event, creating the handler arg list
+ data = data == null ?
+ [ event ] :
+ jQuery.makeArray( data, [ event ] );
+
+ // Allow special events to draw outside the lines
+ special = jQuery.event.special[ type ] || {};
+ if ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) {
+ return;
+ }
+
+ // Determine event propagation path in advance, per W3C events spec (#9951)
+ // Bubble up to document, then to window; watch for a global ownerDocument var (#9724)
+ if ( !onlyHandlers && !special.noBubble && !jQuery.isWindow( elem ) ) {
+
+ bubbleType = special.delegateType || type;
+ if ( !rfocusMorph.test( bubbleType + type ) ) {
+ cur = cur.parentNode;
+ }
+ for ( ; cur; cur = cur.parentNode ) {
+ eventPath.push( cur );
+ tmp = cur;
+ }
+
+ // Only add window if we got to document (e.g., not plain obj or detached DOM)
+ if ( tmp === (elem.ownerDocument || document) ) {
+ eventPath.push( tmp.defaultView || tmp.parentWindow || window );
+ }
+ }
+
+ // Fire handlers on the event path
+ i = 0;
+ while ( (cur = eventPath[i++]) && !event.isPropagationStopped() ) {
+
+ event.type = i > 1 ?
+ bubbleType :
+ special.bindType || type;
+
+ // jQuery handler
+ handle = ( jQuery._data( cur, "events" ) || {} )[ event.type ] && jQuery._data( cur, "handle" );
+ if ( handle ) {
+ handle.apply( cur, data );
+ }
+
+ // Native handler
+ handle = ontype && cur[ ontype ];
+ if ( handle && jQuery.acceptData( cur ) && handle.apply && handle.apply( cur, data ) === false ) {
+ event.preventDefault();
+ }
+ }
+ event.type = type;
+
+ // If nobody prevented the default action, do it now
+ if ( !onlyHandlers && !event.isDefaultPrevented() ) {
+
+ if ( (!special._default || special._default.apply( elem.ownerDocument, data ) === false) &&
+ !(type === "click" && jQuery.nodeName( elem, "a" )) && jQuery.acceptData( elem ) ) {
+
+ // Call a native DOM method on the target with the same name name as the event.
+ // Can't use an .isFunction() check here because IE6/7 fails that test.
+ // Don't do default actions on window, that's where global variables be (#6170)
+ if ( ontype && elem[ type ] && !jQuery.isWindow( elem ) ) {
+
+ // Don't re-trigger an onFOO event when we call its FOO() method
+ tmp = elem[ ontype ];
+
+ if ( tmp ) {
+ elem[ ontype ] = null;
+ }
+
+ // Prevent re-triggering of the same event, since we already bubbled it above
+ jQuery.event.triggered = type;
+ try {
+ elem[ type ]();
+ } catch ( e ) {
+ // IE<9 dies on focus/blur to hidden element (#1486,#12518)
+ // only reproducible on winXP IE8 native, not IE9 in IE8 mode
+ }
+ jQuery.event.triggered = undefined;
+
+ if ( tmp ) {
+ elem[ ontype ] = tmp;
+ }
+ }
+ }
+ }
+
+ return event.result;
+ },
+
+ dispatch: function( event ) {
+
+ // Make a writable jQuery.Event from the native event object
+ event = jQuery.event.fix( event );
+
+ var i, ret, handleObj, matched, j,
+ handlerQueue = [],
+ args = core_slice.call( arguments ),
+ handlers = ( jQuery._data( this, "events" ) || {} )[ event.type ] || [],
+ special = jQuery.event.special[ event.type ] || {};
+
+ // Use the fix-ed jQuery.Event rather than the (read-only) native event
+ args[0] = event;
+ event.delegateTarget = this;
+
+ // Call the preDispatch hook for the mapped type, and let it bail if desired
+ if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {
+ return;
+ }
+
+ // Determine handlers
+ handlerQueue = jQuery.event.handlers.call( this, event, handlers );
+
+ // Run delegates first; they may want to stop propagation beneath us
+ i = 0;
+ while ( (matched = handlerQueue[ i++ ]) && !event.isPropagationStopped() ) {
+ event.currentTarget = matched.elem;
+
+ j = 0;
+ while ( (handleObj = matched.handlers[ j++ ]) && !event.isImmediatePropagationStopped() ) {
+
+ // Triggered event must either 1) have no namespace, or
+ // 2) have namespace(s) a subset or equal to those in the bound event (both can have no namespace).
+ if ( !event.namespace_re || event.namespace_re.test( handleObj.namespace ) ) {
+
+ event.handleObj = handleObj;
+ event.data = handleObj.data;
+
+ ret = ( (jQuery.event.special[ handleObj.origType ] || {}).handle || handleObj.handler )
+ .apply( matched.elem, args );
+
+ if ( ret !== undefined ) {
+ if ( (event.result = ret) === false ) {
+ event.preventDefault();
+ event.stopPropagation();
+ }
+ }
+ }
+ }
+ }
+
+ // Call the postDispatch hook for the mapped type
+ if ( special.postDispatch ) {
+ special.postDispatch.call( this, event );
+ }
+
+ return event.result;
+ },
+
+ handlers: function( event, handlers ) {
+ var sel, handleObj, matches, i,
+ handlerQueue = [],
+ delegateCount = handlers.delegateCount,
+ cur = event.target;
+
+ // Find delegate handlers
+ // Black-hole SVG
+
+ System
+
+
+ +
+
+
+ + + + + + + + + + + + +
+
+
+
+
+
+ Import and Create
+
+
+ +
+
+
+ + + + + + + + + + + + +
+
+
Drag and drop import
+ +
+
+
+ +
+
+ Metadata and Project manipulation
+
+
+ +
+
+
+ + + + + + + + +
+ + + + + + + + + + + + + + + +
+
+
+
+
Export
+
+
+
+
+
+
+
diff --git a/pype/premiere/extensions/com.pype.rename/jsx/PPRO/PPro_API_Constants.jsx b/pype/premiere/extensions/com.pype.rename/jsx/PPRO/PPro_API_Constants.jsx
new file mode 100644
index 0000000000..17524d6968
--- /dev/null
+++ b/pype/premiere/extensions/com.pype.rename/jsx/PPRO/PPro_API_Constants.jsx
@@ -0,0 +1,60 @@
+/*************************************************************************
+* ADOBE CONFIDENTIAL
+* ___________________
+*
+* Copyright 2014 Adobe
+* All Rights Reserved.
+*
+* NOTICE: Adobe permits you to use, modify, and distribute this file in
+* accordance with the terms of the Adobe license agreement accompanying
+* it. If you have received this file from a source other than Adobe,
+* then your use, modification, or distribution of it requires the prior
+* written permission of Adobe.
+**************************************************************************/
+// time display types
+
+TIMEDISPLAY_24Timecode = 100;
+TIMEDISPLAY_25Timecode = 101;
+TIMEDISPLAY_2997DropTimecode = 102;
+TIMEDISPLAY_2997NonDropTimecode = 103;
+TIMEDISPLAY_30Timecode = 104;
+TIMEDISPLAY_50Timecode = 105;
+TIMEDISPLAY_5994DropTimecode = 106;
+TIMEDISPLAY_5994NonDropTimecode = 107;
+TIMEDISPLAY_60Timecode = 108;
+TIMEDISPLAY_Frames = 109;
+TIMEDISPLAY_23976Timecode = 110;
+TIMEDISPLAY_16mmFeetFrames = 111;
+TIMEDISPLAY_35mmFeetFrames = 112;
+TIMEDISPLAY_48Timecode = 113;
+TIMEDISPLAY_AudioSamplesTimecode = 200;
+TIMEDISPLAY_AudioMsTimecode = 201;
+
+// field type constants
+
+FIELDTYPE_Progressive = 0;
+FIELDTYPE_UpperFirst = 1;
+FIELDTYPE_LowerFirst = 2;
+
+// audio channel types
+
+AUDIOCHANNELTYPE_Mono = 0;
+AUDIOCHANNELTYPE_Stereo = 1;
+AUDIOCHANNELTYPE_51 = 2;
+AUDIOCHANNELTYPE_Multichannel = 3;
+AUDIOCHANNELTYPE_4Channel = 4;
+AUDIOCHANNELTYPE_8Channel = 5;
+
+// vr projection type
+
+VRPROJECTIONTYPE_None = 0;
+VRPROJECTIONTYPE_Equirectangular = 1;
+
+// vr stereoscopic type
+
+VRSTEREOSCOPICTYPE_Monoscopic = 0;
+VRSTEREOSCOPICTYPE_OverUnder = 1;
+VRSTEREOSCOPICTYPE_SideBySide = 2;
+
+NOT_SET = -400000;
+
diff --git a/pype/premiere/extensions/com.pype.rename/jsx/PPRO/Premiere.jsx b/pype/premiere/extensions/com.pype.rename/jsx/PPRO/Premiere.jsx
new file mode 100644
index 0000000000..5906196b8f
--- /dev/null
+++ b/pype/premiere/extensions/com.pype.rename/jsx/PPRO/Premiere.jsx
@@ -0,0 +1,2382 @@
+/*************************************************************************
+* ADOBE CONFIDENTIAL
+* ___________________
+*
+* Copyright 2014 Adobe
+* All Rights Reserved.
+*
+* NOTICE: Adobe permits you to use, modify, and distribute this file in
+* accordance with the terms of the Adobe license agreement accompanying
+* it. If you have received this file from a source other than Adobe,
+* then your use, modification, or distribution of it requires the prior
+* written permission of Adobe.
+**************************************************************************/
+#include "PPro_API_Constants.jsx"
+
+$._PPP_={
+
+ createDeepFolderStructure : function(foldersArray, maxDepth) {
+ if (typeof foldersArray !== 'object' || foldersArray.length <= 0) {
+ throw new Error('No valid folders array was provided!');
+ }
+
+ // if the first folder already exists, throw error
+ for (var i = 0; i < app.project.rootItem.children.numItems; i++) {
+ var curChild = app.project.rootItem.children[i];
+ if (curChild.type === ProjectItemType.BIN && curChild.name === foldersArray[0]) {
+ throw new Error('Folder with name "' + curChild.name + '" already exists!');
+ }
+ }
+
+ // create the deep folder structure
+ var currentBin = app.project.rootItem.createBin(foldersArray[0]);
+ for (var m = 1; m < foldersArray.length && m < maxDepth; i++) {
+ currentBin = currentBin.createBin(foldersArray[i]);
+ }
+ },
+
+ getVersionInfo : function() {
+ return 'PPro ' + app.version + 'x' + app.build;
+ },
+
+ getUserName : function() {
+ var homeDir = new File('~/');
+ var userName = homeDir.displayName;
+ homeDir.close();
+ return userName;
+ },
+
+ keepPanelLoaded : function() {
+ app.setExtensionPersistent("com.pype.RenameDialog", 0); // 0, while testing (to enable rapid reload); 1 for "Never unload me, even when not visible."
+ },
+
+ updateGrowingFile : function() {
+ var numItems = app.project.rootItem.children.numItems;
+ for (var i = 0; i < numItems; i++){
+ var currentItem = app.project.rootItem.children[i];
+ if (currentItem){
+ currentItem.refreshMedia();
+ }
+ }
+ },
+
+ getSep : function() {
+ if (Folder.fs == 'Macintosh') {
+ return '/';
+ } else {
+ return '\\';
+ }
+ },
+
+ saveProject : function() {
+ app.project.save();
+ },
+
+ exportCurrentFrameAsPNG : function() {
+ app.enableQE();
+ var activeSequence = qe.project.getActiveSequence(); // note: make sure a sequence is active in PPro UI
+ if (activeSequence) {
+ // Create a file name based on timecode of frame.
+ var time = activeSequence.CTI.timecode; // CTI = Current Time Indicator.
+ var removeThese = /:|;/ig; // Why? Because Windows chokes on colons.
+ time = time.replace(removeThese, '_');
+ var outputPath = new File("~/Desktop");
+ var outputFileName = outputPath.fsName + $._PPP_.getSep() + time + '___' + activeSequence.name;
+ activeSequence.exportFramePNG(time, outputFileName);
+ } else {
+ $._PPP_.updateEventPanel("No active sequence.");
+ }
+ },
+
+ renameFootage : function() {
+ var item = app.project.rootItem.children[0]; // assumes the zero-th item in the project is footage.
+ if (item) {
+ item.name = item.name + ", updated by PProPanel.";
+ } else {
+ $._PPP_.updateEventPanel("No project items found.");
+ }
+ },
+
+ getActiveSequenceName : function() {
+ if (app.project.activeSequence) {
+ return app.project.activeSequence.name;
+ } else {
+ return "No active sequence.";
+ }
+ },
+
+ projectPanelSelectionChanged : function(projectItems, viewID) {
+
+ var remainingArgs = projectItems.length;
+ var message = "";
+
+ if (remainingArgs){
+ var message = remainingArgs + " items selected: ";
+ var view = viewID;
+
+ // Concatenate selected project item names, into message.
+ for (var i = 0; i < projectItems.length; i++) {
+ message += projectItems[i].name;
+ remainingArgs--;
+ if (remainingArgs > 1) {
+ message += ', ';
+ }
+ if (remainingArgs === 1){
+ message += ", and ";
+ }
+ if (remainingArgs === 0) {
+ message += ".";
+ }
+ }
+ } else {
+ message = '0 items selected.';
+ }
+ app.setSDKEventMessage(message, 'info');
+ },
+
+ registerProjectPanelSelectionChangedFxn : function() {
+ var success = app.bind("onSourceClipSelectedInProjectPanel", $._PPP_.projectPanelSelectionChanged);
+ },
+
+ saveCurrentProjectLayout : function() {
+ var currentProjPanelDisplay = app.project.getProjectPanelMetadata();
+ if (currentProjPanelDisplay){
+ var outFileName = 'Previous_Project_Panel_Display_Settings.xml';
+ var actualProjectPath = new File(app.project.path);
+ var projDir = actualProjectPath.parent;
+ if (actualProjectPath){
+ var completeOutputPath = projDir + $._PPP_.getSep() + outFileName;
+ var outFile = new File(completeOutputPath);
+ if (outFile){
+ outFile.encoding = "UTF8";
+ outFile.open("w", "TEXT", "????");
+ outFile.write(currentProjPanelDisplay);
+ $._PPP_.updateEventPanel("Saved layout to next to the project.");
+ outFile.close();
+ }
+ actualProjectPath.close();
+ }
+ } else {
+ $._PPP_.updateEventPanel("Could not retrieve current project layout.");
+ }
+ },
+
+ setProjectPanelMeta : function() {
+ var filterString = "";
+ if (Folder.fs === 'Windows'){
+ filterString = "XML files:*.xml";
+ }
+ var fileToOpen = File.openDialog ( "Choose Project panel layout to open.",
+ filterString,
+ false);
+ if (fileToOpen) {
+ if (fileToOpen.fsName.indexOf('.xml')){ // We should really be more careful, but hey, it says it's XML!
+ fileToOpen.encoding = "UTF8";
+ fileToOpen.open("r", "TEXT", "????");
+ var fileContents = fileToOpen.read();
+ if (fileContents){
+ var setResult = app.project.setProjectPanelMetadata(fileContents);
+ if (setResult){
+ $._PPP_.updateEventPanel("Could not update layout using " + fileToOpen.filename + ".");
+ } else {
+ $._PPP_.updateEventPanel("Updated layout from .xml file.");
+ }
+ }
+ }
+ } else {
+ $._PPP_.updateEventPanel("No valid layout file chosen.");
+ }
+ },
+
+ exportSequenceAsPrProj : function() {
+ var activeSequence = app.project.activeSequence;
+ if (activeSequence) {
+ var startTimeOffset = activeSequence.zeroPoint;
+ var prProjExtension = '.prproj';
+ var outputName = activeSequence.name;
+ var outFolder = Folder.selectDialog();
+
+ if (outFolder) {
+ var completeOutputPath = outFolder.fsName +
+ $._PPP_.getSep() +
+ outputName +
+ prProjExtension;
+
+ app.project.activeSequence.exportAsProject(completeOutputPath);
+
+ $._PPP_.updateEventPanel("Exported " + app.project.activeSequence.name + " to " +completeOutputPath + ".");
+ } else {
+ $._PPP_.updateEventPanel("Could not find or create output folder.");
+ }
+
+ // Here's how to import N sequences from a project.
+ //
+ // var seqIDsToBeImported = new Array;
+ // seqIDsToBeImported[0] = ID1;
+ // ...
+ // seqIDsToBeImported[N] = IDN;
+ //
+ //app.project.importSequences(pathToPrProj, seqIDsToBeImported);
+
+ }else {
+ $._PPP_.updateEventPanel("No active sequence.");
+ }
+ },
+
+ createSequenceMarkers : function() {
+ var activeSequence = app.project.activeSequence;
+ if (activeSequence) {
+ var markers = activeSequence.markers;
+ if (markers) {
+ var numMarkers = markers.numMarkers;
+ if (numMarkers > 0) {
+ var marker_index = 1;
+ for(var current_marker = markers.getFirstMarker();
+ current_marker !== undefined;
+ current_marker = markers.getNextMarker(current_marker)){
+ if (current_marker.name !== "") {
+ $._PPP_.updateEventPanel( 'Marker ' + marker_index + ' name = ' + current_marker.name + '.');
+ } else {
+ $._PPP_.updateEventPanel( 'Marker ' + marker_index + ' has no name.');
+ }
+
+ if (current_marker.end.seconds > 0) {
+ $._PPP_.updateEventPanel( 'Marker ' + marker_index + ' duration = ' + (current_marker.end.seconds - current_marker.start.seconds) + ' seconds.');
+ } else {
+ $._PPP_.updateEventPanel( 'Marker ' + marker_index + ' has no duration.');
+ }
+ $._PPP_.updateEventPanel('Marker ' + marker_index + ' starts at ' + current_marker.start.seconds + ' seconds.');
+ marker_index = marker_index + 1;
+ }
+ }
+ }
+
+ var newCommentMarker = markers.createMarker(12.345);
+ newCommentMarker.name = 'Marker created by PProPanel.';
+ newCommentMarker.comments = 'Here are some comments, inserted by PProPanel.';
+ newCommentMarker.end = 15.6789;
+
+ var newWebMarker = markers.createMarker(14.345);
+ newWebMarker.name = 'Web marker created by PProPanel.';
+ newWebMarker.comments = 'Here are some comments, inserted by PProPanel.';
+ newWebMarker.end = 17.6789;
+ newWebMarker.setTypeAsWebLink("http://www.adobe.com", "frame target");
+ } else {
+ $._PPP_.updateEventPanel("No active sequence.");
+ }
+ },
+
+ exportFCPXML : function() {
+ if (app.project.activeSequence) {
+ var projPath = new File(app.project.path);
+ var parentDir = projPath.parent;
+ var outputName = app.project.activeSequence.name;
+ var xmlExtension = '.xml';
+ var outputPath = Folder.selectDialog("Choose the output directory");
+
+ if (outputPath) {
+ var completeOutputPath = outputPath.fsName + $._PPP_.getSep() + outputName + xmlExtension;
+ app.project.activeSequence.exportAsFinalCutProXML(completeOutputPath, 1); // 1 == suppress UI
+ var info = "Exported FCP XML for " +
+ app.project.activeSequence.name +
+ " to " +
+ completeOutputPath +
+ ".";
+ $._PPP_.updateEventPanel(info);
+ } else {
+ $._PPP_.updateEventPanel("No output path chosen.");
+ }
+ } else {
+ $._PPP_.updateEventPanel("No active sequence.");
+ }
+ },
+
+ openInSource : function() {
+ var filterString = "";
+ if (Folder.fs === 'Windows'){
+ filterString = "All files:*.*";
+ }
+ var fileToOpen = File.openDialog ( "Choose file to open.",
+ filterString,
+ false);
+ if (fileToOpen) {
+ app.sourceMonitor.openFilePath(fileToOpen.fsName);
+ app.sourceMonitor.play(1.73); // playback speed as float, 1.0 = normal speed forward
+ var position = app.sourceMonitor.getPosition(); // new in 13.0
+ $._PPP_.updateEventPanel("Current Source monitor position: " + position.seconds + " seconds.");
+ fileToOpen.close();
+ } else {
+ $._PPP_.updateEventPanel("No file chosen.");
+ }
+ },
+
+ searchForBinWithName : function (nameToFind) {
+ // deep-search a folder by name in project
+ var deepSearchBin = function(inFolder) {
+ if (inFolder && inFolder.name === nameToFind && inFolder.type === 2) {
+ return inFolder;
+ } else {
+ for (var i = 0; i < inFolder.children.numItems; i++) {
+ if (inFolder.children[i] && inFolder.children[i].type === 2) {
+ var foundBin = deepSearchBin(inFolder.children[i]);
+ if (foundBin) return foundBin;
+ }
+ }
+ }
+ return undefined;
+ };
+ return deepSearchBin(app.project.rootItem);
+ },
+
+ importFiles : function() {
+ var filterString = "";
+ if (Folder.fs === 'Windows'){
+ filterString = "All files:*.*";
+ }
+ if (app.project) {
+ var fileOrFilesToImport = File.openDialog ( "Choose files to import", // title
+ filterString, // filter available files?
+ true); // allow multiple?
+ if (fileOrFilesToImport) {
+ // We have an array of File objects; importFiles() takes an array of paths.
+ var importThese = [];
+ if (importThese){
+ for (var i = 0; i < fileOrFilesToImport.length; i++) {
+ importThese[i] = fileOrFilesToImport[i].fsName;
+ }
+ app.project.importFiles(importThese,
+ 1, // suppress warnings
+ app.project.getInsertionBin(),
+ 0); // import as numbered stills
+ }
+ } else {
+ $._PPP_.updateEventPanel("No files to import.");
+ }
+ }
+ },
+
+ muteFun : function() {
+ if (app.project.activeSequence){
+ for (var i = 0; i < app.project.activeSequence.audioTracks.numTracks; i++){
+ var currentTrack = app.project.activeSequence.audioTracks[i];
+ if (Math.random() > 0.5){
+ currentTrack.setMute(!(currentTrack.isMuted()));
+ }
+ }
+ } else {
+ $._PPP_.updateEventPanel("No active sequence.");
+ }
+ },
+
+ disableImportWorkspaceWithProjects : function() {
+ var prefToModify = 'FE.Prefs.ImportWorkspace';
+ var appProperties = app.properties;
+
+ if (appProperties){
+ var propertyExists = app.properties.doesPropertyExist(prefToModify);
+ var propertyIsReadOnly = app.properties.isPropertyReadOnly(prefToModify);
+ var propertyValue = app.properties.getProperty(prefToModify);
+
+ appProperties.setProperty(prefToModify, false, 1); // optional 3rd param : 0 = non-persistent, 1 = persistent (default)
+ var safetyCheck = app.properties.getProperty(prefToModify);
+ if (safetyCheck != propertyValue){
+ $._PPP_.updateEventPanel("Changed \'Import Workspaces with Projects\' from " + propertyValue + " to " + safetyCheck + ".");
+ }
+ } else {
+ $._PPP_.updateEventPanel("Properties not found.");
+ }
+ },
+
+ turnOffStartDialog : function (){
+ var prefToModify = 'MZ.Prefs.ShowQuickstartDialog';
+ var appProperties = app.properties;
+ if (appProperties){
+ var propertyExists = app.properties.doesPropertyExist(prefToModify);
+ var propertyIsReadOnly = app.properties.isPropertyReadOnly(prefToModify);
+ var originalValue = app.properties.getProperty(prefToModify);
+
+ appProperties.setProperty(prefToModify, false, 1, 1); // optional 4th param : 0 = non-persistent, 1 = persistent (default)
+ var safetyCheck = app.properties.getProperty(prefToModify);
+ if (safetyCheck != originalValue){
+ $._PPP_.updateEventPanel("Start dialog now OFF. Enjoy!");
+ } else {
+ $._PPP_.updateEventPanel("Start dialog was already OFF.");
+ }
+ } else {
+ $._PPP_.updateEventPanel("Properties not found.");
+ }
+ },
+
+ replaceMedia : function() {
+
+ // Note: This method of changing paths for projectItems is from the time
+ // before PPro supported full-res AND proxy paths for each projectItem.
+ // This can still be used, and will change the hi-res projectItem path, but
+ // if your panel supports proxy workflows, it should rely instead upon
+ // projectItem.setProxyPath() instead.
+
+ var firstProjectItem = app.project.rootItem.children[0];
+ if (firstProjectItem) {
+ if (firstProjectItem.canChangeMediaPath()) {
+
+ // NEW in 9.0: setScaleToFrameSize() ensures that for all clips created from this footage,
+ // auto scale to frame size will be ON, regardless of the current user preference.
+ // This is important for proxy workflows, to avoid mis-scaling upon replacement.
+
+ // Addendum: This setting will be in effect the NEXT time the projectItem is added to a
+ // sequence; it will not affect or reinterpret clips from this projectItem, already in
+ // sequences.
+
+ firstProjectItem.setScaleToFrameSize();
+ var filterString = "";
+ if (Folder.fs === 'Windows'){
+ filterString = "All files:*.*";
+ }
+ var replacementMedia = File.openDialog( "Choose new media file, for " +
+ firstProjectItem.name,
+ filterString, // file filter
+ false); // allow multiple?
+
+ if (replacementMedia) {
+ var suppressWarnings = true;
+ firstProjectItem.name = replacementMedia.name + ", formerly known as " + firstProjectItem.name;
+ firstProjectItem.changeMediaPath(replacementMedia.fsName, suppressWarnings); // new in 12.1
+ replacementMedia.close();
+ }
+ } else {
+ $._PPP_.updateEventPanel("Couldn't change path of " + firstProjectItem.name + ".");
+ }
+ } else {
+ $._PPP_.updateEventPanel("No project items found.");
+ }
+ },
+
+ openProject : function() {
+ var filterString = "";
+ if (Folder.fs === 'Windows'){
+ filterString = "Premiere Pro project files:*.prproj";
+ }
+ var projToOpen = File.openDialog ( "Choose project:",
+ filterString,
+ false);
+ if ((projToOpen) && projToOpen.exists) {
+ app.openDocument( projToOpen.fsName,
+ 1, // suppress 'Convert Project' dialogs?
+ 1, // suppress 'Locate Files' dialogs?
+ 1); // suppress warning dialogs?
+ projToOpen.close();
+ }
+ },
+
+ exportFramesForMarkers : function (){
+ app.enableQE();
+ var activeSequence = app.project.activeSequence;
+ if (activeSequence) {
+ var markers = activeSequence.markers;
+ var markerCount = markers.numMarkers;
+ if (markerCount){
+ var firstMarker = markers.getFirstMarker();
+ activeSequence.setPlayerPosition(firstMarker.start.ticks);
+ $._PPP_.exportCurrentFrameAsPNG();
+
+ var previousMarker = 0;
+ if (firstMarker){
+ for(var i = 0; i < markerCount; i++){
+ if (i === 0){
+ currentMarker = markers.getNextMarker(firstMarker);
+ } else {
+ currentMarker = markers.getNextMarker(previousMarker);
+ }
+ if (currentMarker){
+ activeSequence.setPlayerPosition(currentMarker.start.ticks);
+ previousMarker = currentMarker;
+ $._PPP_.exportCurrentFrameAsPNG();
+ }
+ }
+ }
+ } else {
+ $._PPP_.updateEventPanel("No markers applied to " + activeSequence.name + ".");
+ }
+ } else {
+ $._PPP_.updateEventPanel("No active sequence.");
+ }
+ },
+
+ createSequence : function(name) {
+ var someID = "xyz123";
+ var seqName = prompt('Name of sequence?', '<<+
+
+
+ + + + + + + + + + + + + + + + + +
+
+
+
+
- "data": An array of the full names of the selected files. + *
- "err": The status of the operation, one of
+ *
NO_ERROR + *
ERR_INVALID_PARAMS
+ *
- "data": An array of the full names of the selected files. + *
- "err": The status of the operation, one of
+ *
NO_ERROR + *
ERR_INVALID_PARAMS
+ *
- "data": The file path selected to save at or "" if canceled + *
- "err": The status of the operation, one of
+ *
NO_ERROR + *
ERR_INVALID_PARAMS
+ *
- "data": An array of the names of the contained files (excluding '.' and '..'. + *
- "err": The status of the operation, one of:
+ *
NO_ERROR + *
ERR_UNKNOWN + *
ERR_INVALID_PARAMS + *
ERR_NOT_FOUND + *
ERR_CANT_READ
- "err": The status of the operation, one of:
+ *
NO_ERROR + *
ERR_UNKNOWN + *
ERR_INVALID_PARAMS
- "err": The status of the operation, one of:
+ *
NO_ERROR + *
ERR_UNKNOWN + *
ERR_INVALID_PARAMS + *
ERR_NOT_FOUND + *
ERR_FILE_EXISTS
- "data": An object with properties
+ *
isFile (boolean) + *
isDirectory (boolean) + *
mtime (modification DateTime)
+ * - "err": The status of the operation, one of
+ *
NO_ERROR + *
ERR_UNKNOWN + *
ERR_INVALID_PARAMS + *
ERR_NOT_FOUND
+ *
- "data": The file contents. + *
- "err": The status of the operation, one of
+ *
NO_ERROR + *
ERR_UNKNOWN + *
ERR_INVALID_PARAMS + *
ERR_NOT_FOUND + *
ERR_CANT_READ + *
ERR_UNSUPPORTED_ENCODING
+ *
- "err": The status of the operation, one of:
+ *
NO_ERROR + *
ERR_UNKNOWN + *
ERR_INVALID_PARAMS + *
ERR_UNSUPPORTED_ENCODING + *
ERR_CANT_WRITE + *
ERR_OUT_OF_SPACE
- "err": The status of the operation, one of:
+ *
NO_ERROR + *
ERR_UNKNOWN + *
ERR_INVALID_PARAMS + *
ERR_CANT_WRITE
- "err": The status of the operation, one of:
+ *
NO_ERROR + *
ERR_UNKNOWN + *
ERR_INVALID_PARAMS + *
ERR_NOT_FOUND + *
ERR_NOT_FILE
- "data": The pid of the process, or -1 on error. + *
- "err": The status of the operation, one of
+ *
NO_ERROR + *
ERR_UNKNOWN + *
ERR_INVALID_PARAMS + *
ERR_EXCEED_MAX_NUM_PROCESS + *
ERR_NOT_FOUND + *
ERR_NOT_FILE
+ *
- "err": The status of the operation, one of:
+ *
NO_ERROR + *
ERR_UNKNOWN + *
ERR_INVALID_PARAMS + *
ERR_INVALID_PROCESS_ID
- "err": The status of the operation, one of:
+ *
NO_ERROR + *
ERR_UNKNOWN + *
ERR_INVALID_PARAMS + *
ERR_INVALID_PROCESS_ID
- "err": The status of the operation, one of:
+ *
NO_ERROR + *
ERR_UNKNOWN + *
ERR_INVALID_PARAMS + *
ERR_INVALID_PROCESS_ID
- "data": The path of the working directory. + *
- "err": The status of the operation, one of
+ *
NO_ERROR + *
ERR_UNKNOWN + *
ERR_INVALID_PARAMS + *
ERR_INVALID_PROCESS_ID
- "err": The status of the operation, one of:
+ *
NO_ERROR + *
ERR_UNKNOWN + *
ERR_INVALID_PARAMS + *
ERR_INVALID_PROCESS_ID
- "err": The status of the operation, one of:
+ *
NO_ERROR + *
ERR_UNKNOWN + *
ERR_INVALID_PARAMS + *
ERR_INVALID_PROCESS_ID
- "data": True if the process is running, false otherwise. + *
- "err": The status of the operation, one of
+ *
NO_ERROR + *
ERR_UNKNOWN + *
ERR_INVALID_PARAMS + *
ERR_INVALID_PROCESS_ID
- "err": The status of the operation, one of:
+ *
NO_ERROR + *
ERR_UNKNOWN + *
ERR_INVALID_PARAMS + *
ERR_INVALID_PROCESS_ID
- "err": The status of the operation, one of:
+ *
NO_ERROR + *
ERR_UNKNOWN + *
ERR_INVALID_PARAMS
- "err": The status of the operation, one of:
+ *
NO_ERROR + *
ERR_INVALID_PARAMS
- "err": The status of the operation, one of
+ *
NO_ERROR + *
ERR_INVALID_PARAMS
+ *
-
+ *
- Access information about the host application in which an extension is running + *
- Launch an extension + *
- Register interest in event notifications, and dispatch events + *
requestOpenExtension("HLP", "");
+ *
+ */
+CSInterface.prototype.requestOpenExtension = function(extensionId, params)
+{
+ window.__adobe_cep__.requestOpenExtension(extensionId, params);
+};
+
+/**
+ * Retrieves the list of extensions currently loaded in the current host application.
+ * The extension list is initialized once, and remains the same during the lifetime
+ * of the CEP session.
+ *
+ * @param extensionIds Optional, an array of unique identifiers for extensions of interest.
+ * If omitted, retrieves data for all extensions.
+ *
+ * @return Zero or more \c #Extension objects.
+ */
+CSInterface.prototype.getExtensions = function(extensionIds)
+{
+ var extensionIdsStr = JSON.stringify(extensionIds);
+ var extensionsStr = window.__adobe_cep__.getExtensions(extensionIdsStr);
+
+ var extensions = JSON.parse(extensionsStr);
+ return extensions;
+};
+
+/**
+ * Retrieves network-related preferences.
+ *
+ * @return A JavaScript object containing network preferences.
+ */
+CSInterface.prototype.getNetworkPreferences = function()
+{
+ var result = window.__adobe_cep__.getNetworkPreferences();
+ var networkPre = JSON.parse(result);
+
+ return networkPre;
+};
+
+/**
+ * Initializes the resource bundle for this extension with property values
+ * for the current application and locale.
+ * To support multiple locales, you must define a property file for each locale,
+ * containing keyed display-string values for that locale.
+ * See localization documentation for Extension Builder and related products.
+ *
+ * Keys can be in the
+ * form key.value="localized string", for use in HTML text elements.
+ * For example, in this input element, the localized \c key.value string is displayed
+ * instead of the empty \c value string:
+ *
+ * - \n
+ *
- NO_ERROR - 0 \n + *
- ERR_UNKNOWN - 1 \n + *
- ERR_INVALID_PARAMS - 2 \n + *
- ERR_INVALID_URL - 201 \n + *
- \n
+ *
- -1.0 when error occurs \n + *
- 1.0 means normal screen \n + *
- >1.0 means HiDPI screen \n + *
CSEvent type in CSInterface.js.
+ *
+ * @param type The message type.
+ * @param appId The peer appId.
+ * @param appVersion The peer appVersion.
+ *
+ */
+function VulcanMessage(type, appId, appVersion)
+{
+ this.type = type;
+ this.scope = VulcanMessage.SCOPE_SUITE;
+ this.appId = requiredParamsValid(appId) ? appId : VulcanMessage.DEFAULT_APP_ID;
+ this.appVersion = requiredParamsValid(appVersion) ? appVersion : VulcanMessage.DEFAULT_APP_VERSION;
+ this.data = VulcanMessage.DEFAULT_DATA;
+}
+
+VulcanMessage.TYPE_PREFIX = "vulcan.SuiteMessage.";
+VulcanMessage.SCOPE_SUITE = "GLOBAL";
+VulcanMessage.DEFAULT_APP_ID = "UNKNOWN";
+VulcanMessage.DEFAULT_APP_VERSION = "UNKNOWN";
+VulcanMessage.DEFAULT_DATA = "| t |