http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/e2cad6e6/externs/GCL/externs/goog/crypt/sha2.js ---------------------------------------------------------------------- diff --git a/externs/GCL/externs/goog/crypt/sha2.js b/externs/GCL/externs/goog/crypt/sha2.js new file mode 100644 index 0000000..eae5b14 --- /dev/null +++ b/externs/GCL/externs/goog/crypt/sha2.js @@ -0,0 +1,338 @@ +// Copyright 2012 The Closure Library Authors. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS-IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/** + * @fileoverview Base class for SHA-2 cryptographic hash. + * + * Variable names follow the notation in FIPS PUB 180-3: + * http://csrc.nist.gov/publications/fips/fips180-3/fips180-3_final.pdf. + * + * Some code similar to SHA1 are borrowed from sha1.js written by mschilder@. + * + */ + +goog.provide('goog.crypt.Sha2'); + +goog.require('goog.array'); +goog.require('goog.asserts'); +goog.require('goog.crypt.Hash'); + + + +/** + * SHA-2 cryptographic hash constructor. + * This constructor should not be used directly to create the object. Rather, + * one should use the constructor of the sub-classes. + * @param {number} numHashBlocks The size of output in 16-byte blocks. + * @param {!Array<number>} initHashBlocks The hash-specific initialization + * @constructor + * @extends {goog.crypt.Hash} + * @struct + */ +goog.crypt.Sha2 = function(numHashBlocks, initHashBlocks) { + goog.crypt.Sha2.base(this, 'constructor'); + + this.blockSize = goog.crypt.Sha2.BLOCKSIZE_; + + /** + * A chunk holding the currently processed message bytes. Once the chunk has + * 64 bytes, we feed it into computeChunk_ function and reset this.chunk_. + * @private {!Array<number>|!Uint8Array} + */ + this.chunk_ = goog.global['Uint8Array'] ? + new Uint8Array(this.blockSize) : new Array(this.blockSize); + + /** + * Current number of bytes in this.chunk_. + * @private {number} + */ + this.inChunk_ = 0; + + /** + * Total number of bytes in currently processed message. + * @private {number} + */ + this.total_ = 0; + + + /** + * Holds the previous values of accumulated hash a-h in the computeChunk_ + * function. + * @private {!Array<number>|!Int32Array} + */ + this.hash_ = []; + + /** + * The number of output hash blocks (each block is 4 bytes long). + * @private {number} + */ + this.numHashBlocks_ = numHashBlocks; + + /** + * @private {!Array<number>} initHashBlocks + */ + this.initHashBlocks_ = initHashBlocks; + + /** + * Temporary array used in chunk computation. Allocate here as a + * member rather than as a local within computeChunk_() as a + * performance optimization to reduce the number of allocations and + * reduce garbage collection. + * @private {!Int32Array|!Array<number>} + */ + this.w_ = goog.global['Int32Array'] ? new Int32Array(64) : new Array(64); + + if (!goog.isDef(goog.crypt.Sha2.Kx_)) { + // This is the first time this constructor has been called. + if (goog.global['Int32Array']) { + // Typed arrays exist + goog.crypt.Sha2.Kx_ = new Int32Array(goog.crypt.Sha2.K_); + } else { + // Typed arrays do not exist + goog.crypt.Sha2.Kx_ = goog.crypt.Sha2.K_; + } + } + + this.reset(); +}; +goog.inherits(goog.crypt.Sha2, goog.crypt.Hash); + + +/** + * The block size + * @private {number} + */ +goog.crypt.Sha2.BLOCKSIZE_ = 512 / 8; + + +/** + * Contains data needed to pad messages less than BLOCK_SIZE_ bytes. + * @private {!Array<number>} + */ +goog.crypt.Sha2.PADDING_ = goog.array.concat(128, + goog.array.repeat(0, goog.crypt.Sha2.BLOCKSIZE_ - 1)); + + +/** @override */ +goog.crypt.Sha2.prototype.reset = function() { + this.inChunk_ = 0; + this.total_ = 0; + this.hash_ = goog.global['Int32Array'] ? + new Int32Array(this.initHashBlocks_) : + goog.array.clone(this.initHashBlocks_); +}; + + +/** + * Helper function to compute the hashes for a given 512-bit message chunk. + * @private + */ +goog.crypt.Sha2.prototype.computeChunk_ = function() { + var chunk = this.chunk_; + goog.asserts.assert(chunk.length == this.blockSize); + var rounds = 64; + + // Divide the chunk into 16 32-bit-words. + var w = this.w_; + var index = 0; + var offset = 0; + while (offset < chunk.length) { + w[index++] = (chunk[offset] << 24) | + (chunk[offset + 1] << 16) | + (chunk[offset + 2] << 8) | + (chunk[offset + 3]); + offset = index * 4; + } + + // Extend the w[] array to be the number of rounds. + for (var i = 16; i < rounds; i++) { + var w_15 = w[i - 15] | 0; + var s0 = ((w_15 >>> 7) | (w_15 << 25)) ^ + ((w_15 >>> 18) | (w_15 << 14)) ^ + (w_15 >>> 3); + var w_2 = w[i - 2] | 0; + var s1 = ((w_2 >>> 17) | (w_2 << 15)) ^ + ((w_2 >>> 19) | (w_2 << 13)) ^ + (w_2 >>> 10); + + // As a performance optimization, construct the sum a pair at a time + // with casting to integer (bitwise OR) to eliminate unnecessary + // double<->integer conversions. + var partialSum1 = ((w[i - 16] | 0) + s0) | 0; + var partialSum2 = ((w[i - 7] | 0) + s1) | 0; + w[i] = (partialSum1 + partialSum2) | 0; + } + + var a = this.hash_[0] | 0; + var b = this.hash_[1] | 0; + var c = this.hash_[2] | 0; + var d = this.hash_[3] | 0; + var e = this.hash_[4] | 0; + var f = this.hash_[5] | 0; + var g = this.hash_[6] | 0; + var h = this.hash_[7] | 0; + for (var i = 0; i < rounds; i++) { + var S0 = ((a >>> 2) | (a << 30)) ^ + ((a >>> 13) | (a << 19)) ^ + ((a >>> 22) | (a << 10)); + var maj = ((a & b) ^ (a & c) ^ (b & c)); + var t2 = (S0 + maj) | 0; + var S1 = ((e >>> 6) | (e << 26)) ^ + ((e >>> 11) | (e << 21)) ^ + ((e >>> 25) | (e << 7)); + var ch = ((e & f) ^ ((~ e) & g)); + + // As a performance optimization, construct the sum a pair at a time + // with casting to integer (bitwise OR) to eliminate unnecessary + // double<->integer conversions. + var partialSum1 = (h + S1) | 0; + var partialSum2 = (ch + (goog.crypt.Sha2.Kx_[i] | 0)) | 0; + var partialSum3 = (partialSum2 + (w[i] | 0)) | 0; + var t1 = (partialSum1 + partialSum3) | 0; + + h = g; + g = f; + f = e; + e = (d + t1) | 0; + d = c; + c = b; + b = a; + a = (t1 + t2) | 0; + } + + this.hash_[0] = (this.hash_[0] + a) | 0; + this.hash_[1] = (this.hash_[1] + b) | 0; + this.hash_[2] = (this.hash_[2] + c) | 0; + this.hash_[3] = (this.hash_[3] + d) | 0; + this.hash_[4] = (this.hash_[4] + e) | 0; + this.hash_[5] = (this.hash_[5] + f) | 0; + this.hash_[6] = (this.hash_[6] + g) | 0; + this.hash_[7] = (this.hash_[7] + h) | 0; +}; + + +/** @override */ +goog.crypt.Sha2.prototype.update = function(message, opt_length) { + if (!goog.isDef(opt_length)) { + opt_length = message.length; + } + // Process the message from left to right up to |opt_length| bytes. + // When we get a 512-bit chunk, compute the hash of it and reset + // this.chunk_. The message might not be multiple of 512 bits so we + // might end up with a chunk that is less than 512 bits. We store + // such partial chunk in this.chunk_ and it will be filled up later + // in digest(). + var n = 0; + var inChunk = this.inChunk_; + + // The input message could be either byte array of string. + if (goog.isString(message)) { + while (n < opt_length) { + this.chunk_[inChunk++] = message.charCodeAt(n++); + if (inChunk == this.blockSize) { + this.computeChunk_(); + inChunk = 0; + } + } + } else if (goog.isArray(message)) { + while (n < opt_length) { + var b = message[n++]; + if (!('number' == typeof b && 0 <= b && 255 >= b && b == (b | 0))) { + throw Error('message must be a byte array'); + } + this.chunk_[inChunk++] = b; + if (inChunk == this.blockSize) { + this.computeChunk_(); + inChunk = 0; + } + } + } else { + throw Error('message must be string or array'); + } + + // Record the current bytes in chunk to support partial update. + this.inChunk_ = inChunk; + + // Record total message bytes we have processed so far. + this.total_ += opt_length; +}; + + +/** @override */ +goog.crypt.Sha2.prototype.digest = function() { + var digest = []; + var totalBits = this.total_ * 8; + + // Append pad 0x80 0x00*. + if (this.inChunk_ < 56) { + this.update(goog.crypt.Sha2.PADDING_, 56 - this.inChunk_); + } else { + this.update(goog.crypt.Sha2.PADDING_, + this.blockSize - (this.inChunk_ - 56)); + } + + // Append # bits in the 64-bit big-endian format. + for (var i = 63; i >= 56; i--) { + this.chunk_[i] = totalBits & 255; + totalBits /= 256; // Don't use bit-shifting here! + } + this.computeChunk_(); + + // Finally, output the result digest. + var n = 0; + for (var i = 0; i < this.numHashBlocks_; i++) { + for (var j = 24; j >= 0; j -= 8) { + digest[n++] = ((this.hash_[i] >> j) & 255); + } + } + return digest; +}; + + +/** + * Constants used in SHA-2. + * @const + * @private {!Array<number>} + */ +goog.crypt.Sha2.K_ = [ + 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, + 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, + 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, + 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, + 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, + 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, + 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, + 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, + 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, + 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, + 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, + 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, + 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, + 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, + 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, + 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2 +]; + + +/** + * Sha2.K as an Int32Array if this JS supports typed arrays; otherwise, + * the same array as Sha2.K. + * + * The compiler cannot remove an Int32Array, even if it is not needed + * (There are certain cases where creating an Int32Array is not + * side-effect free). Instead, the first time we construct a Sha2 + * instance, we convert or assign Sha2.K as appropriate. + * @private {undefined|!Array<number>|!Int32Array} + */ +goog.crypt.Sha2.Kx_;
http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/e2cad6e6/externs/GCL/externs/goog/crypt/sha224.js ---------------------------------------------------------------------- diff --git a/externs/GCL/externs/goog/crypt/sha224.js b/externs/GCL/externs/goog/crypt/sha224.js new file mode 100644 index 0000000..40c59e9 --- /dev/null +++ b/externs/GCL/externs/goog/crypt/sha224.js @@ -0,0 +1,50 @@ +// Copyright 2012 The Closure Library Authors. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS-IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/** + * @fileoverview SHA-224 cryptographic hash. + * + * Usage: + * var sha224 = new goog.crypt.Sha224(); + * sha224.update(bytes); + * var hash = sha224.digest(); + * + */ + +goog.provide('goog.crypt.Sha224'); + +goog.require('goog.crypt.Sha2'); + + + +/** + * SHA-224 cryptographic hash constructor. + * + * @constructor + * @extends {goog.crypt.Sha2} + * @final + * @struct + */ +goog.crypt.Sha224 = function() { + goog.crypt.Sha224.base(this, 'constructor', + 7, goog.crypt.Sha224.INIT_HASH_BLOCK_); +}; +goog.inherits(goog.crypt.Sha224, goog.crypt.Sha2); + + +/** @private {!Array<number>} */ +goog.crypt.Sha224.INIT_HASH_BLOCK_ = [ + 0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, + 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4]; + http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/e2cad6e6/externs/GCL/externs/goog/crypt/sha256.js ---------------------------------------------------------------------- diff --git a/externs/GCL/externs/goog/crypt/sha256.js b/externs/GCL/externs/goog/crypt/sha256.js new file mode 100644 index 0000000..38dafb0 --- /dev/null +++ b/externs/GCL/externs/goog/crypt/sha256.js @@ -0,0 +1,49 @@ +// Copyright 2012 The Closure Library Authors. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS-IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/** + * @fileoverview SHA-256 cryptographic hash. + * + * Usage: + * var sha256 = new goog.crypt.Sha256(); + * sha256.update(bytes); + * var hash = sha256.digest(); + * + */ + +goog.provide('goog.crypt.Sha256'); + +goog.require('goog.crypt.Sha2'); + + + +/** + * SHA-256 cryptographic hash constructor. + * + * @constructor + * @extends {goog.crypt.Sha2} + * @final + * @struct + */ +goog.crypt.Sha256 = function() { + goog.crypt.Sha256.base(this, 'constructor', + 8, goog.crypt.Sha256.INIT_HASH_BLOCK_); +}; +goog.inherits(goog.crypt.Sha256, goog.crypt.Sha2); + + +/** @private {!Array<number>} */ +goog.crypt.Sha256.INIT_HASH_BLOCK_ = [ + 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, + 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19]; http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/e2cad6e6/externs/GCL/externs/goog/crypt/sha2_64bit.js ---------------------------------------------------------------------- diff --git a/externs/GCL/externs/goog/crypt/sha2_64bit.js b/externs/GCL/externs/goog/crypt/sha2_64bit.js new file mode 100644 index 0000000..077b9c4 --- /dev/null +++ b/externs/GCL/externs/goog/crypt/sha2_64bit.js @@ -0,0 +1,550 @@ +// Copyright 2014 The Closure Library Authors. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS-IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/** + * @fileoverview Base class for the 64-bit SHA-2 cryptographic hashes. + * + * Variable names follow the notation in FIPS PUB 180-3: + * http://csrc.nist.gov/publications/fips/fips180-3/fips180-3_final.pdf. + * + * This code borrows heavily from the 32-bit SHA2 implementation written by + * Yue Zhang (zysxqn@). + * + * @author [email protected] (Frank Yellin) + */ + +goog.provide('goog.crypt.Sha2_64bit'); + +goog.require('goog.array'); +goog.require('goog.asserts'); +goog.require('goog.crypt.Hash'); +goog.require('goog.math.Long'); + + + +/** + * Constructs a SHA-2 64-bit cryptographic hash. + * This class should not be used. Rather, one should use one of its + * subclasses. + * @constructor + * @param {number} numHashBlocks The size of the output in 16-byte blocks + * @param {!Array<number>} initHashBlocks The hash-specific initialization + * vector, as a sequence of sixteen 32-bit numbers. + * @extends {goog.crypt.Hash} + * @struct + */ +goog.crypt.Sha2_64bit = function(numHashBlocks, initHashBlocks) { + goog.crypt.Sha2_64bit.base(this, 'constructor'); + + /** + * The number of bytes that are digested in each pass of this hasher. + * @const {number} + */ + this.blockSize = goog.crypt.Sha2_64bit.BLOCK_SIZE_; + + /** + * A chunk holding the currently processed message bytes. Once the chunk has + * {@code this.blocksize} bytes, we feed it into [@code computeChunk_}. + * @private {!Uint8Array|!Array<number>} + */ + this.chunk_ = goog.isDef(goog.global.Uint8Array) ? + new Uint8Array(goog.crypt.Sha2_64bit.BLOCK_SIZE_) : + new Array(goog.crypt.Sha2_64bit.BLOCK_SIZE_); + + /** + * Current number of bytes in {@code this.chunk_}. + * @private {number} + */ + this.chunkBytes_ = 0; + + /** + * Total number of bytes in currently processed message. + * @private {number} + */ + this.total_ = 0; + + /** + * Holds the previous values of accumulated hash a-h in the + * {@code computeChunk_} function. + * @private {!Array<!goog.math.Long>} + */ + this.hash_ = []; + + /** + * The number of blocks of output produced by this hash function, where each + * block is eight bytes long. + * @private {number} + */ + this.numHashBlocks_ = numHashBlocks; + + /** + * Temporary array used in chunk computation. Allocate here as a + * member rather than as a local within computeChunk_() as a + * performance optimization to reduce the number of allocations and + * reduce garbage collection. + * @type {!Array<!goog.math.Long>} + * @private + */ + this.w_ = []; + + /** + * The value to which {@code this.hash_} should be reset when this + * Hasher is reset. + * @private @const {!Array<!goog.math.Long>} + */ + this.initHashBlocks_ = goog.crypt.Sha2_64bit.toLongArray_(initHashBlocks); + + /** + * If true, we have taken the digest from this hasher, but we have not + * yet reset it. + * + * @private {boolean} + */ + this.needsReset_ = false; + + this.reset(); +}; +goog.inherits(goog.crypt.Sha2_64bit, goog.crypt.Hash); + + +/** + * The number of bytes that are digested in each pass of this hasher. + * @private @const {number} + */ +goog.crypt.Sha2_64bit.BLOCK_SIZE_ = 1024 / 8; + + +/** + * Contains data needed to pad messages less than {@code blocksize} bytes. + * @private {!Array<number>} + */ +goog.crypt.Sha2_64bit.PADDING_ = goog.array.concat( + [0x80], goog.array.repeat(0, goog.crypt.Sha2_64bit.BLOCK_SIZE_ - 1)); + + +/** + * Resets this hash function. + * @override + */ +goog.crypt.Sha2_64bit.prototype.reset = function() { + this.chunkBytes_ = 0; + this.total_ = 0; + this.hash_ = goog.array.clone(this.initHashBlocks_); + this.needsReset_ = false; +}; + + +/** @override */ +goog.crypt.Sha2_64bit.prototype.update = function(message, opt_length) { + var length = goog.isDef(opt_length) ? opt_length : message.length; + + // Make sure this hasher is usable. + if (this.needsReset_) { + throw Error('this hasher needs to be reset'); + } + // Process the message from left to right up to |length| bytes. + // When we get a 512-bit chunk, compute the hash of it and reset + // this.chunk_. The message might not be multiple of 512 bits so we + // might end up with a chunk that is less than 512 bits. We store + // such partial chunk in chunk_ and it will be filled up later + // in digest(). + var chunkBytes = this.chunkBytes_; + + // The input message could be either byte array or string. + if (goog.isString(message)) { + for (var i = 0; i < length; i++) { + var b = message.charCodeAt(i); + if (b > 255) { + throw Error('Characters must be in range [0,255]'); + } + this.chunk_[chunkBytes++] = b; + if (chunkBytes == this.blockSize) { + this.computeChunk_(); + chunkBytes = 0; + } + } + } else if (goog.isArray(message)) { + for (var i = 0; i < length; i++) { + var b = message[i]; + // Hack: b|0 coerces b to an integer, so the last part confirms that + // b has no fractional part. + if (!goog.isNumber(b) || b < 0 || b > 255 || b != (b | 0)) { + throw Error('message must be a byte array'); + } + this.chunk_[chunkBytes++] = b; + if (chunkBytes == this.blockSize) { + this.computeChunk_(); + chunkBytes = 0; + } + } + } else { + throw Error('message must be string or array'); + } + + // Record the current bytes in chunk to support partial update. + this.chunkBytes_ = chunkBytes; + + // Record total message bytes we have processed so far. + this.total_ += length; +}; + + +/** @override */ +goog.crypt.Sha2_64bit.prototype.digest = function() { + if (this.needsReset_) { + throw Error('this hasher needs to be reset'); + } + var totalBits = this.total_ * 8; + + // Append pad 0x80 0x00* until this.chunkBytes_ == 112 + if (this.chunkBytes_ < 112) { + this.update(goog.crypt.Sha2_64bit.PADDING_, 112 - this.chunkBytes_); + } else { + // the rest of this block, plus 112 bytes of next block + this.update(goog.crypt.Sha2_64bit.PADDING_, + this.blockSize - this.chunkBytes_ + 112); + } + + // Append # bits in the 64-bit big-endian format. + for (var i = 127; i >= 112; i--) { + this.chunk_[i] = totalBits & 255; + totalBits /= 256; // Don't use bit-shifting here! + } + this.computeChunk_(); + + // Finally, output the result digest. + var n = 0; + var digest = new Array(8 * this.numHashBlocks_); + for (var i = 0; i < this.numHashBlocks_; i++) { + var block = this.hash_[i]; + var high = block.getHighBits(); + var low = block.getLowBits(); + for (var j = 24; j >= 0; j -= 8) { + digest[n++] = ((high >> j) & 255); + } + for (var j = 24; j >= 0; j -= 8) { + digest[n++] = ((low >> j) & 255); + } + } + + // The next call to this hasher must be a reset + this.needsReset_ = true; + return digest; +}; + + +/** + * Updates this hash by processing the 1024-bit message chunk in this.chunk_. + * @private + */ +goog.crypt.Sha2_64bit.prototype.computeChunk_ = function() { + var chunk = this.chunk_; + var K_ = goog.crypt.Sha2_64bit.K_; + + // Divide the chunk into 16 64-bit-words. + var w = this.w_; + for (var i = 0; i < 16; i++) { + var offset = i * 8; + w[i] = new goog.math.Long( + (chunk[offset + 4] << 24) | (chunk[offset + 5] << 16) | + (chunk[offset + 6] << 8) | (chunk[offset + 7]), + (chunk[offset] << 24) | (chunk[offset + 1] << 16) | + (chunk[offset + 2] << 8) | (chunk[offset + 3])); + + } + + // Extend the w[] array to be the number of rounds. + for (var i = 16; i < 80; i++) { + var s0 = this.sigma0_(w[i - 15]); + var s1 = this.sigma1_(w[i - 2]); + w[i] = this.sum_(w[i - 16], w[i - 7], s0, s1); + } + + var a = this.hash_[0]; + var b = this.hash_[1]; + var c = this.hash_[2]; + var d = this.hash_[3]; + var e = this.hash_[4]; + var f = this.hash_[5]; + var g = this.hash_[6]; + var h = this.hash_[7]; + for (var i = 0; i < 80; i++) { + var S0 = this.Sigma0_(a); + var maj = this.majority_(a, b, c); + var t2 = S0.add(maj); + var S1 = this.Sigma1_(e); + var ch = this.choose_(e, f, g); + var t1 = this.sum_(h, S1, ch, K_[i], w[i]); + h = g; + g = f; + f = e; + e = d.add(t1); + d = c; + c = b; + b = a; + a = t1.add(t2); + } + + this.hash_[0] = this.hash_[0].add(a); + this.hash_[1] = this.hash_[1].add(b); + this.hash_[2] = this.hash_[2].add(c); + this.hash_[3] = this.hash_[3].add(d); + this.hash_[4] = this.hash_[4].add(e); + this.hash_[5] = this.hash_[5].add(f); + this.hash_[6] = this.hash_[6].add(g); + this.hash_[7] = this.hash_[7].add(h); +}; + + +/** + * Calculates the SHA2 64-bit sigma0 function. + * rotateRight(value, 1) ^ rotateRight(value, 8) ^ (value >>> 7) + * + * @private + * @param {!goog.math.Long} value + * @return {!goog.math.Long} + */ +goog.crypt.Sha2_64bit.prototype.sigma0_ = function(value) { + var valueLow = value.getLowBits(); + var valueHigh = value.getHighBits(); + // Implementation note: We purposely do not use the shift operations defined + // in goog.math.Long. Inlining the code for specific values of shifting and + // not generating the intermediate results doubles the speed of this code. + var low = (valueLow >>> 1) ^ (valueHigh << 31) ^ + (valueLow >>> 8) ^ (valueHigh << 24) ^ + (valueLow >>> 7) ^ (valueHigh << 25); + var high = (valueHigh >>> 1) ^ (valueLow << 31) ^ + (valueHigh >>> 8) ^ (valueLow << 24) ^ + (valueHigh >>> 7); + return new goog.math.Long(low, high); +}; + + +/** + * Calculates the SHA2 64-bit sigma1 function. + * rotateRight(value, 19) ^ rotateRight(value, 61) ^ (value >>> 6) + * + * @private + * @param {!goog.math.Long} value + * @return {!goog.math.Long} + */ +goog.crypt.Sha2_64bit.prototype.sigma1_ = function(value) { + var valueLow = value.getLowBits(); + var valueHigh = value.getHighBits(); + // Implementation note: See _sigma0() above + var low = (valueLow >>> 19) ^ (valueHigh << 13) ^ + (valueHigh >>> 29) ^ (valueLow << 3) ^ + (valueLow >>> 6) ^ (valueHigh << 26); + var high = (valueHigh >>> 19) ^ (valueLow << 13) ^ + (valueLow >>> 29) ^ (valueHigh << 3) ^ + (valueHigh >>> 6); + return new goog.math.Long(low, high); +}; + + +/** + * Calculates the SHA2 64-bit Sigma0 function. + * rotateRight(value, 28) ^ rotateRight(value, 34) ^ rotateRight(value, 39) + * + * @private + * @param {!goog.math.Long} value + * @return {!goog.math.Long} + */ +goog.crypt.Sha2_64bit.prototype.Sigma0_ = function(value) { + var valueLow = value.getLowBits(); + var valueHigh = value.getHighBits(); + // Implementation note: See _sigma0() above + var low = (valueLow >>> 28) ^ (valueHigh << 4) ^ + (valueHigh >>> 2) ^ (valueLow << 30) ^ + (valueHigh >>> 7) ^ (valueLow << 25); + var high = (valueHigh >>> 28) ^ (valueLow << 4) ^ + (valueLow >>> 2) ^ (valueHigh << 30) ^ + (valueLow >>> 7) ^ (valueHigh << 25); + return new goog.math.Long(low, high); +}; + + +/** + * Calculates the SHA2 64-bit Sigma1 function. + * rotateRight(value, 14) ^ rotateRight(value, 18) ^ rotateRight(value, 41) + * + * @private + * @param {!goog.math.Long} value + * @return {!goog.math.Long} + */ +goog.crypt.Sha2_64bit.prototype.Sigma1_ = function(value) { + var valueLow = value.getLowBits(); + var valueHigh = value.getHighBits(); + // Implementation note: See _sigma0() above + var low = (valueLow >>> 14) ^ (valueHigh << 18) ^ + (valueLow >>> 18) ^ (valueHigh << 14) ^ + (valueHigh >>> 9) ^ (valueLow << 23); + var high = (valueHigh >>> 14) ^ (valueLow << 18) ^ + (valueHigh >>> 18) ^ (valueLow << 14) ^ + (valueLow >>> 9) ^ (valueHigh << 23); + return new goog.math.Long(low, high); +}; + + +/** + * Calculates the SHA-2 64-bit choose function. + * + * This function uses {@code value} as a mask to choose bits from either + * {@code one} if the bit is set or {@code two} if the bit is not set. + * + * @private + * @param {!goog.math.Long} value + * @param {!goog.math.Long} one + * @param {!goog.math.Long} two + * @return {!goog.math.Long} + */ +goog.crypt.Sha2_64bit.prototype.choose_ = function(value, one, two) { + var valueLow = value.getLowBits(); + var valueHigh = value.getHighBits(); + return new goog.math.Long( + (valueLow & one.getLowBits()) | (~valueLow & two.getLowBits()), + (valueHigh & one.getHighBits()) | (~valueHigh & two.getHighBits())); +}; + + +/** + * Calculates the SHA-2 64-bit majority function. + * This function returns, for each bit position, the bit held by the majority + * of its three arguments. + * + * @private + * @param {!goog.math.Long} one + * @param {!goog.math.Long} two + * @param {!goog.math.Long} three + * @return {!goog.math.Long} + */ +goog.crypt.Sha2_64bit.prototype.majority_ = function(one, two, three) { + return new goog.math.Long( + (one.getLowBits() & two.getLowBits()) | + (two.getLowBits() & three.getLowBits()) | + (one.getLowBits() & three.getLowBits()), + (one.getHighBits() & two.getHighBits()) | + (two.getHighBits() & three.getHighBits()) | + (one.getHighBits() & three.getHighBits())); +}; + + +/** + * Adds two or more goog.math.Long values. + * + * @private + * @param {!goog.math.Long} one first summand + * @param {!goog.math.Long} two second summand + * @param {...goog.math.Long} var_args more arguments to sum + * @return {!goog.math.Long} The resulting sum. + */ +goog.crypt.Sha2_64bit.prototype.sum_ = function(one, two, var_args) { + // The low bits may be signed, but they represent a 32-bit unsigned quantity. + // We must be careful to normalize them. + // This doesn't matter for the high bits. + // Implementation note: Performance testing shows that this method runs + // fastest when the first two arguments are pulled out of the loop. + var low = (one.getLowBits() ^ 0x80000000) + (two.getLowBits() ^ 0x80000000); + var high = one.getHighBits() + two.getHighBits(); + for (var i = arguments.length - 1; i >= 2; --i) { + low += arguments[i].getLowBits() ^ 0x80000000; + high += arguments[i].getHighBits(); + } + // Because of the ^0x80000000, each value we added is 0x80000000 too small. + // Add arguments.length * 0x80000000 to the current sum. We can do this + // quickly by adding 0x80000000 to low when the number of arguments is + // odd, and adding (number of arguments) >> 1 to high. + if (arguments.length & 1) { + low += 0x80000000; + } + high += arguments.length >> 1; + + // If low is outside the range [0, 0xFFFFFFFF], its overflow or underflow + // should be added to high. We don't actually need to modify low or + // normalize high because the goog.math.Long constructor already does that. + high += Math.floor(low / 0x100000000); + return new goog.math.Long(low, high); +}; + + +/** + * Converts an array of 32-bit integers into an array of goog.math.Long + * elements. + * + * @private + * @param {!Array<number>} values An array of 32-bit numbers. Its length + * must be even. Each pair of numbers represents a 64-bit integer + * in big-endian order + * @return {!Array<!goog.math.Long>} + */ +goog.crypt.Sha2_64bit.toLongArray_ = function(values) { + goog.asserts.assert(values.length % 2 == 0); + var result = []; + for (var i = 0; i < values.length; i += 2) { + result.push(new goog.math.Long(values[i + 1], values[i])); + } + return result; +}; + + +/** + * Fixed constants used in SHA-512 variants. + * + * These values are from Section 4.2.3 of + * http://csrc.nist.gov/publications/fips/fips180-4/fips-180-4.pdf + * @const + * @private {!Array<!goog.math.Long>} + */ +goog.crypt.Sha2_64bit.K_ = goog.crypt.Sha2_64bit.toLongArray_([ + 0x428a2f98, 0xd728ae22, 0x71374491, 0x23ef65cd, + 0xb5c0fbcf, 0xec4d3b2f, 0xe9b5dba5, 0x8189dbbc, + 0x3956c25b, 0xf348b538, 0x59f111f1, 0xb605d019, + 0x923f82a4, 0xaf194f9b, 0xab1c5ed5, 0xda6d8118, + 0xd807aa98, 0xa3030242, 0x12835b01, 0x45706fbe, + 0x243185be, 0x4ee4b28c, 0x550c7dc3, 0xd5ffb4e2, + 0x72be5d74, 0xf27b896f, 0x80deb1fe, 0x3b1696b1, + 0x9bdc06a7, 0x25c71235, 0xc19bf174, 0xcf692694, + 0xe49b69c1, 0x9ef14ad2, 0xefbe4786, 0x384f25e3, + 0x0fc19dc6, 0x8b8cd5b5, 0x240ca1cc, 0x77ac9c65, + 0x2de92c6f, 0x592b0275, 0x4a7484aa, 0x6ea6e483, + 0x5cb0a9dc, 0xbd41fbd4, 0x76f988da, 0x831153b5, + 0x983e5152, 0xee66dfab, 0xa831c66d, 0x2db43210, + 0xb00327c8, 0x98fb213f, 0xbf597fc7, 0xbeef0ee4, + 0xc6e00bf3, 0x3da88fc2, 0xd5a79147, 0x930aa725, + 0x06ca6351, 0xe003826f, 0x14292967, 0x0a0e6e70, + 0x27b70a85, 0x46d22ffc, 0x2e1b2138, 0x5c26c926, + 0x4d2c6dfc, 0x5ac42aed, 0x53380d13, 0x9d95b3df, + 0x650a7354, 0x8baf63de, 0x766a0abb, 0x3c77b2a8, + 0x81c2c92e, 0x47edaee6, 0x92722c85, 0x1482353b, + 0xa2bfe8a1, 0x4cf10364, 0xa81a664b, 0xbc423001, + 0xc24b8b70, 0xd0f89791, 0xc76c51a3, 0x0654be30, + 0xd192e819, 0xd6ef5218, 0xd6990624, 0x5565a910, + 0xf40e3585, 0x5771202a, 0x106aa070, 0x32bbd1b8, + 0x19a4c116, 0xb8d2d0c8, 0x1e376c08, 0x5141ab53, + 0x2748774c, 0xdf8eeb99, 0x34b0bcb5, 0xe19b48a8, + 0x391c0cb3, 0xc5c95a63, 0x4ed8aa4a, 0xe3418acb, + 0x5b9cca4f, 0x7763e373, 0x682e6ff3, 0xd6b2b8a3, + 0x748f82ee, 0x5defb2fc, 0x78a5636f, 0x43172f60, + 0x84c87814, 0xa1f0ab72, 0x8cc70208, 0x1a6439ec, + 0x90befffa, 0x23631e28, 0xa4506ceb, 0xde82bde9, + 0xbef9a3f7, 0xb2c67915, 0xc67178f2, 0xe372532b, + 0xca273ece, 0xea26619c, 0xd186b8c7, 0x21c0c207, + 0xeada7dd6, 0xcde0eb1e, 0xf57d4f7f, 0xee6ed178, + 0x06f067aa, 0x72176fba, 0x0a637dc5, 0xa2c898a6, + 0x113f9804, 0xbef90dae, 0x1b710b35, 0x131c471b, + 0x28db77f5, 0x23047d84, 0x32caab7b, 0x40c72493, + 0x3c9ebe0a, 0x15c9bebc, 0x431d67c4, 0x9c100d4c, + 0x4cc5d4be, 0xcb3e42b6, 0x597f299c, 0xfc657e2a, + 0x5fcb6fab, 0x3ad6faec, 0x6c44198c, 0x4a475817 +]); http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/e2cad6e6/externs/GCL/externs/goog/crypt/sha384.js ---------------------------------------------------------------------- diff --git a/externs/GCL/externs/goog/crypt/sha384.js b/externs/GCL/externs/goog/crypt/sha384.js new file mode 100644 index 0000000..08ad946 --- /dev/null +++ b/externs/GCL/externs/goog/crypt/sha384.js @@ -0,0 +1,59 @@ +// Copyright 2014 The Closure Library Authors. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS-IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/** + * @fileoverview SHA-384 cryptographic hash. + * + * Usage: + * var sha384 = new goog.crypt.Sha384(); + * sha384.update(bytes); + * var hash = sha384.digest(); + * + * @author [email protected] (Frank Yellin) + */ + +goog.provide('goog.crypt.Sha384'); + +goog.require('goog.crypt.Sha2_64bit'); + + + +/** + * Constructs a SHA-384 cryptographic hash. + * + * @constructor + * @extends {goog.crypt.Sha2_64bit} + * @final + * @struct + */ +goog.crypt.Sha384 = function() { + goog.crypt.Sha384.base(this, 'constructor', 6 /* numHashBlocks */, + goog.crypt.Sha384.INIT_HASH_BLOCK_); +}; +goog.inherits(goog.crypt.Sha384, goog.crypt.Sha2_64bit); + + +/** @private {!Array<number>} */ +goog.crypt.Sha384.INIT_HASH_BLOCK_ = [ + // Section 5.3.4 of + // csrc.nist.gov/publications/fips/fips180-4/fips-180-4.pdf + 0xcbbb9d5d, 0xc1059ed8, // H0 + 0x629a292a, 0x367cd507, // H1 + 0x9159015a, 0x3070dd17, // H2 + 0x152fecd8, 0xf70e5939, // H3 + 0x67332667, 0xffc00b31, // H4 + 0x8eb44a87, 0x68581511, // H5 + 0xdb0c2e0d, 0x64f98fa7, // H6 + 0x47b5481d, 0xbefa4fa4 // H7 +]; http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/e2cad6e6/externs/GCL/externs/goog/crypt/sha512.js ---------------------------------------------------------------------- diff --git a/externs/GCL/externs/goog/crypt/sha512.js b/externs/GCL/externs/goog/crypt/sha512.js new file mode 100644 index 0000000..9ac2280 --- /dev/null +++ b/externs/GCL/externs/goog/crypt/sha512.js @@ -0,0 +1,59 @@ +// Copyright 2014 The Closure Library Authors. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS-IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/** + * @fileoverview SHA-512 cryptographic hash. + * + * Usage: + * var sha512 = new goog.crypt.Sha512(); + * sha512.update(bytes); + * var hash = sha512.digest(); + * + * @author [email protected] (Frank Yellin) + */ + +goog.provide('goog.crypt.Sha512'); + +goog.require('goog.crypt.Sha2_64bit'); + + + +/** + * Constructs a SHA-512 cryptographic hash. + * + * @constructor + * @extends {goog.crypt.Sha2_64bit} + * @final + * @struct + */ +goog.crypt.Sha512 = function() { + goog.crypt.Sha512.base(this, 'constructor', 8 /* numHashBlocks */, + goog.crypt.Sha512.INIT_HASH_BLOCK_); +}; +goog.inherits(goog.crypt.Sha512, goog.crypt.Sha2_64bit); + + +/** @private {!Array<number>} */ +goog.crypt.Sha512.INIT_HASH_BLOCK_ = [ + // Section 5.3.5 of + // csrc.nist.gov/publications/fips/fips180-4/fips-180-4.pdf + 0x6a09e667, 0xf3bcc908, // H0 + 0xbb67ae85, 0x84caa73b, // H1 + 0x3c6ef372, 0xfe94f82b, // H2 + 0xa54ff53a, 0x5f1d36f1, // H3 + 0x510e527f, 0xade682d1, // H4 + 0x9b05688c, 0x2b3e6c1f, // H5 + 0x1f83d9ab, 0xfb41bd6b, // H6 + 0x5be0cd19, 0x137e2179 // H7 +]; http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/e2cad6e6/externs/GCL/externs/goog/crypt/sha512_256.js ---------------------------------------------------------------------- diff --git a/externs/GCL/externs/goog/crypt/sha512_256.js b/externs/GCL/externs/goog/crypt/sha512_256.js new file mode 100644 index 0000000..75a4256 --- /dev/null +++ b/externs/GCL/externs/goog/crypt/sha512_256.js @@ -0,0 +1,65 @@ +// Copyright 2014 The Closure Library Authors. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS-IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/** + * @fileoverview SHA-512/256 cryptographic hash. + * + * WARNING: SHA-256 and SHA-512/256 are different members of the SHA-2 + * family of hashes. Although both give 32-byte results, the two results + * should bear no relationship to each other. + * + * Please be careful before using this hash function. + * <p> + * Usage: + * var sha512_256 = new goog.crypt.Sha512_256(); + * sha512_256.update(bytes); + * var hash = sha512_256.digest(); + * + * @author [email protected] (Frank Yellin) + */ + +goog.provide('goog.crypt.Sha512_256'); + +goog.require('goog.crypt.Sha2_64bit'); + + + +/** + * Constructs a SHA-512/256 cryptographic hash. + * + * @constructor + * @extends {goog.crypt.Sha2_64bit} + * @final + * @struct + */ +goog.crypt.Sha512_256 = function() { + goog.crypt.Sha512_256.base(this, 'constructor', 4 /* numHashBlocks */, + goog.crypt.Sha512_256.INIT_HASH_BLOCK_); +}; +goog.inherits(goog.crypt.Sha512_256, goog.crypt.Sha2_64bit); + + +/** @private {!Array<number>} */ +goog.crypt.Sha512_256.INIT_HASH_BLOCK_ = [ + // Section 5.3.6.2 of + // csrc.nist.gov/publications/fips/fips180-4/fips-180-4.pdf + 0x22312194, 0xFC2BF72C, // H0 + 0x9F555FA3, 0xC84C64C2, // H1 + 0x2393B86B, 0x6F53B151, // H2 + 0x96387719, 0x5940EABD, // H3 + 0x96283EE2, 0xA88EFFE3, // H4 + 0xBE5E1E25, 0x53863992, // H5 + 0x2B0199FC, 0x2C85B8AA, // H6 + 0x0EB72DDC, 0x81C52CA2 // H7 +]; http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/e2cad6e6/externs/GCL/externs/goog/css/autocomplete.css ---------------------------------------------------------------------- diff --git a/externs/GCL/externs/goog/css/autocomplete.css b/externs/GCL/externs/goog/css/autocomplete.css new file mode 100644 index 0000000..033ceba --- /dev/null +++ b/externs/GCL/externs/goog/css/autocomplete.css @@ -0,0 +1,43 @@ +/* + * Copyright 2009 The Closure Library Authors. All Rights Reserved. + * + * Use of this source code is governed by the Apache License, Version 2.0. + * See the COPYING file for details. + */ + +/* + * Styles for goog.ui.ac.AutoComplete and its derivatives. + * Note: these styles need some work to get them working properly at various + * font sizes other than the default. + * + * @author [email protected] (Daniel Pupius) + * @author [email protected] (Srinivas Annam) + */ + + +/* + * TODO(annams): Rename (here and in renderer.js) to specify class name as + * goog-autocomplete-renderer + */ +.ac-renderer { + font: normal 13px Arial, sans-serif; + position: absolute; + background: #fff; + border: 1px solid #666; + -moz-box-shadow: 2px 2px 2px rgba(102, 102, 102, .4); + -webkit-box-shadow: 2px 2px 2px rgba(102, 102, 102, .4); + width: 300px; +} + +.ac-row { + cursor: pointer; + padding: .4em; +} + +.ac-highlighted { + font-weight: bold; +} + +.ac-active { + background-color: #b2b4bf; +} http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/e2cad6e6/externs/GCL/externs/goog/css/bubble.css ---------------------------------------------------------------------- diff --git a/externs/GCL/externs/goog/css/bubble.css b/externs/GCL/externs/goog/css/bubble.css new file mode 100644 index 0000000..4e8d612 --- /dev/null +++ b/externs/GCL/externs/goog/css/bubble.css @@ -0,0 +1,84 @@ +/* + * Copyright 2010 The Closure Library Authors. All Rights Reserved. + * + * Use of this source code is governed by the Apache License, Version 2.0. + * See the COPYING file for details. + */ + +.goog-bubble-font { + font-size: 80%; + color: #888888; +} + +.goog-bubble-close-button { + background-image:url(//ssl.gstatic.com/closure/bubble_close.jpg); + background-color: white; + background-position: top right; + background-repeat: no-repeat; + width: 16px; + height: 16px; +} + +.goog-bubble-left { + background-image:url(//ssl.gstatic.com/closure/bubble_left.gif); + background-position:left; + background-repeat:repeat-y; + width: 4px; +} + +.goog-bubble-right { + background-image:url(//ssl.gstatic.com/closure/bubble_right.gif); + background-position: right; + background-repeat: repeat-y; + width: 4px; +} + +.goog-bubble-top-right-anchor { + background-image:url(//ssl.gstatic.com/closure/right_anchor_bubble_top.gif); + background-position: center; + background-repeat: no-repeat; + width: 147px; + height: 16px; +} + +.goog-bubble-top-left-anchor { + background-image:url(//ssl.gstatic.com/closure/left_anchor_bubble_top.gif); + background-position: center; + background-repeat: no-repeat; + width: 147px; + height: 16px; +} + +.goog-bubble-top-no-anchor { + background-image:url(//ssl.gstatic.com/closure/no_anchor_bubble_top.gif); + background-position: center; + background-repeat: no-repeat; + width: 147px; + height: 6px; +} + +.goog-bubble-bottom-right-anchor { + background-image:url(//ssl.gstatic.com/closure/right_anchor_bubble_bot.gif); + background-position: center; + background-repeat: no-repeat; + width: 147px; + height: 16px; +} + +.goog-bubble-bottom-left-anchor { + background-image:url(//ssl.gstatic.com/closure/left_anchor_bubble_bot.gif); + background-position: center; + background-repeat: no-repeat; + width: 147px; + height: 16px; +} + +.goog-bubble-bottom-no-anchor { + background-image:url(//ssl.gstatic.com/closure/no_anchor_bubble_bot.gif); + background-position: center; + background-repeat: no-repeat; + width: 147px; + height: 8px; +} + + http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/e2cad6e6/externs/GCL/externs/goog/css/button.css ---------------------------------------------------------------------- diff --git a/externs/GCL/externs/goog/css/button.css b/externs/GCL/externs/goog/css/button.css new file mode 100644 index 0000000..b80a92f --- /dev/null +++ b/externs/GCL/externs/goog/css/button.css @@ -0,0 +1,38 @@ +/* + * Copyright 2009 The Closure Library Authors. All Rights Reserved. + * + * Use of this source code is governed by the Apache License, Version 2.0. + * See the COPYING file for details. + */ + +/* + * Styling for buttons rendered by goog.ui.ButtonRenderer. + * + * @author [email protected] (Attila Bodis) + */ + +.goog-button { + color: #036; + border-color: #036; + background-color: #69c; +} + +/* State: disabled. */ +.goog-button-disabled { + border-color: #333; + color: #333; + background-color: #999; +} + +/* State: hover. */ +.goog-button-hover { + color: #369; + border-color: #369; + background-color: #9cf; +} + +/* State: active. */ +.goog-button-active { + color: #69c; + border-color: #69c; +} http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/e2cad6e6/externs/GCL/externs/goog/css/charpicker.css ---------------------------------------------------------------------- diff --git a/externs/GCL/externs/goog/css/charpicker.css b/externs/GCL/externs/goog/css/charpicker.css new file mode 100644 index 0000000..fb33447 --- /dev/null +++ b/externs/GCL/externs/goog/css/charpicker.css @@ -0,0 +1,206 @@ +/* + * Copyright 2009 The Closure Library Authors. All Rights Reserved. + * + * Use of this source code is governed by the Apache License, Version 2.0. + * See the COPYING file for details. + */ + +/* Author: [email protected] (Daniel Pupius) */ +/* Author: [email protected] (Cibu Johny) */ + +.goog-char-picker { + background-color: #ddd; + padding: 16px; + border: 1px solid #777; +} + +/* goog.ui.HoverCard */ +.goog-char-picker-hovercard { + border: solid 5px #ffcc33; + min-width: 64px; + max-width: 160px; + padding: 16px; + background-color: white; + text-align: center; + position: absolute; + visibility: hidden; +} + +.goog-char-picker-name { + font-size: x-small; +} + +.goog-char-picker-unicode { + font-size: x-small; + color: GrayText; +} + +.goog-char-picker-char-zoom { + font-size: xx-large; +} + +/* + * grid + */ +.goog-char-picker-grid-container { + border: 1px solid #777; + background-color: #fff; + width: 272px; +} + +.goog-char-picker-grid { + overflow: hidden; + height: 250px; + width: 250px; + position: relative; +} + +.goog-stick { + width: 1px; + overflow: hidden; +} +.goog-stickwrap { + width: 17px; + height: 250px; + float: right; + overflow: auto; +} + +.goog-char-picker-recents { + border: 1px solid #777; + background-color: #fff; + height: 25px; + width: 275px; + margin: 0 0 16px 0; + position: relative; +} + +.goog-char-picker-notice { + font-size: x-small; + height: 16px; + color: GrayText; + margin: 0 0 16px 0; +} + +/* + * Hex entry + */ + +.goog-char-picker-uplus { +} + +.goog-char-picker-input-box { + width: 96px; +} + +.label-input-label { + color: GrayText; +} + +.goog-char-picker-okbutton { +} + +/* + * Grid buttons + */ +.goog-char-picker-grid .goog-flat-button { + position: relative; + width: 24px; + height: 24px; + line-height: 24px; + border-bottom: 1px solid #ddd; + border-right: 1px solid #ddd; + text-align: center; + cursor: pointer; + outline: none; +} + +.goog-char-picker-grid .goog-flat-button-hover, +.goog-char-picker-grid .goog-flat-button-focus { + background-color: #ffcc33; +} + +/* + * goog.ui.Menu + */ + +/* State: resting. */ +.goog-char-picker-button { + border-width: 0px; + margin: 0; + padding: 0; + position: absolute; + background-position: center left; +} + +/* State: resting. */ +.goog-char-picker-menu { + background-color: #fff; + border-color: #ccc #666 #666 #ccc; + border-style: solid; + border-width: 1px; + cursor: default; + margin: 0; + outline: none; + padding: 0; + position: absolute; + max-height: 400px; + overflow-y: auto; + overflow-x: hide; +} + +/* + * goog.ui.MenuItem + */ + +/* State: resting. */ +.goog-char-picker-menu .goog-menuitem { + color: #000; + list-style: none; + margin: 0; + /* 28px on the left for icon or checkbox; 10ex on the right for shortcut. */ + padding: 1px 32px 1px 8px; + white-space: nowrap; +} + +.goog-char-picker-menu2 .goog-menuitem { + color: #000; + list-style: none; + margin: 0; + /* 28px on the left for icon or checkbox; 10ex on the right for shortcut. */ + padding: 1px 32px 1px 8px; + white-space: nowrap; +} + +.goog-char-picker-menu .goog-subtitle { + color: #fff !important; + background-color: #666; + font-weight: bold; + list-style: none; + margin: 0; + /* 28px on the left for icon or checkbox; 10ex on the right for shortcut. */ + padding: 3px 32px 3px 8px; + white-space: nowrap; +} + +/* BiDi override for the resting state. */ +.goog-char-picker-menu .goog-menuitem-rtl { + /* Flip left/right padding for BiDi. */ + padding: 2px 16px 2px 32px !important; +} + +/* State: hover. */ +.goog-char-picker-menu .goog-menuitem-highlight { + background-color: #d6e9f8; +} +/* + * goog.ui.MenuSeparator + */ + +/* State: resting. */ +.goog-char-picker-menu .goog-menuseparator { + border-top: 1px solid #ccc; + margin: 2px 0; + padding: 0; +} + http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/e2cad6e6/externs/GCL/externs/goog/css/checkbox.css ---------------------------------------------------------------------- diff --git a/externs/GCL/externs/goog/css/checkbox.css b/externs/GCL/externs/goog/css/checkbox.css new file mode 100644 index 0000000..2aed8b5 --- /dev/null +++ b/externs/GCL/externs/goog/css/checkbox.css @@ -0,0 +1,38 @@ +/* + * Copyright 2009 The Closure Library Authors. All Rights Reserved. + * + * Use of this source code is governed by the Apache License, Version 2.0. + * See the COPYING file for details. + */ + +/* Author: [email protected] (Peter Pallos) */ + +/* Sample 3-state checkbox styles. */ + +.goog-checkbox { + border: 1px solid #1C5180; + display: -moz-inline-box; + display: inline-block; + font-size: 1px; /* Fixes the height in IE6 */ + height: 11px; + margin: 0 4px 0 1px; + vertical-align: text-bottom; + width: 11px; +} + +.goog-checkbox-checked { + background: #fff url(//ssl.gstatic.com/closure/check-sprite.gif) no-repeat 2px center; +} + +.goog-checkbox-undetermined { + background: #bbb url(//ssl.gstatic.com/closure/check-sprite.gif) no-repeat 2px center; +} + +.goog-checkbox-unchecked { + background: #fff; +} + +.goog-checkbox-disabled { + border: 1px solid lightgray; + background-position: -7px; +} http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/e2cad6e6/externs/GCL/externs/goog/css/colormenubutton.css ---------------------------------------------------------------------- diff --git a/externs/GCL/externs/goog/css/colormenubutton.css b/externs/GCL/externs/goog/css/colormenubutton.css new file mode 100644 index 0000000..83655dd --- /dev/null +++ b/externs/GCL/externs/goog/css/colormenubutton.css @@ -0,0 +1,25 @@ +/* + * Copyright 2009 The Closure Library Authors. All Rights Reserved. + * + * Use of this source code is governed by the Apache License, Version 2.0. + * See the COPYING file for details. + */ + +/* + * Standard styling for buttons created by goog.ui.ColorMenuButtonRenderer. + * + * @author [email protected] (Attila Bodis) + */ + + +/* Color indicator. */ +.goog-color-menu-button-indicator { + border-bottom: 4px solid #f0f0f0; +} + +/* Thinner padding for color picker buttons, to leave room for the indicator. */ +.goog-color-menu-button .goog-menu-button-inner-box, +.goog-toolbar-color-menu-button .goog-toolbar-menu-button-inner-box { + padding-top: 2px !important; + padding-bottom: 2px !important; +} http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/e2cad6e6/externs/GCL/externs/goog/css/colorpalette.css ---------------------------------------------------------------------- diff --git a/externs/GCL/externs/goog/css/colorpalette.css b/externs/GCL/externs/goog/css/colorpalette.css new file mode 100644 index 0000000..17bed42 --- /dev/null +++ b/externs/GCL/externs/goog/css/colorpalette.css @@ -0,0 +1,54 @@ +/* + * Copyright 2009 The Closure Library Authors. All Rights Reserved. + * + * Use of this source code is governed by the Apache License, Version 2.0. + * See the COPYING file for details. + */ + +/* + * Standard styling for color palettes. + * + * @author [email protected] (Daniel Pupius) + * @author [email protected] (Attila Bodis) + */ + + +.goog-palette-cell .goog-palette-colorswatch { + border: none; + font-size: x-small; + height: 18px; + position: relative; + width: 18px; +} + +.goog-palette-cell-hover .goog-palette-colorswatch { + border: 1px solid #fff; + height: 16px; + width: 16px; +} + +.goog-palette-cell-selected .goog-palette-colorswatch { + /* Client apps may override the URL at which they serve the sprite. */ + background: url(//ssl.gstatic.com/editor/editortoolbar.png) no-repeat -368px 0; + border: 1px solid #333; + color: #fff; + font-weight: bold; + height: 16px; + width: 16px; +} + +.goog-palette-customcolor { + background-color: #fafafa; + border: 1px solid #eee; + color: #666; + font-size: x-small; + height: 15px; + position: relative; + width: 15px; +} + +.goog-palette-cell-hover .goog-palette-customcolor { + background-color: #fee; + border: 1px solid #f66; + color: #f66; +} http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/e2cad6e6/externs/GCL/externs/goog/css/colorpicker-simplegrid.css ---------------------------------------------------------------------- diff --git a/externs/GCL/externs/goog/css/colorpicker-simplegrid.css b/externs/GCL/externs/goog/css/colorpicker-simplegrid.css new file mode 100644 index 0000000..b98f5dc --- /dev/null +++ b/externs/GCL/externs/goog/css/colorpicker-simplegrid.css @@ -0,0 +1,49 @@ +/* + * Copyright 2007 The Closure Library Authors. All Rights Reserved. + * + * Use of this source code is governed by the Apache License, Version 2.0. + * See the COPYING file for details. + */ + +/* Author: [email protected] (Daniel Pupius) */ + +/* + Styles to make the colorpicker look like the old gmail color picker + NOTE: without CSS scoping this will override styles defined in palette.css +*/ +.goog-palette { + outline: none; + cursor: default; +} + +.goog-palette-table { + border: 1px solid #666; + border-collapse: collapse; +} + +.goog-palette-cell { + height: 13px; + width: 15px; + margin: 0; + border: 0; + text-align: center; + vertical-align: middle; + border-right: 1px solid #666; + font-size: 1px; +} + +.goog-palette-colorswatch { + position: relative; + height: 13px; + width: 15px; + border: 1px solid #666; +} + +.goog-palette-cell-hover .goog-palette-colorswatch { + border: 1px solid #FFF; +} + +.goog-palette-cell-selected .goog-palette-colorswatch { + border: 1px solid #000; + color: #fff; +} http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/e2cad6e6/externs/GCL/externs/goog/css/combobox.css ---------------------------------------------------------------------- diff --git a/externs/GCL/externs/goog/css/combobox.css b/externs/GCL/externs/goog/css/combobox.css new file mode 100644 index 0000000..dd1571a --- /dev/null +++ b/externs/GCL/externs/goog/css/combobox.css @@ -0,0 +1,54 @@ +/* + * Copyright 2007 The Closure Library Authors. All Rights Reserved. + * + * Use of this source code is governed by the Apache License, Version 2.0. + * See the COPYING file for details. + */ + +/* Author: [email protected] (Daniel Pupius) */ +/* Author: [email protected] (Peter Pallos) */ + +/* Styles for goog.ui.ComboBox and its derivatives. */ + + +.goog-combobox { + background: #ddd url(//ssl.gstatic.com/closure/button-bg.gif) repeat-x scroll left top; + border: 1px solid #b5b6b5; + font: normal small arial, sans-serif; +} + +.goog-combobox input { + background-color: #fff; + border: 0; + border-right: 1px solid #b5b6b5; + color: #000; + font: normal small arial, sans-serif; + margin: 0; + padding: 0 0 0 2px; + vertical-align: bottom; /* override demo.css */ + width: 200px; +} + +.goog-combobox input.label-input-label { + background-color: #fff; + color: #aaa; +} + +.goog-combobox .goog-menu { + margin-top: -1px; + width: 219px; /* input width + button width + 3 * 1px border */ + z-index: 1000; +} + +.goog-combobox-button { + cursor: pointer; + display: inline-block; + font-size: 10px; + text-align: center; + width: 16px; +} + +/* IE6 only hack */ +* html .goog-combobox-button { + padding: 0 3px; +} http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/e2cad6e6/externs/GCL/externs/goog/css/common.css ---------------------------------------------------------------------- diff --git a/externs/GCL/externs/goog/css/common.css b/externs/GCL/externs/goog/css/common.css new file mode 100644 index 0000000..de140b8 --- /dev/null +++ b/externs/GCL/externs/goog/css/common.css @@ -0,0 +1,41 @@ +/* + * Copyright 2009 The Closure Library Authors. All Rights Reserved. + * + * Use of this source code is governed by the Apache License, Version 2.0. + * See the COPYING file for details. + */ + +/* + * Cross-browser implementation of the "display: inline-block" CSS property. + * See http://www.w3.org/TR/CSS21/visuren.html#propdef-display for details. + * Tested on IE 6 & 7, FF 1.5 & 2.0, Safari 2 & 3, Webkit, and Opera 9. + * + * @author [email protected] (Attila Bodis) + */ + +/* + * Default rule; only Safari, Webkit, and Opera handle it without hacks. + */ +.goog-inline-block { + position: relative; + display: -moz-inline-box; /* Ignored by FF3 and later. */ + display: inline-block; +} + +/* + * Pre-IE7 IE hack. On IE, "display: inline-block" only gives the element + * layout, but doesn't give it inline behavior. Subsequently setting display + * to inline does the trick. + */ +* html .goog-inline-block { + display: inline; +} + +/* + * IE7-only hack. On IE, "display: inline-block" only gives the element + * layout, but doesn't give it inline behavior. Subsequently setting display + * to inline does the trick. + */ +*:first-child+html .goog-inline-block { + display: inline; +} http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/e2cad6e6/externs/GCL/externs/goog/css/css3button.css ---------------------------------------------------------------------- diff --git a/externs/GCL/externs/goog/css/css3button.css b/externs/GCL/externs/goog/css/css3button.css new file mode 100644 index 0000000..a26306f --- /dev/null +++ b/externs/GCL/externs/goog/css/css3button.css @@ -0,0 +1,77 @@ +/* + * Copyright 2010 The Closure Library Authors. All Rights Reserved. + * + * Use of this source code is governed by the Apache License, Version 2.0. + * See the COPYING file for details. + */ + +/* Author: [email protected] (Alex Russell) */ +/* Author: [email protected] (Emil A Eklund) */ + +/* Imageless button styles. */ +.goog-css3-button { + margin: 0 2px; + padding: 3px 6px; + text-align: center; + vertical-align: middle; + white-space: nowrap; + cursor: default; + outline: none; + font-family: Arial, sans-serif; + color: #000; + border: 1px solid #bbb; + -webkit-border-radius: 3px; + -moz-border-radius: 3px; + /* TODO(eae): Change this to -webkit-linear-gradient once + https://bugs.webkit.org/show_bug.cgi?id=28152 is resolved. */ + background: -webkit-gradient(linear, 0% 40%, 0% 70%, from(#f9f9f9), + to(#e3e3e3)); + /* @alternate */ background: -moz-linear-gradient(top, #f9f9f9, #e3e3e3); +} + + +/* Styles for different states (hover, active, focused, open, checked). */ +.goog-css3-button-hover { + border-color: #939393 !important; +} + +.goog-css3-button-focused { + border-color: #444; +} + +.goog-css3-button-active, .goog-css3-button-open, .goog-css3-button-checked { + border-color: #444 !important; + background: -webkit-gradient(linear, 0% 40%, 0% 70%, from(#e3e3e3), + to(#f9f9f9)); + /* @alternate */ background: -moz-linear-gradient(top, #e3e3e3, #f9f9f9); +} + +.goog-css3-button-disabled { + color: #888; +} + +.goog-css3-button-primary { + font-weight: bold; +} + + +/* + * Pill (collapsed border) styles. + */ +.goog-css3-button-collapse-right { + margin-right: 0 !important; + border-right: 1px solid #bbb; + -webkit-border-top-right-radius: 0px; + -webkit-border-bottom-right-radius: 0px; + -moz-border-radius-topright: 0px; + -moz-border-radius-bottomright: 0px; +} + +.goog-css3-button-collapse-left { + border-left: 1px solid #f9f9f9; + margin-left: 0 !important; + -webkit-border-top-left-radius: 0px; + -webkit-border-bottom-left-radius: 0px; + -moz-border-radius-topleft: 0px; + -moz-border-radius-bottomleft: 0px; +} http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/e2cad6e6/externs/GCL/externs/goog/css/css3menubutton.css ---------------------------------------------------------------------- diff --git a/externs/GCL/externs/goog/css/css3menubutton.css b/externs/GCL/externs/goog/css/css3menubutton.css new file mode 100644 index 0000000..a020700 --- /dev/null +++ b/externs/GCL/externs/goog/css/css3menubutton.css @@ -0,0 +1,23 @@ +/* + * Copyright 2010 The Closure Library Authors. All Rights Reserved. + * + * Use of this source code is governed by the Apache License, Version 2.0. + * See the COPYING file for details. + */ + +/* + * Standard styling for buttons created by goog.ui.Css3MenuButtonRenderer. + * + * @author [email protected] (Attila Bodis) + * @author [email protected] (Darren Lewis) + */ + +/* Dropdown arrow style. */ +.goog-css3-button-dropdown { + height: 16px; + width: 7px; + /* Client apps may override the URL at which they serve the sprite. */ + background: url(//ssl.gstatic.com/editor/editortoolbar.png) no-repeat -388px 0; + vertical-align: top; + margin-left: 3px; +} http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/e2cad6e6/externs/GCL/externs/goog/css/custombutton.css ---------------------------------------------------------------------- diff --git a/externs/GCL/externs/goog/css/custombutton.css b/externs/GCL/externs/goog/css/custombutton.css new file mode 100644 index 0000000..1f17052 --- /dev/null +++ b/externs/GCL/externs/goog/css/custombutton.css @@ -0,0 +1,161 @@ +/* + * Copyright 2009 The Closure Library Authors. All Rights Reserved. + * + * Use of this source code is governed by the Apache License, Version 2.0. + * See the COPYING file for details. + */ + +/* + * Styling for custom buttons rendered by goog.ui.CustomButtonRenderer. + * + * @author [email protected] (Attila Bodis) + */ + +.goog-custom-button { + margin: 2px; + border: 0; + padding: 0; + font-family: Arial, sans-serif; + color: #000; + /* Client apps may override the URL at which they serve the image. */ + background: #ddd url(//ssl.gstatic.com/editor/button-bg.png) repeat-x top left; + text-decoration: none; + list-style: none; + vertical-align: middle; + cursor: default; + outline: none; +} + +/* Pseudo-rounded corners. */ +.goog-custom-button-outer-box, +.goog-custom-button-inner-box { + border-style: solid; + border-color: #aaa; + vertical-align: top; +} + +.goog-custom-button-outer-box { + margin: 0; + border-width: 1px 0; + padding: 0; +} + +.goog-custom-button-inner-box { + margin: 0 -1px; + border-width: 0 1px; + padding: 3px 4px; + white-space: nowrap; /* Prevents buttons from line breaking on android. */ +} + +/* Pre-IE7 IE hack; ignored by IE7 and all non-IE browsers. */ +* html .goog-custom-button-inner-box { + /* IE6 needs to have the box shifted to make the borders line up. */ + left: -1px; +} +/* Pre-IE7 BiDi fixes. */ +* html .goog-custom-button-rtl .goog-custom-button-outer-box { + /* @noflip */ left: -1px; +} +* html .goog-custom-button-rtl .goog-custom-button-inner-box { + /* @noflip */ right: auto; +} + +/* IE7-only hack; ignored by all other browsers. */ +*:first-child+html .goog-custom-button-inner-box { + /* IE7 needs to have the box shifted to make the borders line up. */ + left: -1px; +} +/* IE7 BiDi fix. */ +*:first-child+html .goog-custom-button-rtl .goog-custom-button-inner-box { + /* @noflip */ left: 1px; +} + +/* Safari-only hacks. */ +::root .goog-custom-button, +::root .goog-custom-button-outer-box { + /* Required to make pseudo-rounded corners work on Safari. */ + line-height: 0; +} + +::root .goog-custom-button-inner-box { + /* Required to make pseudo-rounded corners work on Safari. */ + line-height: normal; +} + +/* State: disabled. */ +.goog-custom-button-disabled { + background-image: none !important; + opacity: 0.3; + -moz-opacity: 0.3; + filter: alpha(opacity=30); +} + +.goog-custom-button-disabled .goog-custom-button-outer-box, +.goog-custom-button-disabled .goog-custom-button-inner-box { + color: #333 !important; + border-color: #999 !important; +} + +/* Pre-IE7 IE hack; ignored by IE7 and all non-IE browsers. */ +* html .goog-custom-button-disabled { + margin: 2px 1px !important; + padding: 0 1px !important; +} + +/* IE7-only hack; ignored by all other browsers. */ +*:first-child+html .goog-custom-button-disabled { + margin: 2px 1px !important; + padding: 0 1px !important; +} + +/* State: hover. */ +.goog-custom-button-hover .goog-custom-button-outer-box, +.goog-custom-button-hover .goog-custom-button-inner-box { + border-color: #9cf #69e #69e #7af !important; /* Hover border wins. */ +} + +/* State: active, checked. */ +.goog-custom-button-active, +.goog-custom-button-checked { + background-color: #bbb; + background-position: bottom left; +} + +/* State: focused. */ +.goog-custom-button-focused .goog-custom-button-outer-box, +.goog-custom-button-focused .goog-custom-button-inner-box { + border-color: orange; +} + +/* Pill (collapsed border) styles. */ +.goog-custom-button-collapse-right, +.goog-custom-button-collapse-right .goog-custom-button-outer-box, +.goog-custom-button-collapse-right .goog-custom-button-inner-box { + margin-right: 0; +} + +.goog-custom-button-collapse-left, +.goog-custom-button-collapse-left .goog-custom-button-outer-box, +.goog-custom-button-collapse-left .goog-custom-button-inner-box { + margin-left: 0; +} + +.goog-custom-button-collapse-left .goog-custom-button-inner-box { + border-left: 1px solid #fff; +} + +.goog-custom-button-collapse-left.goog-custom-button-checked +.goog-custom-button-inner-box { + border-left: 1px solid #ddd; +} + +/* Pre-IE7 IE hack; ignored by IE7 and all non-IE browsers. */ +* html .goog-custom-button-collapse-left .goog-custom-button-inner-box { + left: 0; +} + +/* IE7-only hack; ignored by all other browsers. */ +*:first-child+html .goog-custom-button-collapse-left +.goog-custom-button-inner-box { + left: 0; +} http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/e2cad6e6/externs/GCL/externs/goog/css/datepicker.css ---------------------------------------------------------------------- diff --git a/externs/GCL/externs/goog/css/datepicker.css b/externs/GCL/externs/goog/css/datepicker.css new file mode 100644 index 0000000..6d5b914 --- /dev/null +++ b/externs/GCL/externs/goog/css/datepicker.css @@ -0,0 +1,154 @@ +/* + * Copyright 2009 The Closure Library Authors. All Rights Reserved. + * + * Use of this source code is governed by the Apache License, Version 2.0. + * See the COPYING file for details. + */ + +/* + * Standard styling for a goog.ui.DatePicker. + * + * @author [email protected] (Erik Arvidsson) + */ + +.goog-date-picker, +.goog-date-picker th, +.goog-date-picker td { + font: 13px Arial, sans-serif; +} + +.goog-date-picker { + -moz-user-focus: normal; + -moz-user-select: none; + position: relative; + border: 1px solid #000; + float: left; + padding: 2px; + color: #000; + background: #c3d9ff; + cursor: default; +} + +.goog-date-picker th { + text-align: center; +} + +.goog-date-picker td { + text-align: center; + vertical-align: middle; + padding: 1px 3px; +} + + +.goog-date-picker-menu { + position: absolute; + background: threedface; + border: 1px solid gray; + -moz-user-focus: normal; + z-index: 1; + outline: none; +} + +.goog-date-picker-menu ul { + list-style: none; + margin: 0px; + padding: 0px; +} + +.goog-date-picker-menu ul li { + cursor: default; +} + +.goog-date-picker-menu-selected { + background: #ccf; +} + +.goog-date-picker th { + font-size: .9em; +} + +.goog-date-picker td div { + float: left; +} + +.goog-date-picker button { + padding: 0px; + margin: 1px 0; + border: 0; + color: #20c; + font-weight: bold; + background: transparent; +} + +.goog-date-picker-date { + background: #fff; +} + +.goog-date-picker-week, +.goog-date-picker-wday { + padding: 1px 3px; + border: 0; + border-color: #a2bbdd; + border-style: solid; +} + +.goog-date-picker-week { + border-right-width: 1px; +} + +.goog-date-picker-wday { + border-bottom-width: 1px; +} + +.goog-date-picker-head td { + text-align: center; +} + +/** Use td.className instead of !important */ +td.goog-date-picker-today-cont { + text-align: center; +} + +/** Use td.className instead of !important */ +td.goog-date-picker-none-cont { + text-align: center; +} + +.goog-date-picker-month { + min-width: 11ex; + white-space: nowrap; +} + +.goog-date-picker-year { + min-width: 6ex; + white-space: nowrap; +} + +.goog-date-picker-monthyear { + white-space: nowrap; +} + +.goog-date-picker table { + border-collapse: collapse; +} + +.goog-date-picker-other-month { + color: #888; +} + +.goog-date-picker-wkend-start, +.goog-date-picker-wkend-end { + background: #eee; +} + +/** Use td.className instead of !important */ +td.goog-date-picker-selected { + background: #c3d9ff; +} + +.goog-date-picker-today { + background: #9ab; + font-weight: bold !important; + border-color: #246 #9bd #9bd #246; + color: #fff; +} http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/e2cad6e6/externs/GCL/externs/goog/css/dialog.css ---------------------------------------------------------------------- diff --git a/externs/GCL/externs/goog/css/dialog.css b/externs/GCL/externs/goog/css/dialog.css new file mode 100644 index 0000000..6bf9020 --- /dev/null +++ b/externs/GCL/externs/goog/css/dialog.css @@ -0,0 +1,72 @@ +/* + * Copyright 2009 The Closure Library Authors. All Rights Reserved. + * + * Use of this source code is governed by the Apache License, Version 2.0. + * See the COPYING file for details. + */ + +/* + * Standard styling for goog.ui.Dialog. + * + * @author [email protected] (Steven Saviano) + * @author [email protected] (Attila Bodis) + */ + + +.modal-dialog { + background: #c1d9ff; + border: 1px solid #3a5774; + color: #000; + padding: 4px; + position: absolute; +} + +.modal-dialog a, +.modal-dialog a:link, +.modal-dialog a:visited { + color: #06c; + cursor: pointer; +} + +.modal-dialog-bg { + background: #666; + left: 0; + position: absolute; + top: 0; +} + +.modal-dialog-title { + background: #e0edfe; + color: #000; + cursor: pointer; + font-size: 120%; + font-weight: bold; + + /* Add padding on the right to ensure the close button has room. */ + padding: 8px 31px 8px 8px; + + position: relative; + _zoom: 1; /* Ensures proper width in IE6 RTL. */ +} + +.modal-dialog-title-close { + /* Client apps may override the URL at which they serve the sprite. */ + background: #e0edfe url(//ssl.gstatic.com/editor/editortoolbar.png) no-repeat -528px 0; + cursor: default; + height: 15px; + position: absolute; + right: 10px; + top: 8px; + width: 15px; + vertical-align: middle; +} + +.modal-dialog-buttons, +.modal-dialog-content { + background-color: #fff; + padding: 8px; +} + +.goog-buttonset-default { + font-weight: bold; +} http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/e2cad6e6/externs/GCL/externs/goog/css/dimensionpicker.css ---------------------------------------------------------------------- diff --git a/externs/GCL/externs/goog/css/dimensionpicker.css b/externs/GCL/externs/goog/css/dimensionpicker.css new file mode 100644 index 0000000..5c51ab8 --- /dev/null +++ b/externs/GCL/externs/goog/css/dimensionpicker.css @@ -0,0 +1,47 @@ +/* + * Copyright 2008 The Closure Library Authors. All Rights Reserved. + * + * Use of this source code is governed by the Apache License, Version 2.0. + * See the COPYING file for details. + */ + +/* + * Styling for dimension pickers rendered by goog.ui.DimensionPickerRenderer. + * + * Author: [email protected] (Robby Walker) + * Author: [email protected] (Abe Fettig) + */ + +.goog-dimension-picker { + font-size: 18px; + padding: 4px; +} + +.goog-dimension-picker div { + position: relative; +} + +.goog-dimension-picker div.goog-dimension-picker-highlighted { +/* Client apps must provide the URL at which they serve the image. */ + /* background: url(dimension-highlighted.png); */ + left: 0; + overflow: hidden; + position: absolute; + top: 0; +} + +.goog-dimension-picker-unhighlighted { + /* Client apps must provide the URL at which they serve the image. */ + /* background: url(dimension-unhighlighted.png); */ +} + +.goog-dimension-picker-status { + font-size: 10pt; + text-align: center; +} + +.goog-dimension-picker div.goog-dimension-picker-mousecatcher { + left: 0; + position: absolute !important; + top: 0; +} http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/e2cad6e6/externs/GCL/externs/goog/css/dragdropdetector.css ---------------------------------------------------------------------- diff --git a/externs/GCL/externs/goog/css/dragdropdetector.css b/externs/GCL/externs/goog/css/dragdropdetector.css new file mode 100644 index 0000000..88266d6 --- /dev/null +++ b/externs/GCL/externs/goog/css/dragdropdetector.css @@ -0,0 +1,48 @@ +/* + * Copyright 2007 The Closure Library Authors. All Rights Reserved. + * + * Use of this source code is governed by the Apache License, Version 2.0. + * See the COPYING file for details. + */ + +/* + * Styling for the drag drop detector. + * + * Author: [email protected] (Robby Walker) + * Author: [email protected] (Wayne Crosby) + */ + +.goog-dragdrop-w3c-editable-iframe { + position: absolute; + width: 100%; + height: 10px; + top: -150px; + left: 0; + z-index: 10000; + padding: 0; + overflow: hidden; + opacity: 0; + -moz-opacity: 0; +} + +.goog-dragdrop-ie-editable-iframe { + width: 100%; + height: 5000px; +} + +.goog-dragdrop-ie-input { + width: 100%; + height: 5000px; +} + +.goog-dragdrop-ie-div { + position: absolute; + top: -5000px; + left: 0; + width: 100%; + height: 5000px; + z-index: 10000; + background-color: white; + filter: alpha(opacity=0); + overflow: hidden; +} http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/e2cad6e6/externs/GCL/externs/goog/css/editor/bubble.css ---------------------------------------------------------------------- diff --git a/externs/GCL/externs/goog/css/editor/bubble.css b/externs/GCL/externs/goog/css/editor/bubble.css new file mode 100644 index 0000000..c76f98f --- /dev/null +++ b/externs/GCL/externs/goog/css/editor/bubble.css @@ -0,0 +1,73 @@ +/* + * Copyright 2005 The Closure Library Authors. All Rights Reserved. + * + * Use of this source code is governed by the Apache License, Version 2.0. + * See the COPYING file for details. + */ + +/* + * Bubble styles. + * + * @author [email protected] (Robby Walker) + * @author [email protected] (Nick Santos) + * @author [email protected] (Julie Parent) + */ + +div.tr_bubble { + position: absolute; + + background-color: #e0ecff; + border: 1px solid #99c0ff; + border-radius: 2px; + -moz-border-radius: 2px; + -webkit-border-radius: 2px; + font-size: 83%; + font-family: Arial, Helvetica, sans-serif; + padding: 2px 19px 6px 6px; + white-space: nowrap; +} + +.tr_bubble_link { + color: #00c; + text-decoration: underline; + cursor: pointer; + font-size: 100%; +} + +.tr_bubble .tr_option-link, +.tr_bubble #tr_delete-image, +.tr_bubble #tr_module-options-link { + font-size: 83%; +} + +.tr_bubble_closebox { + position: absolute; + cursor: default; + background: url(//ssl.gstatic.com/editor/bubble_closebox.gif) top left no-repeat; + padding: 0; + margin: 0; + width: 10px; + height: 10px; + top: 3px; + right: 5px; +} + +div.tr_bubble_panel { + padding: 2px 0 1px; +} + +div.tr_bubble_panel_title { + display: none; +} + +div.tr_multi_bubble div.tr_bubble_panel_title { + margin-right: 1px; + display: block; + float: left; + width: 50px; +} + +div.tr_multi_bubble div.tr_bubble_panel { + padding: 2px 0 1px; + margin-right: 50px; +} http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/e2cad6e6/externs/GCL/externs/goog/css/editor/dialog.css ---------------------------------------------------------------------- diff --git a/externs/GCL/externs/goog/css/editor/dialog.css b/externs/GCL/externs/goog/css/editor/dialog.css new file mode 100644 index 0000000..8868a10 --- /dev/null +++ b/externs/GCL/externs/goog/css/editor/dialog.css @@ -0,0 +1,66 @@ +/* + * Copyright 2007 The Closure Library Authors. All Rights Reserved. + * + * Use of this source code is governed by the Apache License, Version 2.0. + * See the COPYING file for details. + */ + +/* + * Styles for Editor dialogs and their sub-components. + * + * @author [email protected] (Marcos Almeida) + */ + + +.tr-dialog { + width: 475px; +} + +.tr-dialog .goog-tab-content { + margin: 0; + border: 1px solid #6b90da; + padding: 4px 8px; + background: #fff; + overflow: auto; +} + +.tr-tabpane { + font-size: 10pt; + padding: 1.3ex 0; +} + +.tr-tabpane-caption { + font-size: 10pt; + margin-bottom: 0.7ex; + background-color: #fffaf5; + line-height: 1.3em; +} + +.tr-tabpane .goog-tab-content { + border: none; + padding: 5px 7px 1px; +} + +.tr-tabpane .goog-tab { + background-color: #fff; + border: none; + width: 136px; + line-height: 1.3em; + margin-bottom: 0.7ex; +} + +.tr-tabpane .goog-tab { + text-decoration: underline; + color: blue; + cursor: pointer; +} + +.tr-tabpane .goog-tab-selected { + font-weight: bold; + text-decoration: none; + color: black; +} + +.tr-tabpane .goog-tab input { + margin: -2px 5px 0 0; +} http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/e2cad6e6/externs/GCL/externs/goog/css/editor/equationeditor.css ---------------------------------------------------------------------- diff --git a/externs/GCL/externs/goog/css/editor/equationeditor.css b/externs/GCL/externs/goog/css/editor/equationeditor.css new file mode 100644 index 0000000..b6aff34 --- /dev/null +++ b/externs/GCL/externs/goog/css/editor/equationeditor.css @@ -0,0 +1,113 @@ +/* + * Copyright 2009 The Closure Library Authors. All Rights Reserved. + * + * Use of this source code is governed by the Apache License, Version 2.0. + * See the COPYING file for details. + */ + +/* + * The CSS definition for everything inside equation editor dialog. + * + * Author: [email protected] (Yoah Bar-David) + * Author: [email protected] (Ming Zhang) + */ + +.ee-modal-dialog { + width: 475px; +} + +.ee-content { + background: #FFF; + border: 1px solid #369; + overflow: auto; + padding: 4px 8px; +} + +.ee-tex { + border: 1px solid #000; + display: block; + height: 7.5em; + margin: 4px 0 10px 0; + width: 100%; +} + +.ee-section-title { + font-weight: bold; +} + +.ee-section-title-floating { + float: left; +} + +#ee-section-learn-more { + float: right; +} + +.ee-preview-container { + border: 1px dashed #ccc; + height: 80px; + margin: 4px 0 10px 0; + width: 100%; + overflow: auto; +} + +.ee-warning { + color: #F00; +} + +.ee-palette { + border: 1px solid #aaa; + left: 0; + outline: none; + position: absolute; +} + +.ee-palette-table { + border: 0; + border-collapse: separate; +} + +.ee-palette-cell { + background: #F0F0F0; + border: 1px solid #FFF; + margin: 0; + padding: 1px; +} + +.ee-palette-cell-hover { + background: #E2ECF9 !important; + border: 1px solid #000; + padding: 1px; +} + +.ee-palette-cell-selected { + background: #F0F0F0; + border: 1px solid #CCC !important; + padding: 1px; +} + +.ee-menu-palette-table { + margin-right: 10px; +} + +.ee-menu-palette { + outline: none; + padding-top: 2px; +} + +.ee-menu-palette-cell { + background: #F0F0F0 none repeat scroll 0 0; + border-color: #888 #AAA #AAA #888; + border-style: solid; + border-width: 1px; +} +.ee-menu-palette-cell-hover, +.ee-menu-palette-cell-selected { + background: #F0F0F0; +} + +.ee-palette-item, +.ee-menu-palette-item { + background-image: url(//ssl.gstatic.com/editor/ee-palettes.gif); +} + http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/e2cad6e6/externs/GCL/externs/goog/css/editor/linkdialog.css ---------------------------------------------------------------------- diff --git a/externs/GCL/externs/goog/css/editor/linkdialog.css b/externs/GCL/externs/goog/css/editor/linkdialog.css new file mode 100644 index 0000000..a58a4b2 --- /dev/null +++ b/externs/GCL/externs/goog/css/editor/linkdialog.css @@ -0,0 +1,36 @@ +/* + * Copyright 2007 The Closure Library Authors. All Rights Reserved. + * + * Use of this source code is governed by the Apache License, Version 2.0. + * See the COPYING file for details. + */ + +/** + * Styles for the Editor's Edit Link dialog. + * + * @author [email protected] (Marcos Almeida) + */ + + +.tr-link-dialog-explanation-text { + font-size: 83%; + margin-top: 15px; +} + +.tr-link-dialog-target-input { + width: 98%; /* 98% prevents scroll bars in standards mode. */ + /* Input boxes for URLs and email address should always be LTR. */ + direction: ltr; +} + +.tr-link-dialog-email-warning { + text-align: center; + color: #c00; + font-weight: bold; +} + +.tr_pseudo-link { + color: #00c; + text-decoration: underline; + cursor: pointer; +} http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/e2cad6e6/externs/GCL/externs/goog/css/editortoolbar.css ---------------------------------------------------------------------- diff --git a/externs/GCL/externs/goog/css/editortoolbar.css b/externs/GCL/externs/goog/css/editortoolbar.css new file mode 100644 index 0000000..1e26f4f --- /dev/null +++ b/externs/GCL/externs/goog/css/editortoolbar.css @@ -0,0 +1,225 @@ +/* + * Copyright 2008 The Closure Library Authors. All Rights Reserved. + * + * Use of this source code is governed by the Apache License, Version 2.0. + * See the COPYING file for details. + */ + + +/* + * Editor toolbar styles. + * + * @author [email protected] (Attila Bodis) + */ + +/* Common base style for all icons. */ +.tr-icon { + width: 16px; + height: 16px; + background: url(//ssl.gstatic.com/editor/editortoolbar.png) no-repeat; + vertical-align: middle; +} + +.goog-color-menu-button-indicator .tr-icon { + height: 14px; +} + +/* Undo (redo when the chrome is right-to-left). */ +.tr-undo, +.goog-toolbar-button-rtl .tr-redo { + background-position: 0; +} + +/* Redo (undo when the chrome is right-to-left). */ +.tr-redo, +.goog-toolbar-button-rtl .tr-undo { + background-position: -16px; +} + +/* Font name. */ +.tr-fontName .goog-toolbar-menu-button-caption { + color: #246; + width: 16ex; + height: 16px; + overflow: hidden; +} + +/* Font size. */ +.tr-fontSize .goog-toolbar-menu-button-caption { + color: #246; + width: 8ex; + height: 16px; + overflow: hidden; +} + +/* Bold. */ +.tr-bold { + background-position: -32px; +} + +/* Italic. */ +.tr-italic { + background-position: -48px; +} + +/* Underline. */ +.tr-underline { + background-position: -64px; +} + +/* Foreground color. */ +.tr-foreColor { + height: 14px; + background-position: -80px; +} + +/* Background color. */ +.tr-backColor { + height: 14px; + background-position: -96px; +} + +/* Link. */ +.tr-link { + font-weight: bold; + color: #009; + text-decoration: underline; +} + +/* Insert image. */ +.tr-image { + background-position: -112px; +} + +/* Insert drawing. */ +.tr-newDrawing { + background-position: -592px; +} + +/* Insert special character. */ +.tr-spChar { + font-weight: bold; + color: #900; +} + +/* Increase indent. */ +.tr-indent { + background-position: -128px; +} + +/* Increase ident in right-to-left text mode, regardless of chrome direction. */ +.tr-rtl-mode .tr-indent { + background-position: -400px; +} + +/* Decrease indent. */ +.tr-outdent { + background-position: -144px; +} + +/* Decrease indent in right-to-left text mode, regardless of chrome direction. */ +.tr-rtl-mode .tr-outdent { + background-position: -416px; +} + +/* Bullet (unordered) list. */ +.tr-insertUnorderedList { + background-position: -160px; +} + +/* Bullet list in right-to-left text mode, regardless of chrome direction. */ +.tr-rtl-mode .tr-insertUnorderedList { + background-position: -432px; +} + +/* Number (ordered) list. */ +.tr-insertOrderedList { + background-position: -176px; +} + +/* Number list in right-to-left text mode, regardless of chrome direction. */ +.tr-rtl-mode .tr-insertOrderedList { + background-position: -448px; +} + +/* Text alignment buttons. */ +.tr-justifyLeft { + background-position: -192px; +} +.tr-justifyCenter { + background-position: -208px; +} +.tr-justifyRight { + background-position: -224px; +} +.tr-justifyFull { + background-position: -480px; +} + +/* Blockquote. */ +.tr-BLOCKQUOTE { + background-position: -240px; +} + +/* Blockquote in right-to-left text mode, regardless of chrome direction. */ +.tr-rtl-mode .tr-BLOCKQUOTE { + background-position: -464px; +} + +/* Remove formatting. */ +.tr-removeFormat { + background-position: -256px; +} + +/* Spellcheck. */ +.tr-spell { + background-position: -272px; +} + +/* Left-to-right text direction. */ +.tr-ltr { + background-position: -288px; +} + +/* Right-to-left text direction. */ +.tr-rtl { + background-position: -304px; +} + +/* Insert iGoogle module. */ +.tr-insertModule { + background-position: -496px; +} + +/* Strike through text */ +.tr-strikeThrough { + background-position: -544px; +} + +/* Subscript */ +.tr-subscript { + background-position: -560px; +} + +/* Superscript */ +.tr-superscript { + background-position: -576px; +} + +/* Insert drawing. */ +.tr-equation { + background-position: -608px; +} + +/* Edit HTML. */ +.tr-editHtml { + color: #009; +} + +/* "Format block" menu. */ +.tr-formatBlock .goog-toolbar-menu-button-caption { + color: #246; + width: 12ex; + height: 16px; + overflow: hidden; +} http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/e2cad6e6/externs/GCL/externs/goog/css/filteredmenu.css ---------------------------------------------------------------------- diff --git a/externs/GCL/externs/goog/css/filteredmenu.css b/externs/GCL/externs/goog/css/filteredmenu.css new file mode 100644 index 0000000..b43a113 --- /dev/null +++ b/externs/GCL/externs/goog/css/filteredmenu.css @@ -0,0 +1,30 @@ +/* + * Copyright 2007 The Closure Library Authors. All Rights Reserved. + * + * Use of this source code is governed by the Apache License, Version 2.0. + * See the COPYING file for details. + */ + +/* Author: [email protected] (Daniel Pupius) */ + +/* goog.ui.FilteredMenu */ + +.goog-menu-filter { + margin: 2px; + border: 1px solid silver; + background: white; + overflow: hidden; +} + +.goog-menu-filter div { + color: gray; + position: absolute; + padding: 1px; +} + +.goog-menu-filter input { + margin: 0; + border: 0; + background: transparent; + width: 100%; +} http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/e2cad6e6/externs/GCL/externs/goog/css/filterobservingmenuitem.css ---------------------------------------------------------------------- diff --git a/externs/GCL/externs/goog/css/filterobservingmenuitem.css b/externs/GCL/externs/goog/css/filterobservingmenuitem.css new file mode 100644 index 0000000..d48a609 --- /dev/null +++ b/externs/GCL/externs/goog/css/filterobservingmenuitem.css @@ -0,0 +1,25 @@ +/* + * Copyright 2007 The Closure Library Authors. All Rights Reserved. + * + * Use of this source code is governed by the Apache License, Version 2.0. + * See the COPYING file for details. + */ + +/* Author: [email protected] (Daniel Pupius) */ + +/* goog.ui.FilterObservingMenuItem */ + +.goog-filterobsmenuitem { + padding: 2px 5px; + margin: 0; + list-style: none; +} + +.goog-filterobsmenuitem-highlight { + background-color: #4279A5; + color: #FFF; +} + +.goog-filterobsmenuitem-disabled { + color: #999; +}
