text stringlengths 9 39.2M | dir stringlengths 26 295 | lang stringclasses 185
values | created_date timestamp[us] | updated_date timestamp[us] | repo_name stringlengths 1 97 | repo_full_name stringlengths 7 106 | star int64 1k 183k | len_tokens int64 1 13.8M |
|---|---|---|---|---|---|---|---|---|
```javascript
/**
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
/*jslint node:true*/
/**
* Desugars ES6 rest parameters into ES3 arguments slicing.
*
* function printf(template, ...args) {
* args.forEach(...);
* };
*
* function printf(template) {
* var args = [].slice.call(arguments, 1);
* args.forEach(...);
* };
*
*/
var Syntax = require('esprima-fb').Syntax;
var utils = require('../src/utils');
function _nodeIsFunctionWithRestParam(node) {
return (node.type === Syntax.FunctionDeclaration
|| node.type === Syntax.FunctionExpression
|| node.type === Syntax.ArrowFunctionExpression)
&& node.rest;
}
function visitFunctionParamsWithRestParam(traverse, node, path, state) {
// Render params.
if (node.params.length) {
utils.catchup(node.params[node.params.length - 1].range[1], state);
} else {
// -3 is for ... of the rest.
utils.catchup(node.rest.range[0] - 3, state);
}
utils.catchupWhiteSpace(node.rest.range[1], state);
}
visitFunctionParamsWithRestParam.test = function(node, path, state) {
return _nodeIsFunctionWithRestParam(node);
};
function renderRestParamSetup(functionNode) {
return 'var ' + functionNode.rest.name + '=Array.prototype.slice.call(' +
'arguments,' +
functionNode.params.length +
');';
}
function visitFunctionBodyWithRestParam(traverse, node, path, state) {
utils.catchup(node.range[0] + 1, state);
var parentNode = path[0];
utils.append(renderRestParamSetup(parentNode), state);
traverse(node.body, path, state);
return false;
}
visitFunctionBodyWithRestParam.test = function(node, path, state) {
return node.type === Syntax.BlockStatement
&& _nodeIsFunctionWithRestParam(path[0]);
};
exports.renderRestParamSetup = renderRestParamSetup;
exports.visitorList = [
visitFunctionParamsWithRestParam,
visitFunctionBodyWithRestParam
];
``` | /content/code_sandbox/node_modules/jstransform/visitors/es6-rest-param-visitors.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 481 |
```javascript
/**
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
/*jslint node:true*/
/**
* @typechecks
*/
'use strict';
var base62 = require('base62');
var Syntax = require('esprima-fb').Syntax;
var utils = require('../src/utils');
var SUPER_PROTO_IDENT_PREFIX = '____SuperProtoOf';
var _anonClassUUIDCounter = 0;
var _mungedSymbolMaps = {};
/**
* Used to generate a unique class for use with code-gens for anonymous class
* expressions.
*
* @param {object} state
* @return {string}
*/
function _generateAnonymousClassName(state) {
var mungeNamespace = state.mungeNamespace || '';
return '____Class' + mungeNamespace + base62.encode(_anonClassUUIDCounter++);
}
/**
* Given an identifier name, munge it using the current state's mungeNamespace.
*
* @param {string} identName
* @param {object} state
* @return {string}
*/
function _getMungedName(identName, state) {
var mungeNamespace = state.mungeNamespace;
var shouldMinify = state.g.opts.minify;
if (shouldMinify) {
if (!_mungedSymbolMaps[mungeNamespace]) {
_mungedSymbolMaps[mungeNamespace] = {
symbolMap: {},
identUUIDCounter: 0
};
}
var symbolMap = _mungedSymbolMaps[mungeNamespace].symbolMap;
if (!symbolMap[identName]) {
symbolMap[identName] =
base62.encode(_mungedSymbolMaps[mungeNamespace].identUUIDCounter++);
}
identName = symbolMap[identName];
}
return '$' + mungeNamespace + identName;
}
/**
* Extracts super class information from a class node.
*
* Information includes name of the super class and/or the expression string
* (if extending from an expression)
*
* @param {object} node
* @param {object} state
* @return {object}
*/
function _getSuperClassInfo(node, state) {
var ret = {
name: null,
expression: null
};
if (node.superClass) {
if (node.superClass.type === Syntax.Identifier) {
ret.name = node.superClass.name;
} else {
// Extension from an expression
ret.name = _generateAnonymousClassName(state);
ret.expression = state.g.source.substring(
node.superClass.range[0],
node.superClass.range[1]
);
}
}
return ret;
}
/**
* Used with .filter() to find the constructor method in a list of
* MethodDefinition nodes.
*
* @param {object} classElement
* @return {boolean}
*/
function _isConstructorMethod(classElement) {
return classElement.type === Syntax.MethodDefinition &&
classElement.key.type === Syntax.Identifier &&
classElement.key.name === 'constructor';
}
/**
* @param {object} node
* @param {object} state
* @return {boolean}
*/
function _shouldMungeIdentifier(node, state) {
return (
!!state.methodFuncNode &&
!utils.getDocblock(state).hasOwnProperty('preventMunge') &&
/^_(?!_)/.test(node.name)
);
}
/**
* @param {function} traverse
* @param {object} node
* @param {array} path
* @param {object} state
*/
function visitClassMethod(traverse, node, path, state) {
utils.catchup(node.range[0], state);
path.unshift(node);
traverse(node.value, path, state);
path.shift();
return false;
}
visitClassMethod.test = function(node, path, state) {
return node.type === Syntax.MethodDefinition;
};
/**
* @param {function} traverse
* @param {object} node
* @param {array} path
* @param {object} state
*/
function visitClassFunctionExpression(traverse, node, path, state) {
var methodNode = path[0];
state = utils.updateState(state, {
methodFuncNode: node
});
if (methodNode.key.name === 'constructor') {
utils.append('function ' + state.className, state);
} else {
var methodName = methodNode.key.name;
if (_shouldMungeIdentifier(methodNode.key, state)) {
methodName = _getMungedName(methodName, state);
}
var prototypeOrStatic = methodNode.static ? '' : 'prototype.';
utils.append(
state.className + '.' + prototypeOrStatic + methodName + '=function',
state
);
}
utils.move(methodNode.key.range[1], state);
var params = node.params;
var paramName;
if (params.length > 0) {
for (var i = 0; i < params.length; i++) {
utils.catchup(node.params[i].range[0], state);
paramName = params[i].name;
if (_shouldMungeIdentifier(params[i], state)) {
paramName = _getMungedName(params[i].name, state);
}
utils.append(paramName, state);
utils.move(params[i].range[1], state);
}
} else {
utils.append('(', state);
}
utils.append(')', state);
utils.catchupWhiteSpace(node.body.range[0], state);
utils.append('{', state);
if (!state.scopeIsStrict) {
utils.append('"use strict";', state);
}
utils.move(node.body.range[0] + '{'.length, state);
path.unshift(node);
traverse(node.body, path, state);
path.shift();
utils.catchup(node.body.range[1], state);
if (methodNode.key.name !== 'constructor') {
utils.append(';', state);
}
return false;
}
visitClassFunctionExpression.test = function(node, path, state) {
return node.type === Syntax.FunctionExpression
&& path[0].type === Syntax.MethodDefinition;
};
/**
* @param {function} traverse
* @param {object} node
* @param {array} path
* @param {object} state
*/
function _renderClassBody(traverse, node, path, state) {
var className = state.className;
var superClass = state.superClass;
// Set up prototype of constructor on same line as `extends` for line-number
// preservation. This relies on function-hoisting if a constructor function is
// defined in the class body.
if (superClass.name) {
// If the super class is an expression, we need to memoize the output of the
// expression into the generated class name variable and use that to refer
// to the super class going forward. Example:
//
// class Foo extends mixin(Bar, Baz) {}
// --transforms to--
// function Foo() {} var ____Class0Blah = mixin(Bar, Baz);
if (superClass.expression !== null) {
utils.append(
'var ' + superClass.name + '=' + superClass.expression + ';',
state
);
}
var keyName = superClass.name + '____Key';
var keyNameDeclarator = '';
if (!utils.identWithinLexicalScope(keyName, state)) {
keyNameDeclarator = 'var ';
utils.declareIdentInLocalScope(keyName, state);
}
utils.append(
'for(' + keyNameDeclarator + keyName + ' in ' + superClass.name + '){' +
'if(' + superClass.name + '.hasOwnProperty(' + keyName + ')){' +
className + '[' + keyName + ']=' +
superClass.name + '[' + keyName + '];' +
'}' +
'}',
state
);
var superProtoIdentStr = SUPER_PROTO_IDENT_PREFIX + superClass.name;
if (!utils.identWithinLexicalScope(superProtoIdentStr, state)) {
utils.append(
'var ' + superProtoIdentStr + '=' + superClass.name + '===null?' +
'null:' + superClass.name + '.prototype;',
state
);
utils.declareIdentInLocalScope(superProtoIdentStr, state);
}
utils.append(
className + '.prototype=Object.create(' + superProtoIdentStr + ');',
state
);
utils.append(
className + '.prototype.constructor=' + className + ';',
state
);
utils.append(
className + '.__superConstructor__=' + superClass.name + ';',
state
);
}
// If there's no constructor method specified in the class body, create an
// empty constructor function at the top (same line as the class keyword)
if (!node.body.body.filter(_isConstructorMethod).pop()) {
utils.append('function ' + className + '(){', state);
if (!state.scopeIsStrict) {
utils.append('"use strict";', state);
}
if (superClass.name) {
utils.append(
'if(' + superClass.name + '!==null){' +
superClass.name + '.apply(this,arguments);}',
state
);
}
utils.append('}', state);
}
utils.move(node.body.range[0] + '{'.length, state);
traverse(node.body, path, state);
utils.catchupWhiteSpace(node.range[1], state);
}
/**
* @param {function} traverse
* @param {object} node
* @param {array} path
* @param {object} state
*/
function visitClassDeclaration(traverse, node, path, state) {
var className = node.id.name;
var superClass = _getSuperClassInfo(node, state);
state = utils.updateState(state, {
mungeNamespace: className,
className: className,
superClass: superClass
});
_renderClassBody(traverse, node, path, state);
return false;
}
visitClassDeclaration.test = function(node, path, state) {
return node.type === Syntax.ClassDeclaration;
};
/**
* @param {function} traverse
* @param {object} node
* @param {array} path
* @param {object} state
*/
function visitClassExpression(traverse, node, path, state) {
var className = node.id && node.id.name || _generateAnonymousClassName(state);
var superClass = _getSuperClassInfo(node, state);
utils.append('(function(){', state);
state = utils.updateState(state, {
mungeNamespace: className,
className: className,
superClass: superClass
});
_renderClassBody(traverse, node, path, state);
utils.append('return ' + className + ';})()', state);
return false;
}
visitClassExpression.test = function(node, path, state) {
return node.type === Syntax.ClassExpression;
};
/**
* @param {function} traverse
* @param {object} node
* @param {array} path
* @param {object} state
*/
function visitPrivateIdentifier(traverse, node, path, state) {
utils.append(_getMungedName(node.name, state), state);
utils.move(node.range[1], state);
}
visitPrivateIdentifier.test = function(node, path, state) {
if (node.type === Syntax.Identifier && _shouldMungeIdentifier(node, state)) {
// Always munge non-computed properties of MemberExpressions
// (a la preventing access of properties of unowned objects)
if (path[0].type === Syntax.MemberExpression && path[0].object !== node
&& path[0].computed === false) {
return true;
}
// Always munge identifiers that were declared within the method function
// scope
if (utils.identWithinLexicalScope(node.name, state, state.methodFuncNode)) {
return true;
}
// Always munge private keys on object literals defined within a method's
// scope.
if (path[0].type === Syntax.Property
&& path[1].type === Syntax.ObjectExpression) {
return true;
}
// Always munge function parameters
if (path[0].type === Syntax.FunctionExpression
|| path[0].type === Syntax.FunctionDeclaration) {
for (var i = 0; i < path[0].params.length; i++) {
if (path[0].params[i] === node) {
return true;
}
}
}
}
return false;
};
/**
* @param {function} traverse
* @param {object} node
* @param {array} path
* @param {object} state
*/
function visitSuperCallExpression(traverse, node, path, state) {
var superClassName = state.superClass.name;
if (node.callee.type === Syntax.Identifier) {
utils.append(superClassName + '.call(', state);
utils.move(node.callee.range[1], state);
} else if (node.callee.type === Syntax.MemberExpression) {
utils.append(SUPER_PROTO_IDENT_PREFIX + superClassName, state);
utils.move(node.callee.object.range[1], state);
if (node.callee.computed) {
// ["a" + "b"]
utils.catchup(node.callee.property.range[1] + ']'.length, state);
} else {
// .ab
utils.append('.' + node.callee.property.name, state);
}
utils.append('.call(', state);
utils.move(node.callee.range[1], state);
}
utils.append('this', state);
if (node.arguments.length > 0) {
utils.append(',', state);
utils.catchupWhiteSpace(node.arguments[0].range[0], state);
traverse(node.arguments, path, state);
}
utils.catchupWhiteSpace(node.range[1], state);
utils.append(')', state);
return false;
}
visitSuperCallExpression.test = function(node, path, state) {
if (state.superClass && node.type === Syntax.CallExpression) {
var callee = node.callee;
if (callee.type === Syntax.Identifier && callee.name === 'super'
|| callee.type == Syntax.MemberExpression
&& callee.object.name === 'super') {
return true;
}
}
return false;
};
/**
* @param {function} traverse
* @param {object} node
* @param {array} path
* @param {object} state
*/
function visitSuperMemberExpression(traverse, node, path, state) {
var superClassName = state.superClass.name;
utils.append(SUPER_PROTO_IDENT_PREFIX + superClassName, state);
utils.move(node.object.range[1], state);
}
visitSuperMemberExpression.test = function(node, path, state) {
return state.superClass
&& node.type === Syntax.MemberExpression
&& node.object.type === Syntax.Identifier
&& node.object.name === 'super';
};
exports.visitorList = [
visitClassDeclaration,
visitClassExpression,
visitClassFunctionExpression,
visitClassMethod,
visitPrivateIdentifier,
visitSuperCallExpression,
visitSuperMemberExpression
];
``` | /content/code_sandbox/node_modules/jstransform/visitors/es6-class-visitors.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 3,256 |
```javascript
/**
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
/**
* @emails dmitrys@fb.com javascript@lists.facebook.com
*/
/*jshint evil:true*/
require('mock-modules').autoMockOff();
describe('es6ArrowFunctionsTransform', function() {
var transformFn;
var visitors;
beforeEach(function() {
require('mock-modules').dumpCache();
visitors = require('../es6-arrow-function-visitors').visitorList;
transformFn = require('../../jstransform').transform;
});
function transform(code) {
return transformFn(visitors, code).code;
}
function expectTransform(code, result) {
expect(transform(code)).toEqual(result);
}
it('should capture correct this value at different levels', function() {
var code = transform([
'var foo = {',
' createFooGetter: function() {',
' return (x) => [x, this];', // captures foo
' },',
' getParentThis: () => this', // captures parent this
'};'
].join('\n'));
eval(code);
expect(typeof foo.createFooGetter).toBe('function');
expect(typeof foo.createFooGetter()).toBe('function');
expect(typeof foo.getParentThis).toBe('function');
expect(foo.getParentThis()).toEqual(this);
expect(foo.createFooGetter()(10)).toEqual([10, foo]);
});
it('should map an array using arrow capturing this value', function() {
this.factor = 10;
var code = transform(
'[1, 2, 3].map(x => x * x * this.factor);'
);
expect(eval(code)).toEqual([10, 40, 90]);
});
it('should filter an array using arrow with two params', function() {
this.factor = 0;
var code = transform([
'[1, 2, 3].filter((v, idx) => {',
' if (idx > 1 && this.factor > 0) {',
' return true;',
' }',
' this.factor++;',
' return false;',
'});'
].join('\n'));
expect(eval(code)).toEqual([3]);
});
it('should fetch this value data from nested arrow', function() {
var code = transform([
'({',
' bird: 22,',
' run: function() {',
' return () => () => this.bird;',
' }',
'}).run()()();'
].join('\n'));
expect(eval(code)).toEqual(22);
});
// Syntax tests.
it('should correctly transform arrows', function() {
// 0 params, expression.
expectTransform(
'() => this.value;',
'function() {return this.value;}.bind(this);'
);
// 1 param, no-parens, expression, no this.
expectTransform(
'x => x * x;',
'function(x) {return x * x;};'
);
// 1 param, parens, expression, as argument, no this.
expectTransform(
'map((x) => x * x);',
'map(function(x) {return x * x;});'
);
// 2 params, block, as argument, nested.
expectTransform(
'makeRequest((response, error) => {'.concat(
' return this.update(data => this.onData(data), response);',
'});'),
'makeRequest(function(response, error) {'.concat(
' return this.update(function(data) {return this.onData(data);}.bind(this), response);',
'}.bind(this));')
);
// Assignment to a var, simple, 1 param.
expectTransform(
'var action = (value) => this.performAction(value);',
'var action = function(value) {return this.performAction(value);}.bind(this);'
);
// Preserve lines transforming ugly code.
expectTransform([
'(',
'',
'',
' x,',
' y',
'',
')',
'',
' =>',
'',
' {',
' return x + y;',
'};'
].join('\n'), [
'function(',
'',
'',
' x,',
' y)',
'',
'',
'',
' ',
'',
' {',
' return x + y;',
'};'
].join('\n'));
// Preserve line numbers with single parens-free param ugly code.
expectTransform([
'x',
'',
' =>',
' x;'
].join('\n'), [
'function(x)',
'',
' ',
' {return x;};'
].join('\n'));
// Preserve line numbers with single parens param ugly code.
expectTransform([
'(',
'',
' x',
'',
')',
'',
' =>',
' x;'
].join('\n'), [
'function(',
'',
' x)',
'',
'',
'',
' ',
' {return x;};'
].join('\n'));
// Preserve typechecker annotation.
expectTransform(
'(/*string*/foo, /*bool*/bar) => foo;',
'function(/*string*/foo, /*bool*/bar) {return foo;};'
);
});
});
``` | /content/code_sandbox/node_modules/jstransform/visitors/__tests__/es6-arrow-function-visitors-test.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 1,216 |
```javascript
/**
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
/**
* @emails dmitrys@fb.com javascript@lists.facebook.com
*/
/*jshint evil:true*/
require('mock-modules').autoMockOff();
describe('es6-object-short-notation-visitors', function() {
var transformFn;
var visitors;
beforeEach(function() {
require('mock-modules').dumpCache();
visitors = require('../es6-object-short-notation-visitors').visitorList;
transformFn = require('../../jstransform').transform;
});
function transform(code) {
return transformFn(visitors, code).code;
}
function expectTransform(code, result) {
expect(transform(code)).toEqual(result);
}
// Functional tests.
it('should transform short notation and return 5', function() {
var code = transform([
'(function(x, y) {',
' var data = {x, y};',
' return data.x + data.y;',
'})(2, 3);'
].join('\n'));
expect(eval(code)).toEqual(5);
});
// Source code tests.
it('should transform simple short notation', function() {
// Should transform simple short notation.
expectTransform(
'function foo(x, y) { return {x, y}; }',
'function foo(x, y) { return {x:x, y:y}; }'
);
// Should transform: short notation in complex object pattern.
expectTransform([
'function init({name, points: [{x, y}, {z, q}]}) {',
' return function([{data: {value, score}}]) {',
' return {z, q, score, name};',
' };',
'}'
].join('\n'), [
'function init({name:name, points: [{x:x, y:y}, {z:z, q:q}]}) {',
' return function([{data: {value:value, score:score}}]) {',
' return {z:z, q:q, score:score, name:name};',
' };',
'}'
].join('\n'));
// Should preserve lines transforming ugly code.
expectTransform([
'function',
'',
'foo ({',
' x,',
' y',
'',
'})',
'',
' {',
' return {',
' x,',
' y};',
'}'
].join('\n'), [
'function',
'',
'foo ({',
' x:x,',
' y:y',
'',
'})',
'',
' {',
' return {',
' x:x,',
' y:y};',
'}'
].join('\n'));
});
});
``` | /content/code_sandbox/node_modules/jstransform/visitors/__tests__/es6-object-short-notation-visitors-test.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 642 |
```javascript
/**
* @emails mroch@fb.com javascript@lists.facebook.com
*/
/*jshint evil:true*/
require('mock-modules').autoMockOff();
describe('ES6 Template Visitor', function() {
var transformFn;
var visitors;
beforeEach(function() {
require('mock-modules').dumpCache();
visitors = require('../es6-template-visitors').visitorList;
transformFn = require('../../jstransform').transform;
});
function transform(code) {
return transformFn(visitors, code).code;
}
function expectTransform(code, result) {
expect(transform(code)).toEqual(result);
}
function expectEval(code, result, setupFn) {
var actual;
if (setupFn) {
eval(setupFn);
}
eval('actual = ' + transform(code));
expect(actual).toEqual(result);
}
function expectEvalTag(code, tagFn, scope) {
if (scope) {
Object.keys(scope).forEach((key) => this[key] = scope[key]);
}
var tagCalls = 0;
var tag = function(...args) {
tagCalls++;
return tagFn.apply(this, args);
};
var result = transform(code);
expect(result.split('\n').length).toBe(code.split('\n').length);
eval(result);
expect(tagCalls).toBe(1);
}
function expectSiteObj(siteObj, cooked, raw) {
expect(Array.isArray(siteObj)).toBe(true);
expect(Object.isFrozen(siteObj)).toBe(true);
expect(Array.isArray(siteObj.raw)).toBe(true);
expect(Object.isFrozen(siteObj.raw)).toBe(true);
expect(siteObj.length).toBe(cooked.length);
expect(siteObj.raw.length).toBe(raw.length);
for (var ii = 0; ii < cooked.length; ii++) {
expect(siteObj[ii]).toEqual(cooked[ii]);
}
expect(siteObj.raw).toEqual(raw);
}
it('should transform simple literals', function() {
expectTransform('`foo bar`', '("foo bar")');
expectEval('`foo bar`', 'foo bar');
expectEval('`$`', '$');
expectEval('`$foo`', '$foo');
});
it('should properly escape templates containing quotes', function() {
expectTransform('`foo "bar"`', '("foo \\"bar\\"")');
expectEval('`foo "bar"`', 'foo "bar"');
expectTransform("`foo 'bar'`", '("foo \'bar\'")');
expectEval("`foo 'bar'`", "foo 'bar'");
// `foo \\"bar\\"` (foo, literal slash, "bar", literal slash)
expectTransform('`foo \\\\"bar\\\\"`', '("foo \\\\\\"bar\\\\\\"")');
expectEval('`foo \\\\\\"bar\\\\\\"`', 'foo \\"bar\\"');
});
it('should transform simple substitutions', function() {
expectTransform('`foo ${bar}`', '("foo " + bar)');
expectTransform('`${foo} bar`', '(foo + " bar")');
expectTransform('`${foo} ${bar}`', '(foo + " " + bar)');
});
it('should transform expressions', function() {
expectTransform('`foo ${bar()}`', '("foo " + bar())');
expectTransform('`foo ${bar.baz}`', '("foo " + bar.baz)');
expectTransform('`foo ${bar + 5}`', '("foo " + (bar + 5))');
expectTransform('`${foo + 5} bar`', '((foo + 5) + " bar")');
expectTransform('`${foo + 5} ${bar}`', '((foo + 5) + " " + bar)');
expectTransform(
'`${(function(b) {alert(4);})(a)}`',
'((function(b) {alert(4);})(a))');
});
it('should transform tags with simple templates', function() {
var tag = function(elements) {
expectSiteObj(elements, ['foo bar'], ['foo bar']);
};
var result = transform("tag`foo bar`");
expect(result.split('\n').length).toBe(1);
eval(result);
var a = { b: tag };
eval(transform("a.b`foo bar`"));
eval(transform("a['b']`foo bar`"));
var getTag = function() { return tag; };
eval(transform("getTag()`foo bar`"));
eval(transform("(getTag())`foo bar`"));
});
it('should transform tags with substitutions', function() {
expectTransform(
"tag`foo ${bar} baz`",
'tag(function() { var siteObj = ["foo ", " baz"]; ' +
'siteObj.raw = ["foo ", " baz"]; Object.freeze(siteObj.raw); ' +
'Object.freeze(siteObj); return siteObj; }(), bar)'
);
expectEvalTag(
"tag`foo ${bar + 'abc'} baz`",
function(elements, ...args) {
expectSiteObj(elements, ['foo ', ' baz'], ['foo ', ' baz']);
expect(args.length).toBe(1);
expect(args[0]).toBe('barabc');
},
{bar: 'bar'}
);
expectEvalTag(
"tag`foo ${bar + 'abc'}`",
function(elements, ...args) {
expectSiteObj(elements, ['foo ', ''], ['foo ', '']);
expect(args.length).toBe(1);
expect(args[0]).toBe('barabc');
},
{bar: 'bar'}
);
expectEvalTag(
"tag`foo\n\n\nbar`",
(elements) => {
expectSiteObj(elements, ['foo\n\n\nbar'], ['foo\n\n\nbar']);
}
);
expectEvalTag(
"tag`a\nb\n${c}\nd`",
(elements, ...args) => {
expectSiteObj(elements, ['a\nb\n', '\nd'], ['a\nb\n', '\nd']);
expect(args.length).toBe(1);
expect(args[0]).toBe('c');
},
{c: 'c'}
);
});
it('should maintain line numbers', function() {
expectTransform("`foo\n\nbar`", '("foo\\n\\nbar"\n\n)');
expectTransform("`foo\n${bar}\nbaz`", '("foo\\n" + \nbar + "\\nbaz"\n)');
expectTransform("`foo\\nbar`", '("foo\\nbar")');
expectTransform(
"tag`a\nb\n${c}${d}\ne`",
'tag(function() { var siteObj = ["a\\nb\\n", "", "\\ne"]; ' +
'siteObj.raw = ["a\\nb\\n", "", "\\ne"]; Object.freeze(siteObj.raw); ' +
'Object.freeze(siteObj); return siteObj; }(), \n\nc, d\n)'
);
});
it('should handle multiple lines', function() {
expectEval("`foo\n\nbar`", 'foo\n\nbar');
expectEval("`foo\\nbar`", 'foo\nbar');
expectEval("`foo\\\\nbar`", 'foo\\nbar');
expectEval("`foo\n${bar}\nbaz`", 'foo\nabc\nbaz', 'var bar = "abc";');
});
it('should canonicalize line endings', function() {
// TODO: should this be '("foo\\nbar"\r\n)' to maintain the number of lines
// for editors that break on \r\n? I don't think we care in the transformed
// code.
expectTransform("`foo\r\nbar`", '("foo\\nbar"\n)');
// TODO: same as above but with trailing \r
expectTransform("`foo\rbar`", '("foo\\nbar")');
expectEval("`foo\r\nbar`", 'foo\nbar');
expectEval("`foo\rbar`", 'foo\nbar');
expectEval("`foo\r\n${bar}\r\nbaz`", 'foo\nabc\nbaz', 'var bar = "abc";');
expectEvalTag(
"tag`foo\rbar`",
(elements) => {
expectSiteObj(elements, ['foo\nbar'], ['foo\rbar']);
}
);
});
});
``` | /content/code_sandbox/node_modules/jstransform/visitors/__tests__/es6-template-visitors-test.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 1,825 |
```javascript
/**
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
/**
* @emails dmitrys@fb.com javascript@lists.facebook.com
*/
/*jshint evil:true*/
require('mock-modules').autoMockOff();
describe('es6-rest-param-visitors', () => {
var transformFn;
var visitorSet;
var arrowFuncVisitors;
var classVisitors;
var restParamVisitors;
beforeEach(() => {
require('mock-modules').dumpCache();
arrowFuncVisitors = require('../es6-arrow-function-visitors').visitorList;
classVisitors = require('../es6-class-visitors').visitorList;
restParamVisitors = require('../es6-rest-param-visitors').visitorList;
transformFn = require('../../jstransform').transform;
visitorSet =
arrowFuncVisitors
.concat(classVisitors)
.concat(restParamVisitors);
});
function transform(code) {
return transformFn(visitorSet, code).code;
}
function expectTransform(code, result) {
expect(transform(code)).toEqual(result);
}
describe('function expressions', () => {
it('should capture 2 rest params, having 2 args', () => {
var code = transform([
'(function(x, y, ...args) {',
' return [x, y, args.length, args[0], args[1]];',
'})(1, 2, 3, 4);'
].join('\n'));
expect(eval(code)).toEqual([1, 2, 2, 3, 4]);
});
it('should transform rest parameters in nested functions', () => {
var code = transform([
'(function(x, ...args) {',
' return function(...params) {',
' return args.concat(params);',
' };',
'})(1, 2, 3)(4, 5);'
].join('\n'));
expect(eval(code)).toEqual([2, 3, 4, 5]);
});
it('should supply an array object', () => {
var code = transform([
'(function(...args) {',
' return Array.isArray(args);',
'})()'
].join('\n'));
expect(eval(code)).toBe(true);
});
});
describe('function declarations', () => {
it('should capture 2 rest params, having 2 args', () => {
var code = transform([
'function test(x, y, ...args) {',
' return [x, y, args.length, args[0], args[1]];',
'}'
].join('\n'));
eval(code);
expect(test(1, 2, 3, 4)).toEqual([1, 2, 2, 3, 4]);
});
it('should transform rest parameters in nested functions', () => {
var code = transform([
'function testOuter(x, ...args) {',
' function testInner(...params) {',
' return args.concat(params);',
' }',
' return testInner;',
'}'
].join('\n'));
eval(code);
expect(testOuter(1, 2, 3)(4, 5)).toEqual([2, 3, 4, 5]);
});
it('should supply an array object', () => {
var code = transform([
'function test(...args) {',
' return Array.isArray(args);',
'}'
].join('\n'));
eval(code);
expect(test()).toBe(true);
});
});
describe('arrow functions', () => {
it('should transform non-block bodied arrow functions', () => {
var code = transform([
'var test = (...args) => args;'
].join('\n'));
eval(code);
expect(test('foo', 'bar')).toEqual(['foo', 'bar'])
});
it('should capture 2 rest params, having 2 args', () => {
var code = transform([
'var test = (x, y, ...args) => {',
' return [x, y, args.length, args[0], args[1]];',
'}'
].join('\n'));
eval(code);
expect(test(1, 2, 3, 4)).toEqual([1, 2, 2, 3, 4]);
});
it('should transform rest parameters in nested arrow functions', () => {
var code = transform([
'var testOuter = (x, ...args) => {',
' var testInner = (...params) => {',
' return args.concat(params);',
' };',
' return testInner;',
'};'
].join('\n'));
eval(code);
expect(testOuter(1, 2, 3)(4, 5)).toEqual([2, 3, 4, 5]);
});
it('should supply an array object', () => {
var code = transform([
'var test = (...args) => {',
' return Array.isArray(args);',
'};'
].join('\n'));
eval(code);
expect(test()).toBe(true);
});
});
describe('class methods', () => {
it('should capture 2 rest params, having 2 args', () => {
var code = transform([
'class Foo {',
' constructor(x, y, ...args) {',
' this.ctor = [x, y, args.length, args[0], args[1]];',
' }',
' testMethod(x, y, ...args) {',
' return [x, y, args.length, args[0], args[1]];',
' }',
' static testMethod(x, y, ...args) {',
' return [x, y, args.length, args[0], args[1]];',
' }',
'}'
].join('\n'));
eval(code);
var fooInst = new Foo(1, 2, 3, 4);
expect(fooInst.ctor).toEqual([1, 2, 2, 3, 4]);
expect(fooInst.testMethod(1, 2, 3, 4)).toEqual([1, 2, 2, 3, 4]);
expect(Foo.testMethod(1, 2, 3, 4)).toEqual([1, 2, 2, 3, 4]);
});
it('should transform rest parameters in nested functions', () => {
var code = transform([
'class Foo {',
' constructor(x, ...args) {',
' function inner(...params) {',
' return args.concat(params);',
' }',
' this.ctor = inner;',
' }',
' testMethod(x, ...args) {',
' function inner(...params) {',
' return args.concat(params);',
' }',
' return inner;',
' }',
' static testMethod(x, ...args) {',
' function inner(...params) {',
' return args.concat(params);',
' }',
' return inner;',
' }',
'}'
].join('\n'));
eval(code);
var fooInst = new Foo(1, 2, 3);
expect(fooInst.ctor(4, 5)).toEqual([2, 3, 4, 5]);
expect(fooInst.testMethod(1, 2, 3)(4, 5)).toEqual([2, 3, 4, 5]);
expect(Foo.testMethod(1, 2, 3)(4, 5)).toEqual([2, 3, 4, 5]);
});
it('should supply an array object', () => {
var code = transform([
'class Foo {',
' constructor(...args) {',
' this.ctor = Array.isArray(args);',
' }',
' testMethod(...args) {',
' return Array.isArray(args);',
' }',
' static testMethod(...args) {',
' return Array.isArray(args);',
' }',
'}'
].join('\n'));
eval(code);
var fooInst = new Foo();
expect(fooInst.ctor).toBe(true);
expect(fooInst.testMethod()).toBe(true);
expect(Foo.testMethod()).toBe(true);
});
});
describe('whitespace preservation', () => {
it('1-line function decl with 2 args', () => {
expectTransform(
'function foo(x, y, ...args) { return x + y + args[0]; }',
'function foo(x, y ) {var args=Array.prototype.slice.call(arguments,2); return x + y + args[0]; }'
);
})
it('1-line function expression with 1 arg', () => {
expectTransform(
'(function(x, ...args) { return args;});',
'(function(x ) {var args=Array.prototype.slice.call(arguments,1); return args;});'
);
});
it('1-line function expression with no args', () => {
expectTransform(
'map(function(...args) { return args.map(log); });',
'map(function() {var args=Array.prototype.slice.call(arguments,0); return args.map(log); });'
);
});
it('preserves lines for ugly code', () => {
expectTransform([
'function',
'',
'foo (',
' x,',
' ...args',
'',
')',
'',
' {',
' return args;',
'}'
].join('\n'), [
'function',
'',
'foo (',
' x',
' ',
'',
')',
'',
' {var args=Array.prototype.slice.call(arguments,1);',
' return args;',
'}'
].join('\n'));
});
it('preserves inline comments', () => {
expectTransform(
'function foo(/*string*/foo, /*bool*/bar, ...args) { return args; }',
'function foo(/*string*/foo, /*bool*/bar ) {' +
'var args=Array.prototype.slice.call(arguments,2); ' +
'return args; ' +
'}'
);
});
});
});
``` | /content/code_sandbox/node_modules/jstransform/visitors/__tests__/es6-rest-param-visitors-test.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 2,317 |
```javascript
/**
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
/*jslint node: true*/
"use strict";
/**
* Syntax transfomer for javascript. Takes the source in, spits the source
* out.
*
* Parses input source with esprima, applies the given list of visitors to the
* AST tree, and returns the resulting output.
*/
var esprima = require('esprima-fb');
var utils = require('./utils');
var Syntax = esprima.Syntax;
/**
* @param {object} node
* @param {object} parentNode
* @return {boolean}
*/
function _nodeIsClosureScopeBoundary(node, parentNode) {
if (node.type === Syntax.Program) {
return true;
}
var parentIsFunction =
parentNode.type === Syntax.FunctionDeclaration
|| parentNode.type === Syntax.FunctionExpression;
return node.type === Syntax.BlockStatement && parentIsFunction;
}
function _nodeIsBlockScopeBoundary(node, parentNode) {
if (node.type === Syntax.Program) {
return false;
}
return node.type === Syntax.BlockStatement
&& parentNode.type === Syntax.CatchClause;
}
/**
* @param {object} node
* @param {function} visitor
* @param {array} path
* @param {object} state
*/
function traverse(node, path, state) {
// Create a scope stack entry if this is the first node we've encountered in
// its local scope
var parentNode = path[0];
if (!Array.isArray(node) && state.localScope.parentNode !== parentNode) {
if (_nodeIsClosureScopeBoundary(node, parentNode)) {
var scopeIsStrict =
state.scopeIsStrict
|| node.body.length > 0
&& node.body[0].type === Syntax.ExpressionStatement
&& node.body[0].expression.type === Syntax.Literal
&& node.body[0].expression.value === 'use strict';
if (node.type === Syntax.Program) {
state = utils.updateState(state, {
scopeIsStrict: scopeIsStrict
});
} else {
state = utils.updateState(state, {
localScope: {
parentNode: parentNode,
parentScope: state.localScope,
identifiers: {}
},
scopeIsStrict: scopeIsStrict
});
// All functions have an implicit 'arguments' object in scope
state.localScope.identifiers['arguments'] = true;
// Include function arg identifiers in the scope boundaries of the
// function
if (parentNode.params.length > 0) {
var param;
for (var i = 0; i < parentNode.params.length; i++) {
param = parentNode.params[i];
if (param.type === Syntax.Identifier) {
state.localScope.identifiers[param.name] = true;
}
}
}
// Named FunctionExpressions scope their name within the body block of
// themselves only
if (parentNode.type === Syntax.FunctionExpression && parentNode.id) {
state.localScope.identifiers[parentNode.id.name] = true;
}
}
// Traverse and find all local identifiers in this closure first to
// account for function/variable declaration hoisting
collectClosureIdentsAndTraverse(node, path, state);
}
if (_nodeIsBlockScopeBoundary(node, parentNode)) {
state = utils.updateState(state, {
localScope: {
parentNode: parentNode,
parentScope: state.localScope,
identifiers: {}
}
});
if (parentNode.type === Syntax.CatchClause) {
state.localScope.identifiers[parentNode.param.name] = true;
}
collectBlockIdentsAndTraverse(node, path, state);
}
}
// Only catchup() before and after traversing a child node
function traverser(node, path, state) {
node.range && utils.catchup(node.range[0], state);
traverse(node, path, state);
node.range && utils.catchup(node.range[1], state);
}
utils.analyzeAndTraverse(walker, traverser, node, path, state);
}
function collectClosureIdentsAndTraverse(node, path, state) {
utils.analyzeAndTraverse(
visitLocalClosureIdentifiers,
collectClosureIdentsAndTraverse,
node,
path,
state
);
}
function collectBlockIdentsAndTraverse(node, path, state) {
utils.analyzeAndTraverse(
visitLocalBlockIdentifiers,
collectBlockIdentsAndTraverse,
node,
path,
state
);
}
function visitLocalClosureIdentifiers(node, path, state) {
var identifiers = state.localScope.identifiers;
switch (node.type) {
case Syntax.FunctionExpression:
// Function expressions don't get their names (if there is one) added to
// the closure scope they're defined in
return false;
case Syntax.ClassDeclaration:
case Syntax.ClassExpression:
case Syntax.FunctionDeclaration:
if (node.id) {
identifiers[node.id.name] = true;
}
return false;
case Syntax.VariableDeclarator:
if (path[0].kind === 'var') {
identifiers[node.id.name] = true;
}
break;
}
}
function visitLocalBlockIdentifiers(node, path, state) {
// TODO: Support 'let' here...maybe...one day...or something...
if (node.type === Syntax.CatchClause) {
return false;
}
}
function walker(node, path, state) {
var visitors = state.g.visitors;
for (var i = 0; i < visitors.length; i++) {
if (visitors[i].test(node, path, state)) {
return visitors[i](traverse, node, path, state);
}
}
}
/**
* Applies all available transformations to the source
* @param {array} visitors
* @param {string} source
* @param {?object} options
* @return {object}
*/
function transform(visitors, source, options) {
options = options || {};
var ast;
try {
ast = esprima.parse(source, {
comment: true,
loc: true,
range: true
});
} catch (e) {
e.message = 'Parse Error: ' + e.message;
throw e;
}
var state = utils.createState(source, ast, options);
state.g.visitors = visitors;
if (options.sourceMap) {
var SourceMapGenerator = require('source-map').SourceMapGenerator;
state.g.sourceMap = new SourceMapGenerator({file: 'transformed.js'});
}
traverse(ast, [], state);
utils.catchup(source.length, state);
var ret = {code: state.g.buffer};
if (options.sourceMap) {
ret.sourceMap = state.g.sourceMap;
ret.sourceMapFilename = options.filename || 'source.js';
}
return ret;
}
exports.transform = transform;
``` | /content/code_sandbox/node_modules/jstransform/src/jstransform.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 1,509 |
```javascript
/**
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
var docblockRe = /^\s*(\/\*\*(.|\r?\n)*?\*\/)/;
var ltrimRe = /^\s*/;
/**
* @param {String} contents
* @return {String}
*/
function extract(contents) {
var match = contents.match(docblockRe);
if (match) {
return match[0].replace(ltrimRe, '') || '';
}
return '';
}
var commentStartRe = /^\/\*\*?/;
var commentEndRe = /\*+\/$/;
var wsRe = /[\t ]+/g;
var stringStartRe = /(\r?\n|^) *\*/g;
var multilineRe = /(?:^|\r?\n) *(@[^\r\n]*?) *\r?\n *([^@\r\n\s][^@\r\n]+?) *\r?\n/g;
var propertyRe = /(?:^|\r?\n) *@(\S+) *([^\r\n]*)/g;
/**
* @param {String} contents
* @return {Array}
*/
function parse(docblock) {
docblock = docblock
.replace(commentStartRe, '')
.replace(commentEndRe, '')
.replace(wsRe, ' ')
.replace(stringStartRe, '$1');
// Normalize multi-line directives
var prev = '';
while (prev != docblock) {
prev = docblock;
docblock = docblock.replace(multilineRe, "\n$1 $2\n");
}
docblock = docblock.trim();
var result = [];
var match;
while (match = propertyRe.exec(docblock)) {
result.push([match[1], match[2]]);
}
return result;
}
/**
* Same as parse but returns an object of prop: value instead of array of paris
* If a property appers more than once the last one will be returned
*
* @param {String} contents
* @return {Object}
*/
function parseAsObject(docblock) {
var pairs = parse(docblock);
var result = {};
for (var i = 0; i < pairs.length; i++) {
result[pairs[i][0]] = pairs[i][1];
}
return result;
}
exports.extract = extract;
exports.parse = parse;
exports.parseAsObject = parseAsObject;
``` | /content/code_sandbox/node_modules/jstransform/src/docblock.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 535 |
```javascript
/**
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
* @emails jeffmo@fb.com javascript@lists.facebook.com
*/
/*jshint evil:true*/
require('mock-modules').autoMockOff();
describe('es6-classes', function() {
var transformFn;
var visitors;
beforeEach(function() {
require('mock-modules').dumpCache();
visitors = require('../es6-class-visitors').visitorList;
transformFn = require('../../jstransform').transform;
});
function transform(code, opts) {
return transformFn(visitors, code, opts).code;
}
describe('ClassDeclarations', function() {
describe('preserves line numbers', function() {
it('does not add "use strict" unless necessary', function() {
var code = [
'function strictStuff() {',
' "use strict";',
' class A {',
' foo() {}',
' }',
'}',
'class B {',
' bar() {}',
'}'
].join('\n');
var expected = [
'function strictStuff() {',
' "use strict";',
' function A(){}',
' A.prototype.foo=function() {};',
' ',
'}',
'function B(){"use strict";}',
' B.prototype.bar=function() {"use strict";};',
''
].join('\n');
expect(transform(code)).toBe(expected);
});
it('preserves lines with no inheritance', function() {
var code = [
'"use strict";',
'class Foo {',
' foo() {',
' ',
' ',
' }',
'',
' constructor(p1,',
' p2) {',
'',
' this.p1 = p1;',
' this.p2 = p2;',
' }',
'',
' bar(){}',
' static baz() {',
'}',
'}'
].join('\n');
var expected = [
'"use strict";',
'',
' Foo.prototype.foo=function() {',
' ',
' ',
' };',
'',
' function Foo(p1,',
' p2) {',
'',
' this.p1 = p1;',
' this.p2 = p2;',
' }',
'',
' Foo.prototype.bar=function(){};',
' Foo.baz=function() {',
'};',
''
].join('\n');
expect(transform(code)).toBe(expected);
});
it('preserves lines with inheritance from identifier', function() {
var code = [
'class Foo extends Bar {',
' foo() {',
' ',
' ',
' super(p1,',
' p2);',
' }',
'',
' constructor(p1,',
' p2) {',
'',
' this.p1 = p1;',
' this.p2 = p2;',
' super.blah(p1,',
' p2);',
' }',
'',
' bar(){}',
' static baz() {',
'}',
'}'
].join('\n');
var expected = [
'for(var Bar____Key in Bar){' +
'if(Bar.hasOwnProperty(Bar____Key)){' +
'Foo[Bar____Key]=Bar[Bar____Key];' +
'}' +
'}' +
'var ____SuperProtoOfBar=' +
'Bar===null' +
'?null:' +
'Bar.prototype;' +
'Foo.prototype=Object.create(____SuperProtoOfBar);' +
'Foo.prototype.constructor=Foo;' +
'Foo.__superConstructor__=Bar;',
' Foo.prototype.foo=function() {"use strict";',
' ',
' ',
' Bar.call(this,p1,',
' p2);',
' };',
'',
' function Foo(p1,',
' p2) {"use strict";',
'',
' this.p1 = p1;',
' this.p2 = p2;',
' ____SuperProtoOfBar.blah.call(this,p1,',
' p2);',
' }',
'',
' Foo.prototype.bar=function(){"use strict";};',
' Foo.baz=function() {"use strict";',
'};',
''
].join('\n');
expect(transform(code)).toBe(expected);
});
it('preserves lines with inheritance from expression', function() {
var code = [
'class Foo extends mixin(Bar, Baz) {',
' foo() {',
' ',
' ',
' }',
'',
' constructor(p1,',
' p2) {',
'',
' this.p1 = p1;',
' this.p2 = p2;',
' }',
'',
' bar(){}',
' static baz() {',
'}',
'}'
].join('\n');
var expected = [
'var ____Class0=mixin(Bar, Baz);' +
'for(var ____Class0____Key in ____Class0){' +
'if(____Class0.hasOwnProperty(____Class0____Key)){' +
'Foo[____Class0____Key]=____Class0[____Class0____Key];' +
'}' +
'}' +
'var ____SuperProtoOf____Class0=' +
'____Class0===null' +
'?null' +
':____Class0.prototype;' +
'Foo.prototype=Object.create(____SuperProtoOf____Class0);' +
'Foo.prototype.constructor=Foo;' +
'Foo.__superConstructor__=____Class0;',
' Foo.prototype.foo=function() {"use strict";',
' ',
' ',
' };',
'',
' function Foo(p1,',
' p2) {"use strict";',
'',
' this.p1 = p1;',
' this.p2 = p2;',
' }',
'',
' Foo.prototype.bar=function(){"use strict";};',
' Foo.baz=function() {"use strict";',
'};',
''
].join('\n');
expect(transform(code)).toBe(expected);
});
});
describe('functional tests', function() {
it('handles an empty body', function() {
var code = transform(
'class Foo {}'
);
eval(code);
var fooInst = new Foo();
expect(fooInst instanceof Foo).toBe(true);
});
it('handles constructors without params', function() {
var code = transform([
'class Foo {',
' constructor() {',
' this.test = "testValue";',
' }',
'}'
].join('\n'));
eval(code);
var fooInst = new Foo();
expect(fooInst.test).toBe('testValue');
});
it('handles constructors with params', function() {
var code = transform([
'class Foo {',
' constructor(p1, p2) {',
' this.p1 = p1;',
' this.p2 = p2;',
' }',
'}'
].join('\n'));
eval(code);
var fooInst = new Foo('a', 'b');
expect(fooInst.p1).toBe('a');
expect(fooInst.p2).toBe('b');
});
it('handles prototype methods without params', function() {
var code = transform([
'class Foo {',
' bar() {',
' return "stuff";',
' }',
'}'
].join('\n'));
eval(code);
var fooInst = new Foo();
expect(fooInst.bar()).toBe('stuff');
});
it('handles prototype methods with params', function() {
var code = transform([
'class Foo {',
' bar(p1, p2) {',
' this.p1 = p1;',
' this.p2 = p2;',
' }',
'}'
].join('\n'));
eval(code);
var fooInst = new Foo();
fooInst.bar('a', 'b');
expect(fooInst.p1).toBe('a');
expect(fooInst.p2).toBe('b');
});
it('handles static methods without params', function() {
var code = transform([
'class Foo {',
' static bar() {',
' return "stuff";',
' }',
'}'
].join('\n'));
eval(code);
expect(Foo.bar()).toBe('stuff');
var fooInst = new Foo();
expect(fooInst.bar).toBe(undefined);
});
it('handles static methods with params', function() {
var code = transform([
'class Foo {',
' static bar(p1, p2) {',
' return [p1, p2];',
' }',
'}'
].join('\n'));
eval(code);
expect(Foo.bar('a', 'b')).toEqual(['a', 'b']);
var fooInst = new Foo();
expect(fooInst.bar).toBe(undefined);
});
it('handles extension from an identifier', function() {
var code = transform([
'function Parent() {}',
'Parent.prototype.protoProp = "protoProp";',
'Parent.staticProp = "staticProp";',
'class Child extends Parent {}'
].join('\n'));
eval(code);
expect(Child.protoProp).toBe(undefined);
expect(Child.staticProp).toBe('staticProp');
var childInst = new Child();
expect(childInst instanceof Child).toBe(true);
expect(childInst instanceof Parent).toBe(true);
expect(childInst.protoProp).toBe('protoProp');
});
it('handles extension from an expression', function() {
var code = transform([
'function Parent1() {}',
'Parent1.prototype.protoProp = "protoProp";',
'Parent1.staticProp = "staticProp";',
'function Parent2() {}',
'class Child extends true ? Parent1 : Parent2 {}'
].join('\n'));
eval(code);
expect(Child.protoProp).toBe(undefined);
expect(Child.staticProp).toBe('staticProp');
var childInst = new Child();
expect(childInst instanceof Child).toBe(true);
expect(childInst instanceof Parent1).toBe(true);
expect(childInst.protoProp).toBe('protoProp');
expect(childInst.staticProp).toBe(undefined);
});
it('runs parent constructor when child constructor absent', function() {
var code = transform([
'class Parent {',
' constructor(p1, p2) {',
' this.p1 = p1;',
' this.p2 = p2;',
' }',
'}',
'class Child extends Parent {}'
].join('\n'));
eval(code);
var childInst = new Child('a', 'b');
expect(childInst.p1).toBe('a');
expect(childInst.p2).toBe('b');
});
it('sets constructor property to point at constructor func', function() {
var code = transform([
'class Parent {}',
'class Child extends Parent {}'
].join('\n'));
eval(code);
var childInst = new Child();
expect(childInst.constructor).toBe(Child);
});
it('handles super CallExpressions within constructors', function() {
var code = transform([
'class Parent {',
' constructor(p1, p2) {',
' this.p1 = p1;',
' this.p2 = p2;',
' }',
'}',
'class Child extends Parent {',
' constructor() {',
' super("a", "b");',
' this.childRan = true;',
' }',
'}'
].join('\n'));
eval(code);
var childInst = new Child();
expect(childInst.p1).toBe('a');
expect(childInst.p2).toBe('b');
expect(childInst.childRan).toBe(true);
});
it('handles super CallExpressions within proto methods', function() {
var code = transform([
'class Parent {',
' constructor(p1, p2) {',
' this.p1 = p1;',
' this.p2 = p2;',
' }',
'}',
'class Child extends Parent {',
' constructor() {}',
' bar() {',
' super("a", "b");',
' this.barRan = true;',
' }',
'}'
].join('\n'));
eval(code);
var childInst = new Child();
expect(childInst.p1).toBe(undefined);
expect(childInst.p2).toBe(undefined);
expect(childInst.barRan).toBe(undefined);
childInst.bar();
expect(childInst.p1).toBe('a');
expect(childInst.p2).toBe('b');
expect(childInst.barRan).toBe(true);
});
it('handles computed super MemberExpressions',
function() {
var code = transform([
'class Parent {',
' constructor() {',
' this.counter = 0;',
' }',
' incrementCounter(amount) {',
' this.counter += amount;',
' }',
'}',
'class Child extends Parent {',
' childIncrement() {',
' super["increment" + "Counter"](2);',
' }',
'}'
].join('\n'));
eval(code);
var childInst = new Child();
expect(childInst.counter).toBe(0);
childInst.childIncrement();
expect(childInst.counter).toBe(2);
});
it('handles simple super MemberExpression access', function() {
var code = transform([
'class Parent {',
' getFoo(p) {',
' return "foo" + p;',
' }',
'}',
'class Child extends Parent {',
' getChildFoo() {',
' var x = super.getFoo;',
' return x("bar");',
' }',
'}'
].join('\n'));
eval(code);
var childInst = new Child();
expect(childInst.getChildFoo()).toBe('foobar');
});
it('handles CallExpression on a super MemberExpression', function() {
var code = transform([
'class Parent {',
' getFoo(p) {',
' this.fooValue = "foo";',
' return this.fooValue + p;',
' }',
'}',
'class Child extends Parent {',
' getChildFoo() {',
' return super.getFoo.call(this, "bar");',
' }',
'}'
].join('\n'));
eval(code);
var childInst = new Child();
expect(childInst.getChildFoo()).toBe('foobar');
expect(childInst.fooValue).toBe('foo');
});
it('handles super MemberExpressions within constructors', function() {
var code = transform([
'class Parent {',
' setParams(p1, p2) {',
' this.p1 = p1;',
' this.p2 = p2;',
' }',
'}',
'class Child extends Parent {',
' constructor() {',
' super.setParams("a", "b");',
' }',
'}'
].join('\n'));
eval(code);
var childInst = new Child();
expect(childInst.p1).toBe('a');
expect(childInst.p2).toBe('b');
});
it('handles super MemberExpressions within proto methods', function() {
var code = transform([
'class Parent {',
' setParams(p1, p2) {',
' this.p1 = p1;',
' this.p2 = p2;',
' }',
'}',
'class Child extends Parent {',
' bar() {',
' super.setParams("a", "b");',
' this.barRan = true;',
' }',
'}'
].join('\n'));
eval(code);
var childInst = new Child();
expect(childInst.p1).toBe(undefined);
expect(childInst.p2).toBe(undefined);
expect(childInst.barRan).toBe(undefined);
childInst.bar();
expect(childInst.p1).toBe('a');
expect(childInst.p2).toBe('b');
expect(childInst.barRan).toBe(true);
});
it('consistently munges private property identifiers', function() {
var code = transform([
'class Foo {',
' constructor(p1) {',
' this._p1 = p1;',
' }',
' getP1() {',
' return this._p1;',
' }',
'}'
].join('\n'));
eval(code);
var fooInst = new Foo('a');
expect(fooInst._p1).toBe(undefined);
expect(fooInst.getP1()).toBe('a');
});
it('stores munged private properties on the instance', function() {
// Protects against subtle transform bugs like:
// `this._p1 = 42` -> `this$Foo_p1 = 42`
var code = transform([
'class Foo {',
' constructor(p1) {',
' this._p1 = p1;',
' }',
' getP1() {',
' return this._p1;',
' }',
'}'
].join('\n'));
eval(code);
var fooInst1 = new Foo('a');
var fooInst2 = new Foo('b');
expect(fooInst1.getP1()).toBe('a');
expect(fooInst2.getP1()).toBe('b');
});
it('consistently munges nested private property identifiers', function() {
var code = transform([
'class Foo {',
' constructor(p1) {',
' this._data = {_p1: null};',
' this._data._p1 = p1;',
' }',
' getData() {',
' return this._data;',
' }',
' getP1() {',
' return this._data._p1;',
' }',
'}'
].join('\n'));
eval(code);
var fooInst = new Foo('a');
expect(fooInst.getData()._p1).toBe(undefined);
expect(fooInst.getP1()).toBe('a');
});
it('consistently munges private method identifiers', function() {
var code = transform([
'class Foo {',
' getBar() {',
' return this._getBar();',
' }',
' _getBar() {',
' return 42;',
' }',
'}'
].join('\n'));
eval(code);
var fooInst = new Foo();
expect(fooInst._getBar).toBe(undefined);
expect(fooInst.getBar()).toBe(42);
});
it('consistently munges private method params', function() {
var code = transform([
'class Foo {',
' bar(_counter, _function) {',
' this.counter = _counter;',
' _function();',
' }',
'}'
].join('\n'));
eval(code);
var fooInst = new Foo();
var callbackCalled = false;
fooInst.bar(42, function() { callbackCalled = true; });
expect(fooInst.counter).toBe(42);
expect(callbackCalled).toBe(true);
});
it('consistently munges private idents in super call params', function() {
var code = transform([
'class Parent {',
' constructor(foo) {',
' this.foo = foo;',
' }',
' setBar(bar) {',
' this.bar = bar;',
' }',
'}',
'class Child extends Parent {',
' constructor(_foo, _bar) {',
' super(_foo);',
' super.setBar(_bar);',
' }',
'}'
].join('\n'));
eval(code);
var childInst = new Child('foo', 'bar');
expect(childInst.foo).toBe('foo');
expect(childInst.bar).toBe('bar');
});
it('consistently munges private idents in nested funcs', function() {
var code = transform([
'class Foo {',
' bar(_p1, p2) {',
' return function(_a) {',
' return [_p1, p2, _a];',
' };',
' }',
'}'
].join('\n'));
eval(code);
var fooInst = new Foo();
expect(fooInst.bar('a', 'b')('c')).toEqual(['a', 'b', 'c']);
});
it('does not munge dunder-scored properties', function() {
var code = transform([
'class Foo {',
' constructor(p1) {',
' this.__p1 = p1;',
' }',
'}'
].join('\n'));
eval(code);
var fooInst = new Foo('a');
expect(fooInst.__p1).toBe('a');
});
it('does not munge dunder-scored methods', function() {
var code = transform([
'class Foo {',
' __getBar() {',
' return 42;',
' }',
'}'
].join('\n'));
eval(code);
var fooInst = new Foo();
expect(fooInst.__getBar()).toBe(42);
});
it('properly handles private vars declared in outer scope', function() {
var code = transform([
'var _bar = "outer";',
'class Foo {',
' getOuterBar() {',
' return _bar;',
' }',
'}'
].join('\n'));
eval(code);
var fooInst = new Foo();
expect(fooInst.getOuterBar()).toBe('outer');
});
it('does not munge outer-declared private vars when used to calculate ' +
'a computed member expression', function() {
var code = transform([
'var _privateObjKey = "pvt";',
'var outerDataStore = {pvt: 42};',
'class Foo {',
' getStuff() {',
' return outerDataStore[_privateObjKey];',
' }',
'}'
].join('\n'));
eval(code);
var fooInst = new Foo();
expect(fooInst.getStuff()).toBe(42);
});
it('properly handles private vars declared in inner scope', function() {
var code = transform([
'var _bar = {_private: 42};',
'class Foo {',
' getBarPrivate(p1) {',
' var _bar = {_private: p1};',
' return _bar._private;',
' }',
'}'
].join('\n'));
eval(code);
var fooInst = new Foo();
expect(fooInst.getBarPrivate('a')).toBe('a');
});
it('munges properties of private vars declared out of scope', function() {
var code = transform([
'var _bar = {_private: 42}',
'class Foo {',
' getOuterPrivate() {',
' return _bar._private;',
' }',
'}'
].join('\n'));
eval(code);
var fooInst = new Foo();
expect(_bar._private).toBe(42);
expect(fooInst.getOuterPrivate()).toBe(undefined);
});
it('does not munge when @preventMunge is specified', function() {
var code = transform([
'/**',
' * @preventMunge',
' */',
'class Foo {',
' constructor(p1) {',
' this._p1 = p1;',
' }',
' _privateMethod() {',
' }',
'}'
].join('\n'));
eval(code);
var fooInst = new Foo('a');
expect(fooInst._p1).toBe('a');
expect(fooInst._privateMethod).not.toBe(undefined);
});
it('minifies private properties when minify opt is set', function() {
var code = transform([
'class Foo {',
' constructor(p1) {',
' this._p1 = p1;',
' }',
'}'
].join('\n'), {minify: true});
eval(code);
var fooInst = new Foo('a');
expect(fooInst.$Foo0).toBe('a');
});
it('minifies private methods when minify opt is set', function() {
var code = transform([
'class Foo {',
' _bar() {',
' return 42;',
' }',
'}'
].join('\n'), {minify: true});
eval(code);
var fooInst = new Foo();
expect(fooInst.$Foo0()).toBe(42);
});
it('munges child class different from parent in same file', function() {
var code = transform([
'class Parent {',
' setParentFoo(foo) {',
' this._foo = foo;',
' }',
' getParentFoo() {',
' return this._foo;',
' }',
'}',
'class Child extends Parent {',
' setChildFoo(foo) {',
' this._foo = foo;',
' }',
' getChildFoo() {',
' return this._foo;',
' }',
'}'
].join('\n'));
eval(code);
var childInst = new Child();
childInst.setParentFoo('parent');
childInst.setChildFoo('child');
expect(childInst.getParentFoo()).toBe('parent');
expect(childInst.getChildFoo()).toBe('child');
});
it('munges child class different from parent in other file', function() {
var code1 = transform([
'class Parent {',
' setParentFoo(foo) {',
' this._foo = foo;',
' }',
' getParentFoo() {',
' return this._foo;',
' }',
'}'
].join('\n'));
var code2 = transform([
'class Child extends Parent {',
' setChildFoo(foo) {',
' this._foo = foo;',
' }',
' getChildFoo() {',
' return this._foo;',
' }',
'}'
].join('\n'));
eval(code1);
eval(code2);
var childInst = new Child();
childInst.setParentFoo('parent');
childInst.setChildFoo('child');
expect(childInst.getParentFoo()).toBe('parent');
expect(childInst.getChildFoo()).toBe('child');
});
it('makes class methods implicitly "use strict"', function() {
var code = transform([
'class Foo {',
' constructor() {',
' this.constructorIsStrict = ' +
'(function() {return this === undefined;})();',
' }',
' protoFn() {',
' return (function() {return this === undefined;})();',
' }',
' static staticFn() {',
' return (function() {return this === undefined;})();',
' }',
'}'
].join('\n'));
eval(code);
var fooInst = new Foo();
expect(fooInst.constructorIsStrict).toBe(true);
expect(fooInst.protoFn()).toBe(true);
expect(Foo.staticFn()).toBe(true);
});
});
});
describe('ClassExpressions', function() {
describe('preserves line numbers', function() {
it('preserves lines with no inheritance', function() {
var code = [
'var Foo = class {',
' foo() {',
' ',
' ',
' }',
'',
' constructor(p1,',
' p2) {',
'',
' this.p1 = p1;',
' this.p2 = p2;',
' }',
'',
' bar(){}',
' static baz() {',
'}',
'}'
].join('\n');
var expected = [
'var Foo = (function(){',
' ____Class0.prototype.foo=function() {"use strict";',
' ',
' ',
' };',
'',
' function ____Class0(p1,',
' p2) {"use strict";',
'',
' this.p1 = p1;',
' this.p2 = p2;',
' }',
'',
' ____Class0.prototype.bar=function(){"use strict";};',
' ____Class0.baz=function() {"use strict";',
'};',
'return ____Class0;})()'
].join('\n');
expect(transform(code)).toBe(expected);
});
it('preserves lines with inheritance from identifier', function() {
var code = [
'var Foo = class extends Bar {',
' foo() {',
' ',
' ',
' super(p1,',
' p2);',
' }',
'',
' constructor(p1,',
' p2) {',
'',
' this.p1 = p1;',
' this.p2 = p2;',
' super.blah(p1,',
' p2);',
' }',
'',
' bar(){}',
' static baz() {',
'}',
'}'
].join('\n');
var expected = [
'var Foo = (function(){' +
'for(var Bar____Key in Bar){' +
'if(Bar.hasOwnProperty(Bar____Key)){' +
'____Class0[Bar____Key]=Bar[Bar____Key];' +
'}' +
'}' +
'var ____SuperProtoOfBar=' +
'Bar===null' +
'?null' +
':Bar.prototype;' +
'____Class0.prototype=Object.create(____SuperProtoOfBar);' +
'____Class0.prototype.constructor=____Class0;' +
'____Class0.__superConstructor__=Bar;',
' ____Class0.prototype.foo=function() {"use strict";',
' ',
' ',
' Bar.call(this,p1,',
' p2);',
' };',
'',
' function ____Class0(p1,',
' p2) {"use strict";',
'',
' this.p1 = p1;',
' this.p2 = p2;',
' ____SuperProtoOfBar.blah.call(this,p1,',
' p2);',
' }',
'',
' ____Class0.prototype.bar=function(){"use strict";};',
' ____Class0.baz=function() {"use strict";',
'};',
'return ____Class0;})()'
].join('\n');
expect(transform(code)).toBe(expected);
});
it('preserves lines with inheritance from expression', function() {
var code = [
'var Foo = class extends mixin(Bar, Baz) {',
' foo() {',
' ',
' ',
' }',
'',
' constructor(p1,',
' p2) {',
'',
' this.p1 = p1;',
' this.p2 = p2;',
' }',
'',
' bar(){}',
' static baz() {',
'}',
'}'
].join('\n');
var expected = [
'var Foo = (function(){' +
'var ____Class1=mixin(Bar, Baz);' +
'for(var ____Class1____Key in ____Class1){' +
'if(____Class1.hasOwnProperty(____Class1____Key)){' +
'____Class0[____Class1____Key]=____Class1[____Class1____Key];' +
'}' +
'}' +
'var ____SuperProtoOf____Class1=' +
'____Class1===null' +
'?null' +
':____Class1.prototype;' +
'____Class0.prototype=Object.create(____SuperProtoOf____Class1);' +
'____Class0.prototype.constructor=____Class0;' +
'____Class0.__superConstructor__=____Class1;',
' ____Class0.prototype.foo=function() {"use strict";',
' ',
' ',
' };',
'',
' function ____Class0(p1,',
' p2) {"use strict";',
'',
' this.p1 = p1;',
' this.p2 = p2;',
' }',
'',
' ____Class0.prototype.bar=function(){"use strict";};',
' ____Class0.baz=function() {"use strict";',
'};',
'return ____Class0;})()'
].join('\n');
expect(transform(code)).toBe(expected);
});
});
describe('functional tests', function() {
it('scopes each anonymous class separately', function() {
var code = transform([
'var Foo = class {',
' constructor() {',
' this._name = "foo";',
' var properties = [];',
' for (var key in this) {',
' properties.push(key);',
' }',
' this.properties = properties',
' }',
'};',
'var Bar = class {',
' constructor() {',
' this._name = "bar";',
' var properties = [];',
' for (var key in this) {',
' properties.push(key);',
' }',
' this.properties = properties',
' }',
'}'
].join('\n'));
eval(code);
var fooInst = new Foo();
var barInst = new Bar();
expect(fooInst.properties).not.toEqual(barInst.properties);
expect(fooInst[fooInst.properties[0]]).toBe('foo');
expect(barInst[barInst.properties[0]]).toBe('bar');
});
});
});
});
``` | /content/code_sandbox/node_modules/jstransform/visitors/__tests__/es6-class-visitors-test.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 7,689 |
```javascript
/**
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
/*jslint node: true*/
/**
* A `state` object represents the state of the parser. It has "local" and
* "global" parts. Global contains parser position, source, etc. Local contains
* scope based properties like current class name. State should contain all the
* info required for transformation. It's the only mandatory object that is
* being passed to every function in transform chain.
*
* @param {string} source
* @param {object} transformOptions
* @return {object}
*/
function createState(source, rootNode, transformOptions) {
return {
/**
* A tree representing the current local scope (and its lexical scope chain)
* Useful for tracking identifiers from parent scopes, etc.
* @type {Object}
*/
localScope: {
parentNode: rootNode,
parentScope: null,
identifiers: {}
},
/**
* The name (and, if applicable, expression) of the super class
* @type {Object}
*/
superClass: null,
/**
* The namespace to use when munging identifiers
* @type {String}
*/
mungeNamespace: '',
/**
* Ref to the node for the FunctionExpression of the enclosing
* MethodDefinition
* @type {Object}
*/
methodFuncNode: null,
/**
* Name of the enclosing class
* @type {String}
*/
className: null,
/**
* Whether we're currently within a `strict` scope
* @type {Bool}
*/
scopeIsStrict: null,
/**
* Global state (not affected by updateState)
* @type {Object}
*/
g: {
/**
* A set of general options that transformations can consider while doing
* a transformation:
*
* - minify
* Specifies that transformation steps should do their best to minify
* the output source when possible. This is useful for places where
* minification optimizations are possible with higher-level context
* info than what jsxmin can provide.
*
* For example, the ES6 class transform will minify munged private
* variables if this flag is set.
*/
opts: transformOptions,
/**
* Current position in the source code
* @type {Number}
*/
position: 0,
/**
* Buffer containing the result
* @type {String}
*/
buffer: '',
/**
* Indentation offset (only negative offset is supported now)
* @type {Number}
*/
indentBy: 0,
/**
* Source that is being transformed
* @type {String}
*/
source: source,
/**
* Cached parsed docblock (see getDocblock)
* @type {object}
*/
docblock: null,
/**
* Whether the thing was used
* @type {Boolean}
*/
tagNamespaceUsed: false,
/**
* If using bolt xjs transformation
* @type {Boolean}
*/
isBolt: undefined,
/**
* Whether to record source map (expensive) or not
* @type {SourceMapGenerator|null}
*/
sourceMap: null,
/**
* Filename of the file being processed. Will be returned as a source
* attribute in the source map
*/
sourceMapFilename: 'source.js',
/**
* Only when source map is used: last line in the source for which
* source map was generated
* @type {Number}
*/
sourceLine: 1,
/**
* Only when source map is used: last line in the buffer for which
* source map was generated
* @type {Number}
*/
bufferLine: 1,
/**
* The top-level Program AST for the original file.
*/
originalProgramAST: null,
sourceColumn: 0,
bufferColumn: 0
}
};
}
/**
* Updates a copy of a given state with "update" and returns an updated state.
*
* @param {object} state
* @param {object} update
* @return {object}
*/
function updateState(state, update) {
var ret = Object.create(state);
Object.keys(update).forEach(function(updatedKey) {
ret[updatedKey] = update[updatedKey];
});
return ret;
}
/**
* Given a state fill the resulting buffer from the original source up to
* the end
*
* @param {number} end
* @param {object} state
* @param {?function} contentTransformer Optional callback to transform newly
* added content.
*/
function catchup(end, state, contentTransformer) {
if (end < state.g.position) {
// cannot move backwards
return;
}
var source = state.g.source.substring(state.g.position, end);
var transformed = updateIndent(source, state);
if (state.g.sourceMap && transformed) {
// record where we are
state.g.sourceMap.addMapping({
generated: { line: state.g.bufferLine, column: state.g.bufferColumn },
original: { line: state.g.sourceLine, column: state.g.sourceColumn },
source: state.g.sourceMapFilename
});
// record line breaks in transformed source
var sourceLines = source.split('\n');
var transformedLines = transformed.split('\n');
// Add line break mappings between last known mapping and the end of the
// added piece. So for the code piece
// (foo, bar);
// > var x = 2;
// > var b = 3;
// var c =
// only add lines marked with ">": 2, 3.
for (var i = 1; i < sourceLines.length - 1; i++) {
state.g.sourceMap.addMapping({
generated: { line: state.g.bufferLine, column: 0 },
original: { line: state.g.sourceLine, column: 0 },
source: state.g.sourceMapFilename
});
state.g.sourceLine++;
state.g.bufferLine++;
}
// offset for the last piece
if (sourceLines.length > 1) {
state.g.sourceLine++;
state.g.bufferLine++;
state.g.sourceColumn = 0;
state.g.bufferColumn = 0;
}
state.g.sourceColumn += sourceLines[sourceLines.length - 1].length;
state.g.bufferColumn +=
transformedLines[transformedLines.length - 1].length;
}
state.g.buffer +=
contentTransformer ? contentTransformer(transformed) : transformed;
state.g.position = end;
}
/**
* Removes all non-whitespace characters
*/
var reNonWhite = /(\S)/g;
function stripNonWhite(value) {
return value.replace(reNonWhite, function() {
return '';
});
}
/**
* Catches up as `catchup` but removes all non-whitespace characters.
*/
function catchupWhiteSpace(end, state) {
catchup(end, state, stripNonWhite);
}
/**
* Removes all non-newline characters
*/
var reNonNewline = /[^\n]/g;
function stripNonNewline(value) {
return value.replace(reNonNewline, function() {
return '';
});
}
/**
* Catches up as `catchup` but removes all non-newline characters.
*
* Equivalent to appending as many newlines as there are in the original source
* between the current position and `end`.
*/
function catchupNewlines(end, state) {
catchup(end, state, stripNonNewline);
}
/**
* Same as catchup but does not touch the buffer
*
* @param {number} end
* @param {object} state
*/
function move(end, state) {
// move the internal cursors
if (state.g.sourceMap) {
if (end < state.g.position) {
state.g.position = 0;
state.g.sourceLine = 1;
state.g.sourceColumn = 0;
}
var source = state.g.source.substring(state.g.position, end);
var sourceLines = source.split('\n');
if (sourceLines.length > 1) {
state.g.sourceLine += sourceLines.length - 1;
state.g.sourceColumn = 0;
}
state.g.sourceColumn += sourceLines[sourceLines.length - 1].length;
}
state.g.position = end;
}
/**
* Appends a string of text to the buffer
*
* @param {string} str
* @param {object} state
*/
function append(str, state) {
if (state.g.sourceMap && str) {
state.g.sourceMap.addMapping({
generated: { line: state.g.bufferLine, column: state.g.bufferColumn },
original: { line: state.g.sourceLine, column: state.g.sourceColumn },
source: state.g.sourceMapFilename
});
var transformedLines = str.split('\n');
if (transformedLines.length > 1) {
state.g.bufferLine += transformedLines.length - 1;
state.g.bufferColumn = 0;
}
state.g.bufferColumn +=
transformedLines[transformedLines.length - 1].length;
}
state.g.buffer += str;
}
/**
* Update indent using state.indentBy property. Indent is measured in
* double spaces. Updates a single line only.
*
* @param {string} str
* @param {object} state
* @return {string}
*/
function updateIndent(str, state) {
for (var i = 0; i < -state.g.indentBy; i++) {
str = str.replace(/(^|\n)( {2}|\t)/g, '$1');
}
return str;
}
/**
* Calculates indent from the beginning of the line until "start" or the first
* character before start.
* @example
* " foo.bar()"
* ^
* start
* indent will be 2
*
* @param {number} start
* @param {object} state
* @return {number}
*/
function indentBefore(start, state) {
var end = start;
start = start - 1;
while (start > 0 && state.g.source[start] != '\n') {
if (!state.g.source[start].match(/[ \t]/)) {
end = start;
}
start--;
}
return state.g.source.substring(start + 1, end);
}
function getDocblock(state) {
if (!state.g.docblock) {
var docblock = require('./docblock');
state.g.docblock =
docblock.parseAsObject(docblock.extract(state.g.source));
}
return state.g.docblock;
}
function identWithinLexicalScope(identName, state, stopBeforeNode) {
var currScope = state.localScope;
while (currScope) {
if (currScope.identifiers[identName] !== undefined) {
return true;
}
if (stopBeforeNode && currScope.parentNode === stopBeforeNode) {
break;
}
currScope = currScope.parentScope;
}
return false;
}
function identInLocalScope(identName, state) {
return state.localScope.identifiers[identName] !== undefined;
}
function declareIdentInLocalScope(identName, state) {
state.localScope.identifiers[identName] = true;
}
/**
* Apply the given analyzer function to the current node. If the analyzer
* doesn't return false, traverse each child of the current node using the given
* traverser function.
*
* @param {function} analyzer
* @param {function} traverser
* @param {object} node
* @param {function} visitor
* @param {array} path
* @param {object} state
*/
function analyzeAndTraverse(analyzer, traverser, node, path, state) {
var key, child;
if (node.type) {
if (analyzer(node, path, state) === false) {
return;
}
path.unshift(node);
}
for (key in node) {
// skip obviously wrong attributes
if (key === 'range' || key === 'loc') {
continue;
}
if (node.hasOwnProperty(key)) {
child = node[key];
if (typeof child === 'object' && child !== null) {
traverser(child, path, state);
}
}
}
node.type && path.shift();
}
/**
* Checks whether a node or any of its sub-nodes contains
* a syntactic construct of the passed type.
* @param {object} node - AST node to test.
* @param {string} type - node type to lookup.
*/
function containsChildOfType(node, type) {
var foundMatchingChild = false;
function nodeTypeAnalyzer(node) {
if (node.type === type) {
foundMatchingChild = true;
return false;
}
}
function nodeTypeTraverser(child, path, state) {
if (!foundMatchingChild) {
foundMatchingChild = containsChildOfType(child, type);
}
}
analyzeAndTraverse(
nodeTypeAnalyzer,
nodeTypeTraverser,
node,
[]
);
return foundMatchingChild;
}
exports.append = append;
exports.catchup = catchup;
exports.catchupWhiteSpace = catchupWhiteSpace;
exports.catchupNewlines = catchupNewlines;
exports.containsChildOfType = containsChildOfType;
exports.createState = createState;
exports.declareIdentInLocalScope = declareIdentInLocalScope;
exports.getDocblock = getDocblock;
exports.identWithinLexicalScope = identWithinLexicalScope;
exports.identInLocalScope = identInLocalScope;
exports.indentBefore = indentBefore;
exports.move = move;
exports.updateIndent = updateIndent;
exports.updateState = updateState;
exports.analyzeAndTraverse = analyzeAndTraverse;
``` | /content/code_sandbox/node_modules/jstransform/src/utils.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 3,050 |
```javascript
'use strict';
var acorn = require('acorn');
var walk = require('acorn/dist/walk');
function isScope(node) {
return node.type === 'FunctionExpression' || node.type === 'FunctionDeclaration' || node.type === 'ArrowFunctionExpression' || node.type === 'Program';
}
function isBlockScope(node) {
return node.type === 'BlockStatement' || isScope(node);
}
function declaresArguments(node) {
return node.type === 'FunctionExpression' || node.type === 'FunctionDeclaration';
}
function declaresThis(node) {
return node.type === 'FunctionExpression' || node.type === 'FunctionDeclaration';
}
function reallyParse(source) {
try {
return acorn.parse(source, {
ecmaVersion: 6,
allowReturnOutsideFunction: true,
allowImportExportEverywhere: true,
allowHashBang: true
});
} catch (ex) {
return acorn.parse(source, {
ecmaVersion: 5,
allowReturnOutsideFunction: true,
allowImportExportEverywhere: true,
allowHashBang: true
});
}
}
module.exports = findGlobals;
module.exports.parse = reallyParse;
function findGlobals(source) {
var globals = [];
var ast;
// istanbul ignore else
if (typeof source === 'string') {
ast = reallyParse(source);
} else {
ast = source;
}
// istanbul ignore if
if (!(ast && typeof ast === 'object' && ast.type === 'Program')) {
throw new TypeError('Source must be either a string of JavaScript or an acorn AST');
}
var declareFunction = function (node) {
var fn = node;
fn.locals = fn.locals || {};
node.params.forEach(function (node) {
declarePattern(node, fn);
});
if (node.id) {
fn.locals[node.id.name] = true;
}
}
var declarePattern = function (node, parent) {
switch (node.type) {
case 'Identifier':
parent.locals[node.name] = true;
break;
case 'ObjectPattern':
node.properties.forEach(function (node) {
declarePattern(node.value, parent);
});
break;
case 'ArrayPattern':
node.elements.forEach(function (node) {
if (node) declarePattern(node, parent);
});
break;
case 'RestElement':
declarePattern(node.argument, parent);
break;
case 'AssignmentPattern':
declarePattern(node.left, parent);
break;
// istanbul ignore next
default:
throw new Error('Unrecognized pattern type: ' + node.type);
}
}
var declareModuleSpecifier = function (node, parents) {
ast.locals = ast.locals || {};
ast.locals[node.local.name] = true;
}
walk.ancestor(ast, {
'VariableDeclaration': function (node, parents) {
var parent = null;
for (var i = parents.length - 1; i >= 0 && parent === null; i--) {
if (node.kind === 'var' ? isScope(parents[i]) : isBlockScope(parents[i])) {
parent = parents[i];
}
}
parent.locals = parent.locals || {};
node.declarations.forEach(function (declaration) {
declarePattern(declaration.id, parent);
});
},
'FunctionDeclaration': function (node, parents) {
var parent = null;
for (var i = parents.length - 2; i >= 0 && parent === null; i--) {
if (isScope(parents[i])) {
parent = parents[i];
}
}
parent.locals = parent.locals || {};
parent.locals[node.id.name] = true;
declareFunction(node);
},
'Function': declareFunction,
'ClassDeclaration': function (node, parents) {
var parent = null;
for (var i = parents.length - 2; i >= 0 && parent === null; i--) {
if (isScope(parents[i])) {
parent = parents[i];
}
}
parent.locals = parent.locals || {};
parent.locals[node.id.name] = true;
},
'TryStatement': function (node) {
if (node.handler === null) return;
node.handler.body.locals = node.handler.body.locals || {};
node.handler.body.locals[node.handler.param.name] = true;
},
'ImportDefaultSpecifier': declareModuleSpecifier,
'ImportSpecifier': declareModuleSpecifier,
'ImportNamespaceSpecifier': declareModuleSpecifier
});
function identifier(node, parents) {
var name = node.name;
if (name === 'undefined') return;
for (var i = 0; i < parents.length; i++) {
if (name === 'arguments' && declaresArguments(parents[i])) {
return;
}
if (parents[i].locals && name in parents[i].locals) {
return;
}
}
if (
parents[parents.length - 2] &&
parents[parents.length - 2].type === 'TryStatement' &&
parents[parents.length - 2].handler &&
node === parents[parents.length - 2].handler.param
) {
return;
}
node.parents = parents;
globals.push(node);
}
walk.ancestor(ast, {
'VariablePattern': identifier,
'Identifier': identifier,
'ThisExpression': function (node, parents) {
for (var i = 0; i < parents.length; i++) {
if (declaresThis(parents[i])) {
return;
}
}
node.parents = parents;
globals.push(node);
}
});
var groupedGlobals = {};
globals.forEach(function (node) {
groupedGlobals[node.name] = (groupedGlobals[node.name] || []);
groupedGlobals[node.name].push(node);
});
return Object.keys(groupedGlobals).sort().map(function (name) {
return {name: name, nodes: groupedGlobals[name]};
});
}
``` | /content/code_sandbox/node_modules/acorn-globals/index.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 1,289 |
```javascript
/**
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
* @emails jeffmo@fb.com javascript@lists.facebook.com
*/
require('mock-modules').autoMockOff();
describe('jstransform', function() {
var transformFn;
var Syntax = require('esprima-fb').Syntax;
beforeEach(function() {
require('mock-modules').dumpCache();
transformFn = require('../jstransform').transform;
});
function _runVisitor(source, nodeCount, visitor) {
var actualVisitationCount = 0;
function shimVisitor(traverse, node, path, state) {
actualVisitationCount++;
return visitor(traverse, node, path, state);
}
shimVisitor.test = visitor.test;
transformFn([shimVisitor], source);
expect(actualVisitationCount).toBe(nodeCount);
}
function testScopeBoundary(source, localIdents, nodeCount, visitorTest) {
function visitor(traverse, node, path, state) {
var actualLocalIdents = Object.keys(state.localScope.identifiers);
expect(actualLocalIdents.sort()).toEqual(localIdents.sort());
}
visitor.test = visitorTest;
_runVisitor(source, nodeCount, visitor);
}
function testParentScope(source, parentIdents, nodeCount, visitorTest) {
function visitor(traverse, node, path, state) {
parentIdents = parentIdents && parentIdents.sort();
var parentScope = state.localScope.parentScope;
var actualParentIdents =
parentScope && Object.keys(parentScope.identifiers).sort();
expect(actualParentIdents).toEqual(parentIdents);
}
visitor.test = visitorTest;
_runVisitor(source, nodeCount, visitor);
}
describe('closure scope boundaries', function() {
it('creates a scope boundary around Program scope', function() {
var source =
'var foo;' +
'var bar, baz;' +
'function blah() {}';
var idents = ['foo', 'bar', 'baz', 'blah'];
testScopeBoundary(source, idents, 3, function(node, path, state) {
return path[0] && path[0].type === Syntax.Program;
});
});
it('creates a scope boundary around FunctionDeclarations', function() {
var source =
'var foo;' +
'function blah() {' +
' var bar;' +
' function nested() {' +
' var baz;' +
' }' +
'}';
var programIdents = ['foo', 'blah'];
var blahIdents = ['arguments', 'bar', 'nested'];
var nestedIdents = ['arguments', 'baz'];
testScopeBoundary(source, programIdents, 2, function(node, path, state) {
return path[0] && path[0].type === Syntax.Program;
});
testScopeBoundary(source, blahIdents, 2, function(node, path, state) {
// All direct children of blah()
return path[0] && path[0].type === Syntax.BlockStatement &&
path[1] && path[1].type === Syntax.FunctionDeclaration &&
path[1].id.name === 'blah';
});
testScopeBoundary(source, nestedIdents, 1, function(node, path, state) {
// All direct children of nested()
return path[0] && path[0].type === Syntax.BlockStatement &&
path[1] && path[1].type === Syntax.FunctionDeclaration &&
path[1].id.name === 'nested';
});
});
it('creates a scope boundary around MethodDefinitions', function() {
var source =
'var foo;' +
'class ClassA {' +
' blah() {' +
' var bar;' +
' }' +
' another() {' +
' var baz;' +
' }' +
'}';
var programIdents = ['foo', 'ClassA'];
var blahIdents = ['arguments', 'bar'];
var anotherIdents = ['arguments', 'baz'];
testScopeBoundary(source, programIdents, 2, function(node, path, state) {
return path[0] && path[0].type === Syntax.Program;
});
testScopeBoundary(source, blahIdents, 1, function(node, path, state) {
// All direct children of blah()
return path[0] && path[0].type === Syntax.BlockStatement &&
path[1] && path[1].type === Syntax.FunctionExpression &&
path[2] && path[2].type === Syntax.MethodDefinition &&
path[2].key.name === 'blah';
});
testScopeBoundary(source, anotherIdents, 1, function(node, path, state) {
// All direct children of another()
return path[0] && path[0].type === Syntax.BlockStatement &&
path[1] && path[1].type === Syntax.FunctionExpression &&
path[2] && path[2].type === Syntax.MethodDefinition &&
path[2].key.name === 'another';
});
});
it('uses VariableDeclarations to determine scope boundary', function() {
var source =
'var foo = 1;' +
'function bar() {' +
' foo++;' +
' function baz() {' +
' var foo = 2;' +
' }' +
'}';
var programIdents = ['foo', 'bar'];
var barIdents = ['arguments', 'baz'];
var bazIdents = ['arguments', 'foo'];
testScopeBoundary(source, programIdents, 2, function(node, path, state) {
return path[0] && path[0].type === Syntax.Program;
});
testScopeBoundary(source, barIdents, 2, function(node, path, state) {
// All direct children of blah()
return path[0] && path[0].type === Syntax.BlockStatement &&
path[1] && path[1].type === Syntax.FunctionDeclaration &&
path[1].id.name === 'bar';
});
testScopeBoundary(source, bazIdents, 1, function(node, path, state) {
// All direct children of baz()
return path[0] && path[0].type === Syntax.BlockStatement &&
path[1] && path[1].type === Syntax.FunctionDeclaration &&
path[1].id.name === 'baz';
});
});
it('includes function args in functions scope boundary', function() {
var source =
'var foo;' +
'function blah(bar) {' +
' var baz;' +
'}';
var programIdents = ['foo', 'blah'];
var blahIdents = ['arguments', 'bar', 'baz'];
testScopeBoundary(source, programIdents, 2, function(node, path, state) {
return path[0] && path[0].type === Syntax.Program;
});
testScopeBoundary(source, blahIdents, 1, function(node, path, state) {
// All direct children of blah()
return path[0] && path[0].type === Syntax.BlockStatement &&
path[1] && path[1].type === Syntax.FunctionDeclaration &&
path[1].id.name === 'blah';
});
});
it('puts FunctionExpression names within function scope', function() {
var source =
'var foo;' +
'var bar = function baz() {' +
' var blah;' +
'};';
var programIdents = ['foo', 'bar'];
var bazIdents = ['arguments', 'baz', 'blah'];
testScopeBoundary(source, programIdents, 2, function(node, path, state) {
return path[0] && path[0].type === Syntax.Program;
});
testScopeBoundary(source, bazIdents, 1, function(node, path, state) {
// All direct children of baz()
return path[0] && path[0].type === Syntax.BlockStatement &&
path[1] && path[1].type === Syntax.FunctionExpression &&
path[1].id.name === 'baz';
});
});
});
describe('block scope boundaries', function() {
it('creates a scope boundary around CatchClauses with params', function() {
var source =
'var blah = 0;' +
'try {' +
'} catch (e) {' +
' blah++;' +
'}';
var programIdents = ['blah'];
var catchIdents = ['e'];
testScopeBoundary(source, programIdents, 2, function(node, path, state) {
return path[0] && path[0].type === Syntax.Program;
});
testScopeBoundary(source, catchIdents, 1, function(node, path, state) {
// All direct children of catch(e) block
return path[0] && path[0].type === Syntax.BlockStatement &&
path[1] && path[1].type === Syntax.CatchClause;
});
});
it('includes vars defined in CatchClauses in the parent scope', function() {
var source =
'try {' +
'} catch (e) {' +
' var blah;' +
'}';
var programIdents = ['blah'];
var catchIdents = ['e'];
testScopeBoundary(source, programIdents, 1, function(node, path, state) {
return path[0] && path[0].type === Syntax.Program;
});
testScopeBoundary(source, catchIdents, 1, function(node, path, state) {
// All direct children of catch(e) block
return path[0] && path[0].type === Syntax.BlockStatement &&
path[1] && path[1].type === Syntax.CatchClause;
});
});
});
describe('scope chain linking', function() {
it('links parent scope boundaries', function() {
var source =
'var foo;' +
'function blah() {' +
' var bar;' +
' function nested() {' +
' var baz;' +
' }' +
'}';
var programIdents = ['foo', 'blah'];
var blahIdents = ['arguments', 'bar', 'nested'];
testParentScope(source, programIdents, 2, function(node, path, state) {
// All direct children of blah()
return path[0] && path[0].type === Syntax.BlockStatement &&
path[1] && path[1].type === Syntax.FunctionDeclaration &&
path[1].id.name === 'blah';
});
testParentScope(source, blahIdents, 1, function(node, path, state) {
// All direct children of nested()
return path[0] && path[0].type === Syntax.BlockStatement &&
path[1] && path[1].type === Syntax.FunctionDeclaration &&
path[1].id.name === 'nested';
});
});
it('nests MethodDefinition boundaries under parent scope', function() {
var source =
'var foo;' +
'class ClassA {' +
' blah() {' +
' var bar;' +
' }' +
'}';
var programIdents = ['foo', 'ClassA'];
testParentScope(source, programIdents, 1, function(node, path, state) {
// All direct children of blah()
return path[0] && path[0].type === Syntax.BlockStatement &&
path[1] && path[1].type === Syntax.FunctionExpression &&
path[2] && path[2].type === Syntax.MethodDefinition &&
path[2].key.name === 'blah';
});
});
});
describe('"use strict" tracking', function() {
function testStrictness(expectedStrict, source) {
var visitedNodes = 0;
function visitor(traverse, node, path, state) {
visitedNodes++;
expect(state.scopeIsStrict).toBe(expectedStrict);
}
visitor.test = function(node, path, state) {
return node.type === Syntax.Literal
&& node.value === 'testStr';
};
transformFn([visitor], source);
expect(visitedNodes).toBe(1);
}
it('detects program-level strictness', function() {
testStrictness(false, '"testStr";');
testStrictness(true, '"use strict"; "testStr";');
});
it('detects non-inherited strictness', function() {
testStrictness(true, [
'function foo() {',
' "use strict";',
' "testStr";',
'}'
].join('\n'));
});
it('detects program-inherited strictness', function() {
testStrictness(true, [
'"use strict";',
'function foo() {',
' "testStr";',
'}'
].join('\n'));
});
it('detects function-inherited strictness', function() {
testStrictness(true, [
'function foo() {',
' "use strict";',
' function bar() {',
' "testStr";',
' }',
'}'
].join('\n'));
});
it('does not detect sibling strictness', function() {
testStrictness(false, [
'function foo() {',
' "use strict";',
'}',
'function bar() {',
' "testStr";',
'}'
].join('\n'));
});
});
});
``` | /content/code_sandbox/node_modules/jstransform/src/__tests__/jstransform-test.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 2,966 |
```javascript
const Benchmark = require('benchmark')
const suite = new Benchmark.Suite()
const { inspect } = require('util')
const jsonStringifySafe = require('json-stringify-safe')
const fastSafeStringify = require('./')
const array = new Array(10).fill(0).map((_, i) => i)
const obj = { foo: array }
const circ = JSON.parse(JSON.stringify(obj))
circ.o = { obj: circ, array }
const circGetters = JSON.parse(JSON.stringify(obj))
Object.assign(circGetters, { get o () { return { obj: circGetters, array } } })
const deep = require('./package.json')
deep.deep = JSON.parse(JSON.stringify(deep))
deep.deep.deep = JSON.parse(JSON.stringify(deep))
deep.deep.deep.deep = JSON.parse(JSON.stringify(deep))
deep.array = array
const deepCirc = JSON.parse(JSON.stringify(deep))
deepCirc.deep.deep.deep.circ = deepCirc
deepCirc.deep.deep.circ = deepCirc
deepCirc.deep.circ = deepCirc
deepCirc.array = array
const deepCircGetters = JSON.parse(JSON.stringify(deep))
for (let i = 0; i < 10; i++) {
deepCircGetters[i.toString()] = {
deep: {
deep: {
get circ () { return deep.deep },
deep: { get circ () { return deep.deep.deep } }
},
get circ () { return deep }
},
get array () { return array }
}
}
const deepCircNonCongifurableGetters = JSON.parse(JSON.stringify(deep))
Object.defineProperty(deepCircNonCongifurableGetters.deep.deep.deep, 'circ', {
get: () => deepCircNonCongifurableGetters,
enumerable: true,
configurable: false
})
Object.defineProperty(deepCircNonCongifurableGetters.deep.deep, 'circ', {
get: () => deepCircNonCongifurableGetters,
enumerable: true,
configurable: false
})
Object.defineProperty(deepCircNonCongifurableGetters.deep, 'circ', {
get: () => deepCircNonCongifurableGetters,
enumerable: true,
configurable: false
})
Object.defineProperty(deepCircNonCongifurableGetters, 'array', {
get: () => array,
enumerable: true,
configurable: false
})
suite.add('util.inspect: simple object ', function () {
inspect(obj, { showHidden: false, depth: null })
})
suite.add('util.inspect: circular ', function () {
inspect(circ, { showHidden: false, depth: null })
})
suite.add('util.inspect: circular getters ', function () {
inspect(circGetters, { showHidden: false, depth: null })
})
suite.add('util.inspect: deep ', function () {
inspect(deep, { showHidden: false, depth: null })
})
suite.add('util.inspect: deep circular ', function () {
inspect(deepCirc, { showHidden: false, depth: null })
})
suite.add('util.inspect: large deep circular getters ', function () {
inspect(deepCircGetters, { showHidden: false, depth: null })
})
suite.add('util.inspect: deep non-conf circular getters', function () {
inspect(deepCircNonCongifurableGetters, { showHidden: false, depth: null })
})
suite.add('\njson-stringify-safe: simple object ', function () {
jsonStringifySafe(obj)
})
suite.add('json-stringify-safe: circular ', function () {
jsonStringifySafe(circ)
})
suite.add('json-stringify-safe: circular getters ', function () {
jsonStringifySafe(circGetters)
})
suite.add('json-stringify-safe: deep ', function () {
jsonStringifySafe(deep)
})
suite.add('json-stringify-safe: deep circular ', function () {
jsonStringifySafe(deepCirc)
})
suite.add('json-stringify-safe: large deep circular getters ', function () {
jsonStringifySafe(deepCircGetters)
})
suite.add('json-stringify-safe: deep non-conf circular getters', function () {
jsonStringifySafe(deepCircNonCongifurableGetters)
})
suite.add('\nfast-safe-stringify: simple object ', function () {
fastSafeStringify(obj)
})
suite.add('fast-safe-stringify: circular ', function () {
fastSafeStringify(circ)
})
suite.add('fast-safe-stringify: circular getters ', function () {
fastSafeStringify(circGetters)
})
suite.add('fast-safe-stringify: deep ', function () {
fastSafeStringify(deep)
})
suite.add('fast-safe-stringify: deep circular ', function () {
fastSafeStringify(deepCirc)
})
suite.add('fast-safe-stringify: large deep circular getters ', function () {
fastSafeStringify(deepCircGetters)
})
suite.add('fast-safe-stringify: deep non-conf circular getters', function () {
fastSafeStringify(deepCircNonCongifurableGetters)
})
// add listeners
suite.on('cycle', function (event) {
console.log(String(event.target))
})
suite.on('complete', function () {
console.log('\nFastest is ' + this.filter('fastest').map('name'))
})
suite.run({ delay: 1, minSamples: 150 })
``` | /content/code_sandbox/node_modules/fast-safe-stringify/benchmark.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 1,183 |
```javascript
module.exports = stringify
stringify.default = stringify
stringify.stable = deterministicStringify
stringify.stableStringify = deterministicStringify
var LIMIT_REPLACE_NODE = '[...]'
var CIRCULAR_REPLACE_NODE = '[Circular]'
var arr = []
var replacerStack = []
function defaultOptions () {
return {
depthLimit: Number.MAX_SAFE_INTEGER,
edgesLimit: Number.MAX_SAFE_INTEGER
}
}
// Regular stringify
function stringify (obj, replacer, spacer, options) {
if (typeof options === 'undefined') {
options = defaultOptions()
}
decirc(obj, '', 0, [], undefined, 0, options)
var res
try {
if (replacerStack.length === 0) {
res = JSON.stringify(obj, replacer, spacer)
} else {
res = JSON.stringify(obj, replaceGetterValues(replacer), spacer)
}
} catch (_) {
return JSON.stringify('[unable to serialize, circular reference is too complex to analyze]')
} finally {
while (arr.length !== 0) {
var part = arr.pop()
if (part.length === 4) {
Object.defineProperty(part[0], part[1], part[3])
} else {
part[0][part[1]] = part[2]
}
}
}
return res
}
function setReplace (replace, val, k, parent) {
var propertyDescriptor = Object.getOwnPropertyDescriptor(parent, k)
if (propertyDescriptor.get !== undefined) {
if (propertyDescriptor.configurable) {
Object.defineProperty(parent, k, { value: replace })
arr.push([parent, k, val, propertyDescriptor])
} else {
replacerStack.push([val, k, replace])
}
} else {
parent[k] = replace
arr.push([parent, k, val])
}
}
function decirc (val, k, edgeIndex, stack, parent, depth, options) {
depth += 1
var i
if (typeof val === 'object' && val !== null) {
for (i = 0; i < stack.length; i++) {
if (stack[i] === val) {
setReplace(CIRCULAR_REPLACE_NODE, val, k, parent)
return
}
}
if (
typeof options.depthLimit !== 'undefined' &&
depth > options.depthLimit
) {
setReplace(LIMIT_REPLACE_NODE, val, k, parent)
return
}
if (
typeof options.edgesLimit !== 'undefined' &&
edgeIndex + 1 > options.edgesLimit
) {
setReplace(LIMIT_REPLACE_NODE, val, k, parent)
return
}
stack.push(val)
// Optimize for Arrays. Big arrays could kill the performance otherwise!
if (Array.isArray(val)) {
for (i = 0; i < val.length; i++) {
decirc(val[i], i, i, stack, val, depth, options)
}
} else {
var keys = Object.keys(val)
for (i = 0; i < keys.length; i++) {
var key = keys[i]
decirc(val[key], key, i, stack, val, depth, options)
}
}
stack.pop()
}
}
// Stable-stringify
function compareFunction (a, b) {
if (a < b) {
return -1
}
if (a > b) {
return 1
}
return 0
}
function deterministicStringify (obj, replacer, spacer, options) {
if (typeof options === 'undefined') {
options = defaultOptions()
}
var tmp = deterministicDecirc(obj, '', 0, [], undefined, 0, options) || obj
var res
try {
if (replacerStack.length === 0) {
res = JSON.stringify(tmp, replacer, spacer)
} else {
res = JSON.stringify(tmp, replaceGetterValues(replacer), spacer)
}
} catch (_) {
return JSON.stringify('[unable to serialize, circular reference is too complex to analyze]')
} finally {
// Ensure that we restore the object as it was.
while (arr.length !== 0) {
var part = arr.pop()
if (part.length === 4) {
Object.defineProperty(part[0], part[1], part[3])
} else {
part[0][part[1]] = part[2]
}
}
}
return res
}
function deterministicDecirc (val, k, edgeIndex, stack, parent, depth, options) {
depth += 1
var i
if (typeof val === 'object' && val !== null) {
for (i = 0; i < stack.length; i++) {
if (stack[i] === val) {
setReplace(CIRCULAR_REPLACE_NODE, val, k, parent)
return
}
}
try {
if (typeof val.toJSON === 'function') {
return
}
} catch (_) {
return
}
if (
typeof options.depthLimit !== 'undefined' &&
depth > options.depthLimit
) {
setReplace(LIMIT_REPLACE_NODE, val, k, parent)
return
}
if (
typeof options.edgesLimit !== 'undefined' &&
edgeIndex + 1 > options.edgesLimit
) {
setReplace(LIMIT_REPLACE_NODE, val, k, parent)
return
}
stack.push(val)
// Optimize for Arrays. Big arrays could kill the performance otherwise!
if (Array.isArray(val)) {
for (i = 0; i < val.length; i++) {
deterministicDecirc(val[i], i, i, stack, val, depth, options)
}
} else {
// Create a temporary object in the required way
var tmp = {}
var keys = Object.keys(val).sort(compareFunction)
for (i = 0; i < keys.length; i++) {
var key = keys[i]
deterministicDecirc(val[key], key, i, stack, val, depth, options)
tmp[key] = val[key]
}
if (typeof parent !== 'undefined') {
arr.push([parent, k, val])
parent[k] = tmp
} else {
return tmp
}
}
stack.pop()
}
}
// wraps replacer function to handle values we couldn't replace
// and mark them as replaced value
function replaceGetterValues (replacer) {
replacer =
typeof replacer !== 'undefined'
? replacer
: function (k, v) {
return v
}
return function (key, val) {
if (replacerStack.length > 0) {
for (var i = 0; i < replacerStack.length; i++) {
var part = replacerStack[i]
if (part[1] === key && part[0] === val) {
val = part[2]
replacerStack.splice(i, 1)
break
}
}
}
return replacer.call(this, key, val)
}
}
``` | /content/code_sandbox/node_modules/fast-safe-stringify/index.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 1,553 |
```javascript
const test = require('tap').test
const fss = require('./').stable
const clone = require('clone')
const s = JSON.stringify
const stream = require('stream')
test('circular reference to root', function (assert) {
const fixture = { name: 'Tywin Lannister' }
fixture.circle = fixture
const expected = s({ circle: '[Circular]', name: 'Tywin Lannister' })
const actual = fss(fixture)
assert.equal(actual, expected)
assert.end()
})
test('circular getter reference to root', function (assert) {
const fixture = {
name: 'Tywin Lannister',
get circle () {
return fixture
}
}
const expected = s({ circle: '[Circular]', name: 'Tywin Lannister' })
const actual = fss(fixture)
assert.equal(actual, expected)
assert.end()
})
test('nested circular reference to root', function (assert) {
const fixture = { name: 'Tywin Lannister' }
fixture.id = { circle: fixture }
const expected = s({ id: { circle: '[Circular]' }, name: 'Tywin Lannister' })
const actual = fss(fixture)
assert.equal(actual, expected)
assert.end()
})
test('child circular reference', function (assert) {
const fixture = {
name: 'Tywin Lannister',
child: { name: 'Tyrion Lannister' }
}
fixture.child.dinklage = fixture.child
const expected = s({
child: {
dinklage: '[Circular]',
name: 'Tyrion Lannister'
},
name: 'Tywin Lannister'
})
const actual = fss(fixture)
assert.equal(actual, expected)
assert.end()
})
test('nested child circular reference', function (assert) {
const fixture = {
name: 'Tywin Lannister',
child: { name: 'Tyrion Lannister' }
}
fixture.child.actor = { dinklage: fixture.child }
const expected = s({
child: {
actor: { dinklage: '[Circular]' },
name: 'Tyrion Lannister'
},
name: 'Tywin Lannister'
})
const actual = fss(fixture)
assert.equal(actual, expected)
assert.end()
})
test('circular objects in an array', function (assert) {
const fixture = { name: 'Tywin Lannister' }
fixture.hand = [fixture, fixture]
const expected = s({
hand: ['[Circular]', '[Circular]'],
name: 'Tywin Lannister'
})
const actual = fss(fixture)
assert.equal(actual, expected)
assert.end()
})
test('nested circular references in an array', function (assert) {
const fixture = {
name: 'Tywin Lannister',
offspring: [{ name: 'Tyrion Lannister' }, { name: 'Cersei Lannister' }]
}
fixture.offspring[0].dinklage = fixture.offspring[0]
fixture.offspring[1].headey = fixture.offspring[1]
const expected = s({
name: 'Tywin Lannister',
offspring: [
{ dinklage: '[Circular]', name: 'Tyrion Lannister' },
{ headey: '[Circular]', name: 'Cersei Lannister' }
]
})
const actual = fss(fixture)
assert.equal(actual, expected)
assert.end()
})
test('circular arrays', function (assert) {
const fixture = []
fixture.push(fixture, fixture)
const expected = s(['[Circular]', '[Circular]'])
const actual = fss(fixture)
assert.equal(actual, expected)
assert.end()
})
test('nested circular arrays', function (assert) {
const fixture = []
fixture.push(
{ name: 'Jon Snow', bastards: fixture },
{ name: 'Ramsay Bolton', bastards: fixture }
)
const expected = s([
{ bastards: '[Circular]', name: 'Jon Snow' },
{ bastards: '[Circular]', name: 'Ramsay Bolton' }
])
const actual = fss(fixture)
assert.equal(actual, expected)
assert.end()
})
test('repeated non-circular references in objects', function (assert) {
const daenerys = { name: 'Daenerys Targaryen' }
const fixture = {
motherOfDragons: daenerys,
queenOfMeereen: daenerys
}
const expected = s(fixture)
const actual = fss(fixture)
assert.equal(actual, expected)
assert.end()
})
test('repeated non-circular references in arrays', function (assert) {
const daenerys = { name: 'Daenerys Targaryen' }
const fixture = [daenerys, daenerys]
const expected = s(fixture)
const actual = fss(fixture)
assert.equal(actual, expected)
assert.end()
})
test('double child circular reference', function (assert) {
// create circular reference
const child = { name: 'Tyrion Lannister' }
child.dinklage = child
// include it twice in the fixture
const fixture = { name: 'Tywin Lannister', childA: child, childB: child }
const cloned = clone(fixture)
const expected = s({
childA: {
dinklage: '[Circular]',
name: 'Tyrion Lannister'
},
childB: {
dinklage: '[Circular]',
name: 'Tyrion Lannister'
},
name: 'Tywin Lannister'
})
const actual = fss(fixture)
assert.equal(actual, expected)
// check if the fixture has not been modified
assert.same(fixture, cloned)
assert.end()
})
test('child circular reference with toJSON', function (assert) {
// Create a test object that has an overridden `toJSON` property
TestObject.prototype.toJSON = function () {
return { special: 'case' }
}
function TestObject (content) {}
// Creating a simple circular object structure
const parentObject = {}
parentObject.childObject = new TestObject()
parentObject.childObject.parentObject = parentObject
// Creating a simple circular object structure
const otherParentObject = new TestObject()
otherParentObject.otherChildObject = {}
otherParentObject.otherChildObject.otherParentObject = otherParentObject
// Making sure our original tests work
assert.same(parentObject.childObject.parentObject, parentObject)
assert.same(
otherParentObject.otherChildObject.otherParentObject,
otherParentObject
)
// Should both be idempotent
assert.equal(fss(parentObject), '{"childObject":{"special":"case"}}')
assert.equal(fss(otherParentObject), '{"special":"case"}')
// Therefore the following assertion should be `true`
assert.same(parentObject.childObject.parentObject, parentObject)
assert.same(
otherParentObject.otherChildObject.otherParentObject,
otherParentObject
)
assert.end()
})
test('null object', function (assert) {
const expected = s(null)
const actual = fss(null)
assert.equal(actual, expected)
assert.end()
})
test('null property', function (assert) {
const expected = s({ f: null })
const actual = fss({ f: null })
assert.equal(actual, expected)
assert.end()
})
test('nested child circular reference in toJSON', function (assert) {
var circle = { some: 'data' }
circle.circle = circle
var a = {
b: {
toJSON: function () {
a.b = 2
return '[Redacted]'
}
},
baz: {
circle,
toJSON: function () {
a.baz = circle
return '[Redacted]'
}
}
}
var o = {
a,
bar: a
}
const expected = s({
a: {
b: '[Redacted]',
baz: '[Redacted]'
},
bar: {
// TODO: This is a known limitation of the current implementation.
// The ideal result would be:
//
// b: 2,
// baz: {
// circle: '[Circular]',
// some: 'data'
// }
//
b: '[Redacted]',
baz: '[Redacted]'
}
})
const actual = fss(o)
assert.equal(actual, expected)
assert.end()
})
test('circular getters are restored when stringified', function (assert) {
const fixture = {
name: 'Tywin Lannister',
get circle () {
return fixture
}
}
fss(fixture)
assert.equal(fixture.circle, fixture)
assert.end()
})
test('non-configurable circular getters use a replacer instead of markers', function (assert) {
const fixture = { name: 'Tywin Lannister' }
Object.defineProperty(fixture, 'circle', {
configurable: false,
get: function () {
return fixture
},
enumerable: true
})
fss(fixture)
assert.equal(fixture.circle, fixture)
assert.end()
})
test('getter child circular reference', function (assert) {
const fixture = {
name: 'Tywin Lannister',
child: {
name: 'Tyrion Lannister',
get dinklage () {
return fixture.child
}
},
get self () {
return fixture
}
}
const expected = s({
child: {
dinklage: '[Circular]',
name: 'Tyrion Lannister'
},
name: 'Tywin Lannister',
self: '[Circular]'
})
const actual = fss(fixture)
assert.equal(actual, expected)
assert.end()
})
test('Proxy throwing', function (assert) {
assert.plan(1)
const s = new stream.PassThrough()
s.resume()
s.write('', () => {
assert.end()
})
const actual = fss({ s, p: new Proxy({}, { get () { throw new Error('kaboom') } }) })
assert.equal(actual, '"[unable to serialize, circular reference is too complex to analyze]"')
})
test('depthLimit option - will replace deep objects', function (assert) {
const fixture = {
name: 'Tywin Lannister',
child: {
name: 'Tyrion Lannister'
},
get self () {
return fixture
}
}
const expected = s({
child: '[...]',
name: 'Tywin Lannister',
self: '[Circular]'
})
const actual = fss(fixture, undefined, undefined, {
depthLimit: 1,
edgesLimit: 1
})
assert.equal(actual, expected)
assert.end()
})
test('edgesLimit option - will replace deep objects', function (assert) {
const fixture = {
object: {
1: { test: 'test' },
2: { test: 'test' },
3: { test: 'test' },
4: { test: 'test' }
},
array: [
{ test: 'test' },
{ test: 'test' },
{ test: 'test' },
{ test: 'test' }
],
get self () {
return fixture
}
}
const expected = s({
array: [{ test: 'test' }, { test: 'test' }, { test: 'test' }, '[...]'],
object: {
1: { test: 'test' },
2: { test: 'test' },
3: { test: 'test' },
4: '[...]'
},
self: '[Circular]'
})
const actual = fss(fixture, undefined, undefined, {
depthLimit: 3,
edgesLimit: 3
})
assert.equal(actual, expected)
assert.end()
})
``` | /content/code_sandbox/node_modules/fast-safe-stringify/test-stable.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 2,652 |
```javascript
const test = require('tap').test
const fss = require('./')
const clone = require('clone')
const s = JSON.stringify
const stream = require('stream')
test('circular reference to root', function (assert) {
const fixture = { name: 'Tywin Lannister' }
fixture.circle = fixture
const expected = s({ name: 'Tywin Lannister', circle: '[Circular]' })
const actual = fss(fixture)
assert.equal(actual, expected)
assert.end()
})
test('circular getter reference to root', function (assert) {
const fixture = {
name: 'Tywin Lannister',
get circle () {
return fixture
}
}
const expected = s({ name: 'Tywin Lannister', circle: '[Circular]' })
const actual = fss(fixture)
assert.equal(actual, expected)
assert.end()
})
test('nested circular reference to root', function (assert) {
const fixture = { name: 'Tywin Lannister' }
fixture.id = { circle: fixture }
const expected = s({ name: 'Tywin Lannister', id: { circle: '[Circular]' } })
const actual = fss(fixture)
assert.equal(actual, expected)
assert.end()
})
test('child circular reference', function (assert) {
const fixture = {
name: 'Tywin Lannister',
child: { name: 'Tyrion Lannister' }
}
fixture.child.dinklage = fixture.child
const expected = s({
name: 'Tywin Lannister',
child: {
name: 'Tyrion Lannister',
dinklage: '[Circular]'
}
})
const actual = fss(fixture)
assert.equal(actual, expected)
assert.end()
})
test('nested child circular reference', function (assert) {
const fixture = {
name: 'Tywin Lannister',
child: { name: 'Tyrion Lannister' }
}
fixture.child.actor = { dinklage: fixture.child }
const expected = s({
name: 'Tywin Lannister',
child: {
name: 'Tyrion Lannister',
actor: { dinklage: '[Circular]' }
}
})
const actual = fss(fixture)
assert.equal(actual, expected)
assert.end()
})
test('circular objects in an array', function (assert) {
const fixture = { name: 'Tywin Lannister' }
fixture.hand = [fixture, fixture]
const expected = s({
name: 'Tywin Lannister',
hand: ['[Circular]', '[Circular]']
})
const actual = fss(fixture)
assert.equal(actual, expected)
assert.end()
})
test('nested circular references in an array', function (assert) {
const fixture = {
name: 'Tywin Lannister',
offspring: [{ name: 'Tyrion Lannister' }, { name: 'Cersei Lannister' }]
}
fixture.offspring[0].dinklage = fixture.offspring[0]
fixture.offspring[1].headey = fixture.offspring[1]
const expected = s({
name: 'Tywin Lannister',
offspring: [
{ name: 'Tyrion Lannister', dinklage: '[Circular]' },
{ name: 'Cersei Lannister', headey: '[Circular]' }
]
})
const actual = fss(fixture)
assert.equal(actual, expected)
assert.end()
})
test('circular arrays', function (assert) {
const fixture = []
fixture.push(fixture, fixture)
const expected = s(['[Circular]', '[Circular]'])
const actual = fss(fixture)
assert.equal(actual, expected)
assert.end()
})
test('nested circular arrays', function (assert) {
const fixture = []
fixture.push(
{ name: 'Jon Snow', bastards: fixture },
{ name: 'Ramsay Bolton', bastards: fixture }
)
const expected = s([
{ name: 'Jon Snow', bastards: '[Circular]' },
{ name: 'Ramsay Bolton', bastards: '[Circular]' }
])
const actual = fss(fixture)
assert.equal(actual, expected)
assert.end()
})
test('repeated non-circular references in objects', function (assert) {
const daenerys = { name: 'Daenerys Targaryen' }
const fixture = {
motherOfDragons: daenerys,
queenOfMeereen: daenerys
}
const expected = s(fixture)
const actual = fss(fixture)
assert.equal(actual, expected)
assert.end()
})
test('repeated non-circular references in arrays', function (assert) {
const daenerys = { name: 'Daenerys Targaryen' }
const fixture = [daenerys, daenerys]
const expected = s(fixture)
const actual = fss(fixture)
assert.equal(actual, expected)
assert.end()
})
test('double child circular reference', function (assert) {
// create circular reference
const child = { name: 'Tyrion Lannister' }
child.dinklage = child
// include it twice in the fixture
const fixture = { name: 'Tywin Lannister', childA: child, childB: child }
const cloned = clone(fixture)
const expected = s({
name: 'Tywin Lannister',
childA: {
name: 'Tyrion Lannister',
dinklage: '[Circular]'
},
childB: {
name: 'Tyrion Lannister',
dinklage: '[Circular]'
}
})
const actual = fss(fixture)
assert.equal(actual, expected)
// check if the fixture has not been modified
assert.same(fixture, cloned)
assert.end()
})
test('child circular reference with toJSON', function (assert) {
// Create a test object that has an overridden `toJSON` property
TestObject.prototype.toJSON = function () {
return { special: 'case' }
}
function TestObject (content) {}
// Creating a simple circular object structure
const parentObject = {}
parentObject.childObject = new TestObject()
parentObject.childObject.parentObject = parentObject
// Creating a simple circular object structure
const otherParentObject = new TestObject()
otherParentObject.otherChildObject = {}
otherParentObject.otherChildObject.otherParentObject = otherParentObject
// Making sure our original tests work
assert.same(parentObject.childObject.parentObject, parentObject)
assert.same(
otherParentObject.otherChildObject.otherParentObject,
otherParentObject
)
// Should both be idempotent
assert.equal(fss(parentObject), '{"childObject":{"special":"case"}}')
assert.equal(fss(otherParentObject), '{"special":"case"}')
// Therefore the following assertion should be `true`
assert.same(parentObject.childObject.parentObject, parentObject)
assert.same(
otherParentObject.otherChildObject.otherParentObject,
otherParentObject
)
assert.end()
})
test('null object', function (assert) {
const expected = s(null)
const actual = fss(null)
assert.equal(actual, expected)
assert.end()
})
test('null property', function (assert) {
const expected = s({ f: null })
const actual = fss({ f: null })
assert.equal(actual, expected)
assert.end()
})
test('nested child circular reference in toJSON', function (assert) {
const circle = { some: 'data' }
circle.circle = circle
const a = {
b: {
toJSON: function () {
a.b = 2
return '[Redacted]'
}
},
baz: {
circle,
toJSON: function () {
a.baz = circle
return '[Redacted]'
}
}
}
const o = {
a,
bar: a
}
const expected = s({
a: {
b: '[Redacted]',
baz: '[Redacted]'
},
bar: {
b: 2,
baz: {
some: 'data',
circle: '[Circular]'
}
}
})
const actual = fss(o)
assert.equal(actual, expected)
assert.end()
})
test('circular getters are restored when stringified', function (assert) {
const fixture = {
name: 'Tywin Lannister',
get circle () {
return fixture
}
}
fss(fixture)
assert.equal(fixture.circle, fixture)
assert.end()
})
test('non-configurable circular getters use a replacer instead of markers', function (assert) {
const fixture = { name: 'Tywin Lannister' }
Object.defineProperty(fixture, 'circle', {
configurable: false,
get: function () {
return fixture
},
enumerable: true
})
fss(fixture)
assert.equal(fixture.circle, fixture)
assert.end()
})
test('getter child circular reference are replaced instead of marked', function (assert) {
const fixture = {
name: 'Tywin Lannister',
child: {
name: 'Tyrion Lannister',
get dinklage () {
return fixture.child
}
},
get self () {
return fixture
}
}
const expected = s({
name: 'Tywin Lannister',
child: {
name: 'Tyrion Lannister',
dinklage: '[Circular]'
},
self: '[Circular]'
})
const actual = fss(fixture)
assert.equal(actual, expected)
assert.end()
})
test('Proxy throwing', function (assert) {
assert.plan(1)
const s = new stream.PassThrough()
s.resume()
s.write('', () => {
assert.end()
})
const actual = fss({ s, p: new Proxy({}, { get () { throw new Error('kaboom') } }) })
assert.equal(actual, '"[unable to serialize, circular reference is too complex to analyze]"')
})
test('depthLimit option - will replace deep objects', function (assert) {
const fixture = {
name: 'Tywin Lannister',
child: {
name: 'Tyrion Lannister'
},
get self () {
return fixture
}
}
const expected = s({
name: 'Tywin Lannister',
child: '[...]',
self: '[Circular]'
})
const actual = fss(fixture, undefined, undefined, {
depthLimit: 1,
edgesLimit: 1
})
assert.equal(actual, expected)
assert.end()
})
test('edgesLimit option - will replace deep objects', function (assert) {
const fixture = {
object: {
1: { test: 'test' },
2: { test: 'test' },
3: { test: 'test' },
4: { test: 'test' }
},
array: [
{ test: 'test' },
{ test: 'test' },
{ test: 'test' },
{ test: 'test' }
],
get self () {
return fixture
}
}
const expected = s({
object: {
1: { test: 'test' },
2: { test: 'test' },
3: { test: 'test' },
4: '[...]'
},
array: [{ test: 'test' }, { test: 'test' }, { test: 'test' }, '[...]'],
self: '[Circular]'
})
const actual = fss(fixture, undefined, undefined, {
depthLimit: 3,
edgesLimit: 3
})
assert.equal(actual, expected)
assert.end()
})
``` | /content/code_sandbox/node_modules/fast-safe-stringify/test.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 2,608 |
```javascript
'use strict'
exports.fromCallback = function (fn) {
return Object.defineProperty(function () {
if (typeof arguments[arguments.length - 1] === 'function') fn.apply(this, arguments)
else {
return new Promise((resolve, reject) => {
arguments[arguments.length] = (err, res) => {
if (err) return reject(err)
resolve(res)
}
arguments.length++
fn.apply(this, arguments)
})
}
}, 'name', { value: fn.name })
}
exports.fromPromise = function (fn) {
return Object.defineProperty(function () {
const cb = arguments[arguments.length - 1]
if (typeof cb !== 'function') return fn.apply(this, arguments)
else fn.apply(this, arguments).then(r => cb(null, r), cb)
}, 'name', { value: fn.name })
}
``` | /content/code_sandbox/node_modules/universalify/index.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 186 |
```javascript
/*!
* toidentifier
*/
'use strict'
/**
* Module exports.
* @public
*/
module.exports = toIdentifier
/**
* Trasform the given string into a JavaScript identifier
*
* @param {string} str
* @returns {string}
* @public
*/
function toIdentifier (str) {
return str
.split(' ')
.map(function (token) {
return token.slice(0, 1).toUpperCase() + token.slice(1)
})
.join('')
.replace(/[^ _0-9a-z]/gi, '')
}
``` | /content/code_sandbox/node_modules/toidentifier/index.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 123 |
```javascript
'use strict';
var crypto_hash_sha512 = require('tweetnacl').lowlevel.crypto_hash;
/*
* This file is a 1:1 port from the OpenBSD blowfish.c and bcrypt_pbkdf.c. As a
* result, it retains the original copyright and license. The two files are
* under slightly different (but compatible) licenses, and are here combined in
* one file.
*
* Credit for the actual porting work goes to:
* Devi Mandiri <me@devi.web.id>
*/
/*
* The Blowfish portions are under the following license:
*
* Blowfish block cipher for OpenBSD
* All rights reserved.
*
* Implementation advice by David Mazieres <dm@lcs.mit.edu>.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/*
* The bcrypt_pbkdf portions are under the following license:
*
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
/*
* Performance improvements (Javascript-specific):
*
* Author: Alex Wilson <alex.wilson@joyent.com>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
// Ported from OpenBSD bcrypt_pbkdf.c v1.9
var BLF_J = 0;
var Blowfish = function() {
this.S = [
new Uint32Array([
0xd1310ba6, 0x98dfb5ac, 0x2ffd72db, 0xd01adfb7,
0xb8e1afed, 0x6a267e96, 0xba7c9045, 0xf12c7f99,
0x24a19947, 0xb3916cf7, 0x0801f2e2, 0x858efc16,
0x636920d8, 0x71574e69, 0xa458fea3, 0xf4933d7e,
0x0d95748f, 0x728eb658, 0x718bcd58, 0x82154aee,
0x7b54a41d, 0xc25a59b5, 0x9c30d539, 0x2af26013,
0xc5d1b023, 0x286085f0, 0xca417918, 0xb8db38ef,
0x8e79dcb0, 0x603a180e, 0x6c9e0e8b, 0xb01e8a3e,
0xd71577c1, 0xbd314b27, 0x78af2fda, 0x55605c60,
0xe65525f3, 0xaa55ab94, 0x57489862, 0x63e81440,
0x55ca396a, 0x2aab10b6, 0xb4cc5c34, 0x1141e8ce,
0xa15486af, 0x7c72e993, 0xb3ee1411, 0x636fbc2a,
0x2ba9c55d, 0x741831f6, 0xce5c3e16, 0x9b87931e,
0xafd6ba33, 0x6c24cf5c, 0x7a325381, 0x28958677,
0x3b8f4898, 0x6b4bb9af, 0xc4bfe81b, 0x66282193,
0x61d809cc, 0xfb21a991, 0x487cac60, 0x5dec8032,
0xef845d5d, 0xe98575b1, 0xdc262302, 0xeb651b88,
0x23893e81, 0xd396acc5, 0x0f6d6ff3, 0x83f44239,
0x2e0b4482, 0xa4842004, 0x69c8f04a, 0x9e1f9b5e,
0x21c66842, 0xf6e96c9a, 0x670c9c61, 0xabd388f0,
0x6a51a0d2, 0xd8542f68, 0x960fa728, 0xab5133a3,
0x6eef0b6c, 0x137a3be4, 0xba3bf050, 0x7efb2a98,
0xa1f1651d, 0x39af0176, 0x66ca593e, 0x82430e88,
0x8cee8619, 0x456f9fb4, 0x7d84a5c3, 0x3b8b5ebe,
0xe06f75d8, 0x85c12073, 0x401a449f, 0x56c16aa6,
0x4ed3aa62, 0x363f7706, 0x1bfedf72, 0x429b023d,
0x37d0d724, 0xd00a1248, 0xdb0fead3, 0x49f1c09b,
0x075372c9, 0x80991b7b, 0x25d479d8, 0xf6e8def7,
0xe3fe501a, 0xb6794c3b, 0x976ce0bd, 0x04c006ba,
0xc1a94fb6, 0x409f60c4, 0x5e5c9ec2, 0x196a2463,
0x68fb6faf, 0x3e6c53b5, 0x1339b2eb, 0x3b52ec6f,
0x6dfc511f, 0x9b30952c, 0xcc814544, 0xaf5ebd09,
0xbee3d004, 0xde334afd, 0x660f2807, 0x192e4bb3,
0xc0cba857, 0x45c8740f, 0xd20b5f39, 0xb9d3fbdb,
0x5579c0bd, 0x1a60320a, 0xd6a100c6, 0x402c7279,
0x679f25fe, 0xfb1fa3cc, 0x8ea5e9f8, 0xdb3222f8,
0x3c7516df, 0xfd616b15, 0x2f501ec8, 0xad0552ab,
0x323db5fa, 0xfd238760, 0x53317b48, 0x3e00df82,
0x9e5c57bb, 0xca6f8ca0, 0x1a87562e, 0xdf1769db,
0xd542a8f6, 0x287effc3, 0xac6732c6, 0x8c4f5573,
0x695b27b0, 0xbbca58c8, 0xe1ffa35d, 0xb8f011a0,
0x10fa3d98, 0xfd2183b8, 0x4afcb56c, 0x2dd1d35b,
0x9a53e479, 0xb6f84565, 0xd28e49bc, 0x4bfb9790,
0xe1ddf2da, 0xa4cb7e33, 0x62fb1341, 0xcee4c6e8,
0xef20cada, 0x36774c01, 0xd07e9efe, 0x2bf11fb4,
0x95dbda4d, 0xae909198, 0xeaad8e71, 0x6b93d5a0,
0xd08ed1d0, 0xafc725e0, 0x8e3c5b2f, 0x8e7594b7,
0x8ff6e2fb, 0xf2122b64, 0x8888b812, 0x900df01c,
0x4fad5ea0, 0x688fc31c, 0xd1cff191, 0xb3a8c1ad,
0x2f2f2218, 0xbe0e1777, 0xea752dfe, 0x8b021fa1,
0xe5a0cc0f, 0xb56f74e8, 0x18acf3d6, 0xce89e299,
0xb4a84fe0, 0xfd13e0b7, 0x7cc43b81, 0xd2ada8d9,
0x165fa266, 0x80957705, 0x93cc7314, 0x211a1477,
0xe6ad2065, 0x77b5fa86, 0xc75442f5, 0xfb9d35cf,
0xebcdaf0c, 0x7b3e89a0, 0xd6411bd3, 0xae1e7e49,
0x00250e2d, 0x2071b35e, 0x226800bb, 0x57b8e0af,
0x2464369b, 0xf009b91e, 0x5563911d, 0x59dfa6aa,
0x78c14389, 0xd95a537f, 0x207d5ba2, 0x02e5b9c5,
0x83260376, 0x6295cfa9, 0x11c81968, 0x4e734a41,
0xb3472dca, 0x7b14a94a, 0x1b510052, 0x9a532915,
0xd60f573f, 0xbc9bc6e4, 0x2b60a476, 0x81e67400,
0x08ba6fb5, 0x571be91f, 0xf296ec6b, 0x2a0dd915,
0xb6636521, 0xe7b9f9b6, 0xff34052e, 0xc5855664,
0x53b02d5d, 0xa99f8fa1, 0x08ba4799, 0x6e85076a]),
new Uint32Array([
0x4b7a70e9, 0xb5b32944, 0xdb75092e, 0xc4192623,
0xad6ea6b0, 0x49a7df7d, 0x9cee60b8, 0x8fedb266,
0xecaa8c71, 0x699a17ff, 0x5664526c, 0xc2b19ee1,
0x193602a5, 0x75094c29, 0xa0591340, 0xe4183a3e,
0x3f54989a, 0x5b429d65, 0x6b8fe4d6, 0x99f73fd6,
0xa1d29c07, 0xefe830f5, 0x4d2d38e6, 0xf0255dc1,
0x4cdd2086, 0x8470eb26, 0x6382e9c6, 0x021ecc5e,
0x09686b3f, 0x3ebaefc9, 0x3c971814, 0x6b6a70a1,
0x687f3584, 0x52a0e286, 0xb79c5305, 0xaa500737,
0x3e07841c, 0x7fdeae5c, 0x8e7d44ec, 0x5716f2b8,
0xb03ada37, 0xf0500c0d, 0xf01c1f04, 0x0200b3ff,
0xae0cf51a, 0x3cb574b2, 0x25837a58, 0xdc0921bd,
0xd19113f9, 0x7ca92ff6, 0x94324773, 0x22f54701,
0x3ae5e581, 0x37c2dadc, 0xc8b57634, 0x9af3dda7,
0xa9446146, 0x0fd0030e, 0xecc8c73e, 0xa4751e41,
0xe238cd99, 0x3bea0e2f, 0x3280bba1, 0x183eb331,
0x4e548b38, 0x4f6db908, 0x6f420d03, 0xf60a04bf,
0x2cb81290, 0x24977c79, 0x5679b072, 0xbcaf89af,
0xde9a771f, 0xd9930810, 0xb38bae12, 0xdccf3f2e,
0x5512721f, 0x2e6b7124, 0x501adde6, 0x9f84cd87,
0x7a584718, 0x7408da17, 0xbc9f9abc, 0xe94b7d8c,
0xec7aec3a, 0xdb851dfa, 0x63094366, 0xc464c3d2,
0xef1c1847, 0x3215d908, 0xdd433b37, 0x24c2ba16,
0x12a14d43, 0x2a65c451, 0x50940002, 0x133ae4dd,
0x71dff89e, 0x10314e55, 0x81ac77d6, 0x5f11199b,
0x043556f1, 0xd7a3c76b, 0x3c11183b, 0x5924a509,
0xf28fe6ed, 0x97f1fbfa, 0x9ebabf2c, 0x1e153c6e,
0x86e34570, 0xeae96fb1, 0x860e5e0a, 0x5a3e2ab3,
0x771fe71c, 0x4e3d06fa, 0x2965dcb9, 0x99e71d0f,
0x803e89d6, 0x5266c825, 0x2e4cc978, 0x9c10b36a,
0xc6150eba, 0x94e2ea78, 0xa5fc3c53, 0x1e0a2df4,
0xf2f74ea7, 0x361d2b3d, 0x1939260f, 0x19c27960,
0x5223a708, 0xf71312b6, 0xebadfe6e, 0xeac31f66,
0xe3bc4595, 0xa67bc883, 0xb17f37d1, 0x018cff28,
0xc332ddef, 0xbe6c5aa5, 0x65582185, 0x68ab9802,
0xeecea50f, 0xdb2f953b, 0x2aef7dad, 0x5b6e2f84,
0x1521b628, 0x29076170, 0xecdd4775, 0x619f1510,
0x13cca830, 0xeb61bd96, 0x0334fe1e, 0xaa0363cf,
0xb5735c90, 0x4c70a239, 0xd59e9e0b, 0xcbaade14,
0xeecc86bc, 0x60622ca7, 0x9cab5cab, 0xb2f3846e,
0x648b1eaf, 0x19bdf0ca, 0xa02369b9, 0x655abb50,
0x40685a32, 0x3c2ab4b3, 0x319ee9d5, 0xc021b8f7,
0x9b540b19, 0x875fa099, 0x95f7997e, 0x623d7da8,
0xf837889a, 0x97e32d77, 0x11ed935f, 0x16681281,
0x0e358829, 0xc7e61fd6, 0x96dedfa1, 0x7858ba99,
0x57f584a5, 0x1b227263, 0x9b83c3ff, 0x1ac24696,
0xcdb30aeb, 0x532e3054, 0x8fd948e4, 0x6dbc3128,
0x58ebf2ef, 0x34c6ffea, 0xfe28ed61, 0xee7c3c73,
0x5d4a14d9, 0xe864b7e3, 0x42105d14, 0x203e13e0,
0x45eee2b6, 0xa3aaabea, 0xdb6c4f15, 0xfacb4fd0,
0xc742f442, 0xef6abbb5, 0x654f3b1d, 0x41cd2105,
0xd81e799e, 0x86854dc7, 0xe44b476a, 0x3d816250,
0xcf62a1f2, 0x5b8d2646, 0xfc8883a0, 0xc1c7b6a3,
0x7f1524c3, 0x69cb7492, 0x47848a0b, 0x5692b285,
0x095bbf00, 0xad19489d, 0x1462b174, 0x23820e00,
0x58428d2a, 0x0c55f5ea, 0x1dadf43e, 0x233f7061,
0x3372f092, 0x8d937e41, 0xd65fecf1, 0x6c223bdb,
0x7cde3759, 0xcbee7460, 0x4085f2a7, 0xce77326e,
0xa6078084, 0x19f8509e, 0xe8efd855, 0x61d99735,
0xa969a7aa, 0xc50c06c2, 0x5a04abfc, 0x800bcadc,
0x9e447a2e, 0xc3453484, 0xfdd56705, 0x0e1e9ec9,
0xdb73dbd3, 0x105588cd, 0x675fda79, 0xe3674340,
0xc5c43465, 0x713e38d8, 0x3d28f89e, 0xf16dff20,
0x153e21e7, 0x8fb03d4a, 0xe6e39f2b, 0xdb83adf7]),
new Uint32Array([
0xe93d5a68, 0x948140f7, 0xf64c261c, 0x94692934,
0x411520f7, 0x7602d4f7, 0xbcf46b2e, 0xd4a20068,
0xd4082471, 0x3320f46a, 0x43b7d4b7, 0x500061af,
0x1e39f62e, 0x97244546, 0x14214f74, 0xbf8b8840,
0x4d95fc1d, 0x96b591af, 0x70f4ddd3, 0x66a02f45,
0xbfbc09ec, 0x03bd9785, 0x7fac6dd0, 0x31cb8504,
0x96eb27b3, 0x55fd3941, 0xda2547e6, 0xabca0a9a,
0x28507825, 0x530429f4, 0x0a2c86da, 0xe9b66dfb,
0x68dc1462, 0xd7486900, 0x680ec0a4, 0x27a18dee,
0x4f3ffea2, 0xe887ad8c, 0xb58ce006, 0x7af4d6b6,
0xaace1e7c, 0xd3375fec, 0xce78a399, 0x406b2a42,
0x20fe9e35, 0xd9f385b9, 0xee39d7ab, 0x3b124e8b,
0x1dc9faf7, 0x4b6d1856, 0x26a36631, 0xeae397b2,
0x3a6efa74, 0xdd5b4332, 0x6841e7f7, 0xca7820fb,
0xfb0af54e, 0xd8feb397, 0x454056ac, 0xba489527,
0x55533a3a, 0x20838d87, 0xfe6ba9b7, 0xd096954b,
0x55a867bc, 0xa1159a58, 0xcca92963, 0x99e1db33,
0xa62a4a56, 0x3f3125f9, 0x5ef47e1c, 0x9029317c,
0xfdf8e802, 0x04272f70, 0x80bb155c, 0x05282ce3,
0x95c11548, 0xe4c66d22, 0x48c1133f, 0xc70f86dc,
0x07f9c9ee, 0x41041f0f, 0x404779a4, 0x5d886e17,
0x325f51eb, 0xd59bc0d1, 0xf2bcc18f, 0x41113564,
0x257b7834, 0x602a9c60, 0xdff8e8a3, 0x1f636c1b,
0x0e12b4c2, 0x02e1329e, 0xaf664fd1, 0xcad18115,
0x6b2395e0, 0x333e92e1, 0x3b240b62, 0xeebeb922,
0x85b2a20e, 0xe6ba0d99, 0xde720c8c, 0x2da2f728,
0xd0127845, 0x95b794fd, 0x647d0862, 0xe7ccf5f0,
0x5449a36f, 0x877d48fa, 0xc39dfd27, 0xf33e8d1e,
0x0a476341, 0x992eff74, 0x3a6f6eab, 0xf4f8fd37,
0xa812dc60, 0xa1ebddf8, 0x991be14c, 0xdb6e6b0d,
0xc67b5510, 0x6d672c37, 0x2765d43b, 0xdcd0e804,
0xf1290dc7, 0xcc00ffa3, 0xb5390f92, 0x690fed0b,
0x667b9ffb, 0xcedb7d9c, 0xa091cf0b, 0xd9155ea3,
0xbb132f88, 0x515bad24, 0x7b9479bf, 0x763bd6eb,
0x37392eb3, 0xcc115979, 0x8026e297, 0xf42e312d,
0x6842ada7, 0xc66a2b3b, 0x12754ccc, 0x782ef11c,
0x6a124237, 0xb79251e7, 0x06a1bbe6, 0x4bfb6350,
0x1a6b1018, 0x11caedfa, 0x3d25bdd8, 0xe2e1c3c9,
0x44421659, 0x0a121386, 0xd90cec6e, 0xd5abea2a,
0x64af674e, 0xda86a85f, 0xbebfe988, 0x64e4c3fe,
0x9dbc8057, 0xf0f7c086, 0x60787bf8, 0x6003604d,
0xd1fd8346, 0xf6381fb0, 0x7745ae04, 0xd736fccc,
0x83426b33, 0xf01eab71, 0xb0804187, 0x3c005e5f,
0x77a057be, 0xbde8ae24, 0x55464299, 0xbf582e61,
0x4e58f48f, 0xf2ddfda2, 0xf474ef38, 0x8789bdc2,
0x5366f9c3, 0xc8b38e74, 0xb475f255, 0x46fcd9b9,
0x7aeb2661, 0x8b1ddf84, 0x846a0e79, 0x915f95e2,
0x466e598e, 0x20b45770, 0x8cd55591, 0xc902de4c,
0xb90bace1, 0xbb8205d0, 0x11a86248, 0x7574a99e,
0xb77f19b6, 0xe0a9dc09, 0x662d09a1, 0xc4324633,
0xe85a1f02, 0x09f0be8c, 0x4a99a025, 0x1d6efe10,
0x1ab93d1d, 0x0ba5a4df, 0xa186f20f, 0x2868f169,
0xdcb7da83, 0x573906fe, 0xa1e2ce9b, 0x4fcd7f52,
0x50115e01, 0xa70683fa, 0xa002b5c4, 0x0de6d027,
0x9af88c27, 0x773f8641, 0xc3604c06, 0x61a806b5,
0xf0177a28, 0xc0f586e0, 0x006058aa, 0x30dc7d62,
0x11e69ed7, 0x2338ea63, 0x53c2dd94, 0xc2c21634,
0xbbcbee56, 0x90bcb6de, 0xebfc7da1, 0xce591d76,
0x6f05e409, 0x4b7c0188, 0x39720a3d, 0x7c927c24,
0x86e3725f, 0x724d9db9, 0x1ac15bb4, 0xd39eb8fc,
0xed545578, 0x08fca5b5, 0xd83d7cd3, 0x4dad0fc4,
0x1e50ef5e, 0xb161e6f8, 0xa28514d9, 0x6c51133c,
0x6fd5c7e7, 0x56e14ec4, 0x362abfce, 0xddc6c837,
0xd79a3234, 0x92638212, 0x670efa8e, 0x406000e0]),
new Uint32Array([
0x3a39ce37, 0xd3faf5cf, 0xabc27737, 0x5ac52d1b,
0x5cb0679e, 0x4fa33742, 0xd3822740, 0x99bc9bbe,
0xd5118e9d, 0xbf0f7315, 0xd62d1c7e, 0xc700c47b,
0xb78c1b6b, 0x21a19045, 0xb26eb1be, 0x6a366eb4,
0x5748ab2f, 0xbc946e79, 0xc6a376d2, 0x6549c2c8,
0x530ff8ee, 0x468dde7d, 0xd5730a1d, 0x4cd04dc6,
0x2939bbdb, 0xa9ba4650, 0xac9526e8, 0xbe5ee304,
0xa1fad5f0, 0x6a2d519a, 0x63ef8ce2, 0x9a86ee22,
0xc089c2b8, 0x43242ef6, 0xa51e03aa, 0x9cf2d0a4,
0x83c061ba, 0x9be96a4d, 0x8fe51550, 0xba645bd6,
0x2826a2f9, 0xa73a3ae1, 0x4ba99586, 0xef5562e9,
0xc72fefd3, 0xf752f7da, 0x3f046f69, 0x77fa0a59,
0x80e4a915, 0x87b08601, 0x9b09e6ad, 0x3b3ee593,
0xe990fd5a, 0x9e34d797, 0x2cf0b7d9, 0x022b8b51,
0x96d5ac3a, 0x017da67d, 0xd1cf3ed6, 0x7c7d2d28,
0x1f9f25cf, 0xadf2b89b, 0x5ad6b472, 0x5a88f54c,
0xe029ac71, 0xe019a5e6, 0x47b0acfd, 0xed93fa9b,
0xe8d3c48d, 0x283b57cc, 0xf8d56629, 0x79132e28,
0x785f0191, 0xed756055, 0xf7960e44, 0xe3d35e8c,
0x15056dd4, 0x88f46dba, 0x03a16125, 0x0564f0bd,
0xc3eb9e15, 0x3c9057a2, 0x97271aec, 0xa93a072a,
0x1b3f6d9b, 0x1e6321f5, 0xf59c66fb, 0x26dcf319,
0x7533d928, 0xb155fdf5, 0x03563482, 0x8aba3cbb,
0x28517711, 0xc20ad9f8, 0xabcc5167, 0xccad925f,
0x4de81751, 0x3830dc8e, 0x379d5862, 0x9320f991,
0xea7a90c2, 0xfb3e7bce, 0x5121ce64, 0x774fbe32,
0xa8b6e37e, 0xc3293d46, 0x48de5369, 0x6413e680,
0xa2ae0810, 0xdd6db224, 0x69852dfd, 0x09072166,
0xb39a460a, 0x6445c0dd, 0x586cdecf, 0x1c20c8ae,
0x5bbef7dd, 0x1b588d40, 0xccd2017f, 0x6bb4e3bb,
0xdda26a7e, 0x3a59ff45, 0x3e350a44, 0xbcb4cdd5,
0x72eacea8, 0xfa6484bb, 0x8d6612ae, 0xbf3c6f47,
0xd29be463, 0x542f5d9e, 0xaec2771b, 0xf64e6370,
0x740e0d8d, 0xe75b1357, 0xf8721671, 0xaf537d5d,
0x4040cb08, 0x4eb4e2cc, 0x34d2466a, 0x0115af84,
0xe1b00428, 0x95983a1d, 0x06b89fb4, 0xce6ea048,
0x6f3f3b82, 0x3520ab82, 0x011a1d4b, 0x277227f8,
0x611560b1, 0xe7933fdc, 0xbb3a792b, 0x344525bd,
0xa08839e1, 0x51ce794b, 0x2f32c9b7, 0xa01fbac9,
0xe01cc87e, 0xbcc7d1f6, 0xcf0111c3, 0xa1e8aac7,
0x1a908749, 0xd44fbd9a, 0xd0dadecb, 0xd50ada38,
0x0339c32a, 0xc6913667, 0x8df9317c, 0xe0b12b4f,
0xf79e59b7, 0x43f5bb3a, 0xf2d519ff, 0x27d9459c,
0xbf97222c, 0x15e6fc2a, 0x0f91fc71, 0x9b941525,
0xfae59361, 0xceb69ceb, 0xc2a86459, 0x12baa8d1,
0xb6c1075e, 0xe3056a0c, 0x10d25065, 0xcb03a442,
0xe0ec6e0e, 0x1698db3b, 0x4c98a0be, 0x3278e964,
0x9f1f9532, 0xe0d392df, 0xd3a0342b, 0x8971f21e,
0x1b0a7441, 0x4ba3348c, 0xc5be7120, 0xc37632d8,
0xdf359f8d, 0x9b992f2e, 0xe60b6f47, 0x0fe3f11d,
0xe54cda54, 0x1edad891, 0xce6279cf, 0xcd3e7e6f,
0x1618b166, 0xfd2c1d05, 0x848fd2c5, 0xf6fb2299,
0xf523f357, 0xa6327623, 0x93a83531, 0x56cccd02,
0xacf08162, 0x5a75ebb5, 0x6e163697, 0x88d273cc,
0xde966292, 0x81b949d0, 0x4c50901b, 0x71c65614,
0xe6c6c7bd, 0x327a140a, 0x45e1d006, 0xc3f27b9a,
0xc9aa53fd, 0x62a80f00, 0xbb25bfe2, 0x35bdd2f6,
0x71126905, 0xb2040222, 0xb6cbcf7c, 0xcd769c2b,
0x53113ec0, 0x1640e3d3, 0x38abbd60, 0x2547adf0,
0xba38209c, 0xf746ce76, 0x77afa1c5, 0x20756060,
0x85cbfe4e, 0x8ae88dd8, 0x7aaaf9b0, 0x4cf9aa7e,
0x1948c25c, 0x02fb8a8c, 0x01c36ae4, 0xd6ebe1f9,
0x90d4f869, 0xa65cdea0, 0x3f09252d, 0xc208e69f,
0xb74e6132, 0xce77e25b, 0x578fdfe3, 0x3ac372e6])
];
this.P = new Uint32Array([
0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344,
0xa4093822, 0x299f31d0, 0x082efa98, 0xec4e6c89,
0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c,
0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917,
0x9216d5d9, 0x8979fb1b]);
};
function F(S, x8, i) {
return (((S[0][x8[i+3]] +
S[1][x8[i+2]]) ^
S[2][x8[i+1]]) +
S[3][x8[i]]);
};
Blowfish.prototype.encipher = function(x, x8) {
if (x8 === undefined) {
x8 = new Uint8Array(x.buffer);
if (x.byteOffset !== 0)
x8 = x8.subarray(x.byteOffset);
}
x[0] ^= this.P[0];
for (var i = 1; i < 16; i += 2) {
x[1] ^= F(this.S, x8, 0) ^ this.P[i];
x[0] ^= F(this.S, x8, 4) ^ this.P[i+1];
}
var t = x[0];
x[0] = x[1] ^ this.P[17];
x[1] = t;
};
Blowfish.prototype.decipher = function(x) {
var x8 = new Uint8Array(x.buffer);
if (x.byteOffset !== 0)
x8 = x8.subarray(x.byteOffset);
x[0] ^= this.P[17];
for (var i = 16; i > 0; i -= 2) {
x[1] ^= F(this.S, x8, 0) ^ this.P[i];
x[0] ^= F(this.S, x8, 4) ^ this.P[i-1];
}
var t = x[0];
x[0] = x[1] ^ this.P[0];
x[1] = t;
};
function stream2word(data, databytes){
var i, temp = 0;
for (i = 0; i < 4; i++, BLF_J++) {
if (BLF_J >= databytes) BLF_J = 0;
temp = (temp << 8) | data[BLF_J];
}
return temp;
};
Blowfish.prototype.expand0state = function(key, keybytes) {
var d = new Uint32Array(2), i, k;
var d8 = new Uint8Array(d.buffer);
for (i = 0, BLF_J = 0; i < 18; i++) {
this.P[i] ^= stream2word(key, keybytes);
}
BLF_J = 0;
for (i = 0; i < 18; i += 2) {
this.encipher(d, d8);
this.P[i] = d[0];
this.P[i+1] = d[1];
}
for (i = 0; i < 4; i++) {
for (k = 0; k < 256; k += 2) {
this.encipher(d, d8);
this.S[i][k] = d[0];
this.S[i][k+1] = d[1];
}
}
};
Blowfish.prototype.expandstate = function(data, databytes, key, keybytes) {
var d = new Uint32Array(2), i, k;
for (i = 0, BLF_J = 0; i < 18; i++) {
this.P[i] ^= stream2word(key, keybytes);
}
for (i = 0, BLF_J = 0; i < 18; i += 2) {
d[0] ^= stream2word(data, databytes);
d[1] ^= stream2word(data, databytes);
this.encipher(d);
this.P[i] = d[0];
this.P[i+1] = d[1];
}
for (i = 0; i < 4; i++) {
for (k = 0; k < 256; k += 2) {
d[0] ^= stream2word(data, databytes);
d[1] ^= stream2word(data, databytes);
this.encipher(d);
this.S[i][k] = d[0];
this.S[i][k+1] = d[1];
}
}
BLF_J = 0;
};
Blowfish.prototype.enc = function(data, blocks) {
for (var i = 0; i < blocks; i++) {
this.encipher(data.subarray(i*2));
}
};
Blowfish.prototype.dec = function(data, blocks) {
for (var i = 0; i < blocks; i++) {
this.decipher(data.subarray(i*2));
}
};
var BCRYPT_BLOCKS = 8,
BCRYPT_HASHSIZE = 32;
function bcrypt_hash(sha2pass, sha2salt, out) {
var state = new Blowfish(),
cdata = new Uint32Array(BCRYPT_BLOCKS), i,
ciphertext = new Uint8Array([79,120,121,99,104,114,111,109,97,116,105,
99,66,108,111,119,102,105,115,104,83,119,97,116,68,121,110,97,109,
105,116,101]); //"OxychromaticBlowfishSwatDynamite"
state.expandstate(sha2salt, 64, sha2pass, 64);
for (i = 0; i < 64; i++) {
state.expand0state(sha2salt, 64);
state.expand0state(sha2pass, 64);
}
for (i = 0; i < BCRYPT_BLOCKS; i++)
cdata[i] = stream2word(ciphertext, ciphertext.byteLength);
for (i = 0; i < 64; i++)
state.enc(cdata, cdata.byteLength / 8);
for (i = 0; i < BCRYPT_BLOCKS; i++) {
out[4*i+3] = cdata[i] >>> 24;
out[4*i+2] = cdata[i] >>> 16;
out[4*i+1] = cdata[i] >>> 8;
out[4*i+0] = cdata[i];
}
};
function bcrypt_pbkdf(pass, passlen, salt, saltlen, key, keylen, rounds) {
var sha2pass = new Uint8Array(64),
sha2salt = new Uint8Array(64),
out = new Uint8Array(BCRYPT_HASHSIZE),
tmpout = new Uint8Array(BCRYPT_HASHSIZE),
countsalt = new Uint8Array(saltlen+4),
i, j, amt, stride, dest, count,
origkeylen = keylen;
if (rounds < 1)
return -1;
if (passlen === 0 || saltlen === 0 || keylen === 0 ||
keylen > (out.byteLength * out.byteLength) || saltlen > (1<<20))
return -1;
stride = Math.floor((keylen + out.byteLength - 1) / out.byteLength);
amt = Math.floor((keylen + stride - 1) / stride);
for (i = 0; i < saltlen; i++)
countsalt[i] = salt[i];
crypto_hash_sha512(sha2pass, pass, passlen);
for (count = 1; keylen > 0; count++) {
countsalt[saltlen+0] = count >>> 24;
countsalt[saltlen+1] = count >>> 16;
countsalt[saltlen+2] = count >>> 8;
countsalt[saltlen+3] = count;
crypto_hash_sha512(sha2salt, countsalt, saltlen + 4);
bcrypt_hash(sha2pass, sha2salt, tmpout);
for (i = out.byteLength; i--;)
out[i] = tmpout[i];
for (i = 1; i < rounds; i++) {
crypto_hash_sha512(sha2salt, tmpout, tmpout.byteLength);
bcrypt_hash(sha2pass, sha2salt, tmpout);
for (j = 0; j < out.byteLength; j++)
out[j] ^= tmpout[j];
}
amt = Math.min(amt, keylen);
for (i = 0; i < amt; i++) {
dest = i * stride + (count - 1);
if (dest >= origkeylen)
break;
key[dest] = out[i];
}
keylen -= i;
}
return 0;
};
module.exports = {
BLOCKS: BCRYPT_BLOCKS,
HASHSIZE: BCRYPT_HASHSIZE,
hash: bcrypt_hash,
pbkdf: bcrypt_pbkdf
};
``` | /content/code_sandbox/node_modules/bcrypt-pbkdf/index.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 11,907 |
```javascript
;(function (root, factory) {
if (typeof exports === "object") {
// CommonJS
module.exports = exports = factory(require("./core"));
}
else if (typeof define === "function" && define.amd) {
// AMD
define(["./core"], factory);
}
else {
// Global (browser)
factory(root.CryptoJS);
}
}(this, function (CryptoJS) {
(function () {
// Check if typed arrays are supported
if (typeof ArrayBuffer != 'function') {
return;
}
// Shortcuts
var C = CryptoJS;
var C_lib = C.lib;
var WordArray = C_lib.WordArray;
// Reference original init
var superInit = WordArray.init;
// Augment WordArray.init to handle typed arrays
var subInit = WordArray.init = function (typedArray) {
// Convert buffers to uint8
if (typedArray instanceof ArrayBuffer) {
typedArray = new Uint8Array(typedArray);
}
// Convert other array views to uint8
if (
typedArray instanceof Int8Array ||
(typeof Uint8ClampedArray !== "undefined" && typedArray instanceof Uint8ClampedArray) ||
typedArray instanceof Int16Array ||
typedArray instanceof Uint16Array ||
typedArray instanceof Int32Array ||
typedArray instanceof Uint32Array ||
typedArray instanceof Float32Array ||
typedArray instanceof Float64Array
) {
typedArray = new Uint8Array(typedArray.buffer, typedArray.byteOffset, typedArray.byteLength);
}
// Handle Uint8Array
if (typedArray instanceof Uint8Array) {
// Shortcut
var typedArrayByteLength = typedArray.byteLength;
// Extract bytes
var words = [];
for (var i = 0; i < typedArrayByteLength; i++) {
words[i >>> 2] |= typedArray[i] << (24 - (i % 4) * 8);
}
// Initialize this word array
superInit.call(this, words, typedArrayByteLength);
} else {
// Else call normal init
superInit.apply(this, arguments);
}
};
subInit.prototype = WordArray;
}());
return CryptoJS.lib.WordArray;
}));
``` | /content/code_sandbox/node_modules/crypto-js/lib-typedarrays.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 500 |
```javascript
;(function (root, factory, undef) {
if (typeof exports === "object") {
// CommonJS
module.exports = exports = factory(require("./core"), require("./sha1"), require("./hmac"));
}
else if (typeof define === "function" && define.amd) {
// AMD
define(["./core", "./sha1", "./hmac"], factory);
}
else {
// Global (browser)
factory(root.CryptoJS);
}
}(this, function (CryptoJS) {
return CryptoJS.HmacSHA1;
}));
``` | /content/code_sandbox/node_modules/crypto-js/hmac-sha1.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 125 |
```javascript
;(function (root, factory, undef) {
if (typeof exports === "object") {
// CommonJS
module.exports = exports = factory(require("./core"), require("./enc-base64"), require("./md5"), require("./evpkdf"), require("./cipher-core"));
}
else if (typeof define === "function" && define.amd) {
// AMD
define(["./core", "./enc-base64", "./md5", "./evpkdf", "./cipher-core"], factory);
}
else {
// Global (browser)
factory(root.CryptoJS);
}
}(this, function (CryptoJS) {
(function () {
// Shortcuts
var C = CryptoJS;
var C_lib = C.lib;
var BlockCipher = C_lib.BlockCipher;
var C_algo = C.algo;
// Lookup tables
var SBOX = [];
var INV_SBOX = [];
var SUB_MIX_0 = [];
var SUB_MIX_1 = [];
var SUB_MIX_2 = [];
var SUB_MIX_3 = [];
var INV_SUB_MIX_0 = [];
var INV_SUB_MIX_1 = [];
var INV_SUB_MIX_2 = [];
var INV_SUB_MIX_3 = [];
// Compute lookup tables
(function () {
// Compute double table
var d = [];
for (var i = 0; i < 256; i++) {
if (i < 128) {
d[i] = i << 1;
} else {
d[i] = (i << 1) ^ 0x11b;
}
}
// Walk GF(2^8)
var x = 0;
var xi = 0;
for (var i = 0; i < 256; i++) {
// Compute sbox
var sx = xi ^ (xi << 1) ^ (xi << 2) ^ (xi << 3) ^ (xi << 4);
sx = (sx >>> 8) ^ (sx & 0xff) ^ 0x63;
SBOX[x] = sx;
INV_SBOX[sx] = x;
// Compute multiplication
var x2 = d[x];
var x4 = d[x2];
var x8 = d[x4];
// Compute sub bytes, mix columns tables
var t = (d[sx] * 0x101) ^ (sx * 0x1010100);
SUB_MIX_0[x] = (t << 24) | (t >>> 8);
SUB_MIX_1[x] = (t << 16) | (t >>> 16);
SUB_MIX_2[x] = (t << 8) | (t >>> 24);
SUB_MIX_3[x] = t;
// Compute inv sub bytes, inv mix columns tables
var t = (x8 * 0x1010101) ^ (x4 * 0x10001) ^ (x2 * 0x101) ^ (x * 0x1010100);
INV_SUB_MIX_0[sx] = (t << 24) | (t >>> 8);
INV_SUB_MIX_1[sx] = (t << 16) | (t >>> 16);
INV_SUB_MIX_2[sx] = (t << 8) | (t >>> 24);
INV_SUB_MIX_3[sx] = t;
// Compute next counter
if (!x) {
x = xi = 1;
} else {
x = x2 ^ d[d[d[x8 ^ x2]]];
xi ^= d[d[xi]];
}
}
}());
// Precomputed Rcon lookup
var RCON = [0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36];
/**
* AES block cipher algorithm.
*/
var AES = C_algo.AES = BlockCipher.extend({
_doReset: function () {
// Skip reset of nRounds has been set before and key did not change
if (this._nRounds && this._keyPriorReset === this._key) {
return;
}
// Shortcuts
var key = this._keyPriorReset = this._key;
var keyWords = key.words;
var keySize = key.sigBytes / 4;
// Compute number of rounds
var nRounds = this._nRounds = keySize + 6;
// Compute number of key schedule rows
var ksRows = (nRounds + 1) * 4;
// Compute key schedule
var keySchedule = this._keySchedule = [];
for (var ksRow = 0; ksRow < ksRows; ksRow++) {
if (ksRow < keySize) {
keySchedule[ksRow] = keyWords[ksRow];
} else {
var t = keySchedule[ksRow - 1];
if (!(ksRow % keySize)) {
// Rot word
t = (t << 8) | (t >>> 24);
// Sub word
t = (SBOX[t >>> 24] << 24) | (SBOX[(t >>> 16) & 0xff] << 16) | (SBOX[(t >>> 8) & 0xff] << 8) | SBOX[t & 0xff];
// Mix Rcon
t ^= RCON[(ksRow / keySize) | 0] << 24;
} else if (keySize > 6 && ksRow % keySize == 4) {
// Sub word
t = (SBOX[t >>> 24] << 24) | (SBOX[(t >>> 16) & 0xff] << 16) | (SBOX[(t >>> 8) & 0xff] << 8) | SBOX[t & 0xff];
}
keySchedule[ksRow] = keySchedule[ksRow - keySize] ^ t;
}
}
// Compute inv key schedule
var invKeySchedule = this._invKeySchedule = [];
for (var invKsRow = 0; invKsRow < ksRows; invKsRow++) {
var ksRow = ksRows - invKsRow;
if (invKsRow % 4) {
var t = keySchedule[ksRow];
} else {
var t = keySchedule[ksRow - 4];
}
if (invKsRow < 4 || ksRow <= 4) {
invKeySchedule[invKsRow] = t;
} else {
invKeySchedule[invKsRow] = INV_SUB_MIX_0[SBOX[t >>> 24]] ^ INV_SUB_MIX_1[SBOX[(t >>> 16) & 0xff]] ^
INV_SUB_MIX_2[SBOX[(t >>> 8) & 0xff]] ^ INV_SUB_MIX_3[SBOX[t & 0xff]];
}
}
},
encryptBlock: function (M, offset) {
this._doCryptBlock(M, offset, this._keySchedule, SUB_MIX_0, SUB_MIX_1, SUB_MIX_2, SUB_MIX_3, SBOX);
},
decryptBlock: function (M, offset) {
// Swap 2nd and 4th rows
var t = M[offset + 1];
M[offset + 1] = M[offset + 3];
M[offset + 3] = t;
this._doCryptBlock(M, offset, this._invKeySchedule, INV_SUB_MIX_0, INV_SUB_MIX_1, INV_SUB_MIX_2, INV_SUB_MIX_3, INV_SBOX);
// Inv swap 2nd and 4th rows
var t = M[offset + 1];
M[offset + 1] = M[offset + 3];
M[offset + 3] = t;
},
_doCryptBlock: function (M, offset, keySchedule, SUB_MIX_0, SUB_MIX_1, SUB_MIX_2, SUB_MIX_3, SBOX) {
// Shortcut
var nRounds = this._nRounds;
// Get input, add round key
var s0 = M[offset] ^ keySchedule[0];
var s1 = M[offset + 1] ^ keySchedule[1];
var s2 = M[offset + 2] ^ keySchedule[2];
var s3 = M[offset + 3] ^ keySchedule[3];
// Key schedule row counter
var ksRow = 4;
// Rounds
for (var round = 1; round < nRounds; round++) {
// Shift rows, sub bytes, mix columns, add round key
var t0 = SUB_MIX_0[s0 >>> 24] ^ SUB_MIX_1[(s1 >>> 16) & 0xff] ^ SUB_MIX_2[(s2 >>> 8) & 0xff] ^ SUB_MIX_3[s3 & 0xff] ^ keySchedule[ksRow++];
var t1 = SUB_MIX_0[s1 >>> 24] ^ SUB_MIX_1[(s2 >>> 16) & 0xff] ^ SUB_MIX_2[(s3 >>> 8) & 0xff] ^ SUB_MIX_3[s0 & 0xff] ^ keySchedule[ksRow++];
var t2 = SUB_MIX_0[s2 >>> 24] ^ SUB_MIX_1[(s3 >>> 16) & 0xff] ^ SUB_MIX_2[(s0 >>> 8) & 0xff] ^ SUB_MIX_3[s1 & 0xff] ^ keySchedule[ksRow++];
var t3 = SUB_MIX_0[s3 >>> 24] ^ SUB_MIX_1[(s0 >>> 16) & 0xff] ^ SUB_MIX_2[(s1 >>> 8) & 0xff] ^ SUB_MIX_3[s2 & 0xff] ^ keySchedule[ksRow++];
// Update state
s0 = t0;
s1 = t1;
s2 = t2;
s3 = t3;
}
// Shift rows, sub bytes, add round key
var t0 = ((SBOX[s0 >>> 24] << 24) | (SBOX[(s1 >>> 16) & 0xff] << 16) | (SBOX[(s2 >>> 8) & 0xff] << 8) | SBOX[s3 & 0xff]) ^ keySchedule[ksRow++];
var t1 = ((SBOX[s1 >>> 24] << 24) | (SBOX[(s2 >>> 16) & 0xff] << 16) | (SBOX[(s3 >>> 8) & 0xff] << 8) | SBOX[s0 & 0xff]) ^ keySchedule[ksRow++];
var t2 = ((SBOX[s2 >>> 24] << 24) | (SBOX[(s3 >>> 16) & 0xff] << 16) | (SBOX[(s0 >>> 8) & 0xff] << 8) | SBOX[s1 & 0xff]) ^ keySchedule[ksRow++];
var t3 = ((SBOX[s3 >>> 24] << 24) | (SBOX[(s0 >>> 16) & 0xff] << 16) | (SBOX[(s1 >>> 8) & 0xff] << 8) | SBOX[s2 & 0xff]) ^ keySchedule[ksRow++];
// Set output
M[offset] = t0;
M[offset + 1] = t1;
M[offset + 2] = t2;
M[offset + 3] = t3;
},
keySize: 256/32
});
/**
* Shortcut functions to the cipher's object interface.
*
* @example
*
* var ciphertext = CryptoJS.AES.encrypt(message, key, cfg);
* var plaintext = CryptoJS.AES.decrypt(ciphertext, key, cfg);
*/
C.AES = BlockCipher._createHelper(AES);
}());
return CryptoJS.AES;
}));
``` | /content/code_sandbox/node_modules/crypto-js/aes.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 2,722 |
```javascript
;(function (root, factory, undef) {
if (typeof exports === "object") {
// CommonJS
module.exports = exports = factory(require("./core"), require("./x64-core"), require("./sha512"), require("./sha384"), require("./hmac"));
}
else if (typeof define === "function" && define.amd) {
// AMD
define(["./core", "./x64-core", "./sha512", "./sha384", "./hmac"], factory);
}
else {
// Global (browser)
factory(root.CryptoJS);
}
}(this, function (CryptoJS) {
return CryptoJS.HmacSHA384;
}));
``` | /content/code_sandbox/node_modules/crypto-js/hmac-sha384.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 145 |
```javascript
;(function (root, factory) {
if (typeof exports === "object") {
// CommonJS
module.exports = exports = factory(require("./core"));
}
else if (typeof define === "function" && define.amd) {
// AMD
define(["./core"], factory);
}
else {
// Global (browser)
factory(root.CryptoJS);
}
}(this, function (CryptoJS) {
/** @preserve
(c) 2012 by Cdric Mesnil. All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
- Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
(function (Math) {
// Shortcuts
var C = CryptoJS;
var C_lib = C.lib;
var WordArray = C_lib.WordArray;
var Hasher = C_lib.Hasher;
var C_algo = C.algo;
// Constants table
var _zl = WordArray.create([
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8,
3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12,
1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2,
4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13]);
var _zr = WordArray.create([
5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12,
6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2,
15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13,
8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14,
12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11]);
var _sl = WordArray.create([
11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8,
7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12,
11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5,
11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12,
9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6 ]);
var _sr = WordArray.create([
8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6,
9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11,
9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5,
15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8,
8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11 ]);
var _hl = WordArray.create([ 0x00000000, 0x5A827999, 0x6ED9EBA1, 0x8F1BBCDC, 0xA953FD4E]);
var _hr = WordArray.create([ 0x50A28BE6, 0x5C4DD124, 0x6D703EF3, 0x7A6D76E9, 0x00000000]);
/**
* RIPEMD160 hash algorithm.
*/
var RIPEMD160 = C_algo.RIPEMD160 = Hasher.extend({
_doReset: function () {
this._hash = WordArray.create([0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0]);
},
_doProcessBlock: function (M, offset) {
// Swap endian
for (var i = 0; i < 16; i++) {
// Shortcuts
var offset_i = offset + i;
var M_offset_i = M[offset_i];
// Swap
M[offset_i] = (
(((M_offset_i << 8) | (M_offset_i >>> 24)) & 0x00ff00ff) |
(((M_offset_i << 24) | (M_offset_i >>> 8)) & 0xff00ff00)
);
}
// Shortcut
var H = this._hash.words;
var hl = _hl.words;
var hr = _hr.words;
var zl = _zl.words;
var zr = _zr.words;
var sl = _sl.words;
var sr = _sr.words;
// Working variables
var al, bl, cl, dl, el;
var ar, br, cr, dr, er;
ar = al = H[0];
br = bl = H[1];
cr = cl = H[2];
dr = dl = H[3];
er = el = H[4];
// Computation
var t;
for (var i = 0; i < 80; i += 1) {
t = (al + M[offset+zl[i]])|0;
if (i<16){
t += f1(bl,cl,dl) + hl[0];
} else if (i<32) {
t += f2(bl,cl,dl) + hl[1];
} else if (i<48) {
t += f3(bl,cl,dl) + hl[2];
} else if (i<64) {
t += f4(bl,cl,dl) + hl[3];
} else {// if (i<80) {
t += f5(bl,cl,dl) + hl[4];
}
t = t|0;
t = rotl(t,sl[i]);
t = (t+el)|0;
al = el;
el = dl;
dl = rotl(cl, 10);
cl = bl;
bl = t;
t = (ar + M[offset+zr[i]])|0;
if (i<16){
t += f5(br,cr,dr) + hr[0];
} else if (i<32) {
t += f4(br,cr,dr) + hr[1];
} else if (i<48) {
t += f3(br,cr,dr) + hr[2];
} else if (i<64) {
t += f2(br,cr,dr) + hr[3];
} else {// if (i<80) {
t += f1(br,cr,dr) + hr[4];
}
t = t|0;
t = rotl(t,sr[i]) ;
t = (t+er)|0;
ar = er;
er = dr;
dr = rotl(cr, 10);
cr = br;
br = t;
}
// Intermediate hash value
t = (H[1] + cl + dr)|0;
H[1] = (H[2] + dl + er)|0;
H[2] = (H[3] + el + ar)|0;
H[3] = (H[4] + al + br)|0;
H[4] = (H[0] + bl + cr)|0;
H[0] = t;
},
_doFinalize: function () {
// Shortcuts
var data = this._data;
var dataWords = data.words;
var nBitsTotal = this._nDataBytes * 8;
var nBitsLeft = data.sigBytes * 8;
// Add padding
dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32);
dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = (
(((nBitsTotal << 8) | (nBitsTotal >>> 24)) & 0x00ff00ff) |
(((nBitsTotal << 24) | (nBitsTotal >>> 8)) & 0xff00ff00)
);
data.sigBytes = (dataWords.length + 1) * 4;
// Hash final blocks
this._process();
// Shortcuts
var hash = this._hash;
var H = hash.words;
// Swap endian
for (var i = 0; i < 5; i++) {
// Shortcut
var H_i = H[i];
// Swap
H[i] = (((H_i << 8) | (H_i >>> 24)) & 0x00ff00ff) |
(((H_i << 24) | (H_i >>> 8)) & 0xff00ff00);
}
// Return final computed hash
return hash;
},
clone: function () {
var clone = Hasher.clone.call(this);
clone._hash = this._hash.clone();
return clone;
}
});
function f1(x, y, z) {
return ((x) ^ (y) ^ (z));
}
function f2(x, y, z) {
return (((x)&(y)) | ((~x)&(z)));
}
function f3(x, y, z) {
return (((x) | (~(y))) ^ (z));
}
function f4(x, y, z) {
return (((x) & (z)) | ((y)&(~(z))));
}
function f5(x, y, z) {
return ((x) ^ ((y) |(~(z))));
}
function rotl(x,n) {
return (x<<n) | (x>>>(32-n));
}
/**
* Shortcut function to the hasher's object interface.
*
* @param {WordArray|string} message The message to hash.
*
* @return {WordArray} The hash.
*
* @static
*
* @example
*
* var hash = CryptoJS.RIPEMD160('message');
* var hash = CryptoJS.RIPEMD160(wordArray);
*/
C.RIPEMD160 = Hasher._createHelper(RIPEMD160);
/**
* Shortcut function to the HMAC's object interface.
*
* @param {WordArray|string} message The message to hash.
* @param {WordArray|string} key The secret key.
*
* @return {WordArray} The HMAC.
*
* @static
*
* @example
*
* var hmac = CryptoJS.HmacRIPEMD160(message, key);
*/
C.HmacRIPEMD160 = Hasher._createHmacHelper(RIPEMD160);
}(Math));
return CryptoJS.RIPEMD160;
}));
``` | /content/code_sandbox/node_modules/crypto-js/ripemd160.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 3,375 |
```javascript
;(function (root, factory, undef) {
if (typeof exports === "object") {
// CommonJS
module.exports = exports = factory(require("./core"), require("./x64-core"), require("./lib-typedarrays"), require("./enc-utf16"), require("./enc-base64"), require("./md5"), require("./sha1"), require("./sha256"), require("./sha224"), require("./sha512"), require("./sha384"), require("./sha3"), require("./ripemd160"), require("./hmac"), require("./pbkdf2"), require("./evpkdf"), require("./cipher-core"), require("./mode-cfb"), require("./mode-ctr"), require("./mode-ctr-gladman"), require("./mode-ofb"), require("./mode-ecb"), require("./pad-ansix923"), require("./pad-iso10126"), require("./pad-iso97971"), require("./pad-zeropadding"), require("./pad-nopadding"), require("./format-hex"), require("./aes"), require("./tripledes"), require("./rc4"), require("./rabbit"), require("./rabbit-legacy"));
}
else if (typeof define === "function" && define.amd) {
// AMD
define(["./core", "./x64-core", "./lib-typedarrays", "./enc-utf16", "./enc-base64", "./md5", "./sha1", "./sha256", "./sha224", "./sha512", "./sha384", "./sha3", "./ripemd160", "./hmac", "./pbkdf2", "./evpkdf", "./cipher-core", "./mode-cfb", "./mode-ctr", "./mode-ctr-gladman", "./mode-ofb", "./mode-ecb", "./pad-ansix923", "./pad-iso10126", "./pad-iso97971", "./pad-zeropadding", "./pad-nopadding", "./format-hex", "./aes", "./tripledes", "./rc4", "./rabbit", "./rabbit-legacy"], factory);
}
else {
// Global (browser)
root.CryptoJS = factory(root.CryptoJS);
}
}(this, function (CryptoJS) {
return CryptoJS;
}));
``` | /content/code_sandbox/node_modules/crypto-js/index.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 463 |
```javascript
;(function (root, factory, undef) {
if (typeof exports === "object") {
// CommonJS
module.exports = exports = factory(require("./core"), require("./enc-base64"), require("./md5"), require("./evpkdf"), require("./cipher-core"));
}
else if (typeof define === "function" && define.amd) {
// AMD
define(["./core", "./enc-base64", "./md5", "./evpkdf", "./cipher-core"], factory);
}
else {
// Global (browser)
factory(root.CryptoJS);
}
}(this, function (CryptoJS) {
(function () {
// Shortcuts
var C = CryptoJS;
var C_lib = C.lib;
var StreamCipher = C_lib.StreamCipher;
var C_algo = C.algo;
// Reusable objects
var S = [];
var C_ = [];
var G = [];
/**
* Rabbit stream cipher algorithm
*/
var Rabbit = C_algo.Rabbit = StreamCipher.extend({
_doReset: function () {
// Shortcuts
var K = this._key.words;
var iv = this.cfg.iv;
// Swap endian
for (var i = 0; i < 4; i++) {
K[i] = (((K[i] << 8) | (K[i] >>> 24)) & 0x00ff00ff) |
(((K[i] << 24) | (K[i] >>> 8)) & 0xff00ff00);
}
// Generate initial state values
var X = this._X = [
K[0], (K[3] << 16) | (K[2] >>> 16),
K[1], (K[0] << 16) | (K[3] >>> 16),
K[2], (K[1] << 16) | (K[0] >>> 16),
K[3], (K[2] << 16) | (K[1] >>> 16)
];
// Generate initial counter values
var C = this._C = [
(K[2] << 16) | (K[2] >>> 16), (K[0] & 0xffff0000) | (K[1] & 0x0000ffff),
(K[3] << 16) | (K[3] >>> 16), (K[1] & 0xffff0000) | (K[2] & 0x0000ffff),
(K[0] << 16) | (K[0] >>> 16), (K[2] & 0xffff0000) | (K[3] & 0x0000ffff),
(K[1] << 16) | (K[1] >>> 16), (K[3] & 0xffff0000) | (K[0] & 0x0000ffff)
];
// Carry bit
this._b = 0;
// Iterate the system four times
for (var i = 0; i < 4; i++) {
nextState.call(this);
}
// Modify the counters
for (var i = 0; i < 8; i++) {
C[i] ^= X[(i + 4) & 7];
}
// IV setup
if (iv) {
// Shortcuts
var IV = iv.words;
var IV_0 = IV[0];
var IV_1 = IV[1];
// Generate four subvectors
var i0 = (((IV_0 << 8) | (IV_0 >>> 24)) & 0x00ff00ff) | (((IV_0 << 24) | (IV_0 >>> 8)) & 0xff00ff00);
var i2 = (((IV_1 << 8) | (IV_1 >>> 24)) & 0x00ff00ff) | (((IV_1 << 24) | (IV_1 >>> 8)) & 0xff00ff00);
var i1 = (i0 >>> 16) | (i2 & 0xffff0000);
var i3 = (i2 << 16) | (i0 & 0x0000ffff);
// Modify counter values
C[0] ^= i0;
C[1] ^= i1;
C[2] ^= i2;
C[3] ^= i3;
C[4] ^= i0;
C[5] ^= i1;
C[6] ^= i2;
C[7] ^= i3;
// Iterate the system four times
for (var i = 0; i < 4; i++) {
nextState.call(this);
}
}
},
_doProcessBlock: function (M, offset) {
// Shortcut
var X = this._X;
// Iterate the system
nextState.call(this);
// Generate four keystream words
S[0] = X[0] ^ (X[5] >>> 16) ^ (X[3] << 16);
S[1] = X[2] ^ (X[7] >>> 16) ^ (X[5] << 16);
S[2] = X[4] ^ (X[1] >>> 16) ^ (X[7] << 16);
S[3] = X[6] ^ (X[3] >>> 16) ^ (X[1] << 16);
for (var i = 0; i < 4; i++) {
// Swap endian
S[i] = (((S[i] << 8) | (S[i] >>> 24)) & 0x00ff00ff) |
(((S[i] << 24) | (S[i] >>> 8)) & 0xff00ff00);
// Encrypt
M[offset + i] ^= S[i];
}
},
blockSize: 128/32,
ivSize: 64/32
});
function nextState() {
// Shortcuts
var X = this._X;
var C = this._C;
// Save old counter values
for (var i = 0; i < 8; i++) {
C_[i] = C[i];
}
// Calculate new counter values
C[0] = (C[0] + 0x4d34d34d + this._b) | 0;
C[1] = (C[1] + 0xd34d34d3 + ((C[0] >>> 0) < (C_[0] >>> 0) ? 1 : 0)) | 0;
C[2] = (C[2] + 0x34d34d34 + ((C[1] >>> 0) < (C_[1] >>> 0) ? 1 : 0)) | 0;
C[3] = (C[3] + 0x4d34d34d + ((C[2] >>> 0) < (C_[2] >>> 0) ? 1 : 0)) | 0;
C[4] = (C[4] + 0xd34d34d3 + ((C[3] >>> 0) < (C_[3] >>> 0) ? 1 : 0)) | 0;
C[5] = (C[5] + 0x34d34d34 + ((C[4] >>> 0) < (C_[4] >>> 0) ? 1 : 0)) | 0;
C[6] = (C[6] + 0x4d34d34d + ((C[5] >>> 0) < (C_[5] >>> 0) ? 1 : 0)) | 0;
C[7] = (C[7] + 0xd34d34d3 + ((C[6] >>> 0) < (C_[6] >>> 0) ? 1 : 0)) | 0;
this._b = (C[7] >>> 0) < (C_[7] >>> 0) ? 1 : 0;
// Calculate the g-values
for (var i = 0; i < 8; i++) {
var gx = X[i] + C[i];
// Construct high and low argument for squaring
var ga = gx & 0xffff;
var gb = gx >>> 16;
// Calculate high and low result of squaring
var gh = ((((ga * ga) >>> 17) + ga * gb) >>> 15) + gb * gb;
var gl = (((gx & 0xffff0000) * gx) | 0) + (((gx & 0x0000ffff) * gx) | 0);
// High XOR low
G[i] = gh ^ gl;
}
// Calculate new state values
X[0] = (G[0] + ((G[7] << 16) | (G[7] >>> 16)) + ((G[6] << 16) | (G[6] >>> 16))) | 0;
X[1] = (G[1] + ((G[0] << 8) | (G[0] >>> 24)) + G[7]) | 0;
X[2] = (G[2] + ((G[1] << 16) | (G[1] >>> 16)) + ((G[0] << 16) | (G[0] >>> 16))) | 0;
X[3] = (G[3] + ((G[2] << 8) | (G[2] >>> 24)) + G[1]) | 0;
X[4] = (G[4] + ((G[3] << 16) | (G[3] >>> 16)) + ((G[2] << 16) | (G[2] >>> 16))) | 0;
X[5] = (G[5] + ((G[4] << 8) | (G[4] >>> 24)) + G[3]) | 0;
X[6] = (G[6] + ((G[5] << 16) | (G[5] >>> 16)) + ((G[4] << 16) | (G[4] >>> 16))) | 0;
X[7] = (G[7] + ((G[6] << 8) | (G[6] >>> 24)) + G[5]) | 0;
}
/**
* Shortcut functions to the cipher's object interface.
*
* @example
*
* var ciphertext = CryptoJS.Rabbit.encrypt(message, key, cfg);
* var plaintext = CryptoJS.Rabbit.decrypt(ciphertext, key, cfg);
*/
C.Rabbit = StreamCipher._createHelper(Rabbit);
}());
return CryptoJS.Rabbit;
}));
``` | /content/code_sandbox/node_modules/crypto-js/rabbit.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 2,479 |
```javascript
;(function (root, factory, undef) {
if (typeof exports === "object") {
// CommonJS
module.exports = exports = factory(require("./core"), require("./cipher-core"));
}
else if (typeof define === "function" && define.amd) {
// AMD
define(["./core", "./cipher-core"], factory);
}
else {
// Global (browser)
factory(root.CryptoJS);
}
}(this, function (CryptoJS) {
/** @preserve
* Counter block mode compatible with Dr Brian Gladman fileenc.c
* derived from CryptoJS.mode.CTR
* Jan Hruby jhruby.web@gmail.com
*/
CryptoJS.mode.CTRGladman = (function () {
var CTRGladman = CryptoJS.lib.BlockCipherMode.extend();
function incWord(word)
{
if (((word >> 24) & 0xff) === 0xff) { //overflow
var b1 = (word >> 16)&0xff;
var b2 = (word >> 8)&0xff;
var b3 = word & 0xff;
if (b1 === 0xff) // overflow b1
{
b1 = 0;
if (b2 === 0xff)
{
b2 = 0;
if (b3 === 0xff)
{
b3 = 0;
}
else
{
++b3;
}
}
else
{
++b2;
}
}
else
{
++b1;
}
word = 0;
word += (b1 << 16);
word += (b2 << 8);
word += b3;
}
else
{
word += (0x01 << 24);
}
return word;
}
function incCounter(counter)
{
if ((counter[0] = incWord(counter[0])) === 0)
{
// encr_data in fileenc.c from Dr Brian Gladman's counts only with DWORD j < 8
counter[1] = incWord(counter[1]);
}
return counter;
}
var Encryptor = CTRGladman.Encryptor = CTRGladman.extend({
processBlock: function (words, offset) {
// Shortcuts
var cipher = this._cipher
var blockSize = cipher.blockSize;
var iv = this._iv;
var counter = this._counter;
// Generate keystream
if (iv) {
counter = this._counter = iv.slice(0);
// Remove IV for subsequent blocks
this._iv = undefined;
}
incCounter(counter);
var keystream = counter.slice(0);
cipher.encryptBlock(keystream, 0);
// Encrypt
for (var i = 0; i < blockSize; i++) {
words[offset + i] ^= keystream[i];
}
}
});
CTRGladman.Decryptor = Encryptor;
return CTRGladman;
}());
return CryptoJS.mode.CTRGladman;
}));
``` | /content/code_sandbox/node_modules/crypto-js/mode-ctr-gladman.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 722 |
```javascript
;(function (root, factory) {
if (typeof exports === "object") {
// CommonJS
module.exports = exports = factory(require("./core"));
}
else if (typeof define === "function" && define.amd) {
// AMD
define(["./core"], factory);
}
else {
// Global (browser)
factory(root.CryptoJS);
}
}(this, function (CryptoJS) {
(function () {
// Shortcuts
var C = CryptoJS;
var C_lib = C.lib;
var WordArray = C_lib.WordArray;
var C_enc = C.enc;
/**
* Base64 encoding strategy.
*/
var Base64 = C_enc.Base64 = {
/**
* Converts a word array to a Base64 string.
*
* @param {WordArray} wordArray The word array.
*
* @return {string} The Base64 string.
*
* @static
*
* @example
*
* var base64String = CryptoJS.enc.Base64.stringify(wordArray);
*/
stringify: function (wordArray) {
// Shortcuts
var words = wordArray.words;
var sigBytes = wordArray.sigBytes;
var map = this._map;
// Clamp excess bits
wordArray.clamp();
// Convert
var base64Chars = [];
for (var i = 0; i < sigBytes; i += 3) {
var byte1 = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
var byte2 = (words[(i + 1) >>> 2] >>> (24 - ((i + 1) % 4) * 8)) & 0xff;
var byte3 = (words[(i + 2) >>> 2] >>> (24 - ((i + 2) % 4) * 8)) & 0xff;
var triplet = (byte1 << 16) | (byte2 << 8) | byte3;
for (var j = 0; (j < 4) && (i + j * 0.75 < sigBytes); j++) {
base64Chars.push(map.charAt((triplet >>> (6 * (3 - j))) & 0x3f));
}
}
// Add padding
var paddingChar = map.charAt(64);
if (paddingChar) {
while (base64Chars.length % 4) {
base64Chars.push(paddingChar);
}
}
return base64Chars.join('');
},
/**
* Converts a Base64 string to a word array.
*
* @param {string} base64Str The Base64 string.
*
* @return {WordArray} The word array.
*
* @static
*
* @example
*
* var wordArray = CryptoJS.enc.Base64.parse(base64String);
*/
parse: function (base64Str) {
// Shortcuts
var base64StrLength = base64Str.length;
var map = this._map;
var reverseMap = this._reverseMap;
if (!reverseMap) {
reverseMap = this._reverseMap = [];
for (var j = 0; j < map.length; j++) {
reverseMap[map.charCodeAt(j)] = j;
}
}
// Ignore padding
var paddingChar = map.charAt(64);
if (paddingChar) {
var paddingIndex = base64Str.indexOf(paddingChar);
if (paddingIndex !== -1) {
base64StrLength = paddingIndex;
}
}
// Convert
return parseLoop(base64Str, base64StrLength, reverseMap);
},
_map: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='
};
function parseLoop(base64Str, base64StrLength, reverseMap) {
var words = [];
var nBytes = 0;
for (var i = 0; i < base64StrLength; i++) {
if (i % 4) {
var bits1 = reverseMap[base64Str.charCodeAt(i - 1)] << ((i % 4) * 2);
var bits2 = reverseMap[base64Str.charCodeAt(i)] >>> (6 - (i % 4) * 2);
words[nBytes >>> 2] |= (bits1 | bits2) << (24 - (nBytes % 4) * 8);
nBytes++;
}
}
return WordArray.create(words, nBytes);
}
}());
return CryptoJS.enc.Base64;
}));
``` | /content/code_sandbox/node_modules/crypto-js/enc-base64.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 1,020 |
```javascript
;(function (root, factory, undef) {
if (typeof exports === "object") {
// CommonJS
module.exports = exports = factory(require("./core"), require("./cipher-core"));
}
else if (typeof define === "function" && define.amd) {
// AMD
define(["./core", "./cipher-core"], factory);
}
else {
// Global (browser)
factory(root.CryptoJS);
}
}(this, function (CryptoJS) {
/**
* Counter block mode.
*/
CryptoJS.mode.CTR = (function () {
var CTR = CryptoJS.lib.BlockCipherMode.extend();
var Encryptor = CTR.Encryptor = CTR.extend({
processBlock: function (words, offset) {
// Shortcuts
var cipher = this._cipher
var blockSize = cipher.blockSize;
var iv = this._iv;
var counter = this._counter;
// Generate keystream
if (iv) {
counter = this._counter = iv.slice(0);
// Remove IV for subsequent blocks
this._iv = undefined;
}
var keystream = counter.slice(0);
cipher.encryptBlock(keystream, 0);
// Increment counter
counter[blockSize - 1] = (counter[blockSize - 1] + 1) | 0
// Encrypt
for (var i = 0; i < blockSize; i++) {
words[offset + i] ^= keystream[i];
}
}
});
CTR.Decryptor = Encryptor;
return CTR;
}());
return CryptoJS.mode.CTR;
}));
``` | /content/code_sandbox/node_modules/crypto-js/mode-ctr.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 360 |
```javascript
;(function (root, factory, undef) {
if (typeof exports === "object") {
// CommonJS
module.exports = exports = factory(require("./core"), require("./ripemd160"), require("./hmac"));
}
else if (typeof define === "function" && define.amd) {
// AMD
define(["./core", "./ripemd160", "./hmac"], factory);
}
else {
// Global (browser)
factory(root.CryptoJS);
}
}(this, function (CryptoJS) {
return CryptoJS.HmacRIPEMD160;
}));
``` | /content/code_sandbox/node_modules/crypto-js/hmac-ripemd160.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 129 |
```javascript
;(function (root, factory, undef) {
if (typeof exports === "object") {
// CommonJS
module.exports = exports = factory(require("./core"), require("./cipher-core"));
}
else if (typeof define === "function" && define.amd) {
// AMD
define(["./core", "./cipher-core"], factory);
}
else {
// Global (browser)
factory(root.CryptoJS);
}
}(this, function (CryptoJS) {
/**
* Cipher Feedback block mode.
*/
CryptoJS.mode.CFB = (function () {
var CFB = CryptoJS.lib.BlockCipherMode.extend();
CFB.Encryptor = CFB.extend({
processBlock: function (words, offset) {
// Shortcuts
var cipher = this._cipher;
var blockSize = cipher.blockSize;
generateKeystreamAndEncrypt.call(this, words, offset, blockSize, cipher);
// Remember this block to use with next block
this._prevBlock = words.slice(offset, offset + blockSize);
}
});
CFB.Decryptor = CFB.extend({
processBlock: function (words, offset) {
// Shortcuts
var cipher = this._cipher;
var blockSize = cipher.blockSize;
// Remember this block to use with next block
var thisBlock = words.slice(offset, offset + blockSize);
generateKeystreamAndEncrypt.call(this, words, offset, blockSize, cipher);
// This block becomes the previous block
this._prevBlock = thisBlock;
}
});
function generateKeystreamAndEncrypt(words, offset, blockSize, cipher) {
// Shortcut
var iv = this._iv;
// Generate keystream
if (iv) {
var keystream = iv.slice(0);
// Remove IV for subsequent blocks
this._iv = undefined;
} else {
var keystream = this._prevBlock;
}
cipher.encryptBlock(keystream, 0);
// Encrypt
for (var i = 0; i < blockSize; i++) {
words[offset + i] ^= keystream[i];
}
}
return CFB;
}());
return CryptoJS.mode.CFB;
}));
``` | /content/code_sandbox/node_modules/crypto-js/mode-cfb.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 484 |
```javascript
;(function (root, factory, undef) {
if (typeof exports === "object") {
// CommonJS
module.exports = exports = factory(require("./core"), require("./x64-core"), require("./sha3"), require("./hmac"));
}
else if (typeof define === "function" && define.amd) {
// AMD
define(["./core", "./x64-core", "./sha3", "./hmac"], factory);
}
else {
// Global (browser)
factory(root.CryptoJS);
}
}(this, function (CryptoJS) {
return CryptoJS.HmacSHA3;
}));
``` | /content/code_sandbox/node_modules/crypto-js/hmac-sha3.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 136 |
```javascript
;(function (root, factory, undef) {
if (typeof exports === "object") {
// CommonJS
module.exports = exports = factory(require("./core"), require("./sha256"), require("./hmac"));
}
else if (typeof define === "function" && define.amd) {
// AMD
define(["./core", "./sha256", "./hmac"], factory);
}
else {
// Global (browser)
factory(root.CryptoJS);
}
}(this, function (CryptoJS) {
return CryptoJS.HmacSHA256;
}));
``` | /content/code_sandbox/node_modules/crypto-js/hmac-sha256.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 125 |
```javascript
;(function (root, factory) {
if (typeof exports === "object") {
// CommonJS
module.exports = exports = factory();
}
else if (typeof define === "function" && define.amd) {
// AMD
define([], factory);
}
else {
// Global (browser)
root.CryptoJS = factory();
}
}(this, function () {
/**
* CryptoJS core components.
*/
var CryptoJS = CryptoJS || (function (Math, undefined) {
/*
* Local polyfil of Object.create
*/
var create = Object.create || (function () {
function F() {};
return function (obj) {
var subtype;
F.prototype = obj;
subtype = new F();
F.prototype = null;
return subtype;
};
}())
/**
* CryptoJS namespace.
*/
var C = {};
/**
* Library namespace.
*/
var C_lib = C.lib = {};
/**
* Base object for prototypal inheritance.
*/
var Base = C_lib.Base = (function () {
return {
/**
* Creates a new object that inherits from this object.
*
* @param {Object} overrides Properties to copy into the new object.
*
* @return {Object} The new object.
*
* @static
*
* @example
*
* var MyType = CryptoJS.lib.Base.extend({
* field: 'value',
*
* method: function () {
* }
* });
*/
extend: function (overrides) {
// Spawn
var subtype = create(this);
// Augment
if (overrides) {
subtype.mixIn(overrides);
}
// Create default initializer
if (!subtype.hasOwnProperty('init') || this.init === subtype.init) {
subtype.init = function () {
subtype.$super.init.apply(this, arguments);
};
}
// Initializer's prototype is the subtype object
subtype.init.prototype = subtype;
// Reference supertype
subtype.$super = this;
return subtype;
},
/**
* Extends this object and runs the init method.
* Arguments to create() will be passed to init().
*
* @return {Object} The new object.
*
* @static
*
* @example
*
* var instance = MyType.create();
*/
create: function () {
var instance = this.extend();
instance.init.apply(instance, arguments);
return instance;
},
/**
* Initializes a newly created object.
* Override this method to add some logic when your objects are created.
*
* @example
*
* var MyType = CryptoJS.lib.Base.extend({
* init: function () {
* // ...
* }
* });
*/
init: function () {
},
/**
* Copies properties into this object.
*
* @param {Object} properties The properties to mix in.
*
* @example
*
* MyType.mixIn({
* field: 'value'
* });
*/
mixIn: function (properties) {
for (var propertyName in properties) {
if (properties.hasOwnProperty(propertyName)) {
this[propertyName] = properties[propertyName];
}
}
// IE won't copy toString using the loop above
if (properties.hasOwnProperty('toString')) {
this.toString = properties.toString;
}
},
/**
* Creates a copy of this object.
*
* @return {Object} The clone.
*
* @example
*
* var clone = instance.clone();
*/
clone: function () {
return this.init.prototype.extend(this);
}
};
}());
/**
* An array of 32-bit words.
*
* @property {Array} words The array of 32-bit words.
* @property {number} sigBytes The number of significant bytes in this word array.
*/
var WordArray = C_lib.WordArray = Base.extend({
/**
* Initializes a newly created word array.
*
* @param {Array} words (Optional) An array of 32-bit words.
* @param {number} sigBytes (Optional) The number of significant bytes in the words.
*
* @example
*
* var wordArray = CryptoJS.lib.WordArray.create();
* var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607]);
* var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607], 6);
*/
init: function (words, sigBytes) {
words = this.words = words || [];
if (sigBytes != undefined) {
this.sigBytes = sigBytes;
} else {
this.sigBytes = words.length * 4;
}
},
/**
* Converts this word array to a string.
*
* @param {Encoder} encoder (Optional) The encoding strategy to use. Default: CryptoJS.enc.Hex
*
* @return {string} The stringified word array.
*
* @example
*
* var string = wordArray + '';
* var string = wordArray.toString();
* var string = wordArray.toString(CryptoJS.enc.Utf8);
*/
toString: function (encoder) {
return (encoder || Hex).stringify(this);
},
/**
* Concatenates a word array to this word array.
*
* @param {WordArray} wordArray The word array to append.
*
* @return {WordArray} This word array.
*
* @example
*
* wordArray1.concat(wordArray2);
*/
concat: function (wordArray) {
// Shortcuts
var thisWords = this.words;
var thatWords = wordArray.words;
var thisSigBytes = this.sigBytes;
var thatSigBytes = wordArray.sigBytes;
// Clamp excess bits
this.clamp();
// Concat
if (thisSigBytes % 4) {
// Copy one byte at a time
for (var i = 0; i < thatSigBytes; i++) {
var thatByte = (thatWords[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
thisWords[(thisSigBytes + i) >>> 2] |= thatByte << (24 - ((thisSigBytes + i) % 4) * 8);
}
} else {
// Copy one word at a time
for (var i = 0; i < thatSigBytes; i += 4) {
thisWords[(thisSigBytes + i) >>> 2] = thatWords[i >>> 2];
}
}
this.sigBytes += thatSigBytes;
// Chainable
return this;
},
/**
* Removes insignificant bits.
*
* @example
*
* wordArray.clamp();
*/
clamp: function () {
// Shortcuts
var words = this.words;
var sigBytes = this.sigBytes;
// Clamp
words[sigBytes >>> 2] &= 0xffffffff << (32 - (sigBytes % 4) * 8);
words.length = Math.ceil(sigBytes / 4);
},
/**
* Creates a copy of this word array.
*
* @return {WordArray} The clone.
*
* @example
*
* var clone = wordArray.clone();
*/
clone: function () {
var clone = Base.clone.call(this);
clone.words = this.words.slice(0);
return clone;
},
/**
* Creates a word array filled with random bytes.
*
* @param {number} nBytes The number of random bytes to generate.
*
* @return {WordArray} The random word array.
*
* @static
*
* @example
*
* var wordArray = CryptoJS.lib.WordArray.random(16);
*/
random: function (nBytes) {
var words = [];
var r = (function (m_w) {
var m_w = m_w;
var m_z = 0x3ade68b1;
var mask = 0xffffffff;
return function () {
m_z = (0x9069 * (m_z & 0xFFFF) + (m_z >> 0x10)) & mask;
m_w = (0x4650 * (m_w & 0xFFFF) + (m_w >> 0x10)) & mask;
var result = ((m_z << 0x10) + m_w) & mask;
result /= 0x100000000;
result += 0.5;
return result * (Math.random() > .5 ? 1 : -1);
}
});
for (var i = 0, rcache; i < nBytes; i += 4) {
var _r = r((rcache || Math.random()) * 0x100000000);
rcache = _r() * 0x3ade67b7;
words.push((_r() * 0x100000000) | 0);
}
return new WordArray.init(words, nBytes);
}
});
/**
* Encoder namespace.
*/
var C_enc = C.enc = {};
/**
* Hex encoding strategy.
*/
var Hex = C_enc.Hex = {
/**
* Converts a word array to a hex string.
*
* @param {WordArray} wordArray The word array.
*
* @return {string} The hex string.
*
* @static
*
* @example
*
* var hexString = CryptoJS.enc.Hex.stringify(wordArray);
*/
stringify: function (wordArray) {
// Shortcuts
var words = wordArray.words;
var sigBytes = wordArray.sigBytes;
// Convert
var hexChars = [];
for (var i = 0; i < sigBytes; i++) {
var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
hexChars.push((bite >>> 4).toString(16));
hexChars.push((bite & 0x0f).toString(16));
}
return hexChars.join('');
},
/**
* Converts a hex string to a word array.
*
* @param {string} hexStr The hex string.
*
* @return {WordArray} The word array.
*
* @static
*
* @example
*
* var wordArray = CryptoJS.enc.Hex.parse(hexString);
*/
parse: function (hexStr) {
// Shortcut
var hexStrLength = hexStr.length;
// Convert
var words = [];
for (var i = 0; i < hexStrLength; i += 2) {
words[i >>> 3] |= parseInt(hexStr.substr(i, 2), 16) << (24 - (i % 8) * 4);
}
return new WordArray.init(words, hexStrLength / 2);
}
};
/**
* Latin1 encoding strategy.
*/
var Latin1 = C_enc.Latin1 = {
/**
* Converts a word array to a Latin1 string.
*
* @param {WordArray} wordArray The word array.
*
* @return {string} The Latin1 string.
*
* @static
*
* @example
*
* var latin1String = CryptoJS.enc.Latin1.stringify(wordArray);
*/
stringify: function (wordArray) {
// Shortcuts
var words = wordArray.words;
var sigBytes = wordArray.sigBytes;
// Convert
var latin1Chars = [];
for (var i = 0; i < sigBytes; i++) {
var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
latin1Chars.push(String.fromCharCode(bite));
}
return latin1Chars.join('');
},
/**
* Converts a Latin1 string to a word array.
*
* @param {string} latin1Str The Latin1 string.
*
* @return {WordArray} The word array.
*
* @static
*
* @example
*
* var wordArray = CryptoJS.enc.Latin1.parse(latin1String);
*/
parse: function (latin1Str) {
// Shortcut
var latin1StrLength = latin1Str.length;
// Convert
var words = [];
for (var i = 0; i < latin1StrLength; i++) {
words[i >>> 2] |= (latin1Str.charCodeAt(i) & 0xff) << (24 - (i % 4) * 8);
}
return new WordArray.init(words, latin1StrLength);
}
};
/**
* UTF-8 encoding strategy.
*/
var Utf8 = C_enc.Utf8 = {
/**
* Converts a word array to a UTF-8 string.
*
* @param {WordArray} wordArray The word array.
*
* @return {string} The UTF-8 string.
*
* @static
*
* @example
*
* var utf8String = CryptoJS.enc.Utf8.stringify(wordArray);
*/
stringify: function (wordArray) {
try {
return decodeURIComponent(escape(Latin1.stringify(wordArray)));
} catch (e) {
throw new Error('Malformed UTF-8 data');
}
},
/**
* Converts a UTF-8 string to a word array.
*
* @param {string} utf8Str The UTF-8 string.
*
* @return {WordArray} The word array.
*
* @static
*
* @example
*
* var wordArray = CryptoJS.enc.Utf8.parse(utf8String);
*/
parse: function (utf8Str) {
return Latin1.parse(unescape(encodeURIComponent(utf8Str)));
}
};
/**
* Abstract buffered block algorithm template.
*
* The property blockSize must be implemented in a concrete subtype.
*
* @property {number} _minBufferSize The number of blocks that should be kept unprocessed in the buffer. Default: 0
*/
var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm = Base.extend({
/**
* Resets this block algorithm's data buffer to its initial state.
*
* @example
*
* bufferedBlockAlgorithm.reset();
*/
reset: function () {
// Initial values
this._data = new WordArray.init();
this._nDataBytes = 0;
},
/**
* Adds new data to this block algorithm's buffer.
*
* @param {WordArray|string} data The data to append. Strings are converted to a WordArray using UTF-8.
*
* @example
*
* bufferedBlockAlgorithm._append('data');
* bufferedBlockAlgorithm._append(wordArray);
*/
_append: function (data) {
// Convert string to WordArray, else assume WordArray already
if (typeof data == 'string') {
data = Utf8.parse(data);
}
// Append
this._data.concat(data);
this._nDataBytes += data.sigBytes;
},
/**
* Processes available data blocks.
*
* This method invokes _doProcessBlock(offset), which must be implemented by a concrete subtype.
*
* @param {boolean} doFlush Whether all blocks and partial blocks should be processed.
*
* @return {WordArray} The processed data.
*
* @example
*
* var processedData = bufferedBlockAlgorithm._process();
* var processedData = bufferedBlockAlgorithm._process(!!'flush');
*/
_process: function (doFlush) {
// Shortcuts
var data = this._data;
var dataWords = data.words;
var dataSigBytes = data.sigBytes;
var blockSize = this.blockSize;
var blockSizeBytes = blockSize * 4;
// Count blocks ready
var nBlocksReady = dataSigBytes / blockSizeBytes;
if (doFlush) {
// Round up to include partial blocks
nBlocksReady = Math.ceil(nBlocksReady);
} else {
// Round down to include only full blocks,
// less the number of blocks that must remain in the buffer
nBlocksReady = Math.max((nBlocksReady | 0) - this._minBufferSize, 0);
}
// Count words ready
var nWordsReady = nBlocksReady * blockSize;
// Count bytes ready
var nBytesReady = Math.min(nWordsReady * 4, dataSigBytes);
// Process blocks
if (nWordsReady) {
for (var offset = 0; offset < nWordsReady; offset += blockSize) {
// Perform concrete-algorithm logic
this._doProcessBlock(dataWords, offset);
}
// Remove processed words
var processedWords = dataWords.splice(0, nWordsReady);
data.sigBytes -= nBytesReady;
}
// Return processed words
return new WordArray.init(processedWords, nBytesReady);
},
/**
* Creates a copy of this object.
*
* @return {Object} The clone.
*
* @example
*
* var clone = bufferedBlockAlgorithm.clone();
*/
clone: function () {
var clone = Base.clone.call(this);
clone._data = this._data.clone();
return clone;
},
_minBufferSize: 0
});
/**
* Abstract hasher template.
*
* @property {number} blockSize The number of 32-bit words this hasher operates on. Default: 16 (512 bits)
*/
var Hasher = C_lib.Hasher = BufferedBlockAlgorithm.extend({
/**
* Configuration options.
*/
cfg: Base.extend(),
/**
* Initializes a newly created hasher.
*
* @param {Object} cfg (Optional) The configuration options to use for this hash computation.
*
* @example
*
* var hasher = CryptoJS.algo.SHA256.create();
*/
init: function (cfg) {
// Apply config defaults
this.cfg = this.cfg.extend(cfg);
// Set initial values
this.reset();
},
/**
* Resets this hasher to its initial state.
*
* @example
*
* hasher.reset();
*/
reset: function () {
// Reset data buffer
BufferedBlockAlgorithm.reset.call(this);
// Perform concrete-hasher logic
this._doReset();
},
/**
* Updates this hasher with a message.
*
* @param {WordArray|string} messageUpdate The message to append.
*
* @return {Hasher} This hasher.
*
* @example
*
* hasher.update('message');
* hasher.update(wordArray);
*/
update: function (messageUpdate) {
// Append
this._append(messageUpdate);
// Update the hash
this._process();
// Chainable
return this;
},
/**
* Finalizes the hash computation.
* Note that the finalize operation is effectively a destructive, read-once operation.
*
* @param {WordArray|string} messageUpdate (Optional) A final message update.
*
* @return {WordArray} The hash.
*
* @example
*
* var hash = hasher.finalize();
* var hash = hasher.finalize('message');
* var hash = hasher.finalize(wordArray);
*/
finalize: function (messageUpdate) {
// Final message update
if (messageUpdate) {
this._append(messageUpdate);
}
// Perform concrete-hasher logic
var hash = this._doFinalize();
return hash;
},
blockSize: 512/32,
/**
* Creates a shortcut function to a hasher's object interface.
*
* @param {Hasher} hasher The hasher to create a helper for.
*
* @return {Function} The shortcut function.
*
* @static
*
* @example
*
* var SHA256 = CryptoJS.lib.Hasher._createHelper(CryptoJS.algo.SHA256);
*/
_createHelper: function (hasher) {
return function (message, cfg) {
return new hasher.init(cfg).finalize(message);
};
},
/**
* Creates a shortcut function to the HMAC's object interface.
*
* @param {Hasher} hasher The hasher to use in this HMAC helper.
*
* @return {Function} The shortcut function.
*
* @static
*
* @example
*
* var HmacSHA256 = CryptoJS.lib.Hasher._createHmacHelper(CryptoJS.algo.SHA256);
*/
_createHmacHelper: function (hasher) {
return function (message, key) {
return new C_algo.HMAC.init(hasher, key).finalize(message);
};
}
});
/**
* Algorithm namespace.
*/
var C_algo = C.algo = {};
return C;
}(Math));
return CryptoJS;
}));
``` | /content/code_sandbox/node_modules/crypto-js/core.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 4,747 |
```javascript
;(function (root, factory, undef) {
if (typeof exports === "object") {
// CommonJS
module.exports = exports = factory(require("./core"), require("./x64-core"), require("./sha512"));
}
else if (typeof define === "function" && define.amd) {
// AMD
define(["./core", "./x64-core", "./sha512"], factory);
}
else {
// Global (browser)
factory(root.CryptoJS);
}
}(this, function (CryptoJS) {
(function () {
// Shortcuts
var C = CryptoJS;
var C_x64 = C.x64;
var X64Word = C_x64.Word;
var X64WordArray = C_x64.WordArray;
var C_algo = C.algo;
var SHA512 = C_algo.SHA512;
/**
* SHA-384 hash algorithm.
*/
var SHA384 = C_algo.SHA384 = SHA512.extend({
_doReset: function () {
this._hash = new X64WordArray.init([
new X64Word.init(0xcbbb9d5d, 0xc1059ed8), new X64Word.init(0x629a292a, 0x367cd507),
new X64Word.init(0x9159015a, 0x3070dd17), new X64Word.init(0x152fecd8, 0xf70e5939),
new X64Word.init(0x67332667, 0xffc00b31), new X64Word.init(0x8eb44a87, 0x68581511),
new X64Word.init(0xdb0c2e0d, 0x64f98fa7), new X64Word.init(0x47b5481d, 0xbefa4fa4)
]);
},
_doFinalize: function () {
var hash = SHA512._doFinalize.call(this);
hash.sigBytes -= 16;
return hash;
}
});
/**
* Shortcut function to the hasher's object interface.
*
* @param {WordArray|string} message The message to hash.
*
* @return {WordArray} The hash.
*
* @static
*
* @example
*
* var hash = CryptoJS.SHA384('message');
* var hash = CryptoJS.SHA384(wordArray);
*/
C.SHA384 = SHA512._createHelper(SHA384);
/**
* Shortcut function to the HMAC's object interface.
*
* @param {WordArray|string} message The message to hash.
* @param {WordArray|string} key The secret key.
*
* @return {WordArray} The HMAC.
*
* @static
*
* @example
*
* var hmac = CryptoJS.HmacSHA384(message, key);
*/
C.HmacSHA384 = SHA512._createHmacHelper(SHA384);
}());
return CryptoJS.SHA384;
}));
``` | /content/code_sandbox/node_modules/crypto-js/sha384.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 676 |
```javascript
;(function (root, factory) {
if (typeof exports === "object") {
// CommonJS
module.exports = exports = factory(require("./core"));
}
else if (typeof define === "function" && define.amd) {
// AMD
define(["./core"], factory);
}
else {
// Global (browser)
factory(root.CryptoJS);
}
}(this, function (CryptoJS) {
(function () {
// Shortcuts
var C = CryptoJS;
var C_lib = C.lib;
var WordArray = C_lib.WordArray;
var Hasher = C_lib.Hasher;
var C_algo = C.algo;
// Reusable object
var W = [];
/**
* SHA-1 hash algorithm.
*/
var SHA1 = C_algo.SHA1 = Hasher.extend({
_doReset: function () {
this._hash = new WordArray.init([
0x67452301, 0xefcdab89,
0x98badcfe, 0x10325476,
0xc3d2e1f0
]);
},
_doProcessBlock: function (M, offset) {
// Shortcut
var H = this._hash.words;
// Working variables
var a = H[0];
var b = H[1];
var c = H[2];
var d = H[3];
var e = H[4];
// Computation
for (var i = 0; i < 80; i++) {
if (i < 16) {
W[i] = M[offset + i] | 0;
} else {
var n = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16];
W[i] = (n << 1) | (n >>> 31);
}
var t = ((a << 5) | (a >>> 27)) + e + W[i];
if (i < 20) {
t += ((b & c) | (~b & d)) + 0x5a827999;
} else if (i < 40) {
t += (b ^ c ^ d) + 0x6ed9eba1;
} else if (i < 60) {
t += ((b & c) | (b & d) | (c & d)) - 0x70e44324;
} else /* if (i < 80) */ {
t += (b ^ c ^ d) - 0x359d3e2a;
}
e = d;
d = c;
c = (b << 30) | (b >>> 2);
b = a;
a = t;
}
// Intermediate hash value
H[0] = (H[0] + a) | 0;
H[1] = (H[1] + b) | 0;
H[2] = (H[2] + c) | 0;
H[3] = (H[3] + d) | 0;
H[4] = (H[4] + e) | 0;
},
_doFinalize: function () {
// Shortcuts
var data = this._data;
var dataWords = data.words;
var nBitsTotal = this._nDataBytes * 8;
var nBitsLeft = data.sigBytes * 8;
// Add padding
dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32);
dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = Math.floor(nBitsTotal / 0x100000000);
dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = nBitsTotal;
data.sigBytes = dataWords.length * 4;
// Hash final blocks
this._process();
// Return final computed hash
return this._hash;
},
clone: function () {
var clone = Hasher.clone.call(this);
clone._hash = this._hash.clone();
return clone;
}
});
/**
* Shortcut function to the hasher's object interface.
*
* @param {WordArray|string} message The message to hash.
*
* @return {WordArray} The hash.
*
* @static
*
* @example
*
* var hash = CryptoJS.SHA1('message');
* var hash = CryptoJS.SHA1(wordArray);
*/
C.SHA1 = Hasher._createHelper(SHA1);
/**
* Shortcut function to the HMAC's object interface.
*
* @param {WordArray|string} message The message to hash.
* @param {WordArray|string} key The secret key.
*
* @return {WordArray} The HMAC.
*
* @static
*
* @example
*
* var hmac = CryptoJS.HmacSHA1(message, key);
*/
C.HmacSHA1 = Hasher._createHmacHelper(SHA1);
}());
return CryptoJS.SHA1;
}));
``` | /content/code_sandbox/node_modules/crypto-js/sha1.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 1,173 |
```javascript
;(function (root, factory) {
if (typeof exports === "object") {
// CommonJS
module.exports = exports = factory(require("./core"));
}
else if (typeof define === "function" && define.amd) {
// AMD
define(["./core"], factory);
}
else {
// Global (browser)
factory(root.CryptoJS);
}
}(this, function (CryptoJS) {
(function () {
// Shortcuts
var C = CryptoJS;
var C_lib = C.lib;
var WordArray = C_lib.WordArray;
var C_enc = C.enc;
/**
* UTF-16 BE encoding strategy.
*/
var Utf16BE = C_enc.Utf16 = C_enc.Utf16BE = {
/**
* Converts a word array to a UTF-16 BE string.
*
* @param {WordArray} wordArray The word array.
*
* @return {string} The UTF-16 BE string.
*
* @static
*
* @example
*
* var utf16String = CryptoJS.enc.Utf16.stringify(wordArray);
*/
stringify: function (wordArray) {
// Shortcuts
var words = wordArray.words;
var sigBytes = wordArray.sigBytes;
// Convert
var utf16Chars = [];
for (var i = 0; i < sigBytes; i += 2) {
var codePoint = (words[i >>> 2] >>> (16 - (i % 4) * 8)) & 0xffff;
utf16Chars.push(String.fromCharCode(codePoint));
}
return utf16Chars.join('');
},
/**
* Converts a UTF-16 BE string to a word array.
*
* @param {string} utf16Str The UTF-16 BE string.
*
* @return {WordArray} The word array.
*
* @static
*
* @example
*
* var wordArray = CryptoJS.enc.Utf16.parse(utf16String);
*/
parse: function (utf16Str) {
// Shortcut
var utf16StrLength = utf16Str.length;
// Convert
var words = [];
for (var i = 0; i < utf16StrLength; i++) {
words[i >>> 1] |= utf16Str.charCodeAt(i) << (16 - (i % 2) * 16);
}
return WordArray.create(words, utf16StrLength * 2);
}
};
/**
* UTF-16 LE encoding strategy.
*/
C_enc.Utf16LE = {
/**
* Converts a word array to a UTF-16 LE string.
*
* @param {WordArray} wordArray The word array.
*
* @return {string} The UTF-16 LE string.
*
* @static
*
* @example
*
* var utf16Str = CryptoJS.enc.Utf16LE.stringify(wordArray);
*/
stringify: function (wordArray) {
// Shortcuts
var words = wordArray.words;
var sigBytes = wordArray.sigBytes;
// Convert
var utf16Chars = [];
for (var i = 0; i < sigBytes; i += 2) {
var codePoint = swapEndian((words[i >>> 2] >>> (16 - (i % 4) * 8)) & 0xffff);
utf16Chars.push(String.fromCharCode(codePoint));
}
return utf16Chars.join('');
},
/**
* Converts a UTF-16 LE string to a word array.
*
* @param {string} utf16Str The UTF-16 LE string.
*
* @return {WordArray} The word array.
*
* @static
*
* @example
*
* var wordArray = CryptoJS.enc.Utf16LE.parse(utf16Str);
*/
parse: function (utf16Str) {
// Shortcut
var utf16StrLength = utf16Str.length;
// Convert
var words = [];
for (var i = 0; i < utf16StrLength; i++) {
words[i >>> 1] |= swapEndian(utf16Str.charCodeAt(i) << (16 - (i % 2) * 16));
}
return WordArray.create(words, utf16StrLength * 2);
}
};
function swapEndian(word) {
return ((word << 8) & 0xff00ff00) | ((word >>> 8) & 0x00ff00ff);
}
}());
return CryptoJS.enc.Utf16;
}));
``` | /content/code_sandbox/node_modules/crypto-js/enc-utf16.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 1,026 |
```javascript
;(function (root, factory, undef) {
if (typeof exports === "object") {
// CommonJS
module.exports = exports = factory(require("./core"), require("./enc-base64"), require("./md5"), require("./evpkdf"), require("./cipher-core"));
}
else if (typeof define === "function" && define.amd) {
// AMD
define(["./core", "./enc-base64", "./md5", "./evpkdf", "./cipher-core"], factory);
}
else {
// Global (browser)
factory(root.CryptoJS);
}
}(this, function (CryptoJS) {
(function () {
// Shortcuts
var C = CryptoJS;
var C_lib = C.lib;
var StreamCipher = C_lib.StreamCipher;
var C_algo = C.algo;
/**
* RC4 stream cipher algorithm.
*/
var RC4 = C_algo.RC4 = StreamCipher.extend({
_doReset: function () {
// Shortcuts
var key = this._key;
var keyWords = key.words;
var keySigBytes = key.sigBytes;
// Init sbox
var S = this._S = [];
for (var i = 0; i < 256; i++) {
S[i] = i;
}
// Key setup
for (var i = 0, j = 0; i < 256; i++) {
var keyByteIndex = i % keySigBytes;
var keyByte = (keyWords[keyByteIndex >>> 2] >>> (24 - (keyByteIndex % 4) * 8)) & 0xff;
j = (j + S[i] + keyByte) % 256;
// Swap
var t = S[i];
S[i] = S[j];
S[j] = t;
}
// Counters
this._i = this._j = 0;
},
_doProcessBlock: function (M, offset) {
M[offset] ^= generateKeystreamWord.call(this);
},
keySize: 256/32,
ivSize: 0
});
function generateKeystreamWord() {
// Shortcuts
var S = this._S;
var i = this._i;
var j = this._j;
// Generate keystream word
var keystreamWord = 0;
for (var n = 0; n < 4; n++) {
i = (i + 1) % 256;
j = (j + S[i]) % 256;
// Swap
var t = S[i];
S[i] = S[j];
S[j] = t;
keystreamWord |= S[(S[i] + S[j]) % 256] << (24 - n * 8);
}
// Update counters
this._i = i;
this._j = j;
return keystreamWord;
}
/**
* Shortcut functions to the cipher's object interface.
*
* @example
*
* var ciphertext = CryptoJS.RC4.encrypt(message, key, cfg);
* var plaintext = CryptoJS.RC4.decrypt(ciphertext, key, cfg);
*/
C.RC4 = StreamCipher._createHelper(RC4);
/**
* Modified RC4 stream cipher algorithm.
*/
var RC4Drop = C_algo.RC4Drop = RC4.extend({
/**
* Configuration options.
*
* @property {number} drop The number of keystream words to drop. Default 192
*/
cfg: RC4.cfg.extend({
drop: 192
}),
_doReset: function () {
RC4._doReset.call(this);
// Drop
for (var i = this.cfg.drop; i > 0; i--) {
generateKeystreamWord.call(this);
}
}
});
/**
* Shortcut functions to the cipher's object interface.
*
* @example
*
* var ciphertext = CryptoJS.RC4Drop.encrypt(message, key, cfg);
* var plaintext = CryptoJS.RC4Drop.decrypt(ciphertext, key, cfg);
*/
C.RC4Drop = StreamCipher._createHelper(RC4Drop);
}());
return CryptoJS.RC4;
}));
``` | /content/code_sandbox/node_modules/crypto-js/rc4.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 953 |
```javascript
;(function (root, factory, undef) {
if (typeof exports === "object") {
// CommonJS
module.exports = exports = factory(require("./core"), require("./x64-core"), require("./sha512"), require("./hmac"));
}
else if (typeof define === "function" && define.amd) {
// AMD
define(["./core", "./x64-core", "./sha512", "./hmac"], factory);
}
else {
// Global (browser)
factory(root.CryptoJS);
}
}(this, function (CryptoJS) {
return CryptoJS.HmacSHA512;
}));
``` | /content/code_sandbox/node_modules/crypto-js/hmac-sha512.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 136 |
```javascript
;(function (root, factory, undef) {
if (typeof exports === "object") {
// CommonJS
module.exports = exports = factory(require("./core"), require("./sha1"), require("./hmac"));
}
else if (typeof define === "function" && define.amd) {
// AMD
define(["./core", "./sha1", "./hmac"], factory);
}
else {
// Global (browser)
factory(root.CryptoJS);
}
}(this, function (CryptoJS) {
(function () {
// Shortcuts
var C = CryptoJS;
var C_lib = C.lib;
var Base = C_lib.Base;
var WordArray = C_lib.WordArray;
var C_algo = C.algo;
var SHA1 = C_algo.SHA1;
var HMAC = C_algo.HMAC;
/**
* Password-Based Key Derivation Function 2 algorithm.
*/
var PBKDF2 = C_algo.PBKDF2 = Base.extend({
/**
* Configuration options.
*
* @property {number} keySize The key size in words to generate. Default: 4 (128 bits)
* @property {Hasher} hasher The hasher to use. Default: SHA1
* @property {number} iterations The number of iterations to perform. Default: 1
*/
cfg: Base.extend({
keySize: 128/32,
hasher: SHA1,
iterations: 1
}),
/**
* Initializes a newly created key derivation function.
*
* @param {Object} cfg (Optional) The configuration options to use for the derivation.
*
* @example
*
* var kdf = CryptoJS.algo.PBKDF2.create();
* var kdf = CryptoJS.algo.PBKDF2.create({ keySize: 8 });
* var kdf = CryptoJS.algo.PBKDF2.create({ keySize: 8, iterations: 1000 });
*/
init: function (cfg) {
this.cfg = this.cfg.extend(cfg);
},
/**
* Computes the Password-Based Key Derivation Function 2.
*
* @param {WordArray|string} password The password.
* @param {WordArray|string} salt A salt.
*
* @return {WordArray} The derived key.
*
* @example
*
* var key = kdf.compute(password, salt);
*/
compute: function (password, salt) {
// Shortcut
var cfg = this.cfg;
// Init HMAC
var hmac = HMAC.create(cfg.hasher, password);
// Initial values
var derivedKey = WordArray.create();
var blockIndex = WordArray.create([0x00000001]);
// Shortcuts
var derivedKeyWords = derivedKey.words;
var blockIndexWords = blockIndex.words;
var keySize = cfg.keySize;
var iterations = cfg.iterations;
// Generate key
while (derivedKeyWords.length < keySize) {
var block = hmac.update(salt).finalize(blockIndex);
hmac.reset();
// Shortcuts
var blockWords = block.words;
var blockWordsLength = blockWords.length;
// Iterations
var intermediate = block;
for (var i = 1; i < iterations; i++) {
intermediate = hmac.finalize(intermediate);
hmac.reset();
// Shortcut
var intermediateWords = intermediate.words;
// XOR intermediate with block
for (var j = 0; j < blockWordsLength; j++) {
blockWords[j] ^= intermediateWords[j];
}
}
derivedKey.concat(block);
blockIndexWords[0]++;
}
derivedKey.sigBytes = keySize * 4;
return derivedKey;
}
});
/**
* Computes the Password-Based Key Derivation Function 2.
*
* @param {WordArray|string} password The password.
* @param {WordArray|string} salt A salt.
* @param {Object} cfg (Optional) The configuration options to use for this computation.
*
* @return {WordArray} The derived key.
*
* @static
*
* @example
*
* var key = CryptoJS.PBKDF2(password, salt);
* var key = CryptoJS.PBKDF2(password, salt, { keySize: 8 });
* var key = CryptoJS.PBKDF2(password, salt, { keySize: 8, iterations: 1000 });
*/
C.PBKDF2 = function (password, salt, cfg) {
return PBKDF2.create(cfg).compute(password, salt);
};
}());
return CryptoJS.PBKDF2;
}));
``` | /content/code_sandbox/node_modules/crypto-js/pbkdf2.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 1,038 |
```javascript
;(function (root, factory, undef) {
if (typeof exports === "object") {
// CommonJS
module.exports = exports = factory(require("./core"), require("./cipher-core"));
}
else if (typeof define === "function" && define.amd) {
// AMD
define(["./core", "./cipher-core"], factory);
}
else {
// Global (browser)
factory(root.CryptoJS);
}
}(this, function (CryptoJS) {
return CryptoJS.format.OpenSSL;
}));
``` | /content/code_sandbox/node_modules/crypto-js/format-openssl.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 115 |
```javascript
;(function (root, factory, undef) {
if (typeof exports === "object") {
// CommonJS
module.exports = exports = factory(require("./core"), require("./sha256"), require("./sha224"), require("./hmac"));
}
else if (typeof define === "function" && define.amd) {
// AMD
define(["./core", "./sha256", "./sha224", "./hmac"], factory);
}
else {
// Global (browser)
factory(root.CryptoJS);
}
}(this, function (CryptoJS) {
return CryptoJS.HmacSHA224;
}));
``` | /content/code_sandbox/node_modules/crypto-js/hmac-sha224.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 134 |
```javascript
;(function (root, factory, undef) {
if (typeof exports === "object") {
// CommonJS
module.exports = exports = factory(require("./core"), require("./cipher-core"));
}
else if (typeof define === "function" && define.amd) {
// AMD
define(["./core", "./cipher-core"], factory);
}
else {
// Global (browser)
factory(root.CryptoJS);
}
}(this, function (CryptoJS) {
/**
* Output Feedback block mode.
*/
CryptoJS.mode.OFB = (function () {
var OFB = CryptoJS.lib.BlockCipherMode.extend();
var Encryptor = OFB.Encryptor = OFB.extend({
processBlock: function (words, offset) {
// Shortcuts
var cipher = this._cipher
var blockSize = cipher.blockSize;
var iv = this._iv;
var keystream = this._keystream;
// Generate keystream
if (iv) {
keystream = this._keystream = iv.slice(0);
// Remove IV for subsequent blocks
this._iv = undefined;
}
cipher.encryptBlock(keystream, 0);
// Encrypt
for (var i = 0; i < blockSize; i++) {
words[offset + i] ^= keystream[i];
}
}
});
OFB.Decryptor = Encryptor;
return OFB;
}());
return CryptoJS.mode.OFB;
}));
``` | /content/code_sandbox/node_modules/crypto-js/mode-ofb.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 327 |
```javascript
;(function (root, factory, undef) {
if (typeof exports === "object") {
// CommonJS
module.exports = exports = factory(require("./core"), require("./enc-base64"), require("./md5"), require("./evpkdf"), require("./cipher-core"));
}
else if (typeof define === "function" && define.amd) {
// AMD
define(["./core", "./enc-base64", "./md5", "./evpkdf", "./cipher-core"], factory);
}
else {
// Global (browser)
factory(root.CryptoJS);
}
}(this, function (CryptoJS) {
(function () {
// Shortcuts
var C = CryptoJS;
var C_lib = C.lib;
var StreamCipher = C_lib.StreamCipher;
var C_algo = C.algo;
// Reusable objects
var S = [];
var C_ = [];
var G = [];
/**
* Rabbit stream cipher algorithm.
*
* This is a legacy version that neglected to convert the key to little-endian.
* This error doesn't affect the cipher's security,
* but it does affect its compatibility with other implementations.
*/
var RabbitLegacy = C_algo.RabbitLegacy = StreamCipher.extend({
_doReset: function () {
// Shortcuts
var K = this._key.words;
var iv = this.cfg.iv;
// Generate initial state values
var X = this._X = [
K[0], (K[3] << 16) | (K[2] >>> 16),
K[1], (K[0] << 16) | (K[3] >>> 16),
K[2], (K[1] << 16) | (K[0] >>> 16),
K[3], (K[2] << 16) | (K[1] >>> 16)
];
// Generate initial counter values
var C = this._C = [
(K[2] << 16) | (K[2] >>> 16), (K[0] & 0xffff0000) | (K[1] & 0x0000ffff),
(K[3] << 16) | (K[3] >>> 16), (K[1] & 0xffff0000) | (K[2] & 0x0000ffff),
(K[0] << 16) | (K[0] >>> 16), (K[2] & 0xffff0000) | (K[3] & 0x0000ffff),
(K[1] << 16) | (K[1] >>> 16), (K[3] & 0xffff0000) | (K[0] & 0x0000ffff)
];
// Carry bit
this._b = 0;
// Iterate the system four times
for (var i = 0; i < 4; i++) {
nextState.call(this);
}
// Modify the counters
for (var i = 0; i < 8; i++) {
C[i] ^= X[(i + 4) & 7];
}
// IV setup
if (iv) {
// Shortcuts
var IV = iv.words;
var IV_0 = IV[0];
var IV_1 = IV[1];
// Generate four subvectors
var i0 = (((IV_0 << 8) | (IV_0 >>> 24)) & 0x00ff00ff) | (((IV_0 << 24) | (IV_0 >>> 8)) & 0xff00ff00);
var i2 = (((IV_1 << 8) | (IV_1 >>> 24)) & 0x00ff00ff) | (((IV_1 << 24) | (IV_1 >>> 8)) & 0xff00ff00);
var i1 = (i0 >>> 16) | (i2 & 0xffff0000);
var i3 = (i2 << 16) | (i0 & 0x0000ffff);
// Modify counter values
C[0] ^= i0;
C[1] ^= i1;
C[2] ^= i2;
C[3] ^= i3;
C[4] ^= i0;
C[5] ^= i1;
C[6] ^= i2;
C[7] ^= i3;
// Iterate the system four times
for (var i = 0; i < 4; i++) {
nextState.call(this);
}
}
},
_doProcessBlock: function (M, offset) {
// Shortcut
var X = this._X;
// Iterate the system
nextState.call(this);
// Generate four keystream words
S[0] = X[0] ^ (X[5] >>> 16) ^ (X[3] << 16);
S[1] = X[2] ^ (X[7] >>> 16) ^ (X[5] << 16);
S[2] = X[4] ^ (X[1] >>> 16) ^ (X[7] << 16);
S[3] = X[6] ^ (X[3] >>> 16) ^ (X[1] << 16);
for (var i = 0; i < 4; i++) {
// Swap endian
S[i] = (((S[i] << 8) | (S[i] >>> 24)) & 0x00ff00ff) |
(((S[i] << 24) | (S[i] >>> 8)) & 0xff00ff00);
// Encrypt
M[offset + i] ^= S[i];
}
},
blockSize: 128/32,
ivSize: 64/32
});
function nextState() {
// Shortcuts
var X = this._X;
var C = this._C;
// Save old counter values
for (var i = 0; i < 8; i++) {
C_[i] = C[i];
}
// Calculate new counter values
C[0] = (C[0] + 0x4d34d34d + this._b) | 0;
C[1] = (C[1] + 0xd34d34d3 + ((C[0] >>> 0) < (C_[0] >>> 0) ? 1 : 0)) | 0;
C[2] = (C[2] + 0x34d34d34 + ((C[1] >>> 0) < (C_[1] >>> 0) ? 1 : 0)) | 0;
C[3] = (C[3] + 0x4d34d34d + ((C[2] >>> 0) < (C_[2] >>> 0) ? 1 : 0)) | 0;
C[4] = (C[4] + 0xd34d34d3 + ((C[3] >>> 0) < (C_[3] >>> 0) ? 1 : 0)) | 0;
C[5] = (C[5] + 0x34d34d34 + ((C[4] >>> 0) < (C_[4] >>> 0) ? 1 : 0)) | 0;
C[6] = (C[6] + 0x4d34d34d + ((C[5] >>> 0) < (C_[5] >>> 0) ? 1 : 0)) | 0;
C[7] = (C[7] + 0xd34d34d3 + ((C[6] >>> 0) < (C_[6] >>> 0) ? 1 : 0)) | 0;
this._b = (C[7] >>> 0) < (C_[7] >>> 0) ? 1 : 0;
// Calculate the g-values
for (var i = 0; i < 8; i++) {
var gx = X[i] + C[i];
// Construct high and low argument for squaring
var ga = gx & 0xffff;
var gb = gx >>> 16;
// Calculate high and low result of squaring
var gh = ((((ga * ga) >>> 17) + ga * gb) >>> 15) + gb * gb;
var gl = (((gx & 0xffff0000) * gx) | 0) + (((gx & 0x0000ffff) * gx) | 0);
// High XOR low
G[i] = gh ^ gl;
}
// Calculate new state values
X[0] = (G[0] + ((G[7] << 16) | (G[7] >>> 16)) + ((G[6] << 16) | (G[6] >>> 16))) | 0;
X[1] = (G[1] + ((G[0] << 8) | (G[0] >>> 24)) + G[7]) | 0;
X[2] = (G[2] + ((G[1] << 16) | (G[1] >>> 16)) + ((G[0] << 16) | (G[0] >>> 16))) | 0;
X[3] = (G[3] + ((G[2] << 8) | (G[2] >>> 24)) + G[1]) | 0;
X[4] = (G[4] + ((G[3] << 16) | (G[3] >>> 16)) + ((G[2] << 16) | (G[2] >>> 16))) | 0;
X[5] = (G[5] + ((G[4] << 8) | (G[4] >>> 24)) + G[3]) | 0;
X[6] = (G[6] + ((G[5] << 16) | (G[5] >>> 16)) + ((G[4] << 16) | (G[4] >>> 16))) | 0;
X[7] = (G[7] + ((G[6] << 8) | (G[6] >>> 24)) + G[5]) | 0;
}
/**
* Shortcut functions to the cipher's object interface.
*
* @example
*
* var ciphertext = CryptoJS.RabbitLegacy.encrypt(message, key, cfg);
* var plaintext = CryptoJS.RabbitLegacy.decrypt(ciphertext, key, cfg);
*/
C.RabbitLegacy = StreamCipher._createHelper(RabbitLegacy);
}());
return CryptoJS.RabbitLegacy;
}));
``` | /content/code_sandbox/node_modules/crypto-js/rabbit-legacy.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 2,445 |
```javascript
;(function (root, factory, undef) {
if (typeof exports === "object") {
// CommonJS
module.exports = exports = factory(require("./core"), require("./cipher-core"));
}
else if (typeof define === "function" && define.amd) {
// AMD
define(["./core", "./cipher-core"], factory);
}
else {
// Global (browser)
factory(root.CryptoJS);
}
}(this, function (CryptoJS) {
return CryptoJS.pad.Pkcs7;
}));
``` | /content/code_sandbox/node_modules/crypto-js/pad-pkcs7.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 117 |
```javascript
;(function (root, factory) {
if (typeof exports === "object") {
// CommonJS
module.exports = exports = factory(require("./core"));
}
else if (typeof define === "function" && define.amd) {
// AMD
define(["./core"], factory);
}
else {
// Global (browser)
factory(root.CryptoJS);
}
}(this, function (CryptoJS) {
return CryptoJS.enc.Utf8;
}));
``` | /content/code_sandbox/node_modules/crypto-js/enc-utf8.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 105 |
```javascript
;(function (root, factory, undef) {
if (typeof exports === "object") {
// CommonJS
module.exports = exports = factory(require("./core"), require("./sha1"), require("./hmac"));
}
else if (typeof define === "function" && define.amd) {
// AMD
define(["./core", "./sha1", "./hmac"], factory);
}
else {
// Global (browser)
factory(root.CryptoJS);
}
}(this, function (CryptoJS) {
(function () {
// Shortcuts
var C = CryptoJS;
var C_lib = C.lib;
var Base = C_lib.Base;
var WordArray = C_lib.WordArray;
var C_algo = C.algo;
var MD5 = C_algo.MD5;
/**
* This key derivation function is meant to conform with EVP_BytesToKey.
* www.openssl.org/docs/crypto/EVP_BytesToKey.html
*/
var EvpKDF = C_algo.EvpKDF = Base.extend({
/**
* Configuration options.
*
* @property {number} keySize The key size in words to generate. Default: 4 (128 bits)
* @property {Hasher} hasher The hash algorithm to use. Default: MD5
* @property {number} iterations The number of iterations to perform. Default: 1
*/
cfg: Base.extend({
keySize: 128/32,
hasher: MD5,
iterations: 1
}),
/**
* Initializes a newly created key derivation function.
*
* @param {Object} cfg (Optional) The configuration options to use for the derivation.
*
* @example
*
* var kdf = CryptoJS.algo.EvpKDF.create();
* var kdf = CryptoJS.algo.EvpKDF.create({ keySize: 8 });
* var kdf = CryptoJS.algo.EvpKDF.create({ keySize: 8, iterations: 1000 });
*/
init: function (cfg) {
this.cfg = this.cfg.extend(cfg);
},
/**
* Derives a key from a password.
*
* @param {WordArray|string} password The password.
* @param {WordArray|string} salt A salt.
*
* @return {WordArray} The derived key.
*
* @example
*
* var key = kdf.compute(password, salt);
*/
compute: function (password, salt) {
// Shortcut
var cfg = this.cfg;
// Init hasher
var hasher = cfg.hasher.create();
// Initial values
var derivedKey = WordArray.create();
// Shortcuts
var derivedKeyWords = derivedKey.words;
var keySize = cfg.keySize;
var iterations = cfg.iterations;
// Generate key
while (derivedKeyWords.length < keySize) {
if (block) {
hasher.update(block);
}
var block = hasher.update(password).finalize(salt);
hasher.reset();
// Iterations
for (var i = 1; i < iterations; i++) {
block = hasher.finalize(block);
hasher.reset();
}
derivedKey.concat(block);
}
derivedKey.sigBytes = keySize * 4;
return derivedKey;
}
});
/**
* Derives a key from a password.
*
* @param {WordArray|string} password The password.
* @param {WordArray|string} salt A salt.
* @param {Object} cfg (Optional) The configuration options to use for this computation.
*
* @return {WordArray} The derived key.
*
* @static
*
* @example
*
* var key = CryptoJS.EvpKDF(password, salt);
* var key = CryptoJS.EvpKDF(password, salt, { keySize: 8 });
* var key = CryptoJS.EvpKDF(password, salt, { keySize: 8, iterations: 1000 });
*/
C.EvpKDF = function (password, salt, cfg) {
return EvpKDF.create(cfg).compute(password, salt);
};
}());
return CryptoJS.EvpKDF;
}));
``` | /content/code_sandbox/node_modules/crypto-js/evpkdf.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 943 |
```javascript
;(function (root, factory, undef) {
if (typeof exports === "object") {
// CommonJS
module.exports = exports = factory(require("./core"), require("./enc-base64"), require("./md5"), require("./evpkdf"), require("./cipher-core"));
}
else if (typeof define === "function" && define.amd) {
// AMD
define(["./core", "./enc-base64", "./md5", "./evpkdf", "./cipher-core"], factory);
}
else {
// Global (browser)
factory(root.CryptoJS);
}
}(this, function (CryptoJS) {
(function () {
// Shortcuts
var C = CryptoJS;
var C_lib = C.lib;
var WordArray = C_lib.WordArray;
var BlockCipher = C_lib.BlockCipher;
var C_algo = C.algo;
// Permuted Choice 1 constants
var PC1 = [
57, 49, 41, 33, 25, 17, 9, 1,
58, 50, 42, 34, 26, 18, 10, 2,
59, 51, 43, 35, 27, 19, 11, 3,
60, 52, 44, 36, 63, 55, 47, 39,
31, 23, 15, 7, 62, 54, 46, 38,
30, 22, 14, 6, 61, 53, 45, 37,
29, 21, 13, 5, 28, 20, 12, 4
];
// Permuted Choice 2 constants
var PC2 = [
14, 17, 11, 24, 1, 5,
3, 28, 15, 6, 21, 10,
23, 19, 12, 4, 26, 8,
16, 7, 27, 20, 13, 2,
41, 52, 31, 37, 47, 55,
30, 40, 51, 45, 33, 48,
44, 49, 39, 56, 34, 53,
46, 42, 50, 36, 29, 32
];
// Cumulative bit shift constants
var BIT_SHIFTS = [1, 2, 4, 6, 8, 10, 12, 14, 15, 17, 19, 21, 23, 25, 27, 28];
// SBOXes and round permutation constants
var SBOX_P = [
{
0x0: 0x808200,
0x10000000: 0x8000,
0x20000000: 0x808002,
0x30000000: 0x2,
0x40000000: 0x200,
0x50000000: 0x808202,
0x60000000: 0x800202,
0x70000000: 0x800000,
0x80000000: 0x202,
0x90000000: 0x800200,
0xa0000000: 0x8200,
0xb0000000: 0x808000,
0xc0000000: 0x8002,
0xd0000000: 0x800002,
0xe0000000: 0x0,
0xf0000000: 0x8202,
0x8000000: 0x0,
0x18000000: 0x808202,
0x28000000: 0x8202,
0x38000000: 0x8000,
0x48000000: 0x808200,
0x58000000: 0x200,
0x68000000: 0x808002,
0x78000000: 0x2,
0x88000000: 0x800200,
0x98000000: 0x8200,
0xa8000000: 0x808000,
0xb8000000: 0x800202,
0xc8000000: 0x800002,
0xd8000000: 0x8002,
0xe8000000: 0x202,
0xf8000000: 0x800000,
0x1: 0x8000,
0x10000001: 0x2,
0x20000001: 0x808200,
0x30000001: 0x800000,
0x40000001: 0x808002,
0x50000001: 0x8200,
0x60000001: 0x200,
0x70000001: 0x800202,
0x80000001: 0x808202,
0x90000001: 0x808000,
0xa0000001: 0x800002,
0xb0000001: 0x8202,
0xc0000001: 0x202,
0xd0000001: 0x800200,
0xe0000001: 0x8002,
0xf0000001: 0x0,
0x8000001: 0x808202,
0x18000001: 0x808000,
0x28000001: 0x800000,
0x38000001: 0x200,
0x48000001: 0x8000,
0x58000001: 0x800002,
0x68000001: 0x2,
0x78000001: 0x8202,
0x88000001: 0x8002,
0x98000001: 0x800202,
0xa8000001: 0x202,
0xb8000001: 0x808200,
0xc8000001: 0x800200,
0xd8000001: 0x0,
0xe8000001: 0x8200,
0xf8000001: 0x808002
},
{
0x0: 0x40084010,
0x1000000: 0x4000,
0x2000000: 0x80000,
0x3000000: 0x40080010,
0x4000000: 0x40000010,
0x5000000: 0x40084000,
0x6000000: 0x40004000,
0x7000000: 0x10,
0x8000000: 0x84000,
0x9000000: 0x40004010,
0xa000000: 0x40000000,
0xb000000: 0x84010,
0xc000000: 0x80010,
0xd000000: 0x0,
0xe000000: 0x4010,
0xf000000: 0x40080000,
0x800000: 0x40004000,
0x1800000: 0x84010,
0x2800000: 0x10,
0x3800000: 0x40004010,
0x4800000: 0x40084010,
0x5800000: 0x40000000,
0x6800000: 0x80000,
0x7800000: 0x40080010,
0x8800000: 0x80010,
0x9800000: 0x0,
0xa800000: 0x4000,
0xb800000: 0x40080000,
0xc800000: 0x40000010,
0xd800000: 0x84000,
0xe800000: 0x40084000,
0xf800000: 0x4010,
0x10000000: 0x0,
0x11000000: 0x40080010,
0x12000000: 0x40004010,
0x13000000: 0x40084000,
0x14000000: 0x40080000,
0x15000000: 0x10,
0x16000000: 0x84010,
0x17000000: 0x4000,
0x18000000: 0x4010,
0x19000000: 0x80000,
0x1a000000: 0x80010,
0x1b000000: 0x40000010,
0x1c000000: 0x84000,
0x1d000000: 0x40004000,
0x1e000000: 0x40000000,
0x1f000000: 0x40084010,
0x10800000: 0x84010,
0x11800000: 0x80000,
0x12800000: 0x40080000,
0x13800000: 0x4000,
0x14800000: 0x40004000,
0x15800000: 0x40084010,
0x16800000: 0x10,
0x17800000: 0x40000000,
0x18800000: 0x40084000,
0x19800000: 0x40000010,
0x1a800000: 0x40004010,
0x1b800000: 0x80010,
0x1c800000: 0x0,
0x1d800000: 0x4010,
0x1e800000: 0x40080010,
0x1f800000: 0x84000
},
{
0x0: 0x104,
0x100000: 0x0,
0x200000: 0x4000100,
0x300000: 0x10104,
0x400000: 0x10004,
0x500000: 0x4000004,
0x600000: 0x4010104,
0x700000: 0x4010000,
0x800000: 0x4000000,
0x900000: 0x4010100,
0xa00000: 0x10100,
0xb00000: 0x4010004,
0xc00000: 0x4000104,
0xd00000: 0x10000,
0xe00000: 0x4,
0xf00000: 0x100,
0x80000: 0x4010100,
0x180000: 0x4010004,
0x280000: 0x0,
0x380000: 0x4000100,
0x480000: 0x4000004,
0x580000: 0x10000,
0x680000: 0x10004,
0x780000: 0x104,
0x880000: 0x4,
0x980000: 0x100,
0xa80000: 0x4010000,
0xb80000: 0x10104,
0xc80000: 0x10100,
0xd80000: 0x4000104,
0xe80000: 0x4010104,
0xf80000: 0x4000000,
0x1000000: 0x4010100,
0x1100000: 0x10004,
0x1200000: 0x10000,
0x1300000: 0x4000100,
0x1400000: 0x100,
0x1500000: 0x4010104,
0x1600000: 0x4000004,
0x1700000: 0x0,
0x1800000: 0x4000104,
0x1900000: 0x4000000,
0x1a00000: 0x4,
0x1b00000: 0x10100,
0x1c00000: 0x4010000,
0x1d00000: 0x104,
0x1e00000: 0x10104,
0x1f00000: 0x4010004,
0x1080000: 0x4000000,
0x1180000: 0x104,
0x1280000: 0x4010100,
0x1380000: 0x0,
0x1480000: 0x10004,
0x1580000: 0x4000100,
0x1680000: 0x100,
0x1780000: 0x4010004,
0x1880000: 0x10000,
0x1980000: 0x4010104,
0x1a80000: 0x10104,
0x1b80000: 0x4000004,
0x1c80000: 0x4000104,
0x1d80000: 0x4010000,
0x1e80000: 0x4,
0x1f80000: 0x10100
},
{
0x0: 0x80401000,
0x10000: 0x80001040,
0x20000: 0x401040,
0x30000: 0x80400000,
0x40000: 0x0,
0x50000: 0x401000,
0x60000: 0x80000040,
0x70000: 0x400040,
0x80000: 0x80000000,
0x90000: 0x400000,
0xa0000: 0x40,
0xb0000: 0x80001000,
0xc0000: 0x80400040,
0xd0000: 0x1040,
0xe0000: 0x1000,
0xf0000: 0x80401040,
0x8000: 0x80001040,
0x18000: 0x40,
0x28000: 0x80400040,
0x38000: 0x80001000,
0x48000: 0x401000,
0x58000: 0x80401040,
0x68000: 0x0,
0x78000: 0x80400000,
0x88000: 0x1000,
0x98000: 0x80401000,
0xa8000: 0x400000,
0xb8000: 0x1040,
0xc8000: 0x80000000,
0xd8000: 0x400040,
0xe8000: 0x401040,
0xf8000: 0x80000040,
0x100000: 0x400040,
0x110000: 0x401000,
0x120000: 0x80000040,
0x130000: 0x0,
0x140000: 0x1040,
0x150000: 0x80400040,
0x160000: 0x80401000,
0x170000: 0x80001040,
0x180000: 0x80401040,
0x190000: 0x80000000,
0x1a0000: 0x80400000,
0x1b0000: 0x401040,
0x1c0000: 0x80001000,
0x1d0000: 0x400000,
0x1e0000: 0x40,
0x1f0000: 0x1000,
0x108000: 0x80400000,
0x118000: 0x80401040,
0x128000: 0x0,
0x138000: 0x401000,
0x148000: 0x400040,
0x158000: 0x80000000,
0x168000: 0x80001040,
0x178000: 0x40,
0x188000: 0x80000040,
0x198000: 0x1000,
0x1a8000: 0x80001000,
0x1b8000: 0x80400040,
0x1c8000: 0x1040,
0x1d8000: 0x80401000,
0x1e8000: 0x400000,
0x1f8000: 0x401040
},
{
0x0: 0x80,
0x1000: 0x1040000,
0x2000: 0x40000,
0x3000: 0x20000000,
0x4000: 0x20040080,
0x5000: 0x1000080,
0x6000: 0x21000080,
0x7000: 0x40080,
0x8000: 0x1000000,
0x9000: 0x20040000,
0xa000: 0x20000080,
0xb000: 0x21040080,
0xc000: 0x21040000,
0xd000: 0x0,
0xe000: 0x1040080,
0xf000: 0x21000000,
0x800: 0x1040080,
0x1800: 0x21000080,
0x2800: 0x80,
0x3800: 0x1040000,
0x4800: 0x40000,
0x5800: 0x20040080,
0x6800: 0x21040000,
0x7800: 0x20000000,
0x8800: 0x20040000,
0x9800: 0x0,
0xa800: 0x21040080,
0xb800: 0x1000080,
0xc800: 0x20000080,
0xd800: 0x21000000,
0xe800: 0x1000000,
0xf800: 0x40080,
0x10000: 0x40000,
0x11000: 0x80,
0x12000: 0x20000000,
0x13000: 0x21000080,
0x14000: 0x1000080,
0x15000: 0x21040000,
0x16000: 0x20040080,
0x17000: 0x1000000,
0x18000: 0x21040080,
0x19000: 0x21000000,
0x1a000: 0x1040000,
0x1b000: 0x20040000,
0x1c000: 0x40080,
0x1d000: 0x20000080,
0x1e000: 0x0,
0x1f000: 0x1040080,
0x10800: 0x21000080,
0x11800: 0x1000000,
0x12800: 0x1040000,
0x13800: 0x20040080,
0x14800: 0x20000000,
0x15800: 0x1040080,
0x16800: 0x80,
0x17800: 0x21040000,
0x18800: 0x40080,
0x19800: 0x21040080,
0x1a800: 0x0,
0x1b800: 0x21000000,
0x1c800: 0x1000080,
0x1d800: 0x40000,
0x1e800: 0x20040000,
0x1f800: 0x20000080
},
{
0x0: 0x10000008,
0x100: 0x2000,
0x200: 0x10200000,
0x300: 0x10202008,
0x400: 0x10002000,
0x500: 0x200000,
0x600: 0x200008,
0x700: 0x10000000,
0x800: 0x0,
0x900: 0x10002008,
0xa00: 0x202000,
0xb00: 0x8,
0xc00: 0x10200008,
0xd00: 0x202008,
0xe00: 0x2008,
0xf00: 0x10202000,
0x80: 0x10200000,
0x180: 0x10202008,
0x280: 0x8,
0x380: 0x200000,
0x480: 0x202008,
0x580: 0x10000008,
0x680: 0x10002000,
0x780: 0x2008,
0x880: 0x200008,
0x980: 0x2000,
0xa80: 0x10002008,
0xb80: 0x10200008,
0xc80: 0x0,
0xd80: 0x10202000,
0xe80: 0x202000,
0xf80: 0x10000000,
0x1000: 0x10002000,
0x1100: 0x10200008,
0x1200: 0x10202008,
0x1300: 0x2008,
0x1400: 0x200000,
0x1500: 0x10000000,
0x1600: 0x10000008,
0x1700: 0x202000,
0x1800: 0x202008,
0x1900: 0x0,
0x1a00: 0x8,
0x1b00: 0x10200000,
0x1c00: 0x2000,
0x1d00: 0x10002008,
0x1e00: 0x10202000,
0x1f00: 0x200008,
0x1080: 0x8,
0x1180: 0x202000,
0x1280: 0x200000,
0x1380: 0x10000008,
0x1480: 0x10002000,
0x1580: 0x2008,
0x1680: 0x10202008,
0x1780: 0x10200000,
0x1880: 0x10202000,
0x1980: 0x10200008,
0x1a80: 0x2000,
0x1b80: 0x202008,
0x1c80: 0x200008,
0x1d80: 0x0,
0x1e80: 0x10000000,
0x1f80: 0x10002008
},
{
0x0: 0x100000,
0x10: 0x2000401,
0x20: 0x400,
0x30: 0x100401,
0x40: 0x2100401,
0x50: 0x0,
0x60: 0x1,
0x70: 0x2100001,
0x80: 0x2000400,
0x90: 0x100001,
0xa0: 0x2000001,
0xb0: 0x2100400,
0xc0: 0x2100000,
0xd0: 0x401,
0xe0: 0x100400,
0xf0: 0x2000000,
0x8: 0x2100001,
0x18: 0x0,
0x28: 0x2000401,
0x38: 0x2100400,
0x48: 0x100000,
0x58: 0x2000001,
0x68: 0x2000000,
0x78: 0x401,
0x88: 0x100401,
0x98: 0x2000400,
0xa8: 0x2100000,
0xb8: 0x100001,
0xc8: 0x400,
0xd8: 0x2100401,
0xe8: 0x1,
0xf8: 0x100400,
0x100: 0x2000000,
0x110: 0x100000,
0x120: 0x2000401,
0x130: 0x2100001,
0x140: 0x100001,
0x150: 0x2000400,
0x160: 0x2100400,
0x170: 0x100401,
0x180: 0x401,
0x190: 0x2100401,
0x1a0: 0x100400,
0x1b0: 0x1,
0x1c0: 0x0,
0x1d0: 0x2100000,
0x1e0: 0x2000001,
0x1f0: 0x400,
0x108: 0x100400,
0x118: 0x2000401,
0x128: 0x2100001,
0x138: 0x1,
0x148: 0x2000000,
0x158: 0x100000,
0x168: 0x401,
0x178: 0x2100400,
0x188: 0x2000001,
0x198: 0x2100000,
0x1a8: 0x0,
0x1b8: 0x2100401,
0x1c8: 0x100401,
0x1d8: 0x400,
0x1e8: 0x2000400,
0x1f8: 0x100001
},
{
0x0: 0x8000820,
0x1: 0x20000,
0x2: 0x8000000,
0x3: 0x20,
0x4: 0x20020,
0x5: 0x8020820,
0x6: 0x8020800,
0x7: 0x800,
0x8: 0x8020000,
0x9: 0x8000800,
0xa: 0x20800,
0xb: 0x8020020,
0xc: 0x820,
0xd: 0x0,
0xe: 0x8000020,
0xf: 0x20820,
0x80000000: 0x800,
0x80000001: 0x8020820,
0x80000002: 0x8000820,
0x80000003: 0x8000000,
0x80000004: 0x8020000,
0x80000005: 0x20800,
0x80000006: 0x20820,
0x80000007: 0x20,
0x80000008: 0x8000020,
0x80000009: 0x820,
0x8000000a: 0x20020,
0x8000000b: 0x8020800,
0x8000000c: 0x0,
0x8000000d: 0x8020020,
0x8000000e: 0x8000800,
0x8000000f: 0x20000,
0x10: 0x20820,
0x11: 0x8020800,
0x12: 0x20,
0x13: 0x800,
0x14: 0x8000800,
0x15: 0x8000020,
0x16: 0x8020020,
0x17: 0x20000,
0x18: 0x0,
0x19: 0x20020,
0x1a: 0x8020000,
0x1b: 0x8000820,
0x1c: 0x8020820,
0x1d: 0x20800,
0x1e: 0x820,
0x1f: 0x8000000,
0x80000010: 0x20000,
0x80000011: 0x800,
0x80000012: 0x8020020,
0x80000013: 0x20820,
0x80000014: 0x20,
0x80000015: 0x8020000,
0x80000016: 0x8000000,
0x80000017: 0x8000820,
0x80000018: 0x8020820,
0x80000019: 0x8000020,
0x8000001a: 0x8000800,
0x8000001b: 0x0,
0x8000001c: 0x20800,
0x8000001d: 0x820,
0x8000001e: 0x20020,
0x8000001f: 0x8020800
}
];
// Masks that select the SBOX input
var SBOX_MASK = [
0xf8000001, 0x1f800000, 0x01f80000, 0x001f8000,
0x0001f800, 0x00001f80, 0x000001f8, 0x8000001f
];
/**
* DES block cipher algorithm.
*/
var DES = C_algo.DES = BlockCipher.extend({
_doReset: function () {
// Shortcuts
var key = this._key;
var keyWords = key.words;
// Select 56 bits according to PC1
var keyBits = [];
for (var i = 0; i < 56; i++) {
var keyBitPos = PC1[i] - 1;
keyBits[i] = (keyWords[keyBitPos >>> 5] >>> (31 - keyBitPos % 32)) & 1;
}
// Assemble 16 subkeys
var subKeys = this._subKeys = [];
for (var nSubKey = 0; nSubKey < 16; nSubKey++) {
// Create subkey
var subKey = subKeys[nSubKey] = [];
// Shortcut
var bitShift = BIT_SHIFTS[nSubKey];
// Select 48 bits according to PC2
for (var i = 0; i < 24; i++) {
// Select from the left 28 key bits
subKey[(i / 6) | 0] |= keyBits[((PC2[i] - 1) + bitShift) % 28] << (31 - i % 6);
// Select from the right 28 key bits
subKey[4 + ((i / 6) | 0)] |= keyBits[28 + (((PC2[i + 24] - 1) + bitShift) % 28)] << (31 - i % 6);
}
// Since each subkey is applied to an expanded 32-bit input,
// the subkey can be broken into 8 values scaled to 32-bits,
// which allows the key to be used without expansion
subKey[0] = (subKey[0] << 1) | (subKey[0] >>> 31);
for (var i = 1; i < 7; i++) {
subKey[i] = subKey[i] >>> ((i - 1) * 4 + 3);
}
subKey[7] = (subKey[7] << 5) | (subKey[7] >>> 27);
}
// Compute inverse subkeys
var invSubKeys = this._invSubKeys = [];
for (var i = 0; i < 16; i++) {
invSubKeys[i] = subKeys[15 - i];
}
},
encryptBlock: function (M, offset) {
this._doCryptBlock(M, offset, this._subKeys);
},
decryptBlock: function (M, offset) {
this._doCryptBlock(M, offset, this._invSubKeys);
},
_doCryptBlock: function (M, offset, subKeys) {
// Get input
this._lBlock = M[offset];
this._rBlock = M[offset + 1];
// Initial permutation
exchangeLR.call(this, 4, 0x0f0f0f0f);
exchangeLR.call(this, 16, 0x0000ffff);
exchangeRL.call(this, 2, 0x33333333);
exchangeRL.call(this, 8, 0x00ff00ff);
exchangeLR.call(this, 1, 0x55555555);
// Rounds
for (var round = 0; round < 16; round++) {
// Shortcuts
var subKey = subKeys[round];
var lBlock = this._lBlock;
var rBlock = this._rBlock;
// Feistel function
var f = 0;
for (var i = 0; i < 8; i++) {
f |= SBOX_P[i][((rBlock ^ subKey[i]) & SBOX_MASK[i]) >>> 0];
}
this._lBlock = rBlock;
this._rBlock = lBlock ^ f;
}
// Undo swap from last round
var t = this._lBlock;
this._lBlock = this._rBlock;
this._rBlock = t;
// Final permutation
exchangeLR.call(this, 1, 0x55555555);
exchangeRL.call(this, 8, 0x00ff00ff);
exchangeRL.call(this, 2, 0x33333333);
exchangeLR.call(this, 16, 0x0000ffff);
exchangeLR.call(this, 4, 0x0f0f0f0f);
// Set output
M[offset] = this._lBlock;
M[offset + 1] = this._rBlock;
},
keySize: 64/32,
ivSize: 64/32,
blockSize: 64/32
});
// Swap bits across the left and right words
function exchangeLR(offset, mask) {
var t = ((this._lBlock >>> offset) ^ this._rBlock) & mask;
this._rBlock ^= t;
this._lBlock ^= t << offset;
}
function exchangeRL(offset, mask) {
var t = ((this._rBlock >>> offset) ^ this._lBlock) & mask;
this._lBlock ^= t;
this._rBlock ^= t << offset;
}
/**
* Shortcut functions to the cipher's object interface.
*
* @example
*
* var ciphertext = CryptoJS.DES.encrypt(message, key, cfg);
* var plaintext = CryptoJS.DES.decrypt(ciphertext, key, cfg);
*/
C.DES = BlockCipher._createHelper(DES);
/**
* Triple-DES block cipher algorithm.
*/
var TripleDES = C_algo.TripleDES = BlockCipher.extend({
_doReset: function () {
// Shortcuts
var key = this._key;
var keyWords = key.words;
// Create DES instances
this._des1 = DES.createEncryptor(WordArray.create(keyWords.slice(0, 2)));
this._des2 = DES.createEncryptor(WordArray.create(keyWords.slice(2, 4)));
this._des3 = DES.createEncryptor(WordArray.create(keyWords.slice(4, 6)));
},
encryptBlock: function (M, offset) {
this._des1.encryptBlock(M, offset);
this._des2.decryptBlock(M, offset);
this._des3.encryptBlock(M, offset);
},
decryptBlock: function (M, offset) {
this._des3.decryptBlock(M, offset);
this._des2.encryptBlock(M, offset);
this._des1.decryptBlock(M, offset);
},
keySize: 192/32,
ivSize: 64/32,
blockSize: 64/32
});
/**
* Shortcut functions to the cipher's object interface.
*
* @example
*
* var ciphertext = CryptoJS.TripleDES.encrypt(message, key, cfg);
* var plaintext = CryptoJS.TripleDES.decrypt(ciphertext, key, cfg);
*/
C.TripleDES = BlockCipher._createHelper(TripleDES);
}());
return CryptoJS.TripleDES;
}));
``` | /content/code_sandbox/node_modules/crypto-js/tripledes.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 9,314 |
```javascript
;(function (root, factory, undef) {
if (typeof exports === "object") {
// CommonJS
module.exports = exports = factory(require("./core"), require("./cipher-core"));
}
else if (typeof define === "function" && define.amd) {
// AMD
define(["./core", "./cipher-core"], factory);
}
else {
// Global (browser)
factory(root.CryptoJS);
}
}(this, function (CryptoJS) {
/**
* ISO 10126 padding strategy.
*/
CryptoJS.pad.Iso10126 = {
pad: function (data, blockSize) {
// Shortcut
var blockSizeBytes = blockSize * 4;
// Count padding bytes
var nPaddingBytes = blockSizeBytes - data.sigBytes % blockSizeBytes;
// Pad
data.concat(CryptoJS.lib.WordArray.random(nPaddingBytes - 1)).
concat(CryptoJS.lib.WordArray.create([nPaddingBytes << 24], 1));
},
unpad: function (data) {
// Get number of padding bytes from last byte
var nPaddingBytes = data.words[(data.sigBytes - 1) >>> 2] & 0xff;
// Remove padding
data.sigBytes -= nPaddingBytes;
}
};
return CryptoJS.pad.Iso10126;
}));
``` | /content/code_sandbox/node_modules/crypto-js/pad-iso10126.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 292 |
```javascript
;(function (root, factory) {
if (typeof exports === "object") {
// CommonJS
module.exports = exports = factory(require("./core"));
}
else if (typeof define === "function" && define.amd) {
// AMD
define(["./core"], factory);
}
else {
// Global (browser)
factory(root.CryptoJS);
}
}(this, function (CryptoJS) {
return CryptoJS.enc.Latin1;
}));
``` | /content/code_sandbox/node_modules/crypto-js/enc-latin1.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 105 |
```javascript
;(function (root, factory) {
if (typeof exports === "object") {
// CommonJS
module.exports = exports = factory(require("./core"));
}
else if (typeof define === "function" && define.amd) {
// AMD
define(["./core"], factory);
}
else {
// Global (browser)
factory(root.CryptoJS);
}
}(this, function (CryptoJS) {
(function (Math) {
// Shortcuts
var C = CryptoJS;
var C_lib = C.lib;
var WordArray = C_lib.WordArray;
var Hasher = C_lib.Hasher;
var C_algo = C.algo;
// Initialization and round constants tables
var H = [];
var K = [];
// Compute constants
(function () {
function isPrime(n) {
var sqrtN = Math.sqrt(n);
for (var factor = 2; factor <= sqrtN; factor++) {
if (!(n % factor)) {
return false;
}
}
return true;
}
function getFractionalBits(n) {
return ((n - (n | 0)) * 0x100000000) | 0;
}
var n = 2;
var nPrime = 0;
while (nPrime < 64) {
if (isPrime(n)) {
if (nPrime < 8) {
H[nPrime] = getFractionalBits(Math.pow(n, 1 / 2));
}
K[nPrime] = getFractionalBits(Math.pow(n, 1 / 3));
nPrime++;
}
n++;
}
}());
// Reusable object
var W = [];
/**
* SHA-256 hash algorithm.
*/
var SHA256 = C_algo.SHA256 = Hasher.extend({
_doReset: function () {
this._hash = new WordArray.init(H.slice(0));
},
_doProcessBlock: function (M, offset) {
// Shortcut
var H = this._hash.words;
// Working variables
var a = H[0];
var b = H[1];
var c = H[2];
var d = H[3];
var e = H[4];
var f = H[5];
var g = H[6];
var h = H[7];
// Computation
for (var i = 0; i < 64; i++) {
if (i < 16) {
W[i] = M[offset + i] | 0;
} else {
var gamma0x = W[i - 15];
var gamma0 = ((gamma0x << 25) | (gamma0x >>> 7)) ^
((gamma0x << 14) | (gamma0x >>> 18)) ^
(gamma0x >>> 3);
var gamma1x = W[i - 2];
var gamma1 = ((gamma1x << 15) | (gamma1x >>> 17)) ^
((gamma1x << 13) | (gamma1x >>> 19)) ^
(gamma1x >>> 10);
W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16];
}
var ch = (e & f) ^ (~e & g);
var maj = (a & b) ^ (a & c) ^ (b & c);
var sigma0 = ((a << 30) | (a >>> 2)) ^ ((a << 19) | (a >>> 13)) ^ ((a << 10) | (a >>> 22));
var sigma1 = ((e << 26) | (e >>> 6)) ^ ((e << 21) | (e >>> 11)) ^ ((e << 7) | (e >>> 25));
var t1 = h + sigma1 + ch + K[i] + W[i];
var t2 = sigma0 + maj;
h = g;
g = f;
f = e;
e = (d + t1) | 0;
d = c;
c = b;
b = a;
a = (t1 + t2) | 0;
}
// Intermediate hash value
H[0] = (H[0] + a) | 0;
H[1] = (H[1] + b) | 0;
H[2] = (H[2] + c) | 0;
H[3] = (H[3] + d) | 0;
H[4] = (H[4] + e) | 0;
H[5] = (H[5] + f) | 0;
H[6] = (H[6] + g) | 0;
H[7] = (H[7] + h) | 0;
},
_doFinalize: function () {
// Shortcuts
var data = this._data;
var dataWords = data.words;
var nBitsTotal = this._nDataBytes * 8;
var nBitsLeft = data.sigBytes * 8;
// Add padding
dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32);
dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = Math.floor(nBitsTotal / 0x100000000);
dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = nBitsTotal;
data.sigBytes = dataWords.length * 4;
// Hash final blocks
this._process();
// Return final computed hash
return this._hash;
},
clone: function () {
var clone = Hasher.clone.call(this);
clone._hash = this._hash.clone();
return clone;
}
});
/**
* Shortcut function to the hasher's object interface.
*
* @param {WordArray|string} message The message to hash.
*
* @return {WordArray} The hash.
*
* @static
*
* @example
*
* var hash = CryptoJS.SHA256('message');
* var hash = CryptoJS.SHA256(wordArray);
*/
C.SHA256 = Hasher._createHelper(SHA256);
/**
* Shortcut function to the HMAC's object interface.
*
* @param {WordArray|string} message The message to hash.
* @param {WordArray|string} key The secret key.
*
* @return {WordArray} The HMAC.
*
* @static
*
* @example
*
* var hmac = CryptoJS.HmacSHA256(message, key);
*/
C.HmacSHA256 = Hasher._createHmacHelper(SHA256);
}(Math));
return CryptoJS.SHA256;
}));
``` | /content/code_sandbox/node_modules/crypto-js/sha256.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 1,555 |
```javascript
;(function (root, factory, undef) {
if (typeof exports === "object") {
// CommonJS
module.exports = exports = factory(require("./core"), require("./cipher-core"));
}
else if (typeof define === "function" && define.amd) {
// AMD
define(["./core", "./cipher-core"], factory);
}
else {
// Global (browser)
factory(root.CryptoJS);
}
}(this, function (CryptoJS) {
(function (undefined) {
// Shortcuts
var C = CryptoJS;
var C_lib = C.lib;
var CipherParams = C_lib.CipherParams;
var C_enc = C.enc;
var Hex = C_enc.Hex;
var C_format = C.format;
var HexFormatter = C_format.Hex = {
/**
* Converts the ciphertext of a cipher params object to a hexadecimally encoded string.
*
* @param {CipherParams} cipherParams The cipher params object.
*
* @return {string} The hexadecimally encoded string.
*
* @static
*
* @example
*
* var hexString = CryptoJS.format.Hex.stringify(cipherParams);
*/
stringify: function (cipherParams) {
return cipherParams.ciphertext.toString(Hex);
},
/**
* Converts a hexadecimally encoded ciphertext string to a cipher params object.
*
* @param {string} input The hexadecimally encoded string.
*
* @return {CipherParams} The cipher params object.
*
* @static
*
* @example
*
* var cipherParams = CryptoJS.format.Hex.parse(hexString);
*/
parse: function (input) {
var ciphertext = Hex.parse(input);
return CipherParams.create({ ciphertext: ciphertext });
}
};
}());
return CryptoJS.format.Hex;
}));
``` | /content/code_sandbox/node_modules/crypto-js/format-hex.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 417 |
```javascript
;(function (root, factory) {
if (typeof exports === "object") {
// CommonJS
module.exports = exports = factory(require("./core"));
}
else if (typeof define === "function" && define.amd) {
// AMD
define(["./core"], factory);
}
else {
// Global (browser)
factory(root.CryptoJS);
}
}(this, function (CryptoJS) {
(function (Math) {
// Shortcuts
var C = CryptoJS;
var C_lib = C.lib;
var WordArray = C_lib.WordArray;
var Hasher = C_lib.Hasher;
var C_algo = C.algo;
// Constants table
var T = [];
// Compute constants
(function () {
for (var i = 0; i < 64; i++) {
T[i] = (Math.abs(Math.sin(i + 1)) * 0x100000000) | 0;
}
}());
/**
* MD5 hash algorithm.
*/
var MD5 = C_algo.MD5 = Hasher.extend({
_doReset: function () {
this._hash = new WordArray.init([
0x67452301, 0xefcdab89,
0x98badcfe, 0x10325476
]);
},
_doProcessBlock: function (M, offset) {
// Swap endian
for (var i = 0; i < 16; i++) {
// Shortcuts
var offset_i = offset + i;
var M_offset_i = M[offset_i];
M[offset_i] = (
(((M_offset_i << 8) | (M_offset_i >>> 24)) & 0x00ff00ff) |
(((M_offset_i << 24) | (M_offset_i >>> 8)) & 0xff00ff00)
);
}
// Shortcuts
var H = this._hash.words;
var M_offset_0 = M[offset + 0];
var M_offset_1 = M[offset + 1];
var M_offset_2 = M[offset + 2];
var M_offset_3 = M[offset + 3];
var M_offset_4 = M[offset + 4];
var M_offset_5 = M[offset + 5];
var M_offset_6 = M[offset + 6];
var M_offset_7 = M[offset + 7];
var M_offset_8 = M[offset + 8];
var M_offset_9 = M[offset + 9];
var M_offset_10 = M[offset + 10];
var M_offset_11 = M[offset + 11];
var M_offset_12 = M[offset + 12];
var M_offset_13 = M[offset + 13];
var M_offset_14 = M[offset + 14];
var M_offset_15 = M[offset + 15];
// Working varialbes
var a = H[0];
var b = H[1];
var c = H[2];
var d = H[3];
// Computation
a = FF(a, b, c, d, M_offset_0, 7, T[0]);
d = FF(d, a, b, c, M_offset_1, 12, T[1]);
c = FF(c, d, a, b, M_offset_2, 17, T[2]);
b = FF(b, c, d, a, M_offset_3, 22, T[3]);
a = FF(a, b, c, d, M_offset_4, 7, T[4]);
d = FF(d, a, b, c, M_offset_5, 12, T[5]);
c = FF(c, d, a, b, M_offset_6, 17, T[6]);
b = FF(b, c, d, a, M_offset_7, 22, T[7]);
a = FF(a, b, c, d, M_offset_8, 7, T[8]);
d = FF(d, a, b, c, M_offset_9, 12, T[9]);
c = FF(c, d, a, b, M_offset_10, 17, T[10]);
b = FF(b, c, d, a, M_offset_11, 22, T[11]);
a = FF(a, b, c, d, M_offset_12, 7, T[12]);
d = FF(d, a, b, c, M_offset_13, 12, T[13]);
c = FF(c, d, a, b, M_offset_14, 17, T[14]);
b = FF(b, c, d, a, M_offset_15, 22, T[15]);
a = GG(a, b, c, d, M_offset_1, 5, T[16]);
d = GG(d, a, b, c, M_offset_6, 9, T[17]);
c = GG(c, d, a, b, M_offset_11, 14, T[18]);
b = GG(b, c, d, a, M_offset_0, 20, T[19]);
a = GG(a, b, c, d, M_offset_5, 5, T[20]);
d = GG(d, a, b, c, M_offset_10, 9, T[21]);
c = GG(c, d, a, b, M_offset_15, 14, T[22]);
b = GG(b, c, d, a, M_offset_4, 20, T[23]);
a = GG(a, b, c, d, M_offset_9, 5, T[24]);
d = GG(d, a, b, c, M_offset_14, 9, T[25]);
c = GG(c, d, a, b, M_offset_3, 14, T[26]);
b = GG(b, c, d, a, M_offset_8, 20, T[27]);
a = GG(a, b, c, d, M_offset_13, 5, T[28]);
d = GG(d, a, b, c, M_offset_2, 9, T[29]);
c = GG(c, d, a, b, M_offset_7, 14, T[30]);
b = GG(b, c, d, a, M_offset_12, 20, T[31]);
a = HH(a, b, c, d, M_offset_5, 4, T[32]);
d = HH(d, a, b, c, M_offset_8, 11, T[33]);
c = HH(c, d, a, b, M_offset_11, 16, T[34]);
b = HH(b, c, d, a, M_offset_14, 23, T[35]);
a = HH(a, b, c, d, M_offset_1, 4, T[36]);
d = HH(d, a, b, c, M_offset_4, 11, T[37]);
c = HH(c, d, a, b, M_offset_7, 16, T[38]);
b = HH(b, c, d, a, M_offset_10, 23, T[39]);
a = HH(a, b, c, d, M_offset_13, 4, T[40]);
d = HH(d, a, b, c, M_offset_0, 11, T[41]);
c = HH(c, d, a, b, M_offset_3, 16, T[42]);
b = HH(b, c, d, a, M_offset_6, 23, T[43]);
a = HH(a, b, c, d, M_offset_9, 4, T[44]);
d = HH(d, a, b, c, M_offset_12, 11, T[45]);
c = HH(c, d, a, b, M_offset_15, 16, T[46]);
b = HH(b, c, d, a, M_offset_2, 23, T[47]);
a = II(a, b, c, d, M_offset_0, 6, T[48]);
d = II(d, a, b, c, M_offset_7, 10, T[49]);
c = II(c, d, a, b, M_offset_14, 15, T[50]);
b = II(b, c, d, a, M_offset_5, 21, T[51]);
a = II(a, b, c, d, M_offset_12, 6, T[52]);
d = II(d, a, b, c, M_offset_3, 10, T[53]);
c = II(c, d, a, b, M_offset_10, 15, T[54]);
b = II(b, c, d, a, M_offset_1, 21, T[55]);
a = II(a, b, c, d, M_offset_8, 6, T[56]);
d = II(d, a, b, c, M_offset_15, 10, T[57]);
c = II(c, d, a, b, M_offset_6, 15, T[58]);
b = II(b, c, d, a, M_offset_13, 21, T[59]);
a = II(a, b, c, d, M_offset_4, 6, T[60]);
d = II(d, a, b, c, M_offset_11, 10, T[61]);
c = II(c, d, a, b, M_offset_2, 15, T[62]);
b = II(b, c, d, a, M_offset_9, 21, T[63]);
// Intermediate hash value
H[0] = (H[0] + a) | 0;
H[1] = (H[1] + b) | 0;
H[2] = (H[2] + c) | 0;
H[3] = (H[3] + d) | 0;
},
_doFinalize: function () {
// Shortcuts
var data = this._data;
var dataWords = data.words;
var nBitsTotal = this._nDataBytes * 8;
var nBitsLeft = data.sigBytes * 8;
// Add padding
dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32);
var nBitsTotalH = Math.floor(nBitsTotal / 0x100000000);
var nBitsTotalL = nBitsTotal;
dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = (
(((nBitsTotalH << 8) | (nBitsTotalH >>> 24)) & 0x00ff00ff) |
(((nBitsTotalH << 24) | (nBitsTotalH >>> 8)) & 0xff00ff00)
);
dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = (
(((nBitsTotalL << 8) | (nBitsTotalL >>> 24)) & 0x00ff00ff) |
(((nBitsTotalL << 24) | (nBitsTotalL >>> 8)) & 0xff00ff00)
);
data.sigBytes = (dataWords.length + 1) * 4;
// Hash final blocks
this._process();
// Shortcuts
var hash = this._hash;
var H = hash.words;
// Swap endian
for (var i = 0; i < 4; i++) {
// Shortcut
var H_i = H[i];
H[i] = (((H_i << 8) | (H_i >>> 24)) & 0x00ff00ff) |
(((H_i << 24) | (H_i >>> 8)) & 0xff00ff00);
}
// Return final computed hash
return hash;
},
clone: function () {
var clone = Hasher.clone.call(this);
clone._hash = this._hash.clone();
return clone;
}
});
function FF(a, b, c, d, x, s, t) {
var n = a + ((b & c) | (~b & d)) + x + t;
return ((n << s) | (n >>> (32 - s))) + b;
}
function GG(a, b, c, d, x, s, t) {
var n = a + ((b & d) | (c & ~d)) + x + t;
return ((n << s) | (n >>> (32 - s))) + b;
}
function HH(a, b, c, d, x, s, t) {
var n = a + (b ^ c ^ d) + x + t;
return ((n << s) | (n >>> (32 - s))) + b;
}
function II(a, b, c, d, x, s, t) {
var n = a + (c ^ (b | ~d)) + x + t;
return ((n << s) | (n >>> (32 - s))) + b;
}
/**
* Shortcut function to the hasher's object interface.
*
* @param {WordArray|string} message The message to hash.
*
* @return {WordArray} The hash.
*
* @static
*
* @example
*
* var hash = CryptoJS.MD5('message');
* var hash = CryptoJS.MD5(wordArray);
*/
C.MD5 = Hasher._createHelper(MD5);
/**
* Shortcut function to the HMAC's object interface.
*
* @param {WordArray|string} message The message to hash.
* @param {WordArray|string} key The secret key.
*
* @return {WordArray} The HMAC.
*
* @static
*
* @example
*
* var hmac = CryptoJS.HmacMD5(message, key);
*/
C.HmacMD5 = Hasher._createHmacHelper(MD5);
}(Math));
return CryptoJS.MD5;
}));
``` | /content/code_sandbox/node_modules/crypto-js/md5.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 3,325 |
```javascript
;(function (root, factory) {
if (typeof exports === "object") {
// CommonJS
module.exports = exports = factory(require("./core"));
}
else if (typeof define === "function" && define.amd) {
// AMD
define(["./core"], factory);
}
else {
// Global (browser)
factory(root.CryptoJS);
}
}(this, function (CryptoJS) {
(function () {
// Shortcuts
var C = CryptoJS;
var C_lib = C.lib;
var Base = C_lib.Base;
var C_enc = C.enc;
var Utf8 = C_enc.Utf8;
var C_algo = C.algo;
/**
* HMAC algorithm.
*/
var HMAC = C_algo.HMAC = Base.extend({
/**
* Initializes a newly created HMAC.
*
* @param {Hasher} hasher The hash algorithm to use.
* @param {WordArray|string} key The secret key.
*
* @example
*
* var hmacHasher = CryptoJS.algo.HMAC.create(CryptoJS.algo.SHA256, key);
*/
init: function (hasher, key) {
// Init hasher
hasher = this._hasher = new hasher.init();
// Convert string to WordArray, else assume WordArray already
if (typeof key == 'string') {
key = Utf8.parse(key);
}
// Shortcuts
var hasherBlockSize = hasher.blockSize;
var hasherBlockSizeBytes = hasherBlockSize * 4;
// Allow arbitrary length keys
if (key.sigBytes > hasherBlockSizeBytes) {
key = hasher.finalize(key);
}
// Clamp excess bits
key.clamp();
// Clone key for inner and outer pads
var oKey = this._oKey = key.clone();
var iKey = this._iKey = key.clone();
// Shortcuts
var oKeyWords = oKey.words;
var iKeyWords = iKey.words;
// XOR keys with pad constants
for (var i = 0; i < hasherBlockSize; i++) {
oKeyWords[i] ^= 0x5c5c5c5c;
iKeyWords[i] ^= 0x36363636;
}
oKey.sigBytes = iKey.sigBytes = hasherBlockSizeBytes;
// Set initial values
this.reset();
},
/**
* Resets this HMAC to its initial state.
*
* @example
*
* hmacHasher.reset();
*/
reset: function () {
// Shortcut
var hasher = this._hasher;
// Reset
hasher.reset();
hasher.update(this._iKey);
},
/**
* Updates this HMAC with a message.
*
* @param {WordArray|string} messageUpdate The message to append.
*
* @return {HMAC} This HMAC instance.
*
* @example
*
* hmacHasher.update('message');
* hmacHasher.update(wordArray);
*/
update: function (messageUpdate) {
this._hasher.update(messageUpdate);
// Chainable
return this;
},
/**
* Finalizes the HMAC computation.
* Note that the finalize operation is effectively a destructive, read-once operation.
*
* @param {WordArray|string} messageUpdate (Optional) A final message update.
*
* @return {WordArray} The HMAC.
*
* @example
*
* var hmac = hmacHasher.finalize();
* var hmac = hmacHasher.finalize('message');
* var hmac = hmacHasher.finalize(wordArray);
*/
finalize: function (messageUpdate) {
// Shortcut
var hasher = this._hasher;
// Compute HMAC
var innerHash = hasher.finalize(messageUpdate);
hasher.reset();
var hmac = hasher.finalize(this._oKey.clone().concat(innerHash));
return hmac;
}
});
}());
}));
``` | /content/code_sandbox/node_modules/crypto-js/hmac.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 885 |
```javascript
;(function (root, factory, undef) {
if (typeof exports === "object") {
// CommonJS
module.exports = exports = factory(require("./core"), require("./md5"), require("./hmac"));
}
else if (typeof define === "function" && define.amd) {
// AMD
define(["./core", "./md5", "./hmac"], factory);
}
else {
// Global (browser)
factory(root.CryptoJS);
}
}(this, function (CryptoJS) {
return CryptoJS.HmacMD5;
}));
``` | /content/code_sandbox/node_modules/crypto-js/hmac-md5.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 125 |
```javascript
;(function (root, factory, undef) {
if (typeof exports === "object") {
// CommonJS
module.exports = exports = factory(require("./core"), require("./cipher-core"));
}
else if (typeof define === "function" && define.amd) {
// AMD
define(["./core", "./cipher-core"], factory);
}
else {
// Global (browser)
factory(root.CryptoJS);
}
}(this, function (CryptoJS) {
/**
* Zero padding strategy.
*/
CryptoJS.pad.ZeroPadding = {
pad: function (data, blockSize) {
// Shortcut
var blockSizeBytes = blockSize * 4;
// Pad
data.clamp();
data.sigBytes += blockSizeBytes - ((data.sigBytes % blockSizeBytes) || blockSizeBytes);
},
unpad: function (data) {
// Shortcut
var dataWords = data.words;
// Unpad
var i = data.sigBytes - 1;
while (!((dataWords[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff)) {
i--;
}
data.sigBytes = i + 1;
}
};
return CryptoJS.pad.ZeroPadding;
}));
``` | /content/code_sandbox/node_modules/crypto-js/pad-zeropadding.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 274 |
```javascript
;(function (root, factory, undef) {
if (typeof exports === "object") {
// CommonJS
module.exports = exports = factory(require("./core"), require("./cipher-core"));
}
else if (typeof define === "function" && define.amd) {
// AMD
define(["./core", "./cipher-core"], factory);
}
else {
// Global (browser)
factory(root.CryptoJS);
}
}(this, function (CryptoJS) {
/**
* A noop padding strategy.
*/
CryptoJS.pad.NoPadding = {
pad: function () {
},
unpad: function () {
}
};
return CryptoJS.pad.NoPadding;
}));
``` | /content/code_sandbox/node_modules/crypto-js/pad-nopadding.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 153 |
```javascript
;(function (root, factory, undef) {
if (typeof exports === "object") {
// CommonJS
module.exports = exports = factory(require("./core"), require("./cipher-core"));
}
else if (typeof define === "function" && define.amd) {
// AMD
define(["./core", "./cipher-core"], factory);
}
else {
// Global (browser)
factory(root.CryptoJS);
}
}(this, function (CryptoJS) {
/**
* Electronic Codebook block mode.
*/
CryptoJS.mode.ECB = (function () {
var ECB = CryptoJS.lib.BlockCipherMode.extend();
ECB.Encryptor = ECB.extend({
processBlock: function (words, offset) {
this._cipher.encryptBlock(words, offset);
}
});
ECB.Decryptor = ECB.extend({
processBlock: function (words, offset) {
this._cipher.decryptBlock(words, offset);
}
});
return ECB;
}());
return CryptoJS.mode.ECB;
}));
``` | /content/code_sandbox/node_modules/crypto-js/mode-ecb.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 225 |
```javascript
;(function (root, factory, undef) {
if (typeof exports === "object") {
// CommonJS
module.exports = exports = factory(require("./core"), require("./cipher-core"));
}
else if (typeof define === "function" && define.amd) {
// AMD
define(["./core", "./cipher-core"], factory);
}
else {
// Global (browser)
factory(root.CryptoJS);
}
}(this, function (CryptoJS) {
/**
* ANSI X.923 padding strategy.
*/
CryptoJS.pad.AnsiX923 = {
pad: function (data, blockSize) {
// Shortcuts
var dataSigBytes = data.sigBytes;
var blockSizeBytes = blockSize * 4;
// Count padding bytes
var nPaddingBytes = blockSizeBytes - dataSigBytes % blockSizeBytes;
// Compute last byte position
var lastBytePos = dataSigBytes + nPaddingBytes - 1;
// Pad
data.clamp();
data.words[lastBytePos >>> 2] |= nPaddingBytes << (24 - (lastBytePos % 4) * 8);
data.sigBytes += nPaddingBytes;
},
unpad: function (data) {
// Get number of padding bytes from last byte
var nPaddingBytes = data.words[(data.sigBytes - 1) >>> 2] & 0xff;
// Remove padding
data.sigBytes -= nPaddingBytes;
}
};
return CryptoJS.pad.Ansix923;
}));
``` | /content/code_sandbox/node_modules/crypto-js/pad-ansix923.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 335 |
```javascript
;(function (root, factory) {
if (typeof exports === "object") {
// CommonJS
module.exports = exports = factory(require("./core"));
}
else if (typeof define === "function" && define.amd) {
// AMD
define(["./core"], factory);
}
else {
// Global (browser)
factory(root.CryptoJS);
}
}(this, function (CryptoJS) {
return CryptoJS.enc.Hex;
}));
``` | /content/code_sandbox/node_modules/crypto-js/enc-hex.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 103 |
```javascript
;(function (root, factory, undef) {
if (typeof exports === "object") {
// CommonJS
module.exports = exports = factory(require("./core"), require("./sha256"));
}
else if (typeof define === "function" && define.amd) {
// AMD
define(["./core", "./sha256"], factory);
}
else {
// Global (browser)
factory(root.CryptoJS);
}
}(this, function (CryptoJS) {
(function () {
// Shortcuts
var C = CryptoJS;
var C_lib = C.lib;
var WordArray = C_lib.WordArray;
var C_algo = C.algo;
var SHA256 = C_algo.SHA256;
/**
* SHA-224 hash algorithm.
*/
var SHA224 = C_algo.SHA224 = SHA256.extend({
_doReset: function () {
this._hash = new WordArray.init([
0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939,
0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4
]);
},
_doFinalize: function () {
var hash = SHA256._doFinalize.call(this);
hash.sigBytes -= 4;
return hash;
}
});
/**
* Shortcut function to the hasher's object interface.
*
* @param {WordArray|string} message The message to hash.
*
* @return {WordArray} The hash.
*
* @static
*
* @example
*
* var hash = CryptoJS.SHA224('message');
* var hash = CryptoJS.SHA224(wordArray);
*/
C.SHA224 = SHA256._createHelper(SHA224);
/**
* Shortcut function to the HMAC's object interface.
*
* @param {WordArray|string} message The message to hash.
* @param {WordArray|string} key The secret key.
*
* @return {WordArray} The HMAC.
*
* @static
*
* @example
*
* var hmac = CryptoJS.HmacSHA224(message, key);
*/
C.HmacSHA224 = SHA256._createHmacHelper(SHA224);
}());
return CryptoJS.SHA224;
}));
``` | /content/code_sandbox/node_modules/crypto-js/sha224.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 537 |
```javascript
;(function (root, factory, undef) {
if (typeof exports === "object") {
// CommonJS
module.exports = exports = factory(require("./core"), require("./cipher-core"));
}
else if (typeof define === "function" && define.amd) {
// AMD
define(["./core", "./cipher-core"], factory);
}
else {
// Global (browser)
factory(root.CryptoJS);
}
}(this, function (CryptoJS) {
/**
* ISO/IEC 9797-1 Padding Method 2.
*/
CryptoJS.pad.Iso97971 = {
pad: function (data, blockSize) {
// Add 0x80 byte
data.concat(CryptoJS.lib.WordArray.create([0x80000000], 1));
// Zero pad the rest
CryptoJS.pad.ZeroPadding.pad(data, blockSize);
},
unpad: function (data) {
// Remove zero padding
CryptoJS.pad.ZeroPadding.unpad(data);
// Remove one more byte -- the 0x80 byte
data.sigBytes--;
}
};
return CryptoJS.pad.Iso97971;
}));
``` | /content/code_sandbox/node_modules/crypto-js/pad-iso97971.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 254 |
```javascript
;(function (root, factory) {
if (typeof exports === "object") {
// CommonJS
module.exports = exports = factory(require("./core"));
}
else if (typeof define === "function" && define.amd) {
// AMD
define(["./core"], factory);
}
else {
// Global (browser)
factory(root.CryptoJS);
}
}(this, function (CryptoJS) {
(function (undefined) {
// Shortcuts
var C = CryptoJS;
var C_lib = C.lib;
var Base = C_lib.Base;
var X32WordArray = C_lib.WordArray;
/**
* x64 namespace.
*/
var C_x64 = C.x64 = {};
/**
* A 64-bit word.
*/
var X64Word = C_x64.Word = Base.extend({
/**
* Initializes a newly created 64-bit word.
*
* @param {number} high The high 32 bits.
* @param {number} low The low 32 bits.
*
* @example
*
* var x64Word = CryptoJS.x64.Word.create(0x00010203, 0x04050607);
*/
init: function (high, low) {
this.high = high;
this.low = low;
}
/**
* Bitwise NOTs this word.
*
* @return {X64Word} A new x64-Word object after negating.
*
* @example
*
* var negated = x64Word.not();
*/
// not: function () {
// var high = ~this.high;
// var low = ~this.low;
// return X64Word.create(high, low);
// },
/**
* Bitwise ANDs this word with the passed word.
*
* @param {X64Word} word The x64-Word to AND with this word.
*
* @return {X64Word} A new x64-Word object after ANDing.
*
* @example
*
* var anded = x64Word.and(anotherX64Word);
*/
// and: function (word) {
// var high = this.high & word.high;
// var low = this.low & word.low;
// return X64Word.create(high, low);
// },
/**
* Bitwise ORs this word with the passed word.
*
* @param {X64Word} word The x64-Word to OR with this word.
*
* @return {X64Word} A new x64-Word object after ORing.
*
* @example
*
* var ored = x64Word.or(anotherX64Word);
*/
// or: function (word) {
// var high = this.high | word.high;
// var low = this.low | word.low;
// return X64Word.create(high, low);
// },
/**
* Bitwise XORs this word with the passed word.
*
* @param {X64Word} word The x64-Word to XOR with this word.
*
* @return {X64Word} A new x64-Word object after XORing.
*
* @example
*
* var xored = x64Word.xor(anotherX64Word);
*/
// xor: function (word) {
// var high = this.high ^ word.high;
// var low = this.low ^ word.low;
// return X64Word.create(high, low);
// },
/**
* Shifts this word n bits to the left.
*
* @param {number} n The number of bits to shift.
*
* @return {X64Word} A new x64-Word object after shifting.
*
* @example
*
* var shifted = x64Word.shiftL(25);
*/
// shiftL: function (n) {
// if (n < 32) {
// var high = (this.high << n) | (this.low >>> (32 - n));
// var low = this.low << n;
// } else {
// var high = this.low << (n - 32);
// var low = 0;
// }
// return X64Word.create(high, low);
// },
/**
* Shifts this word n bits to the right.
*
* @param {number} n The number of bits to shift.
*
* @return {X64Word} A new x64-Word object after shifting.
*
* @example
*
* var shifted = x64Word.shiftR(7);
*/
// shiftR: function (n) {
// if (n < 32) {
// var low = (this.low >>> n) | (this.high << (32 - n));
// var high = this.high >>> n;
// } else {
// var low = this.high >>> (n - 32);
// var high = 0;
// }
// return X64Word.create(high, low);
// },
/**
* Rotates this word n bits to the left.
*
* @param {number} n The number of bits to rotate.
*
* @return {X64Word} A new x64-Word object after rotating.
*
* @example
*
* var rotated = x64Word.rotL(25);
*/
// rotL: function (n) {
// return this.shiftL(n).or(this.shiftR(64 - n));
// },
/**
* Rotates this word n bits to the right.
*
* @param {number} n The number of bits to rotate.
*
* @return {X64Word} A new x64-Word object after rotating.
*
* @example
*
* var rotated = x64Word.rotR(7);
*/
// rotR: function (n) {
// return this.shiftR(n).or(this.shiftL(64 - n));
// },
/**
* Adds this word with the passed word.
*
* @param {X64Word} word The x64-Word to add with this word.
*
* @return {X64Word} A new x64-Word object after adding.
*
* @example
*
* var added = x64Word.add(anotherX64Word);
*/
// add: function (word) {
// var low = (this.low + word.low) | 0;
// var carry = (low >>> 0) < (this.low >>> 0) ? 1 : 0;
// var high = (this.high + word.high + carry) | 0;
// return X64Word.create(high, low);
// }
});
/**
* An array of 64-bit words.
*
* @property {Array} words The array of CryptoJS.x64.Word objects.
* @property {number} sigBytes The number of significant bytes in this word array.
*/
var X64WordArray = C_x64.WordArray = Base.extend({
/**
* Initializes a newly created word array.
*
* @param {Array} words (Optional) An array of CryptoJS.x64.Word objects.
* @param {number} sigBytes (Optional) The number of significant bytes in the words.
*
* @example
*
* var wordArray = CryptoJS.x64.WordArray.create();
*
* var wordArray = CryptoJS.x64.WordArray.create([
* CryptoJS.x64.Word.create(0x00010203, 0x04050607),
* CryptoJS.x64.Word.create(0x18191a1b, 0x1c1d1e1f)
* ]);
*
* var wordArray = CryptoJS.x64.WordArray.create([
* CryptoJS.x64.Word.create(0x00010203, 0x04050607),
* CryptoJS.x64.Word.create(0x18191a1b, 0x1c1d1e1f)
* ], 10);
*/
init: function (words, sigBytes) {
words = this.words = words || [];
if (sigBytes != undefined) {
this.sigBytes = sigBytes;
} else {
this.sigBytes = words.length * 8;
}
},
/**
* Converts this 64-bit word array to a 32-bit word array.
*
* @return {CryptoJS.lib.WordArray} This word array's data as a 32-bit word array.
*
* @example
*
* var x32WordArray = x64WordArray.toX32();
*/
toX32: function () {
// Shortcuts
var x64Words = this.words;
var x64WordsLength = x64Words.length;
// Convert
var x32Words = [];
for (var i = 0; i < x64WordsLength; i++) {
var x64Word = x64Words[i];
x32Words.push(x64Word.high);
x32Words.push(x64Word.low);
}
return X32WordArray.create(x32Words, this.sigBytes);
},
/**
* Creates a copy of this word array.
*
* @return {X64WordArray} The clone.
*
* @example
*
* var clone = x64WordArray.clone();
*/
clone: function () {
var clone = Base.clone.call(this);
// Clone "words" array
var words = clone.words = this.words.slice(0);
// Clone each X64Word object
var wordsLength = words.length;
for (var i = 0; i < wordsLength; i++) {
words[i] = words[i].clone();
}
return clone;
}
});
}());
return CryptoJS;
}));
``` | /content/code_sandbox/node_modules/crypto-js/x64-core.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 2,208 |
```javascript
;(function (root, factory, undef) {
if (typeof exports === "object") {
// CommonJS
module.exports = exports = factory(require("./core"), require("./x64-core"));
}
else if (typeof define === "function" && define.amd) {
// AMD
define(["./core", "./x64-core"], factory);
}
else {
// Global (browser)
factory(root.CryptoJS);
}
}(this, function (CryptoJS) {
(function () {
// Shortcuts
var C = CryptoJS;
var C_lib = C.lib;
var Hasher = C_lib.Hasher;
var C_x64 = C.x64;
var X64Word = C_x64.Word;
var X64WordArray = C_x64.WordArray;
var C_algo = C.algo;
function X64Word_create() {
return X64Word.create.apply(X64Word, arguments);
}
// Constants
var K = [
X64Word_create(0x428a2f98, 0xd728ae22), X64Word_create(0x71374491, 0x23ef65cd),
X64Word_create(0xb5c0fbcf, 0xec4d3b2f), X64Word_create(0xe9b5dba5, 0x8189dbbc),
X64Word_create(0x3956c25b, 0xf348b538), X64Word_create(0x59f111f1, 0xb605d019),
X64Word_create(0x923f82a4, 0xaf194f9b), X64Word_create(0xab1c5ed5, 0xda6d8118),
X64Word_create(0xd807aa98, 0xa3030242), X64Word_create(0x12835b01, 0x45706fbe),
X64Word_create(0x243185be, 0x4ee4b28c), X64Word_create(0x550c7dc3, 0xd5ffb4e2),
X64Word_create(0x72be5d74, 0xf27b896f), X64Word_create(0x80deb1fe, 0x3b1696b1),
X64Word_create(0x9bdc06a7, 0x25c71235), X64Word_create(0xc19bf174, 0xcf692694),
X64Word_create(0xe49b69c1, 0x9ef14ad2), X64Word_create(0xefbe4786, 0x384f25e3),
X64Word_create(0x0fc19dc6, 0x8b8cd5b5), X64Word_create(0x240ca1cc, 0x77ac9c65),
X64Word_create(0x2de92c6f, 0x592b0275), X64Word_create(0x4a7484aa, 0x6ea6e483),
X64Word_create(0x5cb0a9dc, 0xbd41fbd4), X64Word_create(0x76f988da, 0x831153b5),
X64Word_create(0x983e5152, 0xee66dfab), X64Word_create(0xa831c66d, 0x2db43210),
X64Word_create(0xb00327c8, 0x98fb213f), X64Word_create(0xbf597fc7, 0xbeef0ee4),
X64Word_create(0xc6e00bf3, 0x3da88fc2), X64Word_create(0xd5a79147, 0x930aa725),
X64Word_create(0x06ca6351, 0xe003826f), X64Word_create(0x14292967, 0x0a0e6e70),
X64Word_create(0x27b70a85, 0x46d22ffc), X64Word_create(0x2e1b2138, 0x5c26c926),
X64Word_create(0x4d2c6dfc, 0x5ac42aed), X64Word_create(0x53380d13, 0x9d95b3df),
X64Word_create(0x650a7354, 0x8baf63de), X64Word_create(0x766a0abb, 0x3c77b2a8),
X64Word_create(0x81c2c92e, 0x47edaee6), X64Word_create(0x92722c85, 0x1482353b),
X64Word_create(0xa2bfe8a1, 0x4cf10364), X64Word_create(0xa81a664b, 0xbc423001),
X64Word_create(0xc24b8b70, 0xd0f89791), X64Word_create(0xc76c51a3, 0x0654be30),
X64Word_create(0xd192e819, 0xd6ef5218), X64Word_create(0xd6990624, 0x5565a910),
X64Word_create(0xf40e3585, 0x5771202a), X64Word_create(0x106aa070, 0x32bbd1b8),
X64Word_create(0x19a4c116, 0xb8d2d0c8), X64Word_create(0x1e376c08, 0x5141ab53),
X64Word_create(0x2748774c, 0xdf8eeb99), X64Word_create(0x34b0bcb5, 0xe19b48a8),
X64Word_create(0x391c0cb3, 0xc5c95a63), X64Word_create(0x4ed8aa4a, 0xe3418acb),
X64Word_create(0x5b9cca4f, 0x7763e373), X64Word_create(0x682e6ff3, 0xd6b2b8a3),
X64Word_create(0x748f82ee, 0x5defb2fc), X64Word_create(0x78a5636f, 0x43172f60),
X64Word_create(0x84c87814, 0xa1f0ab72), X64Word_create(0x8cc70208, 0x1a6439ec),
X64Word_create(0x90befffa, 0x23631e28), X64Word_create(0xa4506ceb, 0xde82bde9),
X64Word_create(0xbef9a3f7, 0xb2c67915), X64Word_create(0xc67178f2, 0xe372532b),
X64Word_create(0xca273ece, 0xea26619c), X64Word_create(0xd186b8c7, 0x21c0c207),
X64Word_create(0xeada7dd6, 0xcde0eb1e), X64Word_create(0xf57d4f7f, 0xee6ed178),
X64Word_create(0x06f067aa, 0x72176fba), X64Word_create(0x0a637dc5, 0xa2c898a6),
X64Word_create(0x113f9804, 0xbef90dae), X64Word_create(0x1b710b35, 0x131c471b),
X64Word_create(0x28db77f5, 0x23047d84), X64Word_create(0x32caab7b, 0x40c72493),
X64Word_create(0x3c9ebe0a, 0x15c9bebc), X64Word_create(0x431d67c4, 0x9c100d4c),
X64Word_create(0x4cc5d4be, 0xcb3e42b6), X64Word_create(0x597f299c, 0xfc657e2a),
X64Word_create(0x5fcb6fab, 0x3ad6faec), X64Word_create(0x6c44198c, 0x4a475817)
];
// Reusable objects
var W = [];
(function () {
for (var i = 0; i < 80; i++) {
W[i] = X64Word_create();
}
}());
/**
* SHA-512 hash algorithm.
*/
var SHA512 = C_algo.SHA512 = Hasher.extend({
_doReset: function () {
this._hash = new X64WordArray.init([
new X64Word.init(0x6a09e667, 0xf3bcc908), new X64Word.init(0xbb67ae85, 0x84caa73b),
new X64Word.init(0x3c6ef372, 0xfe94f82b), new X64Word.init(0xa54ff53a, 0x5f1d36f1),
new X64Word.init(0x510e527f, 0xade682d1), new X64Word.init(0x9b05688c, 0x2b3e6c1f),
new X64Word.init(0x1f83d9ab, 0xfb41bd6b), new X64Word.init(0x5be0cd19, 0x137e2179)
]);
},
_doProcessBlock: function (M, offset) {
// Shortcuts
var H = this._hash.words;
var H0 = H[0];
var H1 = H[1];
var H2 = H[2];
var H3 = H[3];
var H4 = H[4];
var H5 = H[5];
var H6 = H[6];
var H7 = H[7];
var H0h = H0.high;
var H0l = H0.low;
var H1h = H1.high;
var H1l = H1.low;
var H2h = H2.high;
var H2l = H2.low;
var H3h = H3.high;
var H3l = H3.low;
var H4h = H4.high;
var H4l = H4.low;
var H5h = H5.high;
var H5l = H5.low;
var H6h = H6.high;
var H6l = H6.low;
var H7h = H7.high;
var H7l = H7.low;
// Working variables
var ah = H0h;
var al = H0l;
var bh = H1h;
var bl = H1l;
var ch = H2h;
var cl = H2l;
var dh = H3h;
var dl = H3l;
var eh = H4h;
var el = H4l;
var fh = H5h;
var fl = H5l;
var gh = H6h;
var gl = H6l;
var hh = H7h;
var hl = H7l;
// Rounds
for (var i = 0; i < 80; i++) {
// Shortcut
var Wi = W[i];
// Extend message
if (i < 16) {
var Wih = Wi.high = M[offset + i * 2] | 0;
var Wil = Wi.low = M[offset + i * 2 + 1] | 0;
} else {
// Gamma0
var gamma0x = W[i - 15];
var gamma0xh = gamma0x.high;
var gamma0xl = gamma0x.low;
var gamma0h = ((gamma0xh >>> 1) | (gamma0xl << 31)) ^ ((gamma0xh >>> 8) | (gamma0xl << 24)) ^ (gamma0xh >>> 7);
var gamma0l = ((gamma0xl >>> 1) | (gamma0xh << 31)) ^ ((gamma0xl >>> 8) | (gamma0xh << 24)) ^ ((gamma0xl >>> 7) | (gamma0xh << 25));
// Gamma1
var gamma1x = W[i - 2];
var gamma1xh = gamma1x.high;
var gamma1xl = gamma1x.low;
var gamma1h = ((gamma1xh >>> 19) | (gamma1xl << 13)) ^ ((gamma1xh << 3) | (gamma1xl >>> 29)) ^ (gamma1xh >>> 6);
var gamma1l = ((gamma1xl >>> 19) | (gamma1xh << 13)) ^ ((gamma1xl << 3) | (gamma1xh >>> 29)) ^ ((gamma1xl >>> 6) | (gamma1xh << 26));
// W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16]
var Wi7 = W[i - 7];
var Wi7h = Wi7.high;
var Wi7l = Wi7.low;
var Wi16 = W[i - 16];
var Wi16h = Wi16.high;
var Wi16l = Wi16.low;
var Wil = gamma0l + Wi7l;
var Wih = gamma0h + Wi7h + ((Wil >>> 0) < (gamma0l >>> 0) ? 1 : 0);
var Wil = Wil + gamma1l;
var Wih = Wih + gamma1h + ((Wil >>> 0) < (gamma1l >>> 0) ? 1 : 0);
var Wil = Wil + Wi16l;
var Wih = Wih + Wi16h + ((Wil >>> 0) < (Wi16l >>> 0) ? 1 : 0);
Wi.high = Wih;
Wi.low = Wil;
}
var chh = (eh & fh) ^ (~eh & gh);
var chl = (el & fl) ^ (~el & gl);
var majh = (ah & bh) ^ (ah & ch) ^ (bh & ch);
var majl = (al & bl) ^ (al & cl) ^ (bl & cl);
var sigma0h = ((ah >>> 28) | (al << 4)) ^ ((ah << 30) | (al >>> 2)) ^ ((ah << 25) | (al >>> 7));
var sigma0l = ((al >>> 28) | (ah << 4)) ^ ((al << 30) | (ah >>> 2)) ^ ((al << 25) | (ah >>> 7));
var sigma1h = ((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9));
var sigma1l = ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9));
// t1 = h + sigma1 + ch + K[i] + W[i]
var Ki = K[i];
var Kih = Ki.high;
var Kil = Ki.low;
var t1l = hl + sigma1l;
var t1h = hh + sigma1h + ((t1l >>> 0) < (hl >>> 0) ? 1 : 0);
var t1l = t1l + chl;
var t1h = t1h + chh + ((t1l >>> 0) < (chl >>> 0) ? 1 : 0);
var t1l = t1l + Kil;
var t1h = t1h + Kih + ((t1l >>> 0) < (Kil >>> 0) ? 1 : 0);
var t1l = t1l + Wil;
var t1h = t1h + Wih + ((t1l >>> 0) < (Wil >>> 0) ? 1 : 0);
// t2 = sigma0 + maj
var t2l = sigma0l + majl;
var t2h = sigma0h + majh + ((t2l >>> 0) < (sigma0l >>> 0) ? 1 : 0);
// Update working variables
hh = gh;
hl = gl;
gh = fh;
gl = fl;
fh = eh;
fl = el;
el = (dl + t1l) | 0;
eh = (dh + t1h + ((el >>> 0) < (dl >>> 0) ? 1 : 0)) | 0;
dh = ch;
dl = cl;
ch = bh;
cl = bl;
bh = ah;
bl = al;
al = (t1l + t2l) | 0;
ah = (t1h + t2h + ((al >>> 0) < (t1l >>> 0) ? 1 : 0)) | 0;
}
// Intermediate hash value
H0l = H0.low = (H0l + al);
H0.high = (H0h + ah + ((H0l >>> 0) < (al >>> 0) ? 1 : 0));
H1l = H1.low = (H1l + bl);
H1.high = (H1h + bh + ((H1l >>> 0) < (bl >>> 0) ? 1 : 0));
H2l = H2.low = (H2l + cl);
H2.high = (H2h + ch + ((H2l >>> 0) < (cl >>> 0) ? 1 : 0));
H3l = H3.low = (H3l + dl);
H3.high = (H3h + dh + ((H3l >>> 0) < (dl >>> 0) ? 1 : 0));
H4l = H4.low = (H4l + el);
H4.high = (H4h + eh + ((H4l >>> 0) < (el >>> 0) ? 1 : 0));
H5l = H5.low = (H5l + fl);
H5.high = (H5h + fh + ((H5l >>> 0) < (fl >>> 0) ? 1 : 0));
H6l = H6.low = (H6l + gl);
H6.high = (H6h + gh + ((H6l >>> 0) < (gl >>> 0) ? 1 : 0));
H7l = H7.low = (H7l + hl);
H7.high = (H7h + hh + ((H7l >>> 0) < (hl >>> 0) ? 1 : 0));
},
_doFinalize: function () {
// Shortcuts
var data = this._data;
var dataWords = data.words;
var nBitsTotal = this._nDataBytes * 8;
var nBitsLeft = data.sigBytes * 8;
// Add padding
dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32);
dataWords[(((nBitsLeft + 128) >>> 10) << 5) + 30] = Math.floor(nBitsTotal / 0x100000000);
dataWords[(((nBitsLeft + 128) >>> 10) << 5) + 31] = nBitsTotal;
data.sigBytes = dataWords.length * 4;
// Hash final blocks
this._process();
// Convert hash to 32-bit word array before returning
var hash = this._hash.toX32();
// Return final computed hash
return hash;
},
clone: function () {
var clone = Hasher.clone.call(this);
clone._hash = this._hash.clone();
return clone;
},
blockSize: 1024/32
});
/**
* Shortcut function to the hasher's object interface.
*
* @param {WordArray|string} message The message to hash.
*
* @return {WordArray} The hash.
*
* @static
*
* @example
*
* var hash = CryptoJS.SHA512('message');
* var hash = CryptoJS.SHA512(wordArray);
*/
C.SHA512 = Hasher._createHelper(SHA512);
/**
* Shortcut function to the HMAC's object interface.
*
* @param {WordArray|string} message The message to hash.
* @param {WordArray|string} key The secret key.
*
* @return {WordArray} The HMAC.
*
* @static
*
* @example
*
* var hmac = CryptoJS.HmacSHA512(message, key);
*/
C.HmacSHA512 = Hasher._createHmacHelper(SHA512);
}());
return CryptoJS.SHA512;
}));
``` | /content/code_sandbox/node_modules/crypto-js/sha512.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 4,889 |
```javascript
;(function (root, factory) {
if (typeof exports === "object") {
// CommonJS
module.exports = exports = factory();
}
else if (typeof define === "function" && define.amd) {
// AMD
define([], factory);
}
else {
// Global (browser)
root.CryptoJS = factory();
}
}(this, function () {
/**
* CryptoJS core components.
*/
var CryptoJS = CryptoJS || (function (Math, undefined) {
/*
* Local polyfil of Object.create
*/
var create = Object.create || (function () {
function F() {};
return function (obj) {
var subtype;
F.prototype = obj;
subtype = new F();
F.prototype = null;
return subtype;
};
}())
/**
* CryptoJS namespace.
*/
var C = {};
/**
* Library namespace.
*/
var C_lib = C.lib = {};
/**
* Base object for prototypal inheritance.
*/
var Base = C_lib.Base = (function () {
return {
/**
* Creates a new object that inherits from this object.
*
* @param {Object} overrides Properties to copy into the new object.
*
* @return {Object} The new object.
*
* @static
*
* @example
*
* var MyType = CryptoJS.lib.Base.extend({
* field: 'value',
*
* method: function () {
* }
* });
*/
extend: function (overrides) {
// Spawn
var subtype = create(this);
// Augment
if (overrides) {
subtype.mixIn(overrides);
}
// Create default initializer
if (!subtype.hasOwnProperty('init') || this.init === subtype.init) {
subtype.init = function () {
subtype.$super.init.apply(this, arguments);
};
}
// Initializer's prototype is the subtype object
subtype.init.prototype = subtype;
// Reference supertype
subtype.$super = this;
return subtype;
},
/**
* Extends this object and runs the init method.
* Arguments to create() will be passed to init().
*
* @return {Object} The new object.
*
* @static
*
* @example
*
* var instance = MyType.create();
*/
create: function () {
var instance = this.extend();
instance.init.apply(instance, arguments);
return instance;
},
/**
* Initializes a newly created object.
* Override this method to add some logic when your objects are created.
*
* @example
*
* var MyType = CryptoJS.lib.Base.extend({
* init: function () {
* // ...
* }
* });
*/
init: function () {
},
/**
* Copies properties into this object.
*
* @param {Object} properties The properties to mix in.
*
* @example
*
* MyType.mixIn({
* field: 'value'
* });
*/
mixIn: function (properties) {
for (var propertyName in properties) {
if (properties.hasOwnProperty(propertyName)) {
this[propertyName] = properties[propertyName];
}
}
// IE won't copy toString using the loop above
if (properties.hasOwnProperty('toString')) {
this.toString = properties.toString;
}
},
/**
* Creates a copy of this object.
*
* @return {Object} The clone.
*
* @example
*
* var clone = instance.clone();
*/
clone: function () {
return this.init.prototype.extend(this);
}
};
}());
/**
* An array of 32-bit words.
*
* @property {Array} words The array of 32-bit words.
* @property {number} sigBytes The number of significant bytes in this word array.
*/
var WordArray = C_lib.WordArray = Base.extend({
/**
* Initializes a newly created word array.
*
* @param {Array} words (Optional) An array of 32-bit words.
* @param {number} sigBytes (Optional) The number of significant bytes in the words.
*
* @example
*
* var wordArray = CryptoJS.lib.WordArray.create();
* var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607]);
* var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607], 6);
*/
init: function (words, sigBytes) {
words = this.words = words || [];
if (sigBytes != undefined) {
this.sigBytes = sigBytes;
} else {
this.sigBytes = words.length * 4;
}
},
/**
* Converts this word array to a string.
*
* @param {Encoder} encoder (Optional) The encoding strategy to use. Default: CryptoJS.enc.Hex
*
* @return {string} The stringified word array.
*
* @example
*
* var string = wordArray + '';
* var string = wordArray.toString();
* var string = wordArray.toString(CryptoJS.enc.Utf8);
*/
toString: function (encoder) {
return (encoder || Hex).stringify(this);
},
/**
* Concatenates a word array to this word array.
*
* @param {WordArray} wordArray The word array to append.
*
* @return {WordArray} This word array.
*
* @example
*
* wordArray1.concat(wordArray2);
*/
concat: function (wordArray) {
// Shortcuts
var thisWords = this.words;
var thatWords = wordArray.words;
var thisSigBytes = this.sigBytes;
var thatSigBytes = wordArray.sigBytes;
// Clamp excess bits
this.clamp();
// Concat
if (thisSigBytes % 4) {
// Copy one byte at a time
for (var i = 0; i < thatSigBytes; i++) {
var thatByte = (thatWords[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
thisWords[(thisSigBytes + i) >>> 2] |= thatByte << (24 - ((thisSigBytes + i) % 4) * 8);
}
} else {
// Copy one word at a time
for (var i = 0; i < thatSigBytes; i += 4) {
thisWords[(thisSigBytes + i) >>> 2] = thatWords[i >>> 2];
}
}
this.sigBytes += thatSigBytes;
// Chainable
return this;
},
/**
* Removes insignificant bits.
*
* @example
*
* wordArray.clamp();
*/
clamp: function () {
// Shortcuts
var words = this.words;
var sigBytes = this.sigBytes;
// Clamp
words[sigBytes >>> 2] &= 0xffffffff << (32 - (sigBytes % 4) * 8);
words.length = Math.ceil(sigBytes / 4);
},
/**
* Creates a copy of this word array.
*
* @return {WordArray} The clone.
*
* @example
*
* var clone = wordArray.clone();
*/
clone: function () {
var clone = Base.clone.call(this);
clone.words = this.words.slice(0);
return clone;
},
/**
* Creates a word array filled with random bytes.
*
* @param {number} nBytes The number of random bytes to generate.
*
* @return {WordArray} The random word array.
*
* @static
*
* @example
*
* var wordArray = CryptoJS.lib.WordArray.random(16);
*/
random: function (nBytes) {
var words = [];
var r = (function (m_w) {
var m_w = m_w;
var m_z = 0x3ade68b1;
var mask = 0xffffffff;
return function () {
m_z = (0x9069 * (m_z & 0xFFFF) + (m_z >> 0x10)) & mask;
m_w = (0x4650 * (m_w & 0xFFFF) + (m_w >> 0x10)) & mask;
var result = ((m_z << 0x10) + m_w) & mask;
result /= 0x100000000;
result += 0.5;
return result * (Math.random() > .5 ? 1 : -1);
}
});
for (var i = 0, rcache; i < nBytes; i += 4) {
var _r = r((rcache || Math.random()) * 0x100000000);
rcache = _r() * 0x3ade67b7;
words.push((_r() * 0x100000000) | 0);
}
return new WordArray.init(words, nBytes);
}
});
/**
* Encoder namespace.
*/
var C_enc = C.enc = {};
/**
* Hex encoding strategy.
*/
var Hex = C_enc.Hex = {
/**
* Converts a word array to a hex string.
*
* @param {WordArray} wordArray The word array.
*
* @return {string} The hex string.
*
* @static
*
* @example
*
* var hexString = CryptoJS.enc.Hex.stringify(wordArray);
*/
stringify: function (wordArray) {
// Shortcuts
var words = wordArray.words;
var sigBytes = wordArray.sigBytes;
// Convert
var hexChars = [];
for (var i = 0; i < sigBytes; i++) {
var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
hexChars.push((bite >>> 4).toString(16));
hexChars.push((bite & 0x0f).toString(16));
}
return hexChars.join('');
},
/**
* Converts a hex string to a word array.
*
* @param {string} hexStr The hex string.
*
* @return {WordArray} The word array.
*
* @static
*
* @example
*
* var wordArray = CryptoJS.enc.Hex.parse(hexString);
*/
parse: function (hexStr) {
// Shortcut
var hexStrLength = hexStr.length;
// Convert
var words = [];
for (var i = 0; i < hexStrLength; i += 2) {
words[i >>> 3] |= parseInt(hexStr.substr(i, 2), 16) << (24 - (i % 8) * 4);
}
return new WordArray.init(words, hexStrLength / 2);
}
};
/**
* Latin1 encoding strategy.
*/
var Latin1 = C_enc.Latin1 = {
/**
* Converts a word array to a Latin1 string.
*
* @param {WordArray} wordArray The word array.
*
* @return {string} The Latin1 string.
*
* @static
*
* @example
*
* var latin1String = CryptoJS.enc.Latin1.stringify(wordArray);
*/
stringify: function (wordArray) {
// Shortcuts
var words = wordArray.words;
var sigBytes = wordArray.sigBytes;
// Convert
var latin1Chars = [];
for (var i = 0; i < sigBytes; i++) {
var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
latin1Chars.push(String.fromCharCode(bite));
}
return latin1Chars.join('');
},
/**
* Converts a Latin1 string to a word array.
*
* @param {string} latin1Str The Latin1 string.
*
* @return {WordArray} The word array.
*
* @static
*
* @example
*
* var wordArray = CryptoJS.enc.Latin1.parse(latin1String);
*/
parse: function (latin1Str) {
// Shortcut
var latin1StrLength = latin1Str.length;
// Convert
var words = [];
for (var i = 0; i < latin1StrLength; i++) {
words[i >>> 2] |= (latin1Str.charCodeAt(i) & 0xff) << (24 - (i % 4) * 8);
}
return new WordArray.init(words, latin1StrLength);
}
};
/**
* UTF-8 encoding strategy.
*/
var Utf8 = C_enc.Utf8 = {
/**
* Converts a word array to a UTF-8 string.
*
* @param {WordArray} wordArray The word array.
*
* @return {string} The UTF-8 string.
*
* @static
*
* @example
*
* var utf8String = CryptoJS.enc.Utf8.stringify(wordArray);
*/
stringify: function (wordArray) {
try {
return decodeURIComponent(escape(Latin1.stringify(wordArray)));
} catch (e) {
throw new Error('Malformed UTF-8 data');
}
},
/**
* Converts a UTF-8 string to a word array.
*
* @param {string} utf8Str The UTF-8 string.
*
* @return {WordArray} The word array.
*
* @static
*
* @example
*
* var wordArray = CryptoJS.enc.Utf8.parse(utf8String);
*/
parse: function (utf8Str) {
return Latin1.parse(unescape(encodeURIComponent(utf8Str)));
}
};
/**
* Abstract buffered block algorithm template.
*
* The property blockSize must be implemented in a concrete subtype.
*
* @property {number} _minBufferSize The number of blocks that should be kept unprocessed in the buffer. Default: 0
*/
var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm = Base.extend({
/**
* Resets this block algorithm's data buffer to its initial state.
*
* @example
*
* bufferedBlockAlgorithm.reset();
*/
reset: function () {
// Initial values
this._data = new WordArray.init();
this._nDataBytes = 0;
},
/**
* Adds new data to this block algorithm's buffer.
*
* @param {WordArray|string} data The data to append. Strings are converted to a WordArray using UTF-8.
*
* @example
*
* bufferedBlockAlgorithm._append('data');
* bufferedBlockAlgorithm._append(wordArray);
*/
_append: function (data) {
// Convert string to WordArray, else assume WordArray already
if (typeof data == 'string') {
data = Utf8.parse(data);
}
// Append
this._data.concat(data);
this._nDataBytes += data.sigBytes;
},
/**
* Processes available data blocks.
*
* This method invokes _doProcessBlock(offset), which must be implemented by a concrete subtype.
*
* @param {boolean} doFlush Whether all blocks and partial blocks should be processed.
*
* @return {WordArray} The processed data.
*
* @example
*
* var processedData = bufferedBlockAlgorithm._process();
* var processedData = bufferedBlockAlgorithm._process(!!'flush');
*/
_process: function (doFlush) {
// Shortcuts
var data = this._data;
var dataWords = data.words;
var dataSigBytes = data.sigBytes;
var blockSize = this.blockSize;
var blockSizeBytes = blockSize * 4;
// Count blocks ready
var nBlocksReady = dataSigBytes / blockSizeBytes;
if (doFlush) {
// Round up to include partial blocks
nBlocksReady = Math.ceil(nBlocksReady);
} else {
// Round down to include only full blocks,
// less the number of blocks that must remain in the buffer
nBlocksReady = Math.max((nBlocksReady | 0) - this._minBufferSize, 0);
}
// Count words ready
var nWordsReady = nBlocksReady * blockSize;
// Count bytes ready
var nBytesReady = Math.min(nWordsReady * 4, dataSigBytes);
// Process blocks
if (nWordsReady) {
for (var offset = 0; offset < nWordsReady; offset += blockSize) {
// Perform concrete-algorithm logic
this._doProcessBlock(dataWords, offset);
}
// Remove processed words
var processedWords = dataWords.splice(0, nWordsReady);
data.sigBytes -= nBytesReady;
}
// Return processed words
return new WordArray.init(processedWords, nBytesReady);
},
/**
* Creates a copy of this object.
*
* @return {Object} The clone.
*
* @example
*
* var clone = bufferedBlockAlgorithm.clone();
*/
clone: function () {
var clone = Base.clone.call(this);
clone._data = this._data.clone();
return clone;
},
_minBufferSize: 0
});
/**
* Abstract hasher template.
*
* @property {number} blockSize The number of 32-bit words this hasher operates on. Default: 16 (512 bits)
*/
var Hasher = C_lib.Hasher = BufferedBlockAlgorithm.extend({
/**
* Configuration options.
*/
cfg: Base.extend(),
/**
* Initializes a newly created hasher.
*
* @param {Object} cfg (Optional) The configuration options to use for this hash computation.
*
* @example
*
* var hasher = CryptoJS.algo.SHA256.create();
*/
init: function (cfg) {
// Apply config defaults
this.cfg = this.cfg.extend(cfg);
// Set initial values
this.reset();
},
/**
* Resets this hasher to its initial state.
*
* @example
*
* hasher.reset();
*/
reset: function () {
// Reset data buffer
BufferedBlockAlgorithm.reset.call(this);
// Perform concrete-hasher logic
this._doReset();
},
/**
* Updates this hasher with a message.
*
* @param {WordArray|string} messageUpdate The message to append.
*
* @return {Hasher} This hasher.
*
* @example
*
* hasher.update('message');
* hasher.update(wordArray);
*/
update: function (messageUpdate) {
// Append
this._append(messageUpdate);
// Update the hash
this._process();
// Chainable
return this;
},
/**
* Finalizes the hash computation.
* Note that the finalize operation is effectively a destructive, read-once operation.
*
* @param {WordArray|string} messageUpdate (Optional) A final message update.
*
* @return {WordArray} The hash.
*
* @example
*
* var hash = hasher.finalize();
* var hash = hasher.finalize('message');
* var hash = hasher.finalize(wordArray);
*/
finalize: function (messageUpdate) {
// Final message update
if (messageUpdate) {
this._append(messageUpdate);
}
// Perform concrete-hasher logic
var hash = this._doFinalize();
return hash;
},
blockSize: 512/32,
/**
* Creates a shortcut function to a hasher's object interface.
*
* @param {Hasher} hasher The hasher to create a helper for.
*
* @return {Function} The shortcut function.
*
* @static
*
* @example
*
* var SHA256 = CryptoJS.lib.Hasher._createHelper(CryptoJS.algo.SHA256);
*/
_createHelper: function (hasher) {
return function (message, cfg) {
return new hasher.init(cfg).finalize(message);
};
},
/**
* Creates a shortcut function to the HMAC's object interface.
*
* @param {Hasher} hasher The hasher to use in this HMAC helper.
*
* @return {Function} The shortcut function.
*
* @static
*
* @example
*
* var HmacSHA256 = CryptoJS.lib.Hasher._createHmacHelper(CryptoJS.algo.SHA256);
*/
_createHmacHelper: function (hasher) {
return function (message, key) {
return new C_algo.HMAC.init(hasher, key).finalize(message);
};
}
});
/**
* Algorithm namespace.
*/
var C_algo = C.algo = {};
return C;
}(Math));
(function () {
// Shortcuts
var C = CryptoJS;
var C_lib = C.lib;
var WordArray = C_lib.WordArray;
var C_enc = C.enc;
/**
* Base64 encoding strategy.
*/
var Base64 = C_enc.Base64 = {
/**
* Converts a word array to a Base64 string.
*
* @param {WordArray} wordArray The word array.
*
* @return {string} The Base64 string.
*
* @static
*
* @example
*
* var base64String = CryptoJS.enc.Base64.stringify(wordArray);
*/
stringify: function (wordArray) {
// Shortcuts
var words = wordArray.words;
var sigBytes = wordArray.sigBytes;
var map = this._map;
// Clamp excess bits
wordArray.clamp();
// Convert
var base64Chars = [];
for (var i = 0; i < sigBytes; i += 3) {
var byte1 = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
var byte2 = (words[(i + 1) >>> 2] >>> (24 - ((i + 1) % 4) * 8)) & 0xff;
var byte3 = (words[(i + 2) >>> 2] >>> (24 - ((i + 2) % 4) * 8)) & 0xff;
var triplet = (byte1 << 16) | (byte2 << 8) | byte3;
for (var j = 0; (j < 4) && (i + j * 0.75 < sigBytes); j++) {
base64Chars.push(map.charAt((triplet >>> (6 * (3 - j))) & 0x3f));
}
}
// Add padding
var paddingChar = map.charAt(64);
if (paddingChar) {
while (base64Chars.length % 4) {
base64Chars.push(paddingChar);
}
}
return base64Chars.join('');
},
/**
* Converts a Base64 string to a word array.
*
* @param {string} base64Str The Base64 string.
*
* @return {WordArray} The word array.
*
* @static
*
* @example
*
* var wordArray = CryptoJS.enc.Base64.parse(base64String);
*/
parse: function (base64Str) {
// Shortcuts
var base64StrLength = base64Str.length;
var map = this._map;
var reverseMap = this._reverseMap;
if (!reverseMap) {
reverseMap = this._reverseMap = [];
for (var j = 0; j < map.length; j++) {
reverseMap[map.charCodeAt(j)] = j;
}
}
// Ignore padding
var paddingChar = map.charAt(64);
if (paddingChar) {
var paddingIndex = base64Str.indexOf(paddingChar);
if (paddingIndex !== -1) {
base64StrLength = paddingIndex;
}
}
// Convert
return parseLoop(base64Str, base64StrLength, reverseMap);
},
_map: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='
};
function parseLoop(base64Str, base64StrLength, reverseMap) {
var words = [];
var nBytes = 0;
for (var i = 0; i < base64StrLength; i++) {
if (i % 4) {
var bits1 = reverseMap[base64Str.charCodeAt(i - 1)] << ((i % 4) * 2);
var bits2 = reverseMap[base64Str.charCodeAt(i)] >>> (6 - (i % 4) * 2);
words[nBytes >>> 2] |= (bits1 | bits2) << (24 - (nBytes % 4) * 8);
nBytes++;
}
}
return WordArray.create(words, nBytes);
}
}());
(function (Math) {
// Shortcuts
var C = CryptoJS;
var C_lib = C.lib;
var WordArray = C_lib.WordArray;
var Hasher = C_lib.Hasher;
var C_algo = C.algo;
// Constants table
var T = [];
// Compute constants
(function () {
for (var i = 0; i < 64; i++) {
T[i] = (Math.abs(Math.sin(i + 1)) * 0x100000000) | 0;
}
}());
/**
* MD5 hash algorithm.
*/
var MD5 = C_algo.MD5 = Hasher.extend({
_doReset: function () {
this._hash = new WordArray.init([
0x67452301, 0xefcdab89,
0x98badcfe, 0x10325476
]);
},
_doProcessBlock: function (M, offset) {
// Swap endian
for (var i = 0; i < 16; i++) {
// Shortcuts
var offset_i = offset + i;
var M_offset_i = M[offset_i];
M[offset_i] = (
(((M_offset_i << 8) | (M_offset_i >>> 24)) & 0x00ff00ff) |
(((M_offset_i << 24) | (M_offset_i >>> 8)) & 0xff00ff00)
);
}
// Shortcuts
var H = this._hash.words;
var M_offset_0 = M[offset + 0];
var M_offset_1 = M[offset + 1];
var M_offset_2 = M[offset + 2];
var M_offset_3 = M[offset + 3];
var M_offset_4 = M[offset + 4];
var M_offset_5 = M[offset + 5];
var M_offset_6 = M[offset + 6];
var M_offset_7 = M[offset + 7];
var M_offset_8 = M[offset + 8];
var M_offset_9 = M[offset + 9];
var M_offset_10 = M[offset + 10];
var M_offset_11 = M[offset + 11];
var M_offset_12 = M[offset + 12];
var M_offset_13 = M[offset + 13];
var M_offset_14 = M[offset + 14];
var M_offset_15 = M[offset + 15];
// Working varialbes
var a = H[0];
var b = H[1];
var c = H[2];
var d = H[3];
// Computation
a = FF(a, b, c, d, M_offset_0, 7, T[0]);
d = FF(d, a, b, c, M_offset_1, 12, T[1]);
c = FF(c, d, a, b, M_offset_2, 17, T[2]);
b = FF(b, c, d, a, M_offset_3, 22, T[3]);
a = FF(a, b, c, d, M_offset_4, 7, T[4]);
d = FF(d, a, b, c, M_offset_5, 12, T[5]);
c = FF(c, d, a, b, M_offset_6, 17, T[6]);
b = FF(b, c, d, a, M_offset_7, 22, T[7]);
a = FF(a, b, c, d, M_offset_8, 7, T[8]);
d = FF(d, a, b, c, M_offset_9, 12, T[9]);
c = FF(c, d, a, b, M_offset_10, 17, T[10]);
b = FF(b, c, d, a, M_offset_11, 22, T[11]);
a = FF(a, b, c, d, M_offset_12, 7, T[12]);
d = FF(d, a, b, c, M_offset_13, 12, T[13]);
c = FF(c, d, a, b, M_offset_14, 17, T[14]);
b = FF(b, c, d, a, M_offset_15, 22, T[15]);
a = GG(a, b, c, d, M_offset_1, 5, T[16]);
d = GG(d, a, b, c, M_offset_6, 9, T[17]);
c = GG(c, d, a, b, M_offset_11, 14, T[18]);
b = GG(b, c, d, a, M_offset_0, 20, T[19]);
a = GG(a, b, c, d, M_offset_5, 5, T[20]);
d = GG(d, a, b, c, M_offset_10, 9, T[21]);
c = GG(c, d, a, b, M_offset_15, 14, T[22]);
b = GG(b, c, d, a, M_offset_4, 20, T[23]);
a = GG(a, b, c, d, M_offset_9, 5, T[24]);
d = GG(d, a, b, c, M_offset_14, 9, T[25]);
c = GG(c, d, a, b, M_offset_3, 14, T[26]);
b = GG(b, c, d, a, M_offset_8, 20, T[27]);
a = GG(a, b, c, d, M_offset_13, 5, T[28]);
d = GG(d, a, b, c, M_offset_2, 9, T[29]);
c = GG(c, d, a, b, M_offset_7, 14, T[30]);
b = GG(b, c, d, a, M_offset_12, 20, T[31]);
a = HH(a, b, c, d, M_offset_5, 4, T[32]);
d = HH(d, a, b, c, M_offset_8, 11, T[33]);
c = HH(c, d, a, b, M_offset_11, 16, T[34]);
b = HH(b, c, d, a, M_offset_14, 23, T[35]);
a = HH(a, b, c, d, M_offset_1, 4, T[36]);
d = HH(d, a, b, c, M_offset_4, 11, T[37]);
c = HH(c, d, a, b, M_offset_7, 16, T[38]);
b = HH(b, c, d, a, M_offset_10, 23, T[39]);
a = HH(a, b, c, d, M_offset_13, 4, T[40]);
d = HH(d, a, b, c, M_offset_0, 11, T[41]);
c = HH(c, d, a, b, M_offset_3, 16, T[42]);
b = HH(b, c, d, a, M_offset_6, 23, T[43]);
a = HH(a, b, c, d, M_offset_9, 4, T[44]);
d = HH(d, a, b, c, M_offset_12, 11, T[45]);
c = HH(c, d, a, b, M_offset_15, 16, T[46]);
b = HH(b, c, d, a, M_offset_2, 23, T[47]);
a = II(a, b, c, d, M_offset_0, 6, T[48]);
d = II(d, a, b, c, M_offset_7, 10, T[49]);
c = II(c, d, a, b, M_offset_14, 15, T[50]);
b = II(b, c, d, a, M_offset_5, 21, T[51]);
a = II(a, b, c, d, M_offset_12, 6, T[52]);
d = II(d, a, b, c, M_offset_3, 10, T[53]);
c = II(c, d, a, b, M_offset_10, 15, T[54]);
b = II(b, c, d, a, M_offset_1, 21, T[55]);
a = II(a, b, c, d, M_offset_8, 6, T[56]);
d = II(d, a, b, c, M_offset_15, 10, T[57]);
c = II(c, d, a, b, M_offset_6, 15, T[58]);
b = II(b, c, d, a, M_offset_13, 21, T[59]);
a = II(a, b, c, d, M_offset_4, 6, T[60]);
d = II(d, a, b, c, M_offset_11, 10, T[61]);
c = II(c, d, a, b, M_offset_2, 15, T[62]);
b = II(b, c, d, a, M_offset_9, 21, T[63]);
// Intermediate hash value
H[0] = (H[0] + a) | 0;
H[1] = (H[1] + b) | 0;
H[2] = (H[2] + c) | 0;
H[3] = (H[3] + d) | 0;
},
_doFinalize: function () {
// Shortcuts
var data = this._data;
var dataWords = data.words;
var nBitsTotal = this._nDataBytes * 8;
var nBitsLeft = data.sigBytes * 8;
// Add padding
dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32);
var nBitsTotalH = Math.floor(nBitsTotal / 0x100000000);
var nBitsTotalL = nBitsTotal;
dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = (
(((nBitsTotalH << 8) | (nBitsTotalH >>> 24)) & 0x00ff00ff) |
(((nBitsTotalH << 24) | (nBitsTotalH >>> 8)) & 0xff00ff00)
);
dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = (
(((nBitsTotalL << 8) | (nBitsTotalL >>> 24)) & 0x00ff00ff) |
(((nBitsTotalL << 24) | (nBitsTotalL >>> 8)) & 0xff00ff00)
);
data.sigBytes = (dataWords.length + 1) * 4;
// Hash final blocks
this._process();
// Shortcuts
var hash = this._hash;
var H = hash.words;
// Swap endian
for (var i = 0; i < 4; i++) {
// Shortcut
var H_i = H[i];
H[i] = (((H_i << 8) | (H_i >>> 24)) & 0x00ff00ff) |
(((H_i << 24) | (H_i >>> 8)) & 0xff00ff00);
}
// Return final computed hash
return hash;
},
clone: function () {
var clone = Hasher.clone.call(this);
clone._hash = this._hash.clone();
return clone;
}
});
function FF(a, b, c, d, x, s, t) {
var n = a + ((b & c) | (~b & d)) + x + t;
return ((n << s) | (n >>> (32 - s))) + b;
}
function GG(a, b, c, d, x, s, t) {
var n = a + ((b & d) | (c & ~d)) + x + t;
return ((n << s) | (n >>> (32 - s))) + b;
}
function HH(a, b, c, d, x, s, t) {
var n = a + (b ^ c ^ d) + x + t;
return ((n << s) | (n >>> (32 - s))) + b;
}
function II(a, b, c, d, x, s, t) {
var n = a + (c ^ (b | ~d)) + x + t;
return ((n << s) | (n >>> (32 - s))) + b;
}
/**
* Shortcut function to the hasher's object interface.
*
* @param {WordArray|string} message The message to hash.
*
* @return {WordArray} The hash.
*
* @static
*
* @example
*
* var hash = CryptoJS.MD5('message');
* var hash = CryptoJS.MD5(wordArray);
*/
C.MD5 = Hasher._createHelper(MD5);
/**
* Shortcut function to the HMAC's object interface.
*
* @param {WordArray|string} message The message to hash.
* @param {WordArray|string} key The secret key.
*
* @return {WordArray} The HMAC.
*
* @static
*
* @example
*
* var hmac = CryptoJS.HmacMD5(message, key);
*/
C.HmacMD5 = Hasher._createHmacHelper(MD5);
}(Math));
(function () {
// Shortcuts
var C = CryptoJS;
var C_lib = C.lib;
var WordArray = C_lib.WordArray;
var Hasher = C_lib.Hasher;
var C_algo = C.algo;
// Reusable object
var W = [];
/**
* SHA-1 hash algorithm.
*/
var SHA1 = C_algo.SHA1 = Hasher.extend({
_doReset: function () {
this._hash = new WordArray.init([
0x67452301, 0xefcdab89,
0x98badcfe, 0x10325476,
0xc3d2e1f0
]);
},
_doProcessBlock: function (M, offset) {
// Shortcut
var H = this._hash.words;
// Working variables
var a = H[0];
var b = H[1];
var c = H[2];
var d = H[3];
var e = H[4];
// Computation
for (var i = 0; i < 80; i++) {
if (i < 16) {
W[i] = M[offset + i] | 0;
} else {
var n = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16];
W[i] = (n << 1) | (n >>> 31);
}
var t = ((a << 5) | (a >>> 27)) + e + W[i];
if (i < 20) {
t += ((b & c) | (~b & d)) + 0x5a827999;
} else if (i < 40) {
t += (b ^ c ^ d) + 0x6ed9eba1;
} else if (i < 60) {
t += ((b & c) | (b & d) | (c & d)) - 0x70e44324;
} else /* if (i < 80) */ {
t += (b ^ c ^ d) - 0x359d3e2a;
}
e = d;
d = c;
c = (b << 30) | (b >>> 2);
b = a;
a = t;
}
// Intermediate hash value
H[0] = (H[0] + a) | 0;
H[1] = (H[1] + b) | 0;
H[2] = (H[2] + c) | 0;
H[3] = (H[3] + d) | 0;
H[4] = (H[4] + e) | 0;
},
_doFinalize: function () {
// Shortcuts
var data = this._data;
var dataWords = data.words;
var nBitsTotal = this._nDataBytes * 8;
var nBitsLeft = data.sigBytes * 8;
// Add padding
dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32);
dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = Math.floor(nBitsTotal / 0x100000000);
dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = nBitsTotal;
data.sigBytes = dataWords.length * 4;
// Hash final blocks
this._process();
// Return final computed hash
return this._hash;
},
clone: function () {
var clone = Hasher.clone.call(this);
clone._hash = this._hash.clone();
return clone;
}
});
/**
* Shortcut function to the hasher's object interface.
*
* @param {WordArray|string} message The message to hash.
*
* @return {WordArray} The hash.
*
* @static
*
* @example
*
* var hash = CryptoJS.SHA1('message');
* var hash = CryptoJS.SHA1(wordArray);
*/
C.SHA1 = Hasher._createHelper(SHA1);
/**
* Shortcut function to the HMAC's object interface.
*
* @param {WordArray|string} message The message to hash.
* @param {WordArray|string} key The secret key.
*
* @return {WordArray} The HMAC.
*
* @static
*
* @example
*
* var hmac = CryptoJS.HmacSHA1(message, key);
*/
C.HmacSHA1 = Hasher._createHmacHelper(SHA1);
}());
(function (Math) {
// Shortcuts
var C = CryptoJS;
var C_lib = C.lib;
var WordArray = C_lib.WordArray;
var Hasher = C_lib.Hasher;
var C_algo = C.algo;
// Initialization and round constants tables
var H = [];
var K = [];
// Compute constants
(function () {
function isPrime(n) {
var sqrtN = Math.sqrt(n);
for (var factor = 2; factor <= sqrtN; factor++) {
if (!(n % factor)) {
return false;
}
}
return true;
}
function getFractionalBits(n) {
return ((n - (n | 0)) * 0x100000000) | 0;
}
var n = 2;
var nPrime = 0;
while (nPrime < 64) {
if (isPrime(n)) {
if (nPrime < 8) {
H[nPrime] = getFractionalBits(Math.pow(n, 1 / 2));
}
K[nPrime] = getFractionalBits(Math.pow(n, 1 / 3));
nPrime++;
}
n++;
}
}());
// Reusable object
var W = [];
/**
* SHA-256 hash algorithm.
*/
var SHA256 = C_algo.SHA256 = Hasher.extend({
_doReset: function () {
this._hash = new WordArray.init(H.slice(0));
},
_doProcessBlock: function (M, offset) {
// Shortcut
var H = this._hash.words;
// Working variables
var a = H[0];
var b = H[1];
var c = H[2];
var d = H[3];
var e = H[4];
var f = H[5];
var g = H[6];
var h = H[7];
// Computation
for (var i = 0; i < 64; i++) {
if (i < 16) {
W[i] = M[offset + i] | 0;
} else {
var gamma0x = W[i - 15];
var gamma0 = ((gamma0x << 25) | (gamma0x >>> 7)) ^
((gamma0x << 14) | (gamma0x >>> 18)) ^
(gamma0x >>> 3);
var gamma1x = W[i - 2];
var gamma1 = ((gamma1x << 15) | (gamma1x >>> 17)) ^
((gamma1x << 13) | (gamma1x >>> 19)) ^
(gamma1x >>> 10);
W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16];
}
var ch = (e & f) ^ (~e & g);
var maj = (a & b) ^ (a & c) ^ (b & c);
var sigma0 = ((a << 30) | (a >>> 2)) ^ ((a << 19) | (a >>> 13)) ^ ((a << 10) | (a >>> 22));
var sigma1 = ((e << 26) | (e >>> 6)) ^ ((e << 21) | (e >>> 11)) ^ ((e << 7) | (e >>> 25));
var t1 = h + sigma1 + ch + K[i] + W[i];
var t2 = sigma0 + maj;
h = g;
g = f;
f = e;
e = (d + t1) | 0;
d = c;
c = b;
b = a;
a = (t1 + t2) | 0;
}
// Intermediate hash value
H[0] = (H[0] + a) | 0;
H[1] = (H[1] + b) | 0;
H[2] = (H[2] + c) | 0;
H[3] = (H[3] + d) | 0;
H[4] = (H[4] + e) | 0;
H[5] = (H[5] + f) | 0;
H[6] = (H[6] + g) | 0;
H[7] = (H[7] + h) | 0;
},
_doFinalize: function () {
// Shortcuts
var data = this._data;
var dataWords = data.words;
var nBitsTotal = this._nDataBytes * 8;
var nBitsLeft = data.sigBytes * 8;
// Add padding
dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32);
dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = Math.floor(nBitsTotal / 0x100000000);
dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = nBitsTotal;
data.sigBytes = dataWords.length * 4;
// Hash final blocks
this._process();
// Return final computed hash
return this._hash;
},
clone: function () {
var clone = Hasher.clone.call(this);
clone._hash = this._hash.clone();
return clone;
}
});
/**
* Shortcut function to the hasher's object interface.
*
* @param {WordArray|string} message The message to hash.
*
* @return {WordArray} The hash.
*
* @static
*
* @example
*
* var hash = CryptoJS.SHA256('message');
* var hash = CryptoJS.SHA256(wordArray);
*/
C.SHA256 = Hasher._createHelper(SHA256);
/**
* Shortcut function to the HMAC's object interface.
*
* @param {WordArray|string} message The message to hash.
* @param {WordArray|string} key The secret key.
*
* @return {WordArray} The HMAC.
*
* @static
*
* @example
*
* var hmac = CryptoJS.HmacSHA256(message, key);
*/
C.HmacSHA256 = Hasher._createHmacHelper(SHA256);
}(Math));
(function () {
// Shortcuts
var C = CryptoJS;
var C_lib = C.lib;
var WordArray = C_lib.WordArray;
var C_enc = C.enc;
/**
* UTF-16 BE encoding strategy.
*/
var Utf16BE = C_enc.Utf16 = C_enc.Utf16BE = {
/**
* Converts a word array to a UTF-16 BE string.
*
* @param {WordArray} wordArray The word array.
*
* @return {string} The UTF-16 BE string.
*
* @static
*
* @example
*
* var utf16String = CryptoJS.enc.Utf16.stringify(wordArray);
*/
stringify: function (wordArray) {
// Shortcuts
var words = wordArray.words;
var sigBytes = wordArray.sigBytes;
// Convert
var utf16Chars = [];
for (var i = 0; i < sigBytes; i += 2) {
var codePoint = (words[i >>> 2] >>> (16 - (i % 4) * 8)) & 0xffff;
utf16Chars.push(String.fromCharCode(codePoint));
}
return utf16Chars.join('');
},
/**
* Converts a UTF-16 BE string to a word array.
*
* @param {string} utf16Str The UTF-16 BE string.
*
* @return {WordArray} The word array.
*
* @static
*
* @example
*
* var wordArray = CryptoJS.enc.Utf16.parse(utf16String);
*/
parse: function (utf16Str) {
// Shortcut
var utf16StrLength = utf16Str.length;
// Convert
var words = [];
for (var i = 0; i < utf16StrLength; i++) {
words[i >>> 1] |= utf16Str.charCodeAt(i) << (16 - (i % 2) * 16);
}
return WordArray.create(words, utf16StrLength * 2);
}
};
/**
* UTF-16 LE encoding strategy.
*/
C_enc.Utf16LE = {
/**
* Converts a word array to a UTF-16 LE string.
*
* @param {WordArray} wordArray The word array.
*
* @return {string} The UTF-16 LE string.
*
* @static
*
* @example
*
* var utf16Str = CryptoJS.enc.Utf16LE.stringify(wordArray);
*/
stringify: function (wordArray) {
// Shortcuts
var words = wordArray.words;
var sigBytes = wordArray.sigBytes;
// Convert
var utf16Chars = [];
for (var i = 0; i < sigBytes; i += 2) {
var codePoint = swapEndian((words[i >>> 2] >>> (16 - (i % 4) * 8)) & 0xffff);
utf16Chars.push(String.fromCharCode(codePoint));
}
return utf16Chars.join('');
},
/**
* Converts a UTF-16 LE string to a word array.
*
* @param {string} utf16Str The UTF-16 LE string.
*
* @return {WordArray} The word array.
*
* @static
*
* @example
*
* var wordArray = CryptoJS.enc.Utf16LE.parse(utf16Str);
*/
parse: function (utf16Str) {
// Shortcut
var utf16StrLength = utf16Str.length;
// Convert
var words = [];
for (var i = 0; i < utf16StrLength; i++) {
words[i >>> 1] |= swapEndian(utf16Str.charCodeAt(i) << (16 - (i % 2) * 16));
}
return WordArray.create(words, utf16StrLength * 2);
}
};
function swapEndian(word) {
return ((word << 8) & 0xff00ff00) | ((word >>> 8) & 0x00ff00ff);
}
}());
(function () {
// Check if typed arrays are supported
if (typeof ArrayBuffer != 'function') {
return;
}
// Shortcuts
var C = CryptoJS;
var C_lib = C.lib;
var WordArray = C_lib.WordArray;
// Reference original init
var superInit = WordArray.init;
// Augment WordArray.init to handle typed arrays
var subInit = WordArray.init = function (typedArray) {
// Convert buffers to uint8
if (typedArray instanceof ArrayBuffer) {
typedArray = new Uint8Array(typedArray);
}
// Convert other array views to uint8
if (
typedArray instanceof Int8Array ||
(typeof Uint8ClampedArray !== "undefined" && typedArray instanceof Uint8ClampedArray) ||
typedArray instanceof Int16Array ||
typedArray instanceof Uint16Array ||
typedArray instanceof Int32Array ||
typedArray instanceof Uint32Array ||
typedArray instanceof Float32Array ||
typedArray instanceof Float64Array
) {
typedArray = new Uint8Array(typedArray.buffer, typedArray.byteOffset, typedArray.byteLength);
}
// Handle Uint8Array
if (typedArray instanceof Uint8Array) {
// Shortcut
var typedArrayByteLength = typedArray.byteLength;
// Extract bytes
var words = [];
for (var i = 0; i < typedArrayByteLength; i++) {
words[i >>> 2] |= typedArray[i] << (24 - (i % 4) * 8);
}
// Initialize this word array
superInit.call(this, words, typedArrayByteLength);
} else {
// Else call normal init
superInit.apply(this, arguments);
}
};
subInit.prototype = WordArray;
}());
/** @preserve
(c) 2012 by Cdric Mesnil. All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
- Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
(function (Math) {
// Shortcuts
var C = CryptoJS;
var C_lib = C.lib;
var WordArray = C_lib.WordArray;
var Hasher = C_lib.Hasher;
var C_algo = C.algo;
// Constants table
var _zl = WordArray.create([
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8,
3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12,
1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2,
4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13]);
var _zr = WordArray.create([
5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12,
6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2,
15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13,
8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14,
12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11]);
var _sl = WordArray.create([
11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8,
7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12,
11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5,
11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12,
9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6 ]);
var _sr = WordArray.create([
8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6,
9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11,
9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5,
15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8,
8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11 ]);
var _hl = WordArray.create([ 0x00000000, 0x5A827999, 0x6ED9EBA1, 0x8F1BBCDC, 0xA953FD4E]);
var _hr = WordArray.create([ 0x50A28BE6, 0x5C4DD124, 0x6D703EF3, 0x7A6D76E9, 0x00000000]);
/**
* RIPEMD160 hash algorithm.
*/
var RIPEMD160 = C_algo.RIPEMD160 = Hasher.extend({
_doReset: function () {
this._hash = WordArray.create([0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0]);
},
_doProcessBlock: function (M, offset) {
// Swap endian
for (var i = 0; i < 16; i++) {
// Shortcuts
var offset_i = offset + i;
var M_offset_i = M[offset_i];
// Swap
M[offset_i] = (
(((M_offset_i << 8) | (M_offset_i >>> 24)) & 0x00ff00ff) |
(((M_offset_i << 24) | (M_offset_i >>> 8)) & 0xff00ff00)
);
}
// Shortcut
var H = this._hash.words;
var hl = _hl.words;
var hr = _hr.words;
var zl = _zl.words;
var zr = _zr.words;
var sl = _sl.words;
var sr = _sr.words;
// Working variables
var al, bl, cl, dl, el;
var ar, br, cr, dr, er;
ar = al = H[0];
br = bl = H[1];
cr = cl = H[2];
dr = dl = H[3];
er = el = H[4];
// Computation
var t;
for (var i = 0; i < 80; i += 1) {
t = (al + M[offset+zl[i]])|0;
if (i<16){
t += f1(bl,cl,dl) + hl[0];
} else if (i<32) {
t += f2(bl,cl,dl) + hl[1];
} else if (i<48) {
t += f3(bl,cl,dl) + hl[2];
} else if (i<64) {
t += f4(bl,cl,dl) + hl[3];
} else {// if (i<80) {
t += f5(bl,cl,dl) + hl[4];
}
t = t|0;
t = rotl(t,sl[i]);
t = (t+el)|0;
al = el;
el = dl;
dl = rotl(cl, 10);
cl = bl;
bl = t;
t = (ar + M[offset+zr[i]])|0;
if (i<16){
t += f5(br,cr,dr) + hr[0];
} else if (i<32) {
t += f4(br,cr,dr) + hr[1];
} else if (i<48) {
t += f3(br,cr,dr) + hr[2];
} else if (i<64) {
t += f2(br,cr,dr) + hr[3];
} else {// if (i<80) {
t += f1(br,cr,dr) + hr[4];
}
t = t|0;
t = rotl(t,sr[i]) ;
t = (t+er)|0;
ar = er;
er = dr;
dr = rotl(cr, 10);
cr = br;
br = t;
}
// Intermediate hash value
t = (H[1] + cl + dr)|0;
H[1] = (H[2] + dl + er)|0;
H[2] = (H[3] + el + ar)|0;
H[3] = (H[4] + al + br)|0;
H[4] = (H[0] + bl + cr)|0;
H[0] = t;
},
_doFinalize: function () {
// Shortcuts
var data = this._data;
var dataWords = data.words;
var nBitsTotal = this._nDataBytes * 8;
var nBitsLeft = data.sigBytes * 8;
// Add padding
dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32);
dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = (
(((nBitsTotal << 8) | (nBitsTotal >>> 24)) & 0x00ff00ff) |
(((nBitsTotal << 24) | (nBitsTotal >>> 8)) & 0xff00ff00)
);
data.sigBytes = (dataWords.length + 1) * 4;
// Hash final blocks
this._process();
// Shortcuts
var hash = this._hash;
var H = hash.words;
// Swap endian
for (var i = 0; i < 5; i++) {
// Shortcut
var H_i = H[i];
// Swap
H[i] = (((H_i << 8) | (H_i >>> 24)) & 0x00ff00ff) |
(((H_i << 24) | (H_i >>> 8)) & 0xff00ff00);
}
// Return final computed hash
return hash;
},
clone: function () {
var clone = Hasher.clone.call(this);
clone._hash = this._hash.clone();
return clone;
}
});
function f1(x, y, z) {
return ((x) ^ (y) ^ (z));
}
function f2(x, y, z) {
return (((x)&(y)) | ((~x)&(z)));
}
function f3(x, y, z) {
return (((x) | (~(y))) ^ (z));
}
function f4(x, y, z) {
return (((x) & (z)) | ((y)&(~(z))));
}
function f5(x, y, z) {
return ((x) ^ ((y) |(~(z))));
}
function rotl(x,n) {
return (x<<n) | (x>>>(32-n));
}
/**
* Shortcut function to the hasher's object interface.
*
* @param {WordArray|string} message The message to hash.
*
* @return {WordArray} The hash.
*
* @static
*
* @example
*
* var hash = CryptoJS.RIPEMD160('message');
* var hash = CryptoJS.RIPEMD160(wordArray);
*/
C.RIPEMD160 = Hasher._createHelper(RIPEMD160);
/**
* Shortcut function to the HMAC's object interface.
*
* @param {WordArray|string} message The message to hash.
* @param {WordArray|string} key The secret key.
*
* @return {WordArray} The HMAC.
*
* @static
*
* @example
*
* var hmac = CryptoJS.HmacRIPEMD160(message, key);
*/
C.HmacRIPEMD160 = Hasher._createHmacHelper(RIPEMD160);
}(Math));
(function () {
// Shortcuts
var C = CryptoJS;
var C_lib = C.lib;
var Base = C_lib.Base;
var C_enc = C.enc;
var Utf8 = C_enc.Utf8;
var C_algo = C.algo;
/**
* HMAC algorithm.
*/
var HMAC = C_algo.HMAC = Base.extend({
/**
* Initializes a newly created HMAC.
*
* @param {Hasher} hasher The hash algorithm to use.
* @param {WordArray|string} key The secret key.
*
* @example
*
* var hmacHasher = CryptoJS.algo.HMAC.create(CryptoJS.algo.SHA256, key);
*/
init: function (hasher, key) {
// Init hasher
hasher = this._hasher = new hasher.init();
// Convert string to WordArray, else assume WordArray already
if (typeof key == 'string') {
key = Utf8.parse(key);
}
// Shortcuts
var hasherBlockSize = hasher.blockSize;
var hasherBlockSizeBytes = hasherBlockSize * 4;
// Allow arbitrary length keys
if (key.sigBytes > hasherBlockSizeBytes) {
key = hasher.finalize(key);
}
// Clamp excess bits
key.clamp();
// Clone key for inner and outer pads
var oKey = this._oKey = key.clone();
var iKey = this._iKey = key.clone();
// Shortcuts
var oKeyWords = oKey.words;
var iKeyWords = iKey.words;
// XOR keys with pad constants
for (var i = 0; i < hasherBlockSize; i++) {
oKeyWords[i] ^= 0x5c5c5c5c;
iKeyWords[i] ^= 0x36363636;
}
oKey.sigBytes = iKey.sigBytes = hasherBlockSizeBytes;
// Set initial values
this.reset();
},
/**
* Resets this HMAC to its initial state.
*
* @example
*
* hmacHasher.reset();
*/
reset: function () {
// Shortcut
var hasher = this._hasher;
// Reset
hasher.reset();
hasher.update(this._iKey);
},
/**
* Updates this HMAC with a message.
*
* @param {WordArray|string} messageUpdate The message to append.
*
* @return {HMAC} This HMAC instance.
*
* @example
*
* hmacHasher.update('message');
* hmacHasher.update(wordArray);
*/
update: function (messageUpdate) {
this._hasher.update(messageUpdate);
// Chainable
return this;
},
/**
* Finalizes the HMAC computation.
* Note that the finalize operation is effectively a destructive, read-once operation.
*
* @param {WordArray|string} messageUpdate (Optional) A final message update.
*
* @return {WordArray} The HMAC.
*
* @example
*
* var hmac = hmacHasher.finalize();
* var hmac = hmacHasher.finalize('message');
* var hmac = hmacHasher.finalize(wordArray);
*/
finalize: function (messageUpdate) {
// Shortcut
var hasher = this._hasher;
// Compute HMAC
var innerHash = hasher.finalize(messageUpdate);
hasher.reset();
var hmac = hasher.finalize(this._oKey.clone().concat(innerHash));
return hmac;
}
});
}());
(function () {
// Shortcuts
var C = CryptoJS;
var C_lib = C.lib;
var Base = C_lib.Base;
var WordArray = C_lib.WordArray;
var C_algo = C.algo;
var SHA1 = C_algo.SHA1;
var HMAC = C_algo.HMAC;
/**
* Password-Based Key Derivation Function 2 algorithm.
*/
var PBKDF2 = C_algo.PBKDF2 = Base.extend({
/**
* Configuration options.
*
* @property {number} keySize The key size in words to generate. Default: 4 (128 bits)
* @property {Hasher} hasher The hasher to use. Default: SHA1
* @property {number} iterations The number of iterations to perform. Default: 1
*/
cfg: Base.extend({
keySize: 128/32,
hasher: SHA1,
iterations: 1
}),
/**
* Initializes a newly created key derivation function.
*
* @param {Object} cfg (Optional) The configuration options to use for the derivation.
*
* @example
*
* var kdf = CryptoJS.algo.PBKDF2.create();
* var kdf = CryptoJS.algo.PBKDF2.create({ keySize: 8 });
* var kdf = CryptoJS.algo.PBKDF2.create({ keySize: 8, iterations: 1000 });
*/
init: function (cfg) {
this.cfg = this.cfg.extend(cfg);
},
/**
* Computes the Password-Based Key Derivation Function 2.
*
* @param {WordArray|string} password The password.
* @param {WordArray|string} salt A salt.
*
* @return {WordArray} The derived key.
*
* @example
*
* var key = kdf.compute(password, salt);
*/
compute: function (password, salt) {
// Shortcut
var cfg = this.cfg;
// Init HMAC
var hmac = HMAC.create(cfg.hasher, password);
// Initial values
var derivedKey = WordArray.create();
var blockIndex = WordArray.create([0x00000001]);
// Shortcuts
var derivedKeyWords = derivedKey.words;
var blockIndexWords = blockIndex.words;
var keySize = cfg.keySize;
var iterations = cfg.iterations;
// Generate key
while (derivedKeyWords.length < keySize) {
var block = hmac.update(salt).finalize(blockIndex);
hmac.reset();
// Shortcuts
var blockWords = block.words;
var blockWordsLength = blockWords.length;
// Iterations
var intermediate = block;
for (var i = 1; i < iterations; i++) {
intermediate = hmac.finalize(intermediate);
hmac.reset();
// Shortcut
var intermediateWords = intermediate.words;
// XOR intermediate with block
for (var j = 0; j < blockWordsLength; j++) {
blockWords[j] ^= intermediateWords[j];
}
}
derivedKey.concat(block);
blockIndexWords[0]++;
}
derivedKey.sigBytes = keySize * 4;
return derivedKey;
}
});
/**
* Computes the Password-Based Key Derivation Function 2.
*
* @param {WordArray|string} password The password.
* @param {WordArray|string} salt A salt.
* @param {Object} cfg (Optional) The configuration options to use for this computation.
*
* @return {WordArray} The derived key.
*
* @static
*
* @example
*
* var key = CryptoJS.PBKDF2(password, salt);
* var key = CryptoJS.PBKDF2(password, salt, { keySize: 8 });
* var key = CryptoJS.PBKDF2(password, salt, { keySize: 8, iterations: 1000 });
*/
C.PBKDF2 = function (password, salt, cfg) {
return PBKDF2.create(cfg).compute(password, salt);
};
}());
(function () {
// Shortcuts
var C = CryptoJS;
var C_lib = C.lib;
var Base = C_lib.Base;
var WordArray = C_lib.WordArray;
var C_algo = C.algo;
var MD5 = C_algo.MD5;
/**
* This key derivation function is meant to conform with EVP_BytesToKey.
* www.openssl.org/docs/crypto/EVP_BytesToKey.html
*/
var EvpKDF = C_algo.EvpKDF = Base.extend({
/**
* Configuration options.
*
* @property {number} keySize The key size in words to generate. Default: 4 (128 bits)
* @property {Hasher} hasher The hash algorithm to use. Default: MD5
* @property {number} iterations The number of iterations to perform. Default: 1
*/
cfg: Base.extend({
keySize: 128/32,
hasher: MD5,
iterations: 1
}),
/**
* Initializes a newly created key derivation function.
*
* @param {Object} cfg (Optional) The configuration options to use for the derivation.
*
* @example
*
* var kdf = CryptoJS.algo.EvpKDF.create();
* var kdf = CryptoJS.algo.EvpKDF.create({ keySize: 8 });
* var kdf = CryptoJS.algo.EvpKDF.create({ keySize: 8, iterations: 1000 });
*/
init: function (cfg) {
this.cfg = this.cfg.extend(cfg);
},
/**
* Derives a key from a password.
*
* @param {WordArray|string} password The password.
* @param {WordArray|string} salt A salt.
*
* @return {WordArray} The derived key.
*
* @example
*
* var key = kdf.compute(password, salt);
*/
compute: function (password, salt) {
// Shortcut
var cfg = this.cfg;
// Init hasher
var hasher = cfg.hasher.create();
// Initial values
var derivedKey = WordArray.create();
// Shortcuts
var derivedKeyWords = derivedKey.words;
var keySize = cfg.keySize;
var iterations = cfg.iterations;
// Generate key
while (derivedKeyWords.length < keySize) {
if (block) {
hasher.update(block);
}
var block = hasher.update(password).finalize(salt);
hasher.reset();
// Iterations
for (var i = 1; i < iterations; i++) {
block = hasher.finalize(block);
hasher.reset();
}
derivedKey.concat(block);
}
derivedKey.sigBytes = keySize * 4;
return derivedKey;
}
});
/**
* Derives a key from a password.
*
* @param {WordArray|string} password The password.
* @param {WordArray|string} salt A salt.
* @param {Object} cfg (Optional) The configuration options to use for this computation.
*
* @return {WordArray} The derived key.
*
* @static
*
* @example
*
* var key = CryptoJS.EvpKDF(password, salt);
* var key = CryptoJS.EvpKDF(password, salt, { keySize: 8 });
* var key = CryptoJS.EvpKDF(password, salt, { keySize: 8, iterations: 1000 });
*/
C.EvpKDF = function (password, salt, cfg) {
return EvpKDF.create(cfg).compute(password, salt);
};
}());
(function () {
// Shortcuts
var C = CryptoJS;
var C_lib = C.lib;
var WordArray = C_lib.WordArray;
var C_algo = C.algo;
var SHA256 = C_algo.SHA256;
/**
* SHA-224 hash algorithm.
*/
var SHA224 = C_algo.SHA224 = SHA256.extend({
_doReset: function () {
this._hash = new WordArray.init([
0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939,
0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4
]);
},
_doFinalize: function () {
var hash = SHA256._doFinalize.call(this);
hash.sigBytes -= 4;
return hash;
}
});
/**
* Shortcut function to the hasher's object interface.
*
* @param {WordArray|string} message The message to hash.
*
* @return {WordArray} The hash.
*
* @static
*
* @example
*
* var hash = CryptoJS.SHA224('message');
* var hash = CryptoJS.SHA224(wordArray);
*/
C.SHA224 = SHA256._createHelper(SHA224);
/**
* Shortcut function to the HMAC's object interface.
*
* @param {WordArray|string} message The message to hash.
* @param {WordArray|string} key The secret key.
*
* @return {WordArray} The HMAC.
*
* @static
*
* @example
*
* var hmac = CryptoJS.HmacSHA224(message, key);
*/
C.HmacSHA224 = SHA256._createHmacHelper(SHA224);
}());
(function (undefined) {
// Shortcuts
var C = CryptoJS;
var C_lib = C.lib;
var Base = C_lib.Base;
var X32WordArray = C_lib.WordArray;
/**
* x64 namespace.
*/
var C_x64 = C.x64 = {};
/**
* A 64-bit word.
*/
var X64Word = C_x64.Word = Base.extend({
/**
* Initializes a newly created 64-bit word.
*
* @param {number} high The high 32 bits.
* @param {number} low The low 32 bits.
*
* @example
*
* var x64Word = CryptoJS.x64.Word.create(0x00010203, 0x04050607);
*/
init: function (high, low) {
this.high = high;
this.low = low;
}
/**
* Bitwise NOTs this word.
*
* @return {X64Word} A new x64-Word object after negating.
*
* @example
*
* var negated = x64Word.not();
*/
// not: function () {
// var high = ~this.high;
// var low = ~this.low;
// return X64Word.create(high, low);
// },
/**
* Bitwise ANDs this word with the passed word.
*
* @param {X64Word} word The x64-Word to AND with this word.
*
* @return {X64Word} A new x64-Word object after ANDing.
*
* @example
*
* var anded = x64Word.and(anotherX64Word);
*/
// and: function (word) {
// var high = this.high & word.high;
// var low = this.low & word.low;
// return X64Word.create(high, low);
// },
/**
* Bitwise ORs this word with the passed word.
*
* @param {X64Word} word The x64-Word to OR with this word.
*
* @return {X64Word} A new x64-Word object after ORing.
*
* @example
*
* var ored = x64Word.or(anotherX64Word);
*/
// or: function (word) {
// var high = this.high | word.high;
// var low = this.low | word.low;
// return X64Word.create(high, low);
// },
/**
* Bitwise XORs this word with the passed word.
*
* @param {X64Word} word The x64-Word to XOR with this word.
*
* @return {X64Word} A new x64-Word object after XORing.
*
* @example
*
* var xored = x64Word.xor(anotherX64Word);
*/
// xor: function (word) {
// var high = this.high ^ word.high;
// var low = this.low ^ word.low;
// return X64Word.create(high, low);
// },
/**
* Shifts this word n bits to the left.
*
* @param {number} n The number of bits to shift.
*
* @return {X64Word} A new x64-Word object after shifting.
*
* @example
*
* var shifted = x64Word.shiftL(25);
*/
// shiftL: function (n) {
// if (n < 32) {
// var high = (this.high << n) | (this.low >>> (32 - n));
// var low = this.low << n;
// } else {
// var high = this.low << (n - 32);
// var low = 0;
// }
// return X64Word.create(high, low);
// },
/**
* Shifts this word n bits to the right.
*
* @param {number} n The number of bits to shift.
*
* @return {X64Word} A new x64-Word object after shifting.
*
* @example
*
* var shifted = x64Word.shiftR(7);
*/
// shiftR: function (n) {
// if (n < 32) {
// var low = (this.low >>> n) | (this.high << (32 - n));
// var high = this.high >>> n;
// } else {
// var low = this.high >>> (n - 32);
// var high = 0;
// }
// return X64Word.create(high, low);
// },
/**
* Rotates this word n bits to the left.
*
* @param {number} n The number of bits to rotate.
*
* @return {X64Word} A new x64-Word object after rotating.
*
* @example
*
* var rotated = x64Word.rotL(25);
*/
// rotL: function (n) {
// return this.shiftL(n).or(this.shiftR(64 - n));
// },
/**
* Rotates this word n bits to the right.
*
* @param {number} n The number of bits to rotate.
*
* @return {X64Word} A new x64-Word object after rotating.
*
* @example
*
* var rotated = x64Word.rotR(7);
*/
// rotR: function (n) {
// return this.shiftR(n).or(this.shiftL(64 - n));
// },
/**
* Adds this word with the passed word.
*
* @param {X64Word} word The x64-Word to add with this word.
*
* @return {X64Word} A new x64-Word object after adding.
*
* @example
*
* var added = x64Word.add(anotherX64Word);
*/
// add: function (word) {
// var low = (this.low + word.low) | 0;
// var carry = (low >>> 0) < (this.low >>> 0) ? 1 : 0;
// var high = (this.high + word.high + carry) | 0;
// return X64Word.create(high, low);
// }
});
/**
* An array of 64-bit words.
*
* @property {Array} words The array of CryptoJS.x64.Word objects.
* @property {number} sigBytes The number of significant bytes in this word array.
*/
var X64WordArray = C_x64.WordArray = Base.extend({
/**
* Initializes a newly created word array.
*
* @param {Array} words (Optional) An array of CryptoJS.x64.Word objects.
* @param {number} sigBytes (Optional) The number of significant bytes in the words.
*
* @example
*
* var wordArray = CryptoJS.x64.WordArray.create();
*
* var wordArray = CryptoJS.x64.WordArray.create([
* CryptoJS.x64.Word.create(0x00010203, 0x04050607),
* CryptoJS.x64.Word.create(0x18191a1b, 0x1c1d1e1f)
* ]);
*
* var wordArray = CryptoJS.x64.WordArray.create([
* CryptoJS.x64.Word.create(0x00010203, 0x04050607),
* CryptoJS.x64.Word.create(0x18191a1b, 0x1c1d1e1f)
* ], 10);
*/
init: function (words, sigBytes) {
words = this.words = words || [];
if (sigBytes != undefined) {
this.sigBytes = sigBytes;
} else {
this.sigBytes = words.length * 8;
}
},
/**
* Converts this 64-bit word array to a 32-bit word array.
*
* @return {CryptoJS.lib.WordArray} This word array's data as a 32-bit word array.
*
* @example
*
* var x32WordArray = x64WordArray.toX32();
*/
toX32: function () {
// Shortcuts
var x64Words = this.words;
var x64WordsLength = x64Words.length;
// Convert
var x32Words = [];
for (var i = 0; i < x64WordsLength; i++) {
var x64Word = x64Words[i];
x32Words.push(x64Word.high);
x32Words.push(x64Word.low);
}
return X32WordArray.create(x32Words, this.sigBytes);
},
/**
* Creates a copy of this word array.
*
* @return {X64WordArray} The clone.
*
* @example
*
* var clone = x64WordArray.clone();
*/
clone: function () {
var clone = Base.clone.call(this);
// Clone "words" array
var words = clone.words = this.words.slice(0);
// Clone each X64Word object
var wordsLength = words.length;
for (var i = 0; i < wordsLength; i++) {
words[i] = words[i].clone();
}
return clone;
}
});
}());
(function (Math) {
// Shortcuts
var C = CryptoJS;
var C_lib = C.lib;
var WordArray = C_lib.WordArray;
var Hasher = C_lib.Hasher;
var C_x64 = C.x64;
var X64Word = C_x64.Word;
var C_algo = C.algo;
// Constants tables
var RHO_OFFSETS = [];
var PI_INDEXES = [];
var ROUND_CONSTANTS = [];
// Compute Constants
(function () {
// Compute rho offset constants
var x = 1, y = 0;
for (var t = 0; t < 24; t++) {
RHO_OFFSETS[x + 5 * y] = ((t + 1) * (t + 2) / 2) % 64;
var newX = y % 5;
var newY = (2 * x + 3 * y) % 5;
x = newX;
y = newY;
}
// Compute pi index constants
for (var x = 0; x < 5; x++) {
for (var y = 0; y < 5; y++) {
PI_INDEXES[x + 5 * y] = y + ((2 * x + 3 * y) % 5) * 5;
}
}
// Compute round constants
var LFSR = 0x01;
for (var i = 0; i < 24; i++) {
var roundConstantMsw = 0;
var roundConstantLsw = 0;
for (var j = 0; j < 7; j++) {
if (LFSR & 0x01) {
var bitPosition = (1 << j) - 1;
if (bitPosition < 32) {
roundConstantLsw ^= 1 << bitPosition;
} else /* if (bitPosition >= 32) */ {
roundConstantMsw ^= 1 << (bitPosition - 32);
}
}
// Compute next LFSR
if (LFSR & 0x80) {
// Primitive polynomial over GF(2): x^8 + x^6 + x^5 + x^4 + 1
LFSR = (LFSR << 1) ^ 0x71;
} else {
LFSR <<= 1;
}
}
ROUND_CONSTANTS[i] = X64Word.create(roundConstantMsw, roundConstantLsw);
}
}());
// Reusable objects for temporary values
var T = [];
(function () {
for (var i = 0; i < 25; i++) {
T[i] = X64Word.create();
}
}());
/**
* SHA-3 hash algorithm.
*/
var SHA3 = C_algo.SHA3 = Hasher.extend({
/**
* Configuration options.
*
* @property {number} outputLength
* The desired number of bits in the output hash.
* Only values permitted are: 224, 256, 384, 512.
* Default: 512
*/
cfg: Hasher.cfg.extend({
outputLength: 512
}),
_doReset: function () {
var state = this._state = []
for (var i = 0; i < 25; i++) {
state[i] = new X64Word.init();
}
this.blockSize = (1600 - 2 * this.cfg.outputLength) / 32;
},
_doProcessBlock: function (M, offset) {
// Shortcuts
var state = this._state;
var nBlockSizeLanes = this.blockSize / 2;
// Absorb
for (var i = 0; i < nBlockSizeLanes; i++) {
// Shortcuts
var M2i = M[offset + 2 * i];
var M2i1 = M[offset + 2 * i + 1];
// Swap endian
M2i = (
(((M2i << 8) | (M2i >>> 24)) & 0x00ff00ff) |
(((M2i << 24) | (M2i >>> 8)) & 0xff00ff00)
);
M2i1 = (
(((M2i1 << 8) | (M2i1 >>> 24)) & 0x00ff00ff) |
(((M2i1 << 24) | (M2i1 >>> 8)) & 0xff00ff00)
);
// Absorb message into state
var lane = state[i];
lane.high ^= M2i1;
lane.low ^= M2i;
}
// Rounds
for (var round = 0; round < 24; round++) {
// Theta
for (var x = 0; x < 5; x++) {
// Mix column lanes
var tMsw = 0, tLsw = 0;
for (var y = 0; y < 5; y++) {
var lane = state[x + 5 * y];
tMsw ^= lane.high;
tLsw ^= lane.low;
}
// Temporary values
var Tx = T[x];
Tx.high = tMsw;
Tx.low = tLsw;
}
for (var x = 0; x < 5; x++) {
// Shortcuts
var Tx4 = T[(x + 4) % 5];
var Tx1 = T[(x + 1) % 5];
var Tx1Msw = Tx1.high;
var Tx1Lsw = Tx1.low;
// Mix surrounding columns
var tMsw = Tx4.high ^ ((Tx1Msw << 1) | (Tx1Lsw >>> 31));
var tLsw = Tx4.low ^ ((Tx1Lsw << 1) | (Tx1Msw >>> 31));
for (var y = 0; y < 5; y++) {
var lane = state[x + 5 * y];
lane.high ^= tMsw;
lane.low ^= tLsw;
}
}
// Rho Pi
for (var laneIndex = 1; laneIndex < 25; laneIndex++) {
// Shortcuts
var lane = state[laneIndex];
var laneMsw = lane.high;
var laneLsw = lane.low;
var rhoOffset = RHO_OFFSETS[laneIndex];
// Rotate lanes
if (rhoOffset < 32) {
var tMsw = (laneMsw << rhoOffset) | (laneLsw >>> (32 - rhoOffset));
var tLsw = (laneLsw << rhoOffset) | (laneMsw >>> (32 - rhoOffset));
} else /* if (rhoOffset >= 32) */ {
var tMsw = (laneLsw << (rhoOffset - 32)) | (laneMsw >>> (64 - rhoOffset));
var tLsw = (laneMsw << (rhoOffset - 32)) | (laneLsw >>> (64 - rhoOffset));
}
// Transpose lanes
var TPiLane = T[PI_INDEXES[laneIndex]];
TPiLane.high = tMsw;
TPiLane.low = tLsw;
}
// Rho pi at x = y = 0
var T0 = T[0];
var state0 = state[0];
T0.high = state0.high;
T0.low = state0.low;
// Chi
for (var x = 0; x < 5; x++) {
for (var y = 0; y < 5; y++) {
// Shortcuts
var laneIndex = x + 5 * y;
var lane = state[laneIndex];
var TLane = T[laneIndex];
var Tx1Lane = T[((x + 1) % 5) + 5 * y];
var Tx2Lane = T[((x + 2) % 5) + 5 * y];
// Mix rows
lane.high = TLane.high ^ (~Tx1Lane.high & Tx2Lane.high);
lane.low = TLane.low ^ (~Tx1Lane.low & Tx2Lane.low);
}
}
// Iota
var lane = state[0];
var roundConstant = ROUND_CONSTANTS[round];
lane.high ^= roundConstant.high;
lane.low ^= roundConstant.low;;
}
},
_doFinalize: function () {
// Shortcuts
var data = this._data;
var dataWords = data.words;
var nBitsTotal = this._nDataBytes * 8;
var nBitsLeft = data.sigBytes * 8;
var blockSizeBits = this.blockSize * 32;
// Add padding
dataWords[nBitsLeft >>> 5] |= 0x1 << (24 - nBitsLeft % 32);
dataWords[((Math.ceil((nBitsLeft + 1) / blockSizeBits) * blockSizeBits) >>> 5) - 1] |= 0x80;
data.sigBytes = dataWords.length * 4;
// Hash final blocks
this._process();
// Shortcuts
var state = this._state;
var outputLengthBytes = this.cfg.outputLength / 8;
var outputLengthLanes = outputLengthBytes / 8;
// Squeeze
var hashWords = [];
for (var i = 0; i < outputLengthLanes; i++) {
// Shortcuts
var lane = state[i];
var laneMsw = lane.high;
var laneLsw = lane.low;
// Swap endian
laneMsw = (
(((laneMsw << 8) | (laneMsw >>> 24)) & 0x00ff00ff) |
(((laneMsw << 24) | (laneMsw >>> 8)) & 0xff00ff00)
);
laneLsw = (
(((laneLsw << 8) | (laneLsw >>> 24)) & 0x00ff00ff) |
(((laneLsw << 24) | (laneLsw >>> 8)) & 0xff00ff00)
);
// Squeeze state to retrieve hash
hashWords.push(laneLsw);
hashWords.push(laneMsw);
}
// Return final computed hash
return new WordArray.init(hashWords, outputLengthBytes);
},
clone: function () {
var clone = Hasher.clone.call(this);
var state = clone._state = this._state.slice(0);
for (var i = 0; i < 25; i++) {
state[i] = state[i].clone();
}
return clone;
}
});
/**
* Shortcut function to the hasher's object interface.
*
* @param {WordArray|string} message The message to hash.
*
* @return {WordArray} The hash.
*
* @static
*
* @example
*
* var hash = CryptoJS.SHA3('message');
* var hash = CryptoJS.SHA3(wordArray);
*/
C.SHA3 = Hasher._createHelper(SHA3);
/**
* Shortcut function to the HMAC's object interface.
*
* @param {WordArray|string} message The message to hash.
* @param {WordArray|string} key The secret key.
*
* @return {WordArray} The HMAC.
*
* @static
*
* @example
*
* var hmac = CryptoJS.HmacSHA3(message, key);
*/
C.HmacSHA3 = Hasher._createHmacHelper(SHA3);
}(Math));
(function () {
// Shortcuts
var C = CryptoJS;
var C_lib = C.lib;
var Hasher = C_lib.Hasher;
var C_x64 = C.x64;
var X64Word = C_x64.Word;
var X64WordArray = C_x64.WordArray;
var C_algo = C.algo;
function X64Word_create() {
return X64Word.create.apply(X64Word, arguments);
}
// Constants
var K = [
X64Word_create(0x428a2f98, 0xd728ae22), X64Word_create(0x71374491, 0x23ef65cd),
X64Word_create(0xb5c0fbcf, 0xec4d3b2f), X64Word_create(0xe9b5dba5, 0x8189dbbc),
X64Word_create(0x3956c25b, 0xf348b538), X64Word_create(0x59f111f1, 0xb605d019),
X64Word_create(0x923f82a4, 0xaf194f9b), X64Word_create(0xab1c5ed5, 0xda6d8118),
X64Word_create(0xd807aa98, 0xa3030242), X64Word_create(0x12835b01, 0x45706fbe),
X64Word_create(0x243185be, 0x4ee4b28c), X64Word_create(0x550c7dc3, 0xd5ffb4e2),
X64Word_create(0x72be5d74, 0xf27b896f), X64Word_create(0x80deb1fe, 0x3b1696b1),
X64Word_create(0x9bdc06a7, 0x25c71235), X64Word_create(0xc19bf174, 0xcf692694),
X64Word_create(0xe49b69c1, 0x9ef14ad2), X64Word_create(0xefbe4786, 0x384f25e3),
X64Word_create(0x0fc19dc6, 0x8b8cd5b5), X64Word_create(0x240ca1cc, 0x77ac9c65),
X64Word_create(0x2de92c6f, 0x592b0275), X64Word_create(0x4a7484aa, 0x6ea6e483),
X64Word_create(0x5cb0a9dc, 0xbd41fbd4), X64Word_create(0x76f988da, 0x831153b5),
X64Word_create(0x983e5152, 0xee66dfab), X64Word_create(0xa831c66d, 0x2db43210),
X64Word_create(0xb00327c8, 0x98fb213f), X64Word_create(0xbf597fc7, 0xbeef0ee4),
X64Word_create(0xc6e00bf3, 0x3da88fc2), X64Word_create(0xd5a79147, 0x930aa725),
X64Word_create(0x06ca6351, 0xe003826f), X64Word_create(0x14292967, 0x0a0e6e70),
X64Word_create(0x27b70a85, 0x46d22ffc), X64Word_create(0x2e1b2138, 0x5c26c926),
X64Word_create(0x4d2c6dfc, 0x5ac42aed), X64Word_create(0x53380d13, 0x9d95b3df),
X64Word_create(0x650a7354, 0x8baf63de), X64Word_create(0x766a0abb, 0x3c77b2a8),
X64Word_create(0x81c2c92e, 0x47edaee6), X64Word_create(0x92722c85, 0x1482353b),
X64Word_create(0xa2bfe8a1, 0x4cf10364), X64Word_create(0xa81a664b, 0xbc423001),
X64Word_create(0xc24b8b70, 0xd0f89791), X64Word_create(0xc76c51a3, 0x0654be30),
X64Word_create(0xd192e819, 0xd6ef5218), X64Word_create(0xd6990624, 0x5565a910),
X64Word_create(0xf40e3585, 0x5771202a), X64Word_create(0x106aa070, 0x32bbd1b8),
X64Word_create(0x19a4c116, 0xb8d2d0c8), X64Word_create(0x1e376c08, 0x5141ab53),
X64Word_create(0x2748774c, 0xdf8eeb99), X64Word_create(0x34b0bcb5, 0xe19b48a8),
X64Word_create(0x391c0cb3, 0xc5c95a63), X64Word_create(0x4ed8aa4a, 0xe3418acb),
X64Word_create(0x5b9cca4f, 0x7763e373), X64Word_create(0x682e6ff3, 0xd6b2b8a3),
X64Word_create(0x748f82ee, 0x5defb2fc), X64Word_create(0x78a5636f, 0x43172f60),
X64Word_create(0x84c87814, 0xa1f0ab72), X64Word_create(0x8cc70208, 0x1a6439ec),
X64Word_create(0x90befffa, 0x23631e28), X64Word_create(0xa4506ceb, 0xde82bde9),
X64Word_create(0xbef9a3f7, 0xb2c67915), X64Word_create(0xc67178f2, 0xe372532b),
X64Word_create(0xca273ece, 0xea26619c), X64Word_create(0xd186b8c7, 0x21c0c207),
X64Word_create(0xeada7dd6, 0xcde0eb1e), X64Word_create(0xf57d4f7f, 0xee6ed178),
X64Word_create(0x06f067aa, 0x72176fba), X64Word_create(0x0a637dc5, 0xa2c898a6),
X64Word_create(0x113f9804, 0xbef90dae), X64Word_create(0x1b710b35, 0x131c471b),
X64Word_create(0x28db77f5, 0x23047d84), X64Word_create(0x32caab7b, 0x40c72493),
X64Word_create(0x3c9ebe0a, 0x15c9bebc), X64Word_create(0x431d67c4, 0x9c100d4c),
X64Word_create(0x4cc5d4be, 0xcb3e42b6), X64Word_create(0x597f299c, 0xfc657e2a),
X64Word_create(0x5fcb6fab, 0x3ad6faec), X64Word_create(0x6c44198c, 0x4a475817)
];
// Reusable objects
var W = [];
(function () {
for (var i = 0; i < 80; i++) {
W[i] = X64Word_create();
}
}());
/**
* SHA-512 hash algorithm.
*/
var SHA512 = C_algo.SHA512 = Hasher.extend({
_doReset: function () {
this._hash = new X64WordArray.init([
new X64Word.init(0x6a09e667, 0xf3bcc908), new X64Word.init(0xbb67ae85, 0x84caa73b),
new X64Word.init(0x3c6ef372, 0xfe94f82b), new X64Word.init(0xa54ff53a, 0x5f1d36f1),
new X64Word.init(0x510e527f, 0xade682d1), new X64Word.init(0x9b05688c, 0x2b3e6c1f),
new X64Word.init(0x1f83d9ab, 0xfb41bd6b), new X64Word.init(0x5be0cd19, 0x137e2179)
]);
},
_doProcessBlock: function (M, offset) {
// Shortcuts
var H = this._hash.words;
var H0 = H[0];
var H1 = H[1];
var H2 = H[2];
var H3 = H[3];
var H4 = H[4];
var H5 = H[5];
var H6 = H[6];
var H7 = H[7];
var H0h = H0.high;
var H0l = H0.low;
var H1h = H1.high;
var H1l = H1.low;
var H2h = H2.high;
var H2l = H2.low;
var H3h = H3.high;
var H3l = H3.low;
var H4h = H4.high;
var H4l = H4.low;
var H5h = H5.high;
var H5l = H5.low;
var H6h = H6.high;
var H6l = H6.low;
var H7h = H7.high;
var H7l = H7.low;
// Working variables
var ah = H0h;
var al = H0l;
var bh = H1h;
var bl = H1l;
var ch = H2h;
var cl = H2l;
var dh = H3h;
var dl = H3l;
var eh = H4h;
var el = H4l;
var fh = H5h;
var fl = H5l;
var gh = H6h;
var gl = H6l;
var hh = H7h;
var hl = H7l;
// Rounds
for (var i = 0; i < 80; i++) {
// Shortcut
var Wi = W[i];
// Extend message
if (i < 16) {
var Wih = Wi.high = M[offset + i * 2] | 0;
var Wil = Wi.low = M[offset + i * 2 + 1] | 0;
} else {
// Gamma0
var gamma0x = W[i - 15];
var gamma0xh = gamma0x.high;
var gamma0xl = gamma0x.low;
var gamma0h = ((gamma0xh >>> 1) | (gamma0xl << 31)) ^ ((gamma0xh >>> 8) | (gamma0xl << 24)) ^ (gamma0xh >>> 7);
var gamma0l = ((gamma0xl >>> 1) | (gamma0xh << 31)) ^ ((gamma0xl >>> 8) | (gamma0xh << 24)) ^ ((gamma0xl >>> 7) | (gamma0xh << 25));
// Gamma1
var gamma1x = W[i - 2];
var gamma1xh = gamma1x.high;
var gamma1xl = gamma1x.low;
var gamma1h = ((gamma1xh >>> 19) | (gamma1xl << 13)) ^ ((gamma1xh << 3) | (gamma1xl >>> 29)) ^ (gamma1xh >>> 6);
var gamma1l = ((gamma1xl >>> 19) | (gamma1xh << 13)) ^ ((gamma1xl << 3) | (gamma1xh >>> 29)) ^ ((gamma1xl >>> 6) | (gamma1xh << 26));
// W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16]
var Wi7 = W[i - 7];
var Wi7h = Wi7.high;
var Wi7l = Wi7.low;
var Wi16 = W[i - 16];
var Wi16h = Wi16.high;
var Wi16l = Wi16.low;
var Wil = gamma0l + Wi7l;
var Wih = gamma0h + Wi7h + ((Wil >>> 0) < (gamma0l >>> 0) ? 1 : 0);
var Wil = Wil + gamma1l;
var Wih = Wih + gamma1h + ((Wil >>> 0) < (gamma1l >>> 0) ? 1 : 0);
var Wil = Wil + Wi16l;
var Wih = Wih + Wi16h + ((Wil >>> 0) < (Wi16l >>> 0) ? 1 : 0);
Wi.high = Wih;
Wi.low = Wil;
}
var chh = (eh & fh) ^ (~eh & gh);
var chl = (el & fl) ^ (~el & gl);
var majh = (ah & bh) ^ (ah & ch) ^ (bh & ch);
var majl = (al & bl) ^ (al & cl) ^ (bl & cl);
var sigma0h = ((ah >>> 28) | (al << 4)) ^ ((ah << 30) | (al >>> 2)) ^ ((ah << 25) | (al >>> 7));
var sigma0l = ((al >>> 28) | (ah << 4)) ^ ((al << 30) | (ah >>> 2)) ^ ((al << 25) | (ah >>> 7));
var sigma1h = ((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9));
var sigma1l = ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9));
// t1 = h + sigma1 + ch + K[i] + W[i]
var Ki = K[i];
var Kih = Ki.high;
var Kil = Ki.low;
var t1l = hl + sigma1l;
var t1h = hh + sigma1h + ((t1l >>> 0) < (hl >>> 0) ? 1 : 0);
var t1l = t1l + chl;
var t1h = t1h + chh + ((t1l >>> 0) < (chl >>> 0) ? 1 : 0);
var t1l = t1l + Kil;
var t1h = t1h + Kih + ((t1l >>> 0) < (Kil >>> 0) ? 1 : 0);
var t1l = t1l + Wil;
var t1h = t1h + Wih + ((t1l >>> 0) < (Wil >>> 0) ? 1 : 0);
// t2 = sigma0 + maj
var t2l = sigma0l + majl;
var t2h = sigma0h + majh + ((t2l >>> 0) < (sigma0l >>> 0) ? 1 : 0);
// Update working variables
hh = gh;
hl = gl;
gh = fh;
gl = fl;
fh = eh;
fl = el;
el = (dl + t1l) | 0;
eh = (dh + t1h + ((el >>> 0) < (dl >>> 0) ? 1 : 0)) | 0;
dh = ch;
dl = cl;
ch = bh;
cl = bl;
bh = ah;
bl = al;
al = (t1l + t2l) | 0;
ah = (t1h + t2h + ((al >>> 0) < (t1l >>> 0) ? 1 : 0)) | 0;
}
// Intermediate hash value
H0l = H0.low = (H0l + al);
H0.high = (H0h + ah + ((H0l >>> 0) < (al >>> 0) ? 1 : 0));
H1l = H1.low = (H1l + bl);
H1.high = (H1h + bh + ((H1l >>> 0) < (bl >>> 0) ? 1 : 0));
H2l = H2.low = (H2l + cl);
H2.high = (H2h + ch + ((H2l >>> 0) < (cl >>> 0) ? 1 : 0));
H3l = H3.low = (H3l + dl);
H3.high = (H3h + dh + ((H3l >>> 0) < (dl >>> 0) ? 1 : 0));
H4l = H4.low = (H4l + el);
H4.high = (H4h + eh + ((H4l >>> 0) < (el >>> 0) ? 1 : 0));
H5l = H5.low = (H5l + fl);
H5.high = (H5h + fh + ((H5l >>> 0) < (fl >>> 0) ? 1 : 0));
H6l = H6.low = (H6l + gl);
H6.high = (H6h + gh + ((H6l >>> 0) < (gl >>> 0) ? 1 : 0));
H7l = H7.low = (H7l + hl);
H7.high = (H7h + hh + ((H7l >>> 0) < (hl >>> 0) ? 1 : 0));
},
_doFinalize: function () {
// Shortcuts
var data = this._data;
var dataWords = data.words;
var nBitsTotal = this._nDataBytes * 8;
var nBitsLeft = data.sigBytes * 8;
// Add padding
dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32);
dataWords[(((nBitsLeft + 128) >>> 10) << 5) + 30] = Math.floor(nBitsTotal / 0x100000000);
dataWords[(((nBitsLeft + 128) >>> 10) << 5) + 31] = nBitsTotal;
data.sigBytes = dataWords.length * 4;
// Hash final blocks
this._process();
// Convert hash to 32-bit word array before returning
var hash = this._hash.toX32();
// Return final computed hash
return hash;
},
clone: function () {
var clone = Hasher.clone.call(this);
clone._hash = this._hash.clone();
return clone;
},
blockSize: 1024/32
});
/**
* Shortcut function to the hasher's object interface.
*
* @param {WordArray|string} message The message to hash.
*
* @return {WordArray} The hash.
*
* @static
*
* @example
*
* var hash = CryptoJS.SHA512('message');
* var hash = CryptoJS.SHA512(wordArray);
*/
C.SHA512 = Hasher._createHelper(SHA512);
/**
* Shortcut function to the HMAC's object interface.
*
* @param {WordArray|string} message The message to hash.
* @param {WordArray|string} key The secret key.
*
* @return {WordArray} The HMAC.
*
* @static
*
* @example
*
* var hmac = CryptoJS.HmacSHA512(message, key);
*/
C.HmacSHA512 = Hasher._createHmacHelper(SHA512);
}());
(function () {
// Shortcuts
var C = CryptoJS;
var C_x64 = C.x64;
var X64Word = C_x64.Word;
var X64WordArray = C_x64.WordArray;
var C_algo = C.algo;
var SHA512 = C_algo.SHA512;
/**
* SHA-384 hash algorithm.
*/
var SHA384 = C_algo.SHA384 = SHA512.extend({
_doReset: function () {
this._hash = new X64WordArray.init([
new X64Word.init(0xcbbb9d5d, 0xc1059ed8), new X64Word.init(0x629a292a, 0x367cd507),
new X64Word.init(0x9159015a, 0x3070dd17), new X64Word.init(0x152fecd8, 0xf70e5939),
new X64Word.init(0x67332667, 0xffc00b31), new X64Word.init(0x8eb44a87, 0x68581511),
new X64Word.init(0xdb0c2e0d, 0x64f98fa7), new X64Word.init(0x47b5481d, 0xbefa4fa4)
]);
},
_doFinalize: function () {
var hash = SHA512._doFinalize.call(this);
hash.sigBytes -= 16;
return hash;
}
});
/**
* Shortcut function to the hasher's object interface.
*
* @param {WordArray|string} message The message to hash.
*
* @return {WordArray} The hash.
*
* @static
*
* @example
*
* var hash = CryptoJS.SHA384('message');
* var hash = CryptoJS.SHA384(wordArray);
*/
C.SHA384 = SHA512._createHelper(SHA384);
/**
* Shortcut function to the HMAC's object interface.
*
* @param {WordArray|string} message The message to hash.
* @param {WordArray|string} key The secret key.
*
* @return {WordArray} The HMAC.
*
* @static
*
* @example
*
* var hmac = CryptoJS.HmacSHA384(message, key);
*/
C.HmacSHA384 = SHA512._createHmacHelper(SHA384);
}());
/**
* Cipher core components.
*/
CryptoJS.lib.Cipher || (function (undefined) {
// Shortcuts
var C = CryptoJS;
var C_lib = C.lib;
var Base = C_lib.Base;
var WordArray = C_lib.WordArray;
var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm;
var C_enc = C.enc;
var Utf8 = C_enc.Utf8;
var Base64 = C_enc.Base64;
var C_algo = C.algo;
var EvpKDF = C_algo.EvpKDF;
/**
* Abstract base cipher template.
*
* @property {number} keySize This cipher's key size. Default: 4 (128 bits)
* @property {number} ivSize This cipher's IV size. Default: 4 (128 bits)
* @property {number} _ENC_XFORM_MODE A constant representing encryption mode.
* @property {number} _DEC_XFORM_MODE A constant representing decryption mode.
*/
var Cipher = C_lib.Cipher = BufferedBlockAlgorithm.extend({
/**
* Configuration options.
*
* @property {WordArray} iv The IV to use for this operation.
*/
cfg: Base.extend(),
/**
* Creates this cipher in encryption mode.
*
* @param {WordArray} key The key.
* @param {Object} cfg (Optional) The configuration options to use for this operation.
*
* @return {Cipher} A cipher instance.
*
* @static
*
* @example
*
* var cipher = CryptoJS.algo.AES.createEncryptor(keyWordArray, { iv: ivWordArray });
*/
createEncryptor: function (key, cfg) {
return this.create(this._ENC_XFORM_MODE, key, cfg);
},
/**
* Creates this cipher in decryption mode.
*
* @param {WordArray} key The key.
* @param {Object} cfg (Optional) The configuration options to use for this operation.
*
* @return {Cipher} A cipher instance.
*
* @static
*
* @example
*
* var cipher = CryptoJS.algo.AES.createDecryptor(keyWordArray, { iv: ivWordArray });
*/
createDecryptor: function (key, cfg) {
return this.create(this._DEC_XFORM_MODE, key, cfg);
},
/**
* Initializes a newly created cipher.
*
* @param {number} xformMode Either the encryption or decryption transormation mode constant.
* @param {WordArray} key The key.
* @param {Object} cfg (Optional) The configuration options to use for this operation.
*
* @example
*
* var cipher = CryptoJS.algo.AES.create(CryptoJS.algo.AES._ENC_XFORM_MODE, keyWordArray, { iv: ivWordArray });
*/
init: function (xformMode, key, cfg) {
// Apply config defaults
this.cfg = this.cfg.extend(cfg);
// Store transform mode and key
this._xformMode = xformMode;
this._key = key;
// Set initial values
this.reset();
},
/**
* Resets this cipher to its initial state.
*
* @example
*
* cipher.reset();
*/
reset: function () {
// Reset data buffer
BufferedBlockAlgorithm.reset.call(this);
// Perform concrete-cipher logic
this._doReset();
},
/**
* Adds data to be encrypted or decrypted.
*
* @param {WordArray|string} dataUpdate The data to encrypt or decrypt.
*
* @return {WordArray} The data after processing.
*
* @example
*
* var encrypted = cipher.process('data');
* var encrypted = cipher.process(wordArray);
*/
process: function (dataUpdate) {
// Append
this._append(dataUpdate);
// Process available blocks
return this._process();
},
/**
* Finalizes the encryption or decryption process.
* Note that the finalize operation is effectively a destructive, read-once operation.
*
* @param {WordArray|string} dataUpdate The final data to encrypt or decrypt.
*
* @return {WordArray} The data after final processing.
*
* @example
*
* var encrypted = cipher.finalize();
* var encrypted = cipher.finalize('data');
* var encrypted = cipher.finalize(wordArray);
*/
finalize: function (dataUpdate) {
// Final data update
if (dataUpdate) {
this._append(dataUpdate);
}
// Perform concrete-cipher logic
var finalProcessedData = this._doFinalize();
return finalProcessedData;
},
keySize: 128/32,
ivSize: 128/32,
_ENC_XFORM_MODE: 1,
_DEC_XFORM_MODE: 2,
/**
* Creates shortcut functions to a cipher's object interface.
*
* @param {Cipher} cipher The cipher to create a helper for.
*
* @return {Object} An object with encrypt and decrypt shortcut functions.
*
* @static
*
* @example
*
* var AES = CryptoJS.lib.Cipher._createHelper(CryptoJS.algo.AES);
*/
_createHelper: (function () {
function selectCipherStrategy(key) {
if (typeof key == 'string') {
return PasswordBasedCipher;
} else {
return SerializableCipher;
}
}
return function (cipher) {
return {
encrypt: function (message, key, cfg) {
return selectCipherStrategy(key).encrypt(cipher, message, key, cfg);
},
decrypt: function (ciphertext, key, cfg) {
return selectCipherStrategy(key).decrypt(cipher, ciphertext, key, cfg);
}
};
};
}())
});
/**
* Abstract base stream cipher template.
*
* @property {number} blockSize The number of 32-bit words this cipher operates on. Default: 1 (32 bits)
*/
var StreamCipher = C_lib.StreamCipher = Cipher.extend({
_doFinalize: function () {
// Process partial blocks
var finalProcessedBlocks = this._process(!!'flush');
return finalProcessedBlocks;
},
blockSize: 1
});
/**
* Mode namespace.
*/
var C_mode = C.mode = {};
/**
* Abstract base block cipher mode template.
*/
var BlockCipherMode = C_lib.BlockCipherMode = Base.extend({
/**
* Creates this mode for encryption.
*
* @param {Cipher} cipher A block cipher instance.
* @param {Array} iv The IV words.
*
* @static
*
* @example
*
* var mode = CryptoJS.mode.CBC.createEncryptor(cipher, iv.words);
*/
createEncryptor: function (cipher, iv) {
return this.Encryptor.create(cipher, iv);
},
/**
* Creates this mode for decryption.
*
* @param {Cipher} cipher A block cipher instance.
* @param {Array} iv The IV words.
*
* @static
*
* @example
*
* var mode = CryptoJS.mode.CBC.createDecryptor(cipher, iv.words);
*/
createDecryptor: function (cipher, iv) {
return this.Decryptor.create(cipher, iv);
},
/**
* Initializes a newly created mode.
*
* @param {Cipher} cipher A block cipher instance.
* @param {Array} iv The IV words.
*
* @example
*
* var mode = CryptoJS.mode.CBC.Encryptor.create(cipher, iv.words);
*/
init: function (cipher, iv) {
this._cipher = cipher;
this._iv = iv;
}
});
/**
* Cipher Block Chaining mode.
*/
var CBC = C_mode.CBC = (function () {
/**
* Abstract base CBC mode.
*/
var CBC = BlockCipherMode.extend();
/**
* CBC encryptor.
*/
CBC.Encryptor = CBC.extend({
/**
* Processes the data block at offset.
*
* @param {Array} words The data words to operate on.
* @param {number} offset The offset where the block starts.
*
* @example
*
* mode.processBlock(data.words, offset);
*/
processBlock: function (words, offset) {
// Shortcuts
var cipher = this._cipher;
var blockSize = cipher.blockSize;
// XOR and encrypt
xorBlock.call(this, words, offset, blockSize);
cipher.encryptBlock(words, offset);
// Remember this block to use with next block
this._prevBlock = words.slice(offset, offset + blockSize);
}
});
/**
* CBC decryptor.
*/
CBC.Decryptor = CBC.extend({
/**
* Processes the data block at offset.
*
* @param {Array} words The data words to operate on.
* @param {number} offset The offset where the block starts.
*
* @example
*
* mode.processBlock(data.words, offset);
*/
processBlock: function (words, offset) {
// Shortcuts
var cipher = this._cipher;
var blockSize = cipher.blockSize;
// Remember this block to use with next block
var thisBlock = words.slice(offset, offset + blockSize);
// Decrypt and XOR
cipher.decryptBlock(words, offset);
xorBlock.call(this, words, offset, blockSize);
// This block becomes the previous block
this._prevBlock = thisBlock;
}
});
function xorBlock(words, offset, blockSize) {
// Shortcut
var iv = this._iv;
// Choose mixing block
if (iv) {
var block = iv;
// Remove IV for subsequent blocks
this._iv = undefined;
} else {
var block = this._prevBlock;
}
// XOR blocks
for (var i = 0; i < blockSize; i++) {
words[offset + i] ^= block[i];
}
}
return CBC;
}());
/**
* Padding namespace.
*/
var C_pad = C.pad = {};
/**
* PKCS #5/7 padding strategy.
*/
var Pkcs7 = C_pad.Pkcs7 = {
/**
* Pads data using the algorithm defined in PKCS #5/7.
*
* @param {WordArray} data The data to pad.
* @param {number} blockSize The multiple that the data should be padded to.
*
* @static
*
* @example
*
* CryptoJS.pad.Pkcs7.pad(wordArray, 4);
*/
pad: function (data, blockSize) {
// Shortcut
var blockSizeBytes = blockSize * 4;
// Count padding bytes
var nPaddingBytes = blockSizeBytes - data.sigBytes % blockSizeBytes;
// Create padding word
var paddingWord = (nPaddingBytes << 24) | (nPaddingBytes << 16) | (nPaddingBytes << 8) | nPaddingBytes;
// Create padding
var paddingWords = [];
for (var i = 0; i < nPaddingBytes; i += 4) {
paddingWords.push(paddingWord);
}
var padding = WordArray.create(paddingWords, nPaddingBytes);
// Add padding
data.concat(padding);
},
/**
* Unpads data that had been padded using the algorithm defined in PKCS #5/7.
*
* @param {WordArray} data The data to unpad.
*
* @static
*
* @example
*
* CryptoJS.pad.Pkcs7.unpad(wordArray);
*/
unpad: function (data) {
// Get number of padding bytes from last byte
var nPaddingBytes = data.words[(data.sigBytes - 1) >>> 2] & 0xff;
// Remove padding
data.sigBytes -= nPaddingBytes;
}
};
/**
* Abstract base block cipher template.
*
* @property {number} blockSize The number of 32-bit words this cipher operates on. Default: 4 (128 bits)
*/
var BlockCipher = C_lib.BlockCipher = Cipher.extend({
/**
* Configuration options.
*
* @property {Mode} mode The block mode to use. Default: CBC
* @property {Padding} padding The padding strategy to use. Default: Pkcs7
*/
cfg: Cipher.cfg.extend({
mode: CBC,
padding: Pkcs7
}),
reset: function () {
// Reset cipher
Cipher.reset.call(this);
// Shortcuts
var cfg = this.cfg;
var iv = cfg.iv;
var mode = cfg.mode;
// Reset block mode
if (this._xformMode == this._ENC_XFORM_MODE) {
var modeCreator = mode.createEncryptor;
} else /* if (this._xformMode == this._DEC_XFORM_MODE) */ {
var modeCreator = mode.createDecryptor;
// Keep at least one block in the buffer for unpadding
this._minBufferSize = 1;
}
if (this._mode && this._mode.__creator == modeCreator) {
this._mode.init(this, iv && iv.words);
} else {
this._mode = modeCreator.call(mode, this, iv && iv.words);
this._mode.__creator = modeCreator;
}
},
_doProcessBlock: function (words, offset) {
this._mode.processBlock(words, offset);
},
_doFinalize: function () {
// Shortcut
var padding = this.cfg.padding;
// Finalize
if (this._xformMode == this._ENC_XFORM_MODE) {
// Pad data
padding.pad(this._data, this.blockSize);
// Process final blocks
var finalProcessedBlocks = this._process(!!'flush');
} else /* if (this._xformMode == this._DEC_XFORM_MODE) */ {
// Process final blocks
var finalProcessedBlocks = this._process(!!'flush');
// Unpad data
padding.unpad(finalProcessedBlocks);
}
return finalProcessedBlocks;
},
blockSize: 128/32
});
/**
* A collection of cipher parameters.
*
* @property {WordArray} ciphertext The raw ciphertext.
* @property {WordArray} key The key to this ciphertext.
* @property {WordArray} iv The IV used in the ciphering operation.
* @property {WordArray} salt The salt used with a key derivation function.
* @property {Cipher} algorithm The cipher algorithm.
* @property {Mode} mode The block mode used in the ciphering operation.
* @property {Padding} padding The padding scheme used in the ciphering operation.
* @property {number} blockSize The block size of the cipher.
* @property {Format} formatter The default formatting strategy to convert this cipher params object to a string.
*/
var CipherParams = C_lib.CipherParams = Base.extend({
/**
* Initializes a newly created cipher params object.
*
* @param {Object} cipherParams An object with any of the possible cipher parameters.
*
* @example
*
* var cipherParams = CryptoJS.lib.CipherParams.create({
* ciphertext: ciphertextWordArray,
* key: keyWordArray,
* iv: ivWordArray,
* salt: saltWordArray,
* algorithm: CryptoJS.algo.AES,
* mode: CryptoJS.mode.CBC,
* padding: CryptoJS.pad.PKCS7,
* blockSize: 4,
* formatter: CryptoJS.format.OpenSSL
* });
*/
init: function (cipherParams) {
this.mixIn(cipherParams);
},
/**
* Converts this cipher params object to a string.
*
* @param {Format} formatter (Optional) The formatting strategy to use.
*
* @return {string} The stringified cipher params.
*
* @throws Error If neither the formatter nor the default formatter is set.
*
* @example
*
* var string = cipherParams + '';
* var string = cipherParams.toString();
* var string = cipherParams.toString(CryptoJS.format.OpenSSL);
*/
toString: function (formatter) {
return (formatter || this.formatter).stringify(this);
}
});
/**
* Format namespace.
*/
var C_format = C.format = {};
/**
* OpenSSL formatting strategy.
*/
var OpenSSLFormatter = C_format.OpenSSL = {
/**
* Converts a cipher params object to an OpenSSL-compatible string.
*
* @param {CipherParams} cipherParams The cipher params object.
*
* @return {string} The OpenSSL-compatible string.
*
* @static
*
* @example
*
* var openSSLString = CryptoJS.format.OpenSSL.stringify(cipherParams);
*/
stringify: function (cipherParams) {
// Shortcuts
var ciphertext = cipherParams.ciphertext;
var salt = cipherParams.salt;
// Format
if (salt) {
var wordArray = WordArray.create([0x53616c74, 0x65645f5f]).concat(salt).concat(ciphertext);
} else {
var wordArray = ciphertext;
}
return wordArray.toString(Base64);
},
/**
* Converts an OpenSSL-compatible string to a cipher params object.
*
* @param {string} openSSLStr The OpenSSL-compatible string.
*
* @return {CipherParams} The cipher params object.
*
* @static
*
* @example
*
* var cipherParams = CryptoJS.format.OpenSSL.parse(openSSLString);
*/
parse: function (openSSLStr) {
// Parse base64
var ciphertext = Base64.parse(openSSLStr);
// Shortcut
var ciphertextWords = ciphertext.words;
// Test for salt
if (ciphertextWords[0] == 0x53616c74 && ciphertextWords[1] == 0x65645f5f) {
// Extract salt
var salt = WordArray.create(ciphertextWords.slice(2, 4));
// Remove salt from ciphertext
ciphertextWords.splice(0, 4);
ciphertext.sigBytes -= 16;
}
return CipherParams.create({ ciphertext: ciphertext, salt: salt });
}
};
/**
* A cipher wrapper that returns ciphertext as a serializable cipher params object.
*/
var SerializableCipher = C_lib.SerializableCipher = Base.extend({
/**
* Configuration options.
*
* @property {Formatter} format The formatting strategy to convert cipher param objects to and from a string. Default: OpenSSL
*/
cfg: Base.extend({
format: OpenSSLFormatter
}),
/**
* Encrypts a message.
*
* @param {Cipher} cipher The cipher algorithm to use.
* @param {WordArray|string} message The message to encrypt.
* @param {WordArray} key The key.
* @param {Object} cfg (Optional) The configuration options to use for this operation.
*
* @return {CipherParams} A cipher params object.
*
* @static
*
* @example
*
* var ciphertextParams = CryptoJS.lib.SerializableCipher.encrypt(CryptoJS.algo.AES, message, key);
* var ciphertextParams = CryptoJS.lib.SerializableCipher.encrypt(CryptoJS.algo.AES, message, key, { iv: iv });
* var ciphertextParams = CryptoJS.lib.SerializableCipher.encrypt(CryptoJS.algo.AES, message, key, { iv: iv, format: CryptoJS.format.OpenSSL });
*/
encrypt: function (cipher, message, key, cfg) {
// Apply config defaults
cfg = this.cfg.extend(cfg);
// Encrypt
var encryptor = cipher.createEncryptor(key, cfg);
var ciphertext = encryptor.finalize(message);
// Shortcut
var cipherCfg = encryptor.cfg;
// Create and return serializable cipher params
return CipherParams.create({
ciphertext: ciphertext,
key: key,
iv: cipherCfg.iv,
algorithm: cipher,
mode: cipherCfg.mode,
padding: cipherCfg.padding,
blockSize: cipher.blockSize,
formatter: cfg.format
});
},
/**
* Decrypts serialized ciphertext.
*
* @param {Cipher} cipher The cipher algorithm to use.
* @param {CipherParams|string} ciphertext The ciphertext to decrypt.
* @param {WordArray} key The key.
* @param {Object} cfg (Optional) The configuration options to use for this operation.
*
* @return {WordArray} The plaintext.
*
* @static
*
* @example
*
* var plaintext = CryptoJS.lib.SerializableCipher.decrypt(CryptoJS.algo.AES, formattedCiphertext, key, { iv: iv, format: CryptoJS.format.OpenSSL });
* var plaintext = CryptoJS.lib.SerializableCipher.decrypt(CryptoJS.algo.AES, ciphertextParams, key, { iv: iv, format: CryptoJS.format.OpenSSL });
*/
decrypt: function (cipher, ciphertext, key, cfg) {
// Apply config defaults
cfg = this.cfg.extend(cfg);
// Convert string to CipherParams
ciphertext = this._parse(ciphertext, cfg.format);
// Decrypt
var plaintext = cipher.createDecryptor(key, cfg).finalize(ciphertext.ciphertext);
return plaintext;
},
/**
* Converts serialized ciphertext to CipherParams,
* else assumed CipherParams already and returns ciphertext unchanged.
*
* @param {CipherParams|string} ciphertext The ciphertext.
* @param {Formatter} format The formatting strategy to use to parse serialized ciphertext.
*
* @return {CipherParams} The unserialized ciphertext.
*
* @static
*
* @example
*
* var ciphertextParams = CryptoJS.lib.SerializableCipher._parse(ciphertextStringOrParams, format);
*/
_parse: function (ciphertext, format) {
if (typeof ciphertext == 'string') {
return format.parse(ciphertext, this);
} else {
return ciphertext;
}
}
});
/**
* Key derivation function namespace.
*/
var C_kdf = C.kdf = {};
/**
* OpenSSL key derivation function.
*/
var OpenSSLKdf = C_kdf.OpenSSL = {
/**
* Derives a key and IV from a password.
*
* @param {string} password The password to derive from.
* @param {number} keySize The size in words of the key to generate.
* @param {number} ivSize The size in words of the IV to generate.
* @param {WordArray|string} salt (Optional) A 64-bit salt to use. If omitted, a salt will be generated randomly.
*
* @return {CipherParams} A cipher params object with the key, IV, and salt.
*
* @static
*
* @example
*
* var derivedParams = CryptoJS.kdf.OpenSSL.execute('Password', 256/32, 128/32);
* var derivedParams = CryptoJS.kdf.OpenSSL.execute('Password', 256/32, 128/32, 'saltsalt');
*/
execute: function (password, keySize, ivSize, salt) {
// Generate random salt
if (!salt) {
salt = WordArray.random(64/8);
}
// Derive key and IV
var key = EvpKDF.create({ keySize: keySize + ivSize }).compute(password, salt);
// Separate key and IV
var iv = WordArray.create(key.words.slice(keySize), ivSize * 4);
key.sigBytes = keySize * 4;
// Return params
return CipherParams.create({ key: key, iv: iv, salt: salt });
}
};
/**
* A serializable cipher wrapper that derives the key from a password,
* and returns ciphertext as a serializable cipher params object.
*/
var PasswordBasedCipher = C_lib.PasswordBasedCipher = SerializableCipher.extend({
/**
* Configuration options.
*
* @property {KDF} kdf The key derivation function to use to generate a key and IV from a password. Default: OpenSSL
*/
cfg: SerializableCipher.cfg.extend({
kdf: OpenSSLKdf
}),
/**
* Encrypts a message using a password.
*
* @param {Cipher} cipher The cipher algorithm to use.
* @param {WordArray|string} message The message to encrypt.
* @param {string} password The password.
* @param {Object} cfg (Optional) The configuration options to use for this operation.
*
* @return {CipherParams} A cipher params object.
*
* @static
*
* @example
*
* var ciphertextParams = CryptoJS.lib.PasswordBasedCipher.encrypt(CryptoJS.algo.AES, message, 'password');
* var ciphertextParams = CryptoJS.lib.PasswordBasedCipher.encrypt(CryptoJS.algo.AES, message, 'password', { format: CryptoJS.format.OpenSSL });
*/
encrypt: function (cipher, message, password, cfg) {
// Apply config defaults
cfg = this.cfg.extend(cfg);
// Derive key and other params
var derivedParams = cfg.kdf.execute(password, cipher.keySize, cipher.ivSize);
// Add IV to config
cfg.iv = derivedParams.iv;
// Encrypt
var ciphertext = SerializableCipher.encrypt.call(this, cipher, message, derivedParams.key, cfg);
// Mix in derived params
ciphertext.mixIn(derivedParams);
return ciphertext;
},
/**
* Decrypts serialized ciphertext using a password.
*
* @param {Cipher} cipher The cipher algorithm to use.
* @param {CipherParams|string} ciphertext The ciphertext to decrypt.
* @param {string} password The password.
* @param {Object} cfg (Optional) The configuration options to use for this operation.
*
* @return {WordArray} The plaintext.
*
* @static
*
* @example
*
* var plaintext = CryptoJS.lib.PasswordBasedCipher.decrypt(CryptoJS.algo.AES, formattedCiphertext, 'password', { format: CryptoJS.format.OpenSSL });
* var plaintext = CryptoJS.lib.PasswordBasedCipher.decrypt(CryptoJS.algo.AES, ciphertextParams, 'password', { format: CryptoJS.format.OpenSSL });
*/
decrypt: function (cipher, ciphertext, password, cfg) {
// Apply config defaults
cfg = this.cfg.extend(cfg);
// Convert string to CipherParams
ciphertext = this._parse(ciphertext, cfg.format);
// Derive key and other params
var derivedParams = cfg.kdf.execute(password, cipher.keySize, cipher.ivSize, ciphertext.salt);
// Add IV to config
cfg.iv = derivedParams.iv;
// Decrypt
var plaintext = SerializableCipher.decrypt.call(this, cipher, ciphertext, derivedParams.key, cfg);
return plaintext;
}
});
}());
/**
* Cipher Feedback block mode.
*/
CryptoJS.mode.CFB = (function () {
var CFB = CryptoJS.lib.BlockCipherMode.extend();
CFB.Encryptor = CFB.extend({
processBlock: function (words, offset) {
// Shortcuts
var cipher = this._cipher;
var blockSize = cipher.blockSize;
generateKeystreamAndEncrypt.call(this, words, offset, blockSize, cipher);
// Remember this block to use with next block
this._prevBlock = words.slice(offset, offset + blockSize);
}
});
CFB.Decryptor = CFB.extend({
processBlock: function (words, offset) {
// Shortcuts
var cipher = this._cipher;
var blockSize = cipher.blockSize;
// Remember this block to use with next block
var thisBlock = words.slice(offset, offset + blockSize);
generateKeystreamAndEncrypt.call(this, words, offset, blockSize, cipher);
// This block becomes the previous block
this._prevBlock = thisBlock;
}
});
function generateKeystreamAndEncrypt(words, offset, blockSize, cipher) {
// Shortcut
var iv = this._iv;
// Generate keystream
if (iv) {
var keystream = iv.slice(0);
// Remove IV for subsequent blocks
this._iv = undefined;
} else {
var keystream = this._prevBlock;
}
cipher.encryptBlock(keystream, 0);
// Encrypt
for (var i = 0; i < blockSize; i++) {
words[offset + i] ^= keystream[i];
}
}
return CFB;
}());
/**
* Electronic Codebook block mode.
*/
CryptoJS.mode.ECB = (function () {
var ECB = CryptoJS.lib.BlockCipherMode.extend();
ECB.Encryptor = ECB.extend({
processBlock: function (words, offset) {
this._cipher.encryptBlock(words, offset);
}
});
ECB.Decryptor = ECB.extend({
processBlock: function (words, offset) {
this._cipher.decryptBlock(words, offset);
}
});
return ECB;
}());
/**
* ANSI X.923 padding strategy.
*/
CryptoJS.pad.AnsiX923 = {
pad: function (data, blockSize) {
// Shortcuts
var dataSigBytes = data.sigBytes;
var blockSizeBytes = blockSize * 4;
// Count padding bytes
var nPaddingBytes = blockSizeBytes - dataSigBytes % blockSizeBytes;
// Compute last byte position
var lastBytePos = dataSigBytes + nPaddingBytes - 1;
// Pad
data.clamp();
data.words[lastBytePos >>> 2] |= nPaddingBytes << (24 - (lastBytePos % 4) * 8);
data.sigBytes += nPaddingBytes;
},
unpad: function (data) {
// Get number of padding bytes from last byte
var nPaddingBytes = data.words[(data.sigBytes - 1) >>> 2] & 0xff;
// Remove padding
data.sigBytes -= nPaddingBytes;
}
};
/**
* ISO 10126 padding strategy.
*/
CryptoJS.pad.Iso10126 = {
pad: function (data, blockSize) {
// Shortcut
var blockSizeBytes = blockSize * 4;
// Count padding bytes
var nPaddingBytes = blockSizeBytes - data.sigBytes % blockSizeBytes;
// Pad
data.concat(CryptoJS.lib.WordArray.random(nPaddingBytes - 1)).
concat(CryptoJS.lib.WordArray.create([nPaddingBytes << 24], 1));
},
unpad: function (data) {
// Get number of padding bytes from last byte
var nPaddingBytes = data.words[(data.sigBytes - 1) >>> 2] & 0xff;
// Remove padding
data.sigBytes -= nPaddingBytes;
}
};
/**
* ISO/IEC 9797-1 Padding Method 2.
*/
CryptoJS.pad.Iso97971 = {
pad: function (data, blockSize) {
// Add 0x80 byte
data.concat(CryptoJS.lib.WordArray.create([0x80000000], 1));
// Zero pad the rest
CryptoJS.pad.ZeroPadding.pad(data, blockSize);
},
unpad: function (data) {
// Remove zero padding
CryptoJS.pad.ZeroPadding.unpad(data);
// Remove one more byte -- the 0x80 byte
data.sigBytes--;
}
};
/**
* Output Feedback block mode.
*/
CryptoJS.mode.OFB = (function () {
var OFB = CryptoJS.lib.BlockCipherMode.extend();
var Encryptor = OFB.Encryptor = OFB.extend({
processBlock: function (words, offset) {
// Shortcuts
var cipher = this._cipher
var blockSize = cipher.blockSize;
var iv = this._iv;
var keystream = this._keystream;
// Generate keystream
if (iv) {
keystream = this._keystream = iv.slice(0);
// Remove IV for subsequent blocks
this._iv = undefined;
}
cipher.encryptBlock(keystream, 0);
// Encrypt
for (var i = 0; i < blockSize; i++) {
words[offset + i] ^= keystream[i];
}
}
});
OFB.Decryptor = Encryptor;
return OFB;
}());
/**
* A noop padding strategy.
*/
CryptoJS.pad.NoPadding = {
pad: function () {
},
unpad: function () {
}
};
(function (undefined) {
// Shortcuts
var C = CryptoJS;
var C_lib = C.lib;
var CipherParams = C_lib.CipherParams;
var C_enc = C.enc;
var Hex = C_enc.Hex;
var C_format = C.format;
var HexFormatter = C_format.Hex = {
/**
* Converts the ciphertext of a cipher params object to a hexadecimally encoded string.
*
* @param {CipherParams} cipherParams The cipher params object.
*
* @return {string} The hexadecimally encoded string.
*
* @static
*
* @example
*
* var hexString = CryptoJS.format.Hex.stringify(cipherParams);
*/
stringify: function (cipherParams) {
return cipherParams.ciphertext.toString(Hex);
},
/**
* Converts a hexadecimally encoded ciphertext string to a cipher params object.
*
* @param {string} input The hexadecimally encoded string.
*
* @return {CipherParams} The cipher params object.
*
* @static
*
* @example
*
* var cipherParams = CryptoJS.format.Hex.parse(hexString);
*/
parse: function (input) {
var ciphertext = Hex.parse(input);
return CipherParams.create({ ciphertext: ciphertext });
}
};
}());
(function () {
// Shortcuts
var C = CryptoJS;
var C_lib = C.lib;
var BlockCipher = C_lib.BlockCipher;
var C_algo = C.algo;
// Lookup tables
var SBOX = [];
var INV_SBOX = [];
var SUB_MIX_0 = [];
var SUB_MIX_1 = [];
var SUB_MIX_2 = [];
var SUB_MIX_3 = [];
var INV_SUB_MIX_0 = [];
var INV_SUB_MIX_1 = [];
var INV_SUB_MIX_2 = [];
var INV_SUB_MIX_3 = [];
// Compute lookup tables
(function () {
// Compute double table
var d = [];
for (var i = 0; i < 256; i++) {
if (i < 128) {
d[i] = i << 1;
} else {
d[i] = (i << 1) ^ 0x11b;
}
}
// Walk GF(2^8)
var x = 0;
var xi = 0;
for (var i = 0; i < 256; i++) {
// Compute sbox
var sx = xi ^ (xi << 1) ^ (xi << 2) ^ (xi << 3) ^ (xi << 4);
sx = (sx >>> 8) ^ (sx & 0xff) ^ 0x63;
SBOX[x] = sx;
INV_SBOX[sx] = x;
// Compute multiplication
var x2 = d[x];
var x4 = d[x2];
var x8 = d[x4];
// Compute sub bytes, mix columns tables
var t = (d[sx] * 0x101) ^ (sx * 0x1010100);
SUB_MIX_0[x] = (t << 24) | (t >>> 8);
SUB_MIX_1[x] = (t << 16) | (t >>> 16);
SUB_MIX_2[x] = (t << 8) | (t >>> 24);
SUB_MIX_3[x] = t;
// Compute inv sub bytes, inv mix columns tables
var t = (x8 * 0x1010101) ^ (x4 * 0x10001) ^ (x2 * 0x101) ^ (x * 0x1010100);
INV_SUB_MIX_0[sx] = (t << 24) | (t >>> 8);
INV_SUB_MIX_1[sx] = (t << 16) | (t >>> 16);
INV_SUB_MIX_2[sx] = (t << 8) | (t >>> 24);
INV_SUB_MIX_3[sx] = t;
// Compute next counter
if (!x) {
x = xi = 1;
} else {
x = x2 ^ d[d[d[x8 ^ x2]]];
xi ^= d[d[xi]];
}
}
}());
// Precomputed Rcon lookup
var RCON = [0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36];
/**
* AES block cipher algorithm.
*/
var AES = C_algo.AES = BlockCipher.extend({
_doReset: function () {
// Skip reset of nRounds has been set before and key did not change
if (this._nRounds && this._keyPriorReset === this._key) {
return;
}
// Shortcuts
var key = this._keyPriorReset = this._key;
var keyWords = key.words;
var keySize = key.sigBytes / 4;
// Compute number of rounds
var nRounds = this._nRounds = keySize + 6;
// Compute number of key schedule rows
var ksRows = (nRounds + 1) * 4;
// Compute key schedule
var keySchedule = this._keySchedule = [];
for (var ksRow = 0; ksRow < ksRows; ksRow++) {
if (ksRow < keySize) {
keySchedule[ksRow] = keyWords[ksRow];
} else {
var t = keySchedule[ksRow - 1];
if (!(ksRow % keySize)) {
// Rot word
t = (t << 8) | (t >>> 24);
// Sub word
t = (SBOX[t >>> 24] << 24) | (SBOX[(t >>> 16) & 0xff] << 16) | (SBOX[(t >>> 8) & 0xff] << 8) | SBOX[t & 0xff];
// Mix Rcon
t ^= RCON[(ksRow / keySize) | 0] << 24;
} else if (keySize > 6 && ksRow % keySize == 4) {
// Sub word
t = (SBOX[t >>> 24] << 24) | (SBOX[(t >>> 16) & 0xff] << 16) | (SBOX[(t >>> 8) & 0xff] << 8) | SBOX[t & 0xff];
}
keySchedule[ksRow] = keySchedule[ksRow - keySize] ^ t;
}
}
// Compute inv key schedule
var invKeySchedule = this._invKeySchedule = [];
for (var invKsRow = 0; invKsRow < ksRows; invKsRow++) {
var ksRow = ksRows - invKsRow;
if (invKsRow % 4) {
var t = keySchedule[ksRow];
} else {
var t = keySchedule[ksRow - 4];
}
if (invKsRow < 4 || ksRow <= 4) {
invKeySchedule[invKsRow] = t;
} else {
invKeySchedule[invKsRow] = INV_SUB_MIX_0[SBOX[t >>> 24]] ^ INV_SUB_MIX_1[SBOX[(t >>> 16) & 0xff]] ^
INV_SUB_MIX_2[SBOX[(t >>> 8) & 0xff]] ^ INV_SUB_MIX_3[SBOX[t & 0xff]];
}
}
},
encryptBlock: function (M, offset) {
this._doCryptBlock(M, offset, this._keySchedule, SUB_MIX_0, SUB_MIX_1, SUB_MIX_2, SUB_MIX_3, SBOX);
},
decryptBlock: function (M, offset) {
// Swap 2nd and 4th rows
var t = M[offset + 1];
M[offset + 1] = M[offset + 3];
M[offset + 3] = t;
this._doCryptBlock(M, offset, this._invKeySchedule, INV_SUB_MIX_0, INV_SUB_MIX_1, INV_SUB_MIX_2, INV_SUB_MIX_3, INV_SBOX);
// Inv swap 2nd and 4th rows
var t = M[offset + 1];
M[offset + 1] = M[offset + 3];
M[offset + 3] = t;
},
_doCryptBlock: function (M, offset, keySchedule, SUB_MIX_0, SUB_MIX_1, SUB_MIX_2, SUB_MIX_3, SBOX) {
// Shortcut
var nRounds = this._nRounds;
// Get input, add round key
var s0 = M[offset] ^ keySchedule[0];
var s1 = M[offset + 1] ^ keySchedule[1];
var s2 = M[offset + 2] ^ keySchedule[2];
var s3 = M[offset + 3] ^ keySchedule[3];
// Key schedule row counter
var ksRow = 4;
// Rounds
for (var round = 1; round < nRounds; round++) {
// Shift rows, sub bytes, mix columns, add round key
var t0 = SUB_MIX_0[s0 >>> 24] ^ SUB_MIX_1[(s1 >>> 16) & 0xff] ^ SUB_MIX_2[(s2 >>> 8) & 0xff] ^ SUB_MIX_3[s3 & 0xff] ^ keySchedule[ksRow++];
var t1 = SUB_MIX_0[s1 >>> 24] ^ SUB_MIX_1[(s2 >>> 16) & 0xff] ^ SUB_MIX_2[(s3 >>> 8) & 0xff] ^ SUB_MIX_3[s0 & 0xff] ^ keySchedule[ksRow++];
var t2 = SUB_MIX_0[s2 >>> 24] ^ SUB_MIX_1[(s3 >>> 16) & 0xff] ^ SUB_MIX_2[(s0 >>> 8) & 0xff] ^ SUB_MIX_3[s1 & 0xff] ^ keySchedule[ksRow++];
var t3 = SUB_MIX_0[s3 >>> 24] ^ SUB_MIX_1[(s0 >>> 16) & 0xff] ^ SUB_MIX_2[(s1 >>> 8) & 0xff] ^ SUB_MIX_3[s2 & 0xff] ^ keySchedule[ksRow++];
// Update state
s0 = t0;
s1 = t1;
s2 = t2;
s3 = t3;
}
// Shift rows, sub bytes, add round key
var t0 = ((SBOX[s0 >>> 24] << 24) | (SBOX[(s1 >>> 16) & 0xff] << 16) | (SBOX[(s2 >>> 8) & 0xff] << 8) | SBOX[s3 & 0xff]) ^ keySchedule[ksRow++];
var t1 = ((SBOX[s1 >>> 24] << 24) | (SBOX[(s2 >>> 16) & 0xff] << 16) | (SBOX[(s3 >>> 8) & 0xff] << 8) | SBOX[s0 & 0xff]) ^ keySchedule[ksRow++];
var t2 = ((SBOX[s2 >>> 24] << 24) | (SBOX[(s3 >>> 16) & 0xff] << 16) | (SBOX[(s0 >>> 8) & 0xff] << 8) | SBOX[s1 & 0xff]) ^ keySchedule[ksRow++];
var t3 = ((SBOX[s3 >>> 24] << 24) | (SBOX[(s0 >>> 16) & 0xff] << 16) | (SBOX[(s1 >>> 8) & 0xff] << 8) | SBOX[s2 & 0xff]) ^ keySchedule[ksRow++];
// Set output
M[offset] = t0;
M[offset + 1] = t1;
M[offset + 2] = t2;
M[offset + 3] = t3;
},
keySize: 256/32
});
/**
* Shortcut functions to the cipher's object interface.
*
* @example
*
* var ciphertext = CryptoJS.AES.encrypt(message, key, cfg);
* var plaintext = CryptoJS.AES.decrypt(ciphertext, key, cfg);
*/
C.AES = BlockCipher._createHelper(AES);
}());
(function () {
// Shortcuts
var C = CryptoJS;
var C_lib = C.lib;
var WordArray = C_lib.WordArray;
var BlockCipher = C_lib.BlockCipher;
var C_algo = C.algo;
// Permuted Choice 1 constants
var PC1 = [
57, 49, 41, 33, 25, 17, 9, 1,
58, 50, 42, 34, 26, 18, 10, 2,
59, 51, 43, 35, 27, 19, 11, 3,
60, 52, 44, 36, 63, 55, 47, 39,
31, 23, 15, 7, 62, 54, 46, 38,
30, 22, 14, 6, 61, 53, 45, 37,
29, 21, 13, 5, 28, 20, 12, 4
];
// Permuted Choice 2 constants
var PC2 = [
14, 17, 11, 24, 1, 5,
3, 28, 15, 6, 21, 10,
23, 19, 12, 4, 26, 8,
16, 7, 27, 20, 13, 2,
41, 52, 31, 37, 47, 55,
30, 40, 51, 45, 33, 48,
44, 49, 39, 56, 34, 53,
46, 42, 50, 36, 29, 32
];
// Cumulative bit shift constants
var BIT_SHIFTS = [1, 2, 4, 6, 8, 10, 12, 14, 15, 17, 19, 21, 23, 25, 27, 28];
// SBOXes and round permutation constants
var SBOX_P = [
{
0x0: 0x808200,
0x10000000: 0x8000,
0x20000000: 0x808002,
0x30000000: 0x2,
0x40000000: 0x200,
0x50000000: 0x808202,
0x60000000: 0x800202,
0x70000000: 0x800000,
0x80000000: 0x202,
0x90000000: 0x800200,
0xa0000000: 0x8200,
0xb0000000: 0x808000,
0xc0000000: 0x8002,
0xd0000000: 0x800002,
0xe0000000: 0x0,
0xf0000000: 0x8202,
0x8000000: 0x0,
0x18000000: 0x808202,
0x28000000: 0x8202,
0x38000000: 0x8000,
0x48000000: 0x808200,
0x58000000: 0x200,
0x68000000: 0x808002,
0x78000000: 0x2,
0x88000000: 0x800200,
0x98000000: 0x8200,
0xa8000000: 0x808000,
0xb8000000: 0x800202,
0xc8000000: 0x800002,
0xd8000000: 0x8002,
0xe8000000: 0x202,
0xf8000000: 0x800000,
0x1: 0x8000,
0x10000001: 0x2,
0x20000001: 0x808200,
0x30000001: 0x800000,
0x40000001: 0x808002,
0x50000001: 0x8200,
0x60000001: 0x200,
0x70000001: 0x800202,
0x80000001: 0x808202,
0x90000001: 0x808000,
0xa0000001: 0x800002,
0xb0000001: 0x8202,
0xc0000001: 0x202,
0xd0000001: 0x800200,
0xe0000001: 0x8002,
0xf0000001: 0x0,
0x8000001: 0x808202,
0x18000001: 0x808000,
0x28000001: 0x800000,
0x38000001: 0x200,
0x48000001: 0x8000,
0x58000001: 0x800002,
0x68000001: 0x2,
0x78000001: 0x8202,
0x88000001: 0x8002,
0x98000001: 0x800202,
0xa8000001: 0x202,
0xb8000001: 0x808200,
0xc8000001: 0x800200,
0xd8000001: 0x0,
0xe8000001: 0x8200,
0xf8000001: 0x808002
},
{
0x0: 0x40084010,
0x1000000: 0x4000,
0x2000000: 0x80000,
0x3000000: 0x40080010,
0x4000000: 0x40000010,
0x5000000: 0x40084000,
0x6000000: 0x40004000,
0x7000000: 0x10,
0x8000000: 0x84000,
0x9000000: 0x40004010,
0xa000000: 0x40000000,
0xb000000: 0x84010,
0xc000000: 0x80010,
0xd000000: 0x0,
0xe000000: 0x4010,
0xf000000: 0x40080000,
0x800000: 0x40004000,
0x1800000: 0x84010,
0x2800000: 0x10,
0x3800000: 0x40004010,
0x4800000: 0x40084010,
0x5800000: 0x40000000,
0x6800000: 0x80000,
0x7800000: 0x40080010,
0x8800000: 0x80010,
0x9800000: 0x0,
0xa800000: 0x4000,
0xb800000: 0x40080000,
0xc800000: 0x40000010,
0xd800000: 0x84000,
0xe800000: 0x40084000,
0xf800000: 0x4010,
0x10000000: 0x0,
0x11000000: 0x40080010,
0x12000000: 0x40004010,
0x13000000: 0x40084000,
0x14000000: 0x40080000,
0x15000000: 0x10,
0x16000000: 0x84010,
0x17000000: 0x4000,
0x18000000: 0x4010,
0x19000000: 0x80000,
0x1a000000: 0x80010,
0x1b000000: 0x40000010,
0x1c000000: 0x84000,
0x1d000000: 0x40004000,
0x1e000000: 0x40000000,
0x1f000000: 0x40084010,
0x10800000: 0x84010,
0x11800000: 0x80000,
0x12800000: 0x40080000,
0x13800000: 0x4000,
0x14800000: 0x40004000,
0x15800000: 0x40084010,
0x16800000: 0x10,
0x17800000: 0x40000000,
0x18800000: 0x40084000,
0x19800000: 0x40000010,
0x1a800000: 0x40004010,
0x1b800000: 0x80010,
0x1c800000: 0x0,
0x1d800000: 0x4010,
0x1e800000: 0x40080010,
0x1f800000: 0x84000
},
{
0x0: 0x104,
0x100000: 0x0,
0x200000: 0x4000100,
0x300000: 0x10104,
0x400000: 0x10004,
0x500000: 0x4000004,
0x600000: 0x4010104,
0x700000: 0x4010000,
0x800000: 0x4000000,
0x900000: 0x4010100,
0xa00000: 0x10100,
0xb00000: 0x4010004,
0xc00000: 0x4000104,
0xd00000: 0x10000,
0xe00000: 0x4,
0xf00000: 0x100,
0x80000: 0x4010100,
0x180000: 0x4010004,
0x280000: 0x0,
0x380000: 0x4000100,
0x480000: 0x4000004,
0x580000: 0x10000,
0x680000: 0x10004,
0x780000: 0x104,
0x880000: 0x4,
0x980000: 0x100,
0xa80000: 0x4010000,
0xb80000: 0x10104,
0xc80000: 0x10100,
0xd80000: 0x4000104,
0xe80000: 0x4010104,
0xf80000: 0x4000000,
0x1000000: 0x4010100,
0x1100000: 0x10004,
0x1200000: 0x10000,
0x1300000: 0x4000100,
0x1400000: 0x100,
0x1500000: 0x4010104,
0x1600000: 0x4000004,
0x1700000: 0x0,
0x1800000: 0x4000104,
0x1900000: 0x4000000,
0x1a00000: 0x4,
0x1b00000: 0x10100,
0x1c00000: 0x4010000,
0x1d00000: 0x104,
0x1e00000: 0x10104,
0x1f00000: 0x4010004,
0x1080000: 0x4000000,
0x1180000: 0x104,
0x1280000: 0x4010100,
0x1380000: 0x0,
0x1480000: 0x10004,
0x1580000: 0x4000100,
0x1680000: 0x100,
0x1780000: 0x4010004,
0x1880000: 0x10000,
0x1980000: 0x4010104,
0x1a80000: 0x10104,
0x1b80000: 0x4000004,
0x1c80000: 0x4000104,
0x1d80000: 0x4010000,
0x1e80000: 0x4,
0x1f80000: 0x10100
},
{
0x0: 0x80401000,
0x10000: 0x80001040,
0x20000: 0x401040,
0x30000: 0x80400000,
0x40000: 0x0,
0x50000: 0x401000,
0x60000: 0x80000040,
0x70000: 0x400040,
0x80000: 0x80000000,
0x90000: 0x400000,
0xa0000: 0x40,
0xb0000: 0x80001000,
0xc0000: 0x80400040,
0xd0000: 0x1040,
0xe0000: 0x1000,
0xf0000: 0x80401040,
0x8000: 0x80001040,
0x18000: 0x40,
0x28000: 0x80400040,
0x38000: 0x80001000,
0x48000: 0x401000,
0x58000: 0x80401040,
0x68000: 0x0,
0x78000: 0x80400000,
0x88000: 0x1000,
0x98000: 0x80401000,
0xa8000: 0x400000,
0xb8000: 0x1040,
0xc8000: 0x80000000,
0xd8000: 0x400040,
0xe8000: 0x401040,
0xf8000: 0x80000040,
0x100000: 0x400040,
0x110000: 0x401000,
0x120000: 0x80000040,
0x130000: 0x0,
0x140000: 0x1040,
0x150000: 0x80400040,
0x160000: 0x80401000,
0x170000: 0x80001040,
0x180000: 0x80401040,
0x190000: 0x80000000,
0x1a0000: 0x80400000,
0x1b0000: 0x401040,
0x1c0000: 0x80001000,
0x1d0000: 0x400000,
0x1e0000: 0x40,
0x1f0000: 0x1000,
0x108000: 0x80400000,
0x118000: 0x80401040,
0x128000: 0x0,
0x138000: 0x401000,
0x148000: 0x400040,
0x158000: 0x80000000,
0x168000: 0x80001040,
0x178000: 0x40,
0x188000: 0x80000040,
0x198000: 0x1000,
0x1a8000: 0x80001000,
0x1b8000: 0x80400040,
0x1c8000: 0x1040,
0x1d8000: 0x80401000,
0x1e8000: 0x400000,
0x1f8000: 0x401040
},
{
0x0: 0x80,
0x1000: 0x1040000,
0x2000: 0x40000,
0x3000: 0x20000000,
0x4000: 0x20040080,
0x5000: 0x1000080,
0x6000: 0x21000080,
0x7000: 0x40080,
0x8000: 0x1000000,
0x9000: 0x20040000,
0xa000: 0x20000080,
0xb000: 0x21040080,
0xc000: 0x21040000,
0xd000: 0x0,
0xe000: 0x1040080,
0xf000: 0x21000000,
0x800: 0x1040080,
0x1800: 0x21000080,
0x2800: 0x80,
0x3800: 0x1040000,
0x4800: 0x40000,
0x5800: 0x20040080,
0x6800: 0x21040000,
0x7800: 0x20000000,
0x8800: 0x20040000,
0x9800: 0x0,
0xa800: 0x21040080,
0xb800: 0x1000080,
0xc800: 0x20000080,
0xd800: 0x21000000,
0xe800: 0x1000000,
0xf800: 0x40080,
0x10000: 0x40000,
0x11000: 0x80,
0x12000: 0x20000000,
0x13000: 0x21000080,
0x14000: 0x1000080,
0x15000: 0x21040000,
0x16000: 0x20040080,
0x17000: 0x1000000,
0x18000: 0x21040080,
0x19000: 0x21000000,
0x1a000: 0x1040000,
0x1b000: 0x20040000,
0x1c000: 0x40080,
0x1d000: 0x20000080,
0x1e000: 0x0,
0x1f000: 0x1040080,
0x10800: 0x21000080,
0x11800: 0x1000000,
0x12800: 0x1040000,
0x13800: 0x20040080,
0x14800: 0x20000000,
0x15800: 0x1040080,
0x16800: 0x80,
0x17800: 0x21040000,
0x18800: 0x40080,
0x19800: 0x21040080,
0x1a800: 0x0,
0x1b800: 0x21000000,
0x1c800: 0x1000080,
0x1d800: 0x40000,
0x1e800: 0x20040000,
0x1f800: 0x20000080
},
{
0x0: 0x10000008,
0x100: 0x2000,
0x200: 0x10200000,
0x300: 0x10202008,
0x400: 0x10002000,
0x500: 0x200000,
0x600: 0x200008,
0x700: 0x10000000,
0x800: 0x0,
0x900: 0x10002008,
0xa00: 0x202000,
0xb00: 0x8,
0xc00: 0x10200008,
0xd00: 0x202008,
0xe00: 0x2008,
0xf00: 0x10202000,
0x80: 0x10200000,
0x180: 0x10202008,
0x280: 0x8,
0x380: 0x200000,
0x480: 0x202008,
0x580: 0x10000008,
0x680: 0x10002000,
0x780: 0x2008,
0x880: 0x200008,
0x980: 0x2000,
0xa80: 0x10002008,
0xb80: 0x10200008,
0xc80: 0x0,
0xd80: 0x10202000,
0xe80: 0x202000,
0xf80: 0x10000000,
0x1000: 0x10002000,
0x1100: 0x10200008,
0x1200: 0x10202008,
0x1300: 0x2008,
0x1400: 0x200000,
0x1500: 0x10000000,
0x1600: 0x10000008,
0x1700: 0x202000,
0x1800: 0x202008,
0x1900: 0x0,
0x1a00: 0x8,
0x1b00: 0x10200000,
0x1c00: 0x2000,
0x1d00: 0x10002008,
0x1e00: 0x10202000,
0x1f00: 0x200008,
0x1080: 0x8,
0x1180: 0x202000,
0x1280: 0x200000,
0x1380: 0x10000008,
0x1480: 0x10002000,
0x1580: 0x2008,
0x1680: 0x10202008,
0x1780: 0x10200000,
0x1880: 0x10202000,
0x1980: 0x10200008,
0x1a80: 0x2000,
0x1b80: 0x202008,
0x1c80: 0x200008,
0x1d80: 0x0,
0x1e80: 0x10000000,
0x1f80: 0x10002008
},
{
0x0: 0x100000,
0x10: 0x2000401,
0x20: 0x400,
0x30: 0x100401,
0x40: 0x2100401,
0x50: 0x0,
0x60: 0x1,
0x70: 0x2100001,
0x80: 0x2000400,
0x90: 0x100001,
0xa0: 0x2000001,
0xb0: 0x2100400,
0xc0: 0x2100000,
0xd0: 0x401,
0xe0: 0x100400,
0xf0: 0x2000000,
0x8: 0x2100001,
0x18: 0x0,
0x28: 0x2000401,
0x38: 0x2100400,
0x48: 0x100000,
0x58: 0x2000001,
0x68: 0x2000000,
0x78: 0x401,
0x88: 0x100401,
0x98: 0x2000400,
0xa8: 0x2100000,
0xb8: 0x100001,
0xc8: 0x400,
0xd8: 0x2100401,
0xe8: 0x1,
0xf8: 0x100400,
0x100: 0x2000000,
0x110: 0x100000,
0x120: 0x2000401,
0x130: 0x2100001,
0x140: 0x100001,
0x150: 0x2000400,
0x160: 0x2100400,
0x170: 0x100401,
0x180: 0x401,
0x190: 0x2100401,
0x1a0: 0x100400,
0x1b0: 0x1,
0x1c0: 0x0,
0x1d0: 0x2100000,
0x1e0: 0x2000001,
0x1f0: 0x400,
0x108: 0x100400,
0x118: 0x2000401,
0x128: 0x2100001,
0x138: 0x1,
0x148: 0x2000000,
0x158: 0x100000,
0x168: 0x401,
0x178: 0x2100400,
0x188: 0x2000001,
0x198: 0x2100000,
0x1a8: 0x0,
0x1b8: 0x2100401,
0x1c8: 0x100401,
0x1d8: 0x400,
0x1e8: 0x2000400,
0x1f8: 0x100001
},
{
0x0: 0x8000820,
0x1: 0x20000,
0x2: 0x8000000,
0x3: 0x20,
0x4: 0x20020,
0x5: 0x8020820,
0x6: 0x8020800,
0x7: 0x800,
0x8: 0x8020000,
0x9: 0x8000800,
0xa: 0x20800,
0xb: 0x8020020,
0xc: 0x820,
0xd: 0x0,
0xe: 0x8000020,
0xf: 0x20820,
0x80000000: 0x800,
0x80000001: 0x8020820,
0x80000002: 0x8000820,
0x80000003: 0x8000000,
0x80000004: 0x8020000,
0x80000005: 0x20800,
0x80000006: 0x20820,
0x80000007: 0x20,
0x80000008: 0x8000020,
0x80000009: 0x820,
0x8000000a: 0x20020,
0x8000000b: 0x8020800,
0x8000000c: 0x0,
0x8000000d: 0x8020020,
0x8000000e: 0x8000800,
0x8000000f: 0x20000,
0x10: 0x20820,
0x11: 0x8020800,
0x12: 0x20,
0x13: 0x800,
0x14: 0x8000800,
0x15: 0x8000020,
0x16: 0x8020020,
0x17: 0x20000,
0x18: 0x0,
0x19: 0x20020,
0x1a: 0x8020000,
0x1b: 0x8000820,
0x1c: 0x8020820,
0x1d: 0x20800,
0x1e: 0x820,
0x1f: 0x8000000,
0x80000010: 0x20000,
0x80000011: 0x800,
0x80000012: 0x8020020,
0x80000013: 0x20820,
0x80000014: 0x20,
0x80000015: 0x8020000,
0x80000016: 0x8000000,
0x80000017: 0x8000820,
0x80000018: 0x8020820,
0x80000019: 0x8000020,
0x8000001a: 0x8000800,
0x8000001b: 0x0,
0x8000001c: 0x20800,
0x8000001d: 0x820,
0x8000001e: 0x20020,
0x8000001f: 0x8020800
}
];
// Masks that select the SBOX input
var SBOX_MASK = [
0xf8000001, 0x1f800000, 0x01f80000, 0x001f8000,
0x0001f800, 0x00001f80, 0x000001f8, 0x8000001f
];
/**
* DES block cipher algorithm.
*/
var DES = C_algo.DES = BlockCipher.extend({
_doReset: function () {
// Shortcuts
var key = this._key;
var keyWords = key.words;
// Select 56 bits according to PC1
var keyBits = [];
for (var i = 0; i < 56; i++) {
var keyBitPos = PC1[i] - 1;
keyBits[i] = (keyWords[keyBitPos >>> 5] >>> (31 - keyBitPos % 32)) & 1;
}
// Assemble 16 subkeys
var subKeys = this._subKeys = [];
for (var nSubKey = 0; nSubKey < 16; nSubKey++) {
// Create subkey
var subKey = subKeys[nSubKey] = [];
// Shortcut
var bitShift = BIT_SHIFTS[nSubKey];
// Select 48 bits according to PC2
for (var i = 0; i < 24; i++) {
// Select from the left 28 key bits
subKey[(i / 6) | 0] |= keyBits[((PC2[i] - 1) + bitShift) % 28] << (31 - i % 6);
// Select from the right 28 key bits
subKey[4 + ((i / 6) | 0)] |= keyBits[28 + (((PC2[i + 24] - 1) + bitShift) % 28)] << (31 - i % 6);
}
// Since each subkey is applied to an expanded 32-bit input,
// the subkey can be broken into 8 values scaled to 32-bits,
// which allows the key to be used without expansion
subKey[0] = (subKey[0] << 1) | (subKey[0] >>> 31);
for (var i = 1; i < 7; i++) {
subKey[i] = subKey[i] >>> ((i - 1) * 4 + 3);
}
subKey[7] = (subKey[7] << 5) | (subKey[7] >>> 27);
}
// Compute inverse subkeys
var invSubKeys = this._invSubKeys = [];
for (var i = 0; i < 16; i++) {
invSubKeys[i] = subKeys[15 - i];
}
},
encryptBlock: function (M, offset) {
this._doCryptBlock(M, offset, this._subKeys);
},
decryptBlock: function (M, offset) {
this._doCryptBlock(M, offset, this._invSubKeys);
},
_doCryptBlock: function (M, offset, subKeys) {
// Get input
this._lBlock = M[offset];
this._rBlock = M[offset + 1];
// Initial permutation
exchangeLR.call(this, 4, 0x0f0f0f0f);
exchangeLR.call(this, 16, 0x0000ffff);
exchangeRL.call(this, 2, 0x33333333);
exchangeRL.call(this, 8, 0x00ff00ff);
exchangeLR.call(this, 1, 0x55555555);
// Rounds
for (var round = 0; round < 16; round++) {
// Shortcuts
var subKey = subKeys[round];
var lBlock = this._lBlock;
var rBlock = this._rBlock;
// Feistel function
var f = 0;
for (var i = 0; i < 8; i++) {
f |= SBOX_P[i][((rBlock ^ subKey[i]) & SBOX_MASK[i]) >>> 0];
}
this._lBlock = rBlock;
this._rBlock = lBlock ^ f;
}
// Undo swap from last round
var t = this._lBlock;
this._lBlock = this._rBlock;
this._rBlock = t;
// Final permutation
exchangeLR.call(this, 1, 0x55555555);
exchangeRL.call(this, 8, 0x00ff00ff);
exchangeRL.call(this, 2, 0x33333333);
exchangeLR.call(this, 16, 0x0000ffff);
exchangeLR.call(this, 4, 0x0f0f0f0f);
// Set output
M[offset] = this._lBlock;
M[offset + 1] = this._rBlock;
},
keySize: 64/32,
ivSize: 64/32,
blockSize: 64/32
});
// Swap bits across the left and right words
function exchangeLR(offset, mask) {
var t = ((this._lBlock >>> offset) ^ this._rBlock) & mask;
this._rBlock ^= t;
this._lBlock ^= t << offset;
}
function exchangeRL(offset, mask) {
var t = ((this._rBlock >>> offset) ^ this._lBlock) & mask;
this._lBlock ^= t;
this._rBlock ^= t << offset;
}
/**
* Shortcut functions to the cipher's object interface.
*
* @example
*
* var ciphertext = CryptoJS.DES.encrypt(message, key, cfg);
* var plaintext = CryptoJS.DES.decrypt(ciphertext, key, cfg);
*/
C.DES = BlockCipher._createHelper(DES);
/**
* Triple-DES block cipher algorithm.
*/
var TripleDES = C_algo.TripleDES = BlockCipher.extend({
_doReset: function () {
// Shortcuts
var key = this._key;
var keyWords = key.words;
// Create DES instances
this._des1 = DES.createEncryptor(WordArray.create(keyWords.slice(0, 2)));
this._des2 = DES.createEncryptor(WordArray.create(keyWords.slice(2, 4)));
this._des3 = DES.createEncryptor(WordArray.create(keyWords.slice(4, 6)));
},
encryptBlock: function (M, offset) {
this._des1.encryptBlock(M, offset);
this._des2.decryptBlock(M, offset);
this._des3.encryptBlock(M, offset);
},
decryptBlock: function (M, offset) {
this._des3.decryptBlock(M, offset);
this._des2.encryptBlock(M, offset);
this._des1.decryptBlock(M, offset);
},
keySize: 192/32,
ivSize: 64/32,
blockSize: 64/32
});
/**
* Shortcut functions to the cipher's object interface.
*
* @example
*
* var ciphertext = CryptoJS.TripleDES.encrypt(message, key, cfg);
* var plaintext = CryptoJS.TripleDES.decrypt(ciphertext, key, cfg);
*/
C.TripleDES = BlockCipher._createHelper(TripleDES);
}());
(function () {
// Shortcuts
var C = CryptoJS;
var C_lib = C.lib;
var StreamCipher = C_lib.StreamCipher;
var C_algo = C.algo;
/**
* RC4 stream cipher algorithm.
*/
var RC4 = C_algo.RC4 = StreamCipher.extend({
_doReset: function () {
// Shortcuts
var key = this._key;
var keyWords = key.words;
var keySigBytes = key.sigBytes;
// Init sbox
var S = this._S = [];
for (var i = 0; i < 256; i++) {
S[i] = i;
}
// Key setup
for (var i = 0, j = 0; i < 256; i++) {
var keyByteIndex = i % keySigBytes;
var keyByte = (keyWords[keyByteIndex >>> 2] >>> (24 - (keyByteIndex % 4) * 8)) & 0xff;
j = (j + S[i] + keyByte) % 256;
// Swap
var t = S[i];
S[i] = S[j];
S[j] = t;
}
// Counters
this._i = this._j = 0;
},
_doProcessBlock: function (M, offset) {
M[offset] ^= generateKeystreamWord.call(this);
},
keySize: 256/32,
ivSize: 0
});
function generateKeystreamWord() {
// Shortcuts
var S = this._S;
var i = this._i;
var j = this._j;
// Generate keystream word
var keystreamWord = 0;
for (var n = 0; n < 4; n++) {
i = (i + 1) % 256;
j = (j + S[i]) % 256;
// Swap
var t = S[i];
S[i] = S[j];
S[j] = t;
keystreamWord |= S[(S[i] + S[j]) % 256] << (24 - n * 8);
}
// Update counters
this._i = i;
this._j = j;
return keystreamWord;
}
/**
* Shortcut functions to the cipher's object interface.
*
* @example
*
* var ciphertext = CryptoJS.RC4.encrypt(message, key, cfg);
* var plaintext = CryptoJS.RC4.decrypt(ciphertext, key, cfg);
*/
C.RC4 = StreamCipher._createHelper(RC4);
/**
* Modified RC4 stream cipher algorithm.
*/
var RC4Drop = C_algo.RC4Drop = RC4.extend({
/**
* Configuration options.
*
* @property {number} drop The number of keystream words to drop. Default 192
*/
cfg: RC4.cfg.extend({
drop: 192
}),
_doReset: function () {
RC4._doReset.call(this);
// Drop
for (var i = this.cfg.drop; i > 0; i--) {
generateKeystreamWord.call(this);
}
}
});
/**
* Shortcut functions to the cipher's object interface.
*
* @example
*
* var ciphertext = CryptoJS.RC4Drop.encrypt(message, key, cfg);
* var plaintext = CryptoJS.RC4Drop.decrypt(ciphertext, key, cfg);
*/
C.RC4Drop = StreamCipher._createHelper(RC4Drop);
}());
/** @preserve
* Counter block mode compatible with Dr Brian Gladman fileenc.c
* derived from CryptoJS.mode.CTR
* Jan Hruby jhruby.web@gmail.com
*/
CryptoJS.mode.CTRGladman = (function () {
var CTRGladman = CryptoJS.lib.BlockCipherMode.extend();
function incWord(word)
{
if (((word >> 24) & 0xff) === 0xff) { //overflow
var b1 = (word >> 16)&0xff;
var b2 = (word >> 8)&0xff;
var b3 = word & 0xff;
if (b1 === 0xff) // overflow b1
{
b1 = 0;
if (b2 === 0xff)
{
b2 = 0;
if (b3 === 0xff)
{
b3 = 0;
}
else
{
++b3;
}
}
else
{
++b2;
}
}
else
{
++b1;
}
word = 0;
word += (b1 << 16);
word += (b2 << 8);
word += b3;
}
else
{
word += (0x01 << 24);
}
return word;
}
function incCounter(counter)
{
if ((counter[0] = incWord(counter[0])) === 0)
{
// encr_data in fileenc.c from Dr Brian Gladman's counts only with DWORD j < 8
counter[1] = incWord(counter[1]);
}
return counter;
}
var Encryptor = CTRGladman.Encryptor = CTRGladman.extend({
processBlock: function (words, offset) {
// Shortcuts
var cipher = this._cipher
var blockSize = cipher.blockSize;
var iv = this._iv;
var counter = this._counter;
// Generate keystream
if (iv) {
counter = this._counter = iv.slice(0);
// Remove IV for subsequent blocks
this._iv = undefined;
}
incCounter(counter);
var keystream = counter.slice(0);
cipher.encryptBlock(keystream, 0);
// Encrypt
for (var i = 0; i < blockSize; i++) {
words[offset + i] ^= keystream[i];
}
}
});
CTRGladman.Decryptor = Encryptor;
return CTRGladman;
}());
(function () {
// Shortcuts
var C = CryptoJS;
var C_lib = C.lib;
var StreamCipher = C_lib.StreamCipher;
var C_algo = C.algo;
// Reusable objects
var S = [];
var C_ = [];
var G = [];
/**
* Rabbit stream cipher algorithm
*/
var Rabbit = C_algo.Rabbit = StreamCipher.extend({
_doReset: function () {
// Shortcuts
var K = this._key.words;
var iv = this.cfg.iv;
// Swap endian
for (var i = 0; i < 4; i++) {
K[i] = (((K[i] << 8) | (K[i] >>> 24)) & 0x00ff00ff) |
(((K[i] << 24) | (K[i] >>> 8)) & 0xff00ff00);
}
// Generate initial state values
var X = this._X = [
K[0], (K[3] << 16) | (K[2] >>> 16),
K[1], (K[0] << 16) | (K[3] >>> 16),
K[2], (K[1] << 16) | (K[0] >>> 16),
K[3], (K[2] << 16) | (K[1] >>> 16)
];
// Generate initial counter values
var C = this._C = [
(K[2] << 16) | (K[2] >>> 16), (K[0] & 0xffff0000) | (K[1] & 0x0000ffff),
(K[3] << 16) | (K[3] >>> 16), (K[1] & 0xffff0000) | (K[2] & 0x0000ffff),
(K[0] << 16) | (K[0] >>> 16), (K[2] & 0xffff0000) | (K[3] & 0x0000ffff),
(K[1] << 16) | (K[1] >>> 16), (K[3] & 0xffff0000) | (K[0] & 0x0000ffff)
];
// Carry bit
this._b = 0;
// Iterate the system four times
for (var i = 0; i < 4; i++) {
nextState.call(this);
}
// Modify the counters
for (var i = 0; i < 8; i++) {
C[i] ^= X[(i + 4) & 7];
}
// IV setup
if (iv) {
// Shortcuts
var IV = iv.words;
var IV_0 = IV[0];
var IV_1 = IV[1];
// Generate four subvectors
var i0 = (((IV_0 << 8) | (IV_0 >>> 24)) & 0x00ff00ff) | (((IV_0 << 24) | (IV_0 >>> 8)) & 0xff00ff00);
var i2 = (((IV_1 << 8) | (IV_1 >>> 24)) & 0x00ff00ff) | (((IV_1 << 24) | (IV_1 >>> 8)) & 0xff00ff00);
var i1 = (i0 >>> 16) | (i2 & 0xffff0000);
var i3 = (i2 << 16) | (i0 & 0x0000ffff);
// Modify counter values
C[0] ^= i0;
C[1] ^= i1;
C[2] ^= i2;
C[3] ^= i3;
C[4] ^= i0;
C[5] ^= i1;
C[6] ^= i2;
C[7] ^= i3;
// Iterate the system four times
for (var i = 0; i < 4; i++) {
nextState.call(this);
}
}
},
_doProcessBlock: function (M, offset) {
// Shortcut
var X = this._X;
// Iterate the system
nextState.call(this);
// Generate four keystream words
S[0] = X[0] ^ (X[5] >>> 16) ^ (X[3] << 16);
S[1] = X[2] ^ (X[7] >>> 16) ^ (X[5] << 16);
S[2] = X[4] ^ (X[1] >>> 16) ^ (X[7] << 16);
S[3] = X[6] ^ (X[3] >>> 16) ^ (X[1] << 16);
for (var i = 0; i < 4; i++) {
// Swap endian
S[i] = (((S[i] << 8) | (S[i] >>> 24)) & 0x00ff00ff) |
(((S[i] << 24) | (S[i] >>> 8)) & 0xff00ff00);
// Encrypt
M[offset + i] ^= S[i];
}
},
blockSize: 128/32,
ivSize: 64/32
});
function nextState() {
// Shortcuts
var X = this._X;
var C = this._C;
// Save old counter values
for (var i = 0; i < 8; i++) {
C_[i] = C[i];
}
// Calculate new counter values
C[0] = (C[0] + 0x4d34d34d + this._b) | 0;
C[1] = (C[1] + 0xd34d34d3 + ((C[0] >>> 0) < (C_[0] >>> 0) ? 1 : 0)) | 0;
C[2] = (C[2] + 0x34d34d34 + ((C[1] >>> 0) < (C_[1] >>> 0) ? 1 : 0)) | 0;
C[3] = (C[3] + 0x4d34d34d + ((C[2] >>> 0) < (C_[2] >>> 0) ? 1 : 0)) | 0;
C[4] = (C[4] + 0xd34d34d3 + ((C[3] >>> 0) < (C_[3] >>> 0) ? 1 : 0)) | 0;
C[5] = (C[5] + 0x34d34d34 + ((C[4] >>> 0) < (C_[4] >>> 0) ? 1 : 0)) | 0;
C[6] = (C[6] + 0x4d34d34d + ((C[5] >>> 0) < (C_[5] >>> 0) ? 1 : 0)) | 0;
C[7] = (C[7] + 0xd34d34d3 + ((C[6] >>> 0) < (C_[6] >>> 0) ? 1 : 0)) | 0;
this._b = (C[7] >>> 0) < (C_[7] >>> 0) ? 1 : 0;
// Calculate the g-values
for (var i = 0; i < 8; i++) {
var gx = X[i] + C[i];
// Construct high and low argument for squaring
var ga = gx & 0xffff;
var gb = gx >>> 16;
// Calculate high and low result of squaring
var gh = ((((ga * ga) >>> 17) + ga * gb) >>> 15) + gb * gb;
var gl = (((gx & 0xffff0000) * gx) | 0) + (((gx & 0x0000ffff) * gx) | 0);
// High XOR low
G[i] = gh ^ gl;
}
// Calculate new state values
X[0] = (G[0] + ((G[7] << 16) | (G[7] >>> 16)) + ((G[6] << 16) | (G[6] >>> 16))) | 0;
X[1] = (G[1] + ((G[0] << 8) | (G[0] >>> 24)) + G[7]) | 0;
X[2] = (G[2] + ((G[1] << 16) | (G[1] >>> 16)) + ((G[0] << 16) | (G[0] >>> 16))) | 0;
X[3] = (G[3] + ((G[2] << 8) | (G[2] >>> 24)) + G[1]) | 0;
X[4] = (G[4] + ((G[3] << 16) | (G[3] >>> 16)) + ((G[2] << 16) | (G[2] >>> 16))) | 0;
X[5] = (G[5] + ((G[4] << 8) | (G[4] >>> 24)) + G[3]) | 0;
X[6] = (G[6] + ((G[5] << 16) | (G[5] >>> 16)) + ((G[4] << 16) | (G[4] >>> 16))) | 0;
X[7] = (G[7] + ((G[6] << 8) | (G[6] >>> 24)) + G[5]) | 0;
}
/**
* Shortcut functions to the cipher's object interface.
*
* @example
*
* var ciphertext = CryptoJS.Rabbit.encrypt(message, key, cfg);
* var plaintext = CryptoJS.Rabbit.decrypt(ciphertext, key, cfg);
*/
C.Rabbit = StreamCipher._createHelper(Rabbit);
}());
/**
* Counter block mode.
*/
CryptoJS.mode.CTR = (function () {
var CTR = CryptoJS.lib.BlockCipherMode.extend();
var Encryptor = CTR.Encryptor = CTR.extend({
processBlock: function (words, offset) {
// Shortcuts
var cipher = this._cipher
var blockSize = cipher.blockSize;
var iv = this._iv;
var counter = this._counter;
// Generate keystream
if (iv) {
counter = this._counter = iv.slice(0);
// Remove IV for subsequent blocks
this._iv = undefined;
}
var keystream = counter.slice(0);
cipher.encryptBlock(keystream, 0);
// Increment counter
counter[blockSize - 1] = (counter[blockSize - 1] + 1) | 0
// Encrypt
for (var i = 0; i < blockSize; i++) {
words[offset + i] ^= keystream[i];
}
}
});
CTR.Decryptor = Encryptor;
return CTR;
}());
(function () {
// Shortcuts
var C = CryptoJS;
var C_lib = C.lib;
var StreamCipher = C_lib.StreamCipher;
var C_algo = C.algo;
// Reusable objects
var S = [];
var C_ = [];
var G = [];
/**
* Rabbit stream cipher algorithm.
*
* This is a legacy version that neglected to convert the key to little-endian.
* This error doesn't affect the cipher's security,
* but it does affect its compatibility with other implementations.
*/
var RabbitLegacy = C_algo.RabbitLegacy = StreamCipher.extend({
_doReset: function () {
// Shortcuts
var K = this._key.words;
var iv = this.cfg.iv;
// Generate initial state values
var X = this._X = [
K[0], (K[3] << 16) | (K[2] >>> 16),
K[1], (K[0] << 16) | (K[3] >>> 16),
K[2], (K[1] << 16) | (K[0] >>> 16),
K[3], (K[2] << 16) | (K[1] >>> 16)
];
// Generate initial counter values
var C = this._C = [
(K[2] << 16) | (K[2] >>> 16), (K[0] & 0xffff0000) | (K[1] & 0x0000ffff),
(K[3] << 16) | (K[3] >>> 16), (K[1] & 0xffff0000) | (K[2] & 0x0000ffff),
(K[0] << 16) | (K[0] >>> 16), (K[2] & 0xffff0000) | (K[3] & 0x0000ffff),
(K[1] << 16) | (K[1] >>> 16), (K[3] & 0xffff0000) | (K[0] & 0x0000ffff)
];
// Carry bit
this._b = 0;
// Iterate the system four times
for (var i = 0; i < 4; i++) {
nextState.call(this);
}
// Modify the counters
for (var i = 0; i < 8; i++) {
C[i] ^= X[(i + 4) & 7];
}
// IV setup
if (iv) {
// Shortcuts
var IV = iv.words;
var IV_0 = IV[0];
var IV_1 = IV[1];
// Generate four subvectors
var i0 = (((IV_0 << 8) | (IV_0 >>> 24)) & 0x00ff00ff) | (((IV_0 << 24) | (IV_0 >>> 8)) & 0xff00ff00);
var i2 = (((IV_1 << 8) | (IV_1 >>> 24)) & 0x00ff00ff) | (((IV_1 << 24) | (IV_1 >>> 8)) & 0xff00ff00);
var i1 = (i0 >>> 16) | (i2 & 0xffff0000);
var i3 = (i2 << 16) | (i0 & 0x0000ffff);
// Modify counter values
C[0] ^= i0;
C[1] ^= i1;
C[2] ^= i2;
C[3] ^= i3;
C[4] ^= i0;
C[5] ^= i1;
C[6] ^= i2;
C[7] ^= i3;
// Iterate the system four times
for (var i = 0; i < 4; i++) {
nextState.call(this);
}
}
},
_doProcessBlock: function (M, offset) {
// Shortcut
var X = this._X;
// Iterate the system
nextState.call(this);
// Generate four keystream words
S[0] = X[0] ^ (X[5] >>> 16) ^ (X[3] << 16);
S[1] = X[2] ^ (X[7] >>> 16) ^ (X[5] << 16);
S[2] = X[4] ^ (X[1] >>> 16) ^ (X[7] << 16);
S[3] = X[6] ^ (X[3] >>> 16) ^ (X[1] << 16);
for (var i = 0; i < 4; i++) {
// Swap endian
S[i] = (((S[i] << 8) | (S[i] >>> 24)) & 0x00ff00ff) |
(((S[i] << 24) | (S[i] >>> 8)) & 0xff00ff00);
// Encrypt
M[offset + i] ^= S[i];
}
},
blockSize: 128/32,
ivSize: 64/32
});
function nextState() {
// Shortcuts
var X = this._X;
var C = this._C;
// Save old counter values
for (var i = 0; i < 8; i++) {
C_[i] = C[i];
}
// Calculate new counter values
C[0] = (C[0] + 0x4d34d34d + this._b) | 0;
C[1] = (C[1] + 0xd34d34d3 + ((C[0] >>> 0) < (C_[0] >>> 0) ? 1 : 0)) | 0;
C[2] = (C[2] + 0x34d34d34 + ((C[1] >>> 0) < (C_[1] >>> 0) ? 1 : 0)) | 0;
C[3] = (C[3] + 0x4d34d34d + ((C[2] >>> 0) < (C_[2] >>> 0) ? 1 : 0)) | 0;
C[4] = (C[4] + 0xd34d34d3 + ((C[3] >>> 0) < (C_[3] >>> 0) ? 1 : 0)) | 0;
C[5] = (C[5] + 0x34d34d34 + ((C[4] >>> 0) < (C_[4] >>> 0) ? 1 : 0)) | 0;
C[6] = (C[6] + 0x4d34d34d + ((C[5] >>> 0) < (C_[5] >>> 0) ? 1 : 0)) | 0;
C[7] = (C[7] + 0xd34d34d3 + ((C[6] >>> 0) < (C_[6] >>> 0) ? 1 : 0)) | 0;
this._b = (C[7] >>> 0) < (C_[7] >>> 0) ? 1 : 0;
// Calculate the g-values
for (var i = 0; i < 8; i++) {
var gx = X[i] + C[i];
// Construct high and low argument for squaring
var ga = gx & 0xffff;
var gb = gx >>> 16;
// Calculate high and low result of squaring
var gh = ((((ga * ga) >>> 17) + ga * gb) >>> 15) + gb * gb;
var gl = (((gx & 0xffff0000) * gx) | 0) + (((gx & 0x0000ffff) * gx) | 0);
// High XOR low
G[i] = gh ^ gl;
}
// Calculate new state values
X[0] = (G[0] + ((G[7] << 16) | (G[7] >>> 16)) + ((G[6] << 16) | (G[6] >>> 16))) | 0;
X[1] = (G[1] + ((G[0] << 8) | (G[0] >>> 24)) + G[7]) | 0;
X[2] = (G[2] + ((G[1] << 16) | (G[1] >>> 16)) + ((G[0] << 16) | (G[0] >>> 16))) | 0;
X[3] = (G[3] + ((G[2] << 8) | (G[2] >>> 24)) + G[1]) | 0;
X[4] = (G[4] + ((G[3] << 16) | (G[3] >>> 16)) + ((G[2] << 16) | (G[2] >>> 16))) | 0;
X[5] = (G[5] + ((G[4] << 8) | (G[4] >>> 24)) + G[3]) | 0;
X[6] = (G[6] + ((G[5] << 16) | (G[5] >>> 16)) + ((G[4] << 16) | (G[4] >>> 16))) | 0;
X[7] = (G[7] + ((G[6] << 8) | (G[6] >>> 24)) + G[5]) | 0;
}
/**
* Shortcut functions to the cipher's object interface.
*
* @example
*
* var ciphertext = CryptoJS.RabbitLegacy.encrypt(message, key, cfg);
* var plaintext = CryptoJS.RabbitLegacy.decrypt(ciphertext, key, cfg);
*/
C.RabbitLegacy = StreamCipher._createHelper(RabbitLegacy);
}());
/**
* Zero padding strategy.
*/
CryptoJS.pad.ZeroPadding = {
pad: function (data, blockSize) {
// Shortcut
var blockSizeBytes = blockSize * 4;
// Pad
data.clamp();
data.sigBytes += blockSizeBytes - ((data.sigBytes % blockSizeBytes) || blockSizeBytes);
},
unpad: function (data) {
// Shortcut
var dataWords = data.words;
// Unpad
var i = data.sigBytes - 1;
while (!((dataWords[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff)) {
i--;
}
data.sigBytes = i + 1;
}
};
return CryptoJS;
}));
``` | /content/code_sandbox/node_modules/crypto-js/crypto-js.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 54,821 |
```javascript
;(function (root, factory, undef) {
if (typeof exports === "object") {
// CommonJS
module.exports = exports = factory(require("./core"), require("./x64-core"));
}
else if (typeof define === "function" && define.amd) {
// AMD
define(["./core", "./x64-core"], factory);
}
else {
// Global (browser)
factory(root.CryptoJS);
}
}(this, function (CryptoJS) {
(function (Math) {
// Shortcuts
var C = CryptoJS;
var C_lib = C.lib;
var WordArray = C_lib.WordArray;
var Hasher = C_lib.Hasher;
var C_x64 = C.x64;
var X64Word = C_x64.Word;
var C_algo = C.algo;
// Constants tables
var RHO_OFFSETS = [];
var PI_INDEXES = [];
var ROUND_CONSTANTS = [];
// Compute Constants
(function () {
// Compute rho offset constants
var x = 1, y = 0;
for (var t = 0; t < 24; t++) {
RHO_OFFSETS[x + 5 * y] = ((t + 1) * (t + 2) / 2) % 64;
var newX = y % 5;
var newY = (2 * x + 3 * y) % 5;
x = newX;
y = newY;
}
// Compute pi index constants
for (var x = 0; x < 5; x++) {
for (var y = 0; y < 5; y++) {
PI_INDEXES[x + 5 * y] = y + ((2 * x + 3 * y) % 5) * 5;
}
}
// Compute round constants
var LFSR = 0x01;
for (var i = 0; i < 24; i++) {
var roundConstantMsw = 0;
var roundConstantLsw = 0;
for (var j = 0; j < 7; j++) {
if (LFSR & 0x01) {
var bitPosition = (1 << j) - 1;
if (bitPosition < 32) {
roundConstantLsw ^= 1 << bitPosition;
} else /* if (bitPosition >= 32) */ {
roundConstantMsw ^= 1 << (bitPosition - 32);
}
}
// Compute next LFSR
if (LFSR & 0x80) {
// Primitive polynomial over GF(2): x^8 + x^6 + x^5 + x^4 + 1
LFSR = (LFSR << 1) ^ 0x71;
} else {
LFSR <<= 1;
}
}
ROUND_CONSTANTS[i] = X64Word.create(roundConstantMsw, roundConstantLsw);
}
}());
// Reusable objects for temporary values
var T = [];
(function () {
for (var i = 0; i < 25; i++) {
T[i] = X64Word.create();
}
}());
/**
* SHA-3 hash algorithm.
*/
var SHA3 = C_algo.SHA3 = Hasher.extend({
/**
* Configuration options.
*
* @property {number} outputLength
* The desired number of bits in the output hash.
* Only values permitted are: 224, 256, 384, 512.
* Default: 512
*/
cfg: Hasher.cfg.extend({
outputLength: 512
}),
_doReset: function () {
var state = this._state = []
for (var i = 0; i < 25; i++) {
state[i] = new X64Word.init();
}
this.blockSize = (1600 - 2 * this.cfg.outputLength) / 32;
},
_doProcessBlock: function (M, offset) {
// Shortcuts
var state = this._state;
var nBlockSizeLanes = this.blockSize / 2;
// Absorb
for (var i = 0; i < nBlockSizeLanes; i++) {
// Shortcuts
var M2i = M[offset + 2 * i];
var M2i1 = M[offset + 2 * i + 1];
// Swap endian
M2i = (
(((M2i << 8) | (M2i >>> 24)) & 0x00ff00ff) |
(((M2i << 24) | (M2i >>> 8)) & 0xff00ff00)
);
M2i1 = (
(((M2i1 << 8) | (M2i1 >>> 24)) & 0x00ff00ff) |
(((M2i1 << 24) | (M2i1 >>> 8)) & 0xff00ff00)
);
// Absorb message into state
var lane = state[i];
lane.high ^= M2i1;
lane.low ^= M2i;
}
// Rounds
for (var round = 0; round < 24; round++) {
// Theta
for (var x = 0; x < 5; x++) {
// Mix column lanes
var tMsw = 0, tLsw = 0;
for (var y = 0; y < 5; y++) {
var lane = state[x + 5 * y];
tMsw ^= lane.high;
tLsw ^= lane.low;
}
// Temporary values
var Tx = T[x];
Tx.high = tMsw;
Tx.low = tLsw;
}
for (var x = 0; x < 5; x++) {
// Shortcuts
var Tx4 = T[(x + 4) % 5];
var Tx1 = T[(x + 1) % 5];
var Tx1Msw = Tx1.high;
var Tx1Lsw = Tx1.low;
// Mix surrounding columns
var tMsw = Tx4.high ^ ((Tx1Msw << 1) | (Tx1Lsw >>> 31));
var tLsw = Tx4.low ^ ((Tx1Lsw << 1) | (Tx1Msw >>> 31));
for (var y = 0; y < 5; y++) {
var lane = state[x + 5 * y];
lane.high ^= tMsw;
lane.low ^= tLsw;
}
}
// Rho Pi
for (var laneIndex = 1; laneIndex < 25; laneIndex++) {
// Shortcuts
var lane = state[laneIndex];
var laneMsw = lane.high;
var laneLsw = lane.low;
var rhoOffset = RHO_OFFSETS[laneIndex];
// Rotate lanes
if (rhoOffset < 32) {
var tMsw = (laneMsw << rhoOffset) | (laneLsw >>> (32 - rhoOffset));
var tLsw = (laneLsw << rhoOffset) | (laneMsw >>> (32 - rhoOffset));
} else /* if (rhoOffset >= 32) */ {
var tMsw = (laneLsw << (rhoOffset - 32)) | (laneMsw >>> (64 - rhoOffset));
var tLsw = (laneMsw << (rhoOffset - 32)) | (laneLsw >>> (64 - rhoOffset));
}
// Transpose lanes
var TPiLane = T[PI_INDEXES[laneIndex]];
TPiLane.high = tMsw;
TPiLane.low = tLsw;
}
// Rho pi at x = y = 0
var T0 = T[0];
var state0 = state[0];
T0.high = state0.high;
T0.low = state0.low;
// Chi
for (var x = 0; x < 5; x++) {
for (var y = 0; y < 5; y++) {
// Shortcuts
var laneIndex = x + 5 * y;
var lane = state[laneIndex];
var TLane = T[laneIndex];
var Tx1Lane = T[((x + 1) % 5) + 5 * y];
var Tx2Lane = T[((x + 2) % 5) + 5 * y];
// Mix rows
lane.high = TLane.high ^ (~Tx1Lane.high & Tx2Lane.high);
lane.low = TLane.low ^ (~Tx1Lane.low & Tx2Lane.low);
}
}
// Iota
var lane = state[0];
var roundConstant = ROUND_CONSTANTS[round];
lane.high ^= roundConstant.high;
lane.low ^= roundConstant.low;;
}
},
_doFinalize: function () {
// Shortcuts
var data = this._data;
var dataWords = data.words;
var nBitsTotal = this._nDataBytes * 8;
var nBitsLeft = data.sigBytes * 8;
var blockSizeBits = this.blockSize * 32;
// Add padding
dataWords[nBitsLeft >>> 5] |= 0x1 << (24 - nBitsLeft % 32);
dataWords[((Math.ceil((nBitsLeft + 1) / blockSizeBits) * blockSizeBits) >>> 5) - 1] |= 0x80;
data.sigBytes = dataWords.length * 4;
// Hash final blocks
this._process();
// Shortcuts
var state = this._state;
var outputLengthBytes = this.cfg.outputLength / 8;
var outputLengthLanes = outputLengthBytes / 8;
// Squeeze
var hashWords = [];
for (var i = 0; i < outputLengthLanes; i++) {
// Shortcuts
var lane = state[i];
var laneMsw = lane.high;
var laneLsw = lane.low;
// Swap endian
laneMsw = (
(((laneMsw << 8) | (laneMsw >>> 24)) & 0x00ff00ff) |
(((laneMsw << 24) | (laneMsw >>> 8)) & 0xff00ff00)
);
laneLsw = (
(((laneLsw << 8) | (laneLsw >>> 24)) & 0x00ff00ff) |
(((laneLsw << 24) | (laneLsw >>> 8)) & 0xff00ff00)
);
// Squeeze state to retrieve hash
hashWords.push(laneLsw);
hashWords.push(laneMsw);
}
// Return final computed hash
return new WordArray.init(hashWords, outputLengthBytes);
},
clone: function () {
var clone = Hasher.clone.call(this);
var state = clone._state = this._state.slice(0);
for (var i = 0; i < 25; i++) {
state[i] = state[i].clone();
}
return clone;
}
});
/**
* Shortcut function to the hasher's object interface.
*
* @param {WordArray|string} message The message to hash.
*
* @return {WordArray} The hash.
*
* @static
*
* @example
*
* var hash = CryptoJS.SHA3('message');
* var hash = CryptoJS.SHA3(wordArray);
*/
C.SHA3 = Hasher._createHelper(SHA3);
/**
* Shortcut function to the HMAC's object interface.
*
* @param {WordArray|string} message The message to hash.
* @param {WordArray|string} key The secret key.
*
* @return {WordArray} The HMAC.
*
* @static
*
* @example
*
* var hmac = CryptoJS.HmacSHA3(message, key);
*/
C.HmacSHA3 = Hasher._createHmacHelper(SHA3);
}(Math));
return CryptoJS.SHA3;
}));
``` | /content/code_sandbox/node_modules/crypto-js/sha3.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 2,769 |
```mediawiki
<wiki:toc/>
----
= Quick-start Guide =
== Hashers ==
=== The Hasher Algorithms ===
==== MD5 ====
MD5 is a widely used hash function. It's been used in a variety of security applications and is also commonly used to check the integrity of files. Though, MD5 is not collision resistant, and it isn't suitable for applications like SSL certificates or digital signatures that rely on this property.
{{{
<script src="path_to_url"></script>
<script>
var hash = CryptoJS.MD5("Message");
</script>
}}}
==== SHA-1 ====
The SHA hash functions were designed by the National Security Agency (NSA). SHA-1 is the most established of the existing SHA hash functions, and it's used in a variety of security applications and protocols. Though, SHA-1's collision resistance has been weakening as new attacks are discovered or improved.
{{{
<script src="path_to_url"></script>
<script>
var hash = CryptoJS.SHA1("Message");
</script>
}}}
==== SHA-2 ====
SHA-256 is one of the four variants in the SHA-2 set. It isn't as widely used as SHA-1, though it appears to provide much better security.
{{{
<script src="path_to_url"></script>
<script>
var hash = CryptoJS.SHA256("Message");
</script>
}}}
SHA-512 is largely identical to SHA-256 but operates on 64-bit words rather than 32.
{{{
<script src="path_to_url"></script>
<script>
var hash = CryptoJS.SHA512("Message");
</script>
}}}
CryptoJS also supports SHA-224 and SHA-384, which are largely identical but truncated versions of SHA-256 and SHA-512 respectively.
==== SHA-3 ====
SHA-3 is the winner of a five-year competition to select a new cryptographic hash algorithm where 64 competing designs were evaluated.
{{{
<script src="path_to_url"></script>
<script>
var hash = CryptoJS.SHA3("Message");
</script>
}}}
SHA-3 can be configured to output hash lengths of one of 224, 256, 384, or 512 bits. The default is 512 bits.
{{{
<script src="path_to_url"></script>
<script>
var hash = CryptoJS.SHA3("Message", { outputLength: 512 });
var hash = CryptoJS.SHA3("Message", { outputLength: 384 });
var hash = CryptoJS.SHA3("Message", { outputLength: 256 });
var hash = CryptoJS.SHA3("Message", { outputLength: 224 });
</script>
}}}
==== RIPEMD-160 ====
{{{
<script src="path_to_url"></script>
<script>
var hash = CryptoJS.RIPEMD160("Message");
</script>
}}}
=== The Hasher Input ===
The hash algorithms accept either strings or instances of CryptoJS.lib.WordArray. A WordArray object represents an array of 32-bit words. When you pass a string, it's automatically converted to a WordArray encoded as UTF-8.
=== The Hasher Output ===
The hash you get back isn't a string yet. It's a WordArray object. When you use a WordArray object in a string context, it's automatically converted to a hex string.
{{{
<script src="path_to_url"></script>
<script>
var hash = CryptoJS.SHA256("Message");
alert(typeof hash); // object
alert(hash); // your_sha256_hash
</script>
}}}
You can convert a WordArray object to other formats by explicitly calling the toString method and passing an encoder.
{{{
<script src="path_to_url"></script>
<script src="path_to_url"></script>
<script>
var hash = CryptoJS.SHA256("Message");
alert(hash.toString(CryptoJS.enc.Base64)); // L3dmip37+NWEi57rSnFFypTG7ZI25Kdz9tyvpRMrL5E=
alert(hash.toString(CryptoJS.enc.Latin1)); // /wfJqE6s+/
alert(hash.toString(CryptoJS.enc.Hex)); // your_sha256_hash
</script>
}}}
=== Progressive Hashing ===
{{{
<script src="path_to_url"></script>
<script>
var sha256 = CryptoJS.algo.SHA256.create();
sha256.update("Message Part 1");
sha256.update("Message Part 2");
sha256.update("Message Part 3");
var hash = sha256.finalize();
</script>
}}}
== HMAC ==
Keyed-hash message authentication codes (HMAC) is a mechanism for message authentication using cryptographic hash functions.
HMAC can be used in combination with any iterated cryptographic hash function.
{{{
<script src="path_to_url"></script>
<script src="path_to_url"></script>
<script src="path_to_url"></script>
<script src="path_to_url"></script>
<script>
var hash = CryptoJS.HmacMD5("Message", "Secret Passphrase");
var hash = CryptoJS.HmacSHA1("Message", "Secret Passphrase");
var hash = CryptoJS.HmacSHA256("Message", "Secret Passphrase");
var hash = CryptoJS.HmacSHA512("Message", "Secret Passphrase");
</script>
}}}
=== Progressive HMAC Hashing ===
{{{
<script src="path_to_url"></script>
<script>
var hmac = CryptoJS.algo.HMAC.create(CryptoJS.algo.SHA256, "Secret Passphrase");
hmac.update("Message Part 1");
hmac.update("Message Part 2");
hmac.update("Message Part 3");
var hash = hmac.finalize();
</script>
}}}
== PBKDF2 ==
PBKDF2 is a password-based key derivation function. In many applications of cryptography, user security is ultimately dependent on a password, and because a password usually can't be used directly as a cryptographic key, some processing is required.
A salt provides a large set of keys for any given password, and an iteration count increases the cost of producing keys from a password, thereby also increasing the difficulty of attack.
{{{
<script src="path_to_url"></script>
<script>
var salt = CryptoJS.lib.WordArray.random(128/8);
var key128Bits = CryptoJS.PBKDF2("Secret Passphrase", salt, { keySize: 128/32 });
var key256Bits = CryptoJS.PBKDF2("Secret Passphrase", salt, { keySize: 256/32 });
var key512Bits = CryptoJS.PBKDF2("Secret Passphrase", salt, { keySize: 512/32 });
var key512Bits1000Iterations = CryptoJS.PBKDF2("Secret Passphrase", salt, { keySize: 512/32, iterations: 1000 });
</script>
}}}
== Ciphers ==
=== The Cipher Algorithms ===
==== AES ====
The Advanced Encryption Standard (AES) is a U.S. Federal Information Processing Standard (FIPS). It was selected after a 5-year process where 15 competing designs were evaluated.
{{{
<script src="path_to_url"></script>
<script>
var encrypted = CryptoJS.AES.encrypt("Message", "Secret Passphrase");
var decrypted = CryptoJS.AES.decrypt(encrypted, "Secret Passphrase");
</script>
}}}
CryptoJS supports AES-128, AES-192, and AES-256. It will pick the variant by the size of the key you pass in. If you use a passphrase, then it will generate a 256-bit key.
==== DES, Triple DES ====
DES is a previously dominant algorithm for encryption, and was published as an official Federal Information Processing Standard (FIPS). DES is now considered to be insecure due to the small key size.
{{{
<script src="path_to_url"></script>
<script>
var encrypted = CryptoJS.DES.encrypt("Message", "Secret Passphrase");
var decrypted = CryptoJS.DES.decrypt(encrypted, "Secret Passphrase");
</script>
}}}
Triple DES applies DES three times to each block to increase the key size. The algorithm is believed to be secure in this form.
{{{
<script src="path_to_url"></script>
<script>
var encrypted = CryptoJS.TripleDES.encrypt("Message", "Secret Passphrase");
var decrypted = CryptoJS.TripleDES.decrypt(encrypted, "Secret Passphrase");
</script>
}}}
==== Rabbit ====
Rabbit is a high-performance stream cipher and a finalist in the eSTREAM Portfolio. It is one of the four designs selected after a 3 1/2-year process where 22 designs were evaluated.
{{{
<script src="path_to_url"></script>
<script>
var encrypted = CryptoJS.Rabbit.encrypt("Message", "Secret Passphrase");
var decrypted = CryptoJS.Rabbit.decrypt(encrypted, "Secret Passphrase");
</script>
}}}
==== RC4, RC4Drop ====
RC4 is a widely-used stream cipher. It's used in popular protocols such as SSL and WEP. Although remarkable for its simplicity and speed, the algorithm's history doesn't inspire confidence in its security.
{{{
<script src="path_to_url"></script>
<script>
var encrypted = CryptoJS.RC4.encrypt("Message", "Secret Passphrase");
var decrypted = CryptoJS.RC4.decrypt(encrypted, "Secret Passphrase");
</script>
}}}
It was discovered that the first few bytes of keystream are strongly non-random and leak information about the key. We can defend against this attack by discarding the initial portion of the keystream. This modified algorithm is traditionally called RC4-drop.
By default, 192 words (768 bytes) are dropped, but you can configure the algorithm to drop any number of words.
{{{
<script src="path_to_url"></script>
<script>
var encrypted = CryptoJS.RC4Drop.encrypt("Message", "Secret Passphrase");
var encrypted = CryptoJS.RC4Drop.encrypt("Message", "Secret Passphrase", { drop: 3072/4 });
var decrypted = CryptoJS.RC4Drop.decrypt(encrypted, "Secret Passphrase", { drop: 3072/4 });
</script>
}}}
=== Custom Key and IV ===
{{{
<script src="path_to_url"></script>
<script>
var key = CryptoJS.enc.Hex.parse('000102030405060708090a0b0c0d0e0f');
var iv = CryptoJS.enc.Hex.parse('101112131415161718191a1b1c1d1e1f');
var encrypted = CryptoJS.AES.encrypt("Message", key, { iv: iv });
</script>
}}}
=== Block Modes and Padding ===
{{{
<script src="path_to_url"></script>
<script src="path_to_url"></script>
<script src="path_to_url"></script>
<script>
var encrypted = CryptoJS.AES.encrypt("Message", "Secret Passphrase", { mode: CryptoJS.mode.CFB, padding: CryptoJS.pad.AnsiX923 });
</script>
}}}
CryptoJS supports the following modes:
* CBC (the default)
* CFB
* CTR
* OFB
* ECB
And CryptoJS supports the following padding schemes:
* Pkcs7 (the default)
* Iso97971
* AnsiX923
* Iso10126
* ZeroPadding
* NoPadding
=== The Cipher Input ===
For the plaintext message, the cipher algorithms accept either strings or instances of CryptoJS.lib.WordArray.
For the key, when you pass a string, it's treated as a passphrase and used to derive an actual key and IV. Or you can pass a WordArray that represents the actual key. If you pass the actual key, you must also pass the actual IV.
For the ciphertext, the cipher algorithms accept either strings or instances of CryptoJS.lib.CipherParams. A CipherParams object represents a collection of parameters such as the IV, a salt, and the raw ciphertext itself. When you pass a string, it's automatically converted to a CipherParams object according to a configurable format strategy.
=== The Cipher Output ===
The plaintext you get back after decryption is a WordArray object. See Hashers' Output for more detail.
The ciphertext you get back after encryption isn't a string yet. It's a CipherParams object. A CipherParams object gives you access to all the parameters used during encryption. When you use a CipherParams object in a string context, it's automatically converted to a string according to a format strategy. The default is an OpenSSL-compatible format.
{{{
<script src="path_to_url"></script>
<script>
var encrypted = CryptoJS.AES.encrypt("Message", "Secret Passphrase");
alert(encrypted.key); // your_sha256_hash3
alert(encrypted.iv); // 7781157e2629b094f0e3dd48c4d786115
alert(encrypted.salt); // 7a25f9132ec6a8b34
alert(encrypted.ciphertext); // 73e54154a15d1beeb509d9e12f1e462a0
alert(encrypted); // U2FsdGVkX1+iX5Ey7GqLND5UFUoV0b7rUJ2eEvHkYqA=
</script>
}}}
You can define your own formats in order to be compatible with other crypto implementations. A format is an object with two methodsstringify and parsethat converts between CipherParams objects and ciphertext strings.
Here's how you might write a JSON formatter:
{{{
<script src="path_to_url"></script>
<script>
var JsonFormatter = {
stringify: function (cipherParams) {
// create json object with ciphertext
var jsonObj = {
ct: cipherParams.ciphertext.toString(CryptoJS.enc.Base64)
};
// optionally add iv and salt
if (cipherParams.iv) {
jsonObj.iv = cipherParams.iv.toString();
}
if (cipherParams.salt) {
jsonObj.s = cipherParams.salt.toString();
}
// stringify json object
return JSON.stringify(jsonObj);
},
parse: function (jsonStr) {
// parse json string
var jsonObj = JSON.parse(jsonStr);
// extract ciphertext from json object, and create cipher params object
var cipherParams = CryptoJS.lib.CipherParams.create({
ciphertext: CryptoJS.enc.Base64.parse(jsonObj.ct)
});
// optionally extract iv and salt
if (jsonObj.iv) {
cipherParams.iv = CryptoJS.enc.Hex.parse(jsonObj.iv)
}
if (jsonObj.s) {
cipherParams.salt = CryptoJS.enc.Hex.parse(jsonObj.s)
}
return cipherParams;
}
};
var encrypted = CryptoJS.AES.encrypt("Message", "Secret Passphrase", { format: JsonFormatter });
alert(encrypted); // {"ct":"tZ4MsEnfbcDOwqau68aOrQ==","iv":"8a8c8fd8fe33743d3638737ea4a00698","s":"ba06373c8f57179c"}
var decrypted = CryptoJS.AES.decrypt(encrypted, "Secret Passphrase", { format: JsonFormatter });
alert(decrypted.toString(CryptoJS.enc.Utf8)); // Message
</script>
}}}
=== Progressive Ciphering ===
{{{
<script src="path_to_url"></script>
<script>
var key = CryptoJS.enc.Hex.parse('000102030405060708090a0b0c0d0e0f');
var iv = CryptoJS.enc.Hex.parse('101112131415161718191a1b1c1d1e1f');
var aesEncryptor = CryptoJS.algo.AES.createEncryptor(key, { iv: iv });
var ciphertextPart1 = aesEncryptor.process("Message Part 1");
var ciphertextPart2 = aesEncryptor.process("Message Part 2");
var ciphertextPart3 = aesEncryptor.process("Message Part 3");
var ciphertextPart4 = aesEncryptor.finalize();
var aesDecryptor = CryptoJS.algo.AES.createDecryptor(key, { iv: iv });
var plaintextPart1 = aesDecryptor.process(ciphertextPart1);
var plaintextPart2 = aesDecryptor.process(ciphertextPart2);
var plaintextPart3 = aesDecryptor.process(ciphertextPart3);
var plaintextPart4 = aesDecryptor.process(ciphertextPart4);
var plaintextPart5 = aesDecryptor.finalize();
</script>
}}}
=== Interoperability ===
==== With OpenSSL ====
Encrypt with OpenSSL:
{{{
openssl enc -aes-256-cbc -in infile -out outfile -pass pass:"Secret Passphrase" -e -base64
}}}
Decrypt with CryptoJS:
{{{
<script src="path_to_url"></script>
<script>
var decrypted = CryptoJS.AES.decrypt(openSSLEncrypted, "Secret Passphrase");
</script>
}}}
== Encoders ==
CryptoJS can convert from encoding formats such as Base64, Latin1 or Hex to WordArray objects and vica versa.
{{{
<script src="path_to_url"></script>
<script src="path_to_url"></script>
<script src="path_to_url"></script>
<script>
var words = CryptoJS.enc.Base64.parse('SGVsbG8sIFdvcmxkIQ==');
var base64 = CryptoJS.enc.Base64.stringify(words);
var words = CryptoJS.enc.Latin1.parse('Hello, World!');
var latin1 = CryptoJS.enc.Latin1.stringify(words);
var words = CryptoJS.enc.Hex.parse('48656c6c6f2c20576f726c6421');
var hex = CryptoJS.enc.Hex.stringify(words);
var words = CryptoJS.enc.Utf8.parse('');
var utf8 = CryptoJS.enc.Utf8.stringify(words);
var words = CryptoJS.enc.Utf16.parse('Hello, World!');
var utf16 = CryptoJS.enc.Utf16.stringify(words);
var words = CryptoJS.enc.Utf16LE.parse('Hello, World!');
var utf16 = CryptoJS.enc.Utf16LE.stringify(words);
</script>
}}}
``` | /content/code_sandbox/node_modules/crypto-js/docs/QuickStartGuide.wiki | mediawiki | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 3,870 |
```yaml
parser: typescript
printWidth: 80
tabWidth: 2
singleQuote: true
trailingComma: all
arrowParens: always
bracketSpacing: false
``` | /content/code_sandbox/node_modules/socks/.prettierrc.yaml | yaml | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 42 |
```javascript
;(function (root, factory, undef) {
if (typeof exports === "object") {
// CommonJS
module.exports = exports = factory(require("./core"), require("./evpkdf"));
}
else if (typeof define === "function" && define.amd) {
// AMD
define(["./core", "./evpkdf"], factory);
}
else {
// Global (browser)
factory(root.CryptoJS);
}
}(this, function (CryptoJS) {
/**
* Cipher core components.
*/
CryptoJS.lib.Cipher || (function (undefined) {
// Shortcuts
var C = CryptoJS;
var C_lib = C.lib;
var Base = C_lib.Base;
var WordArray = C_lib.WordArray;
var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm;
var C_enc = C.enc;
var Utf8 = C_enc.Utf8;
var Base64 = C_enc.Base64;
var C_algo = C.algo;
var EvpKDF = C_algo.EvpKDF;
/**
* Abstract base cipher template.
*
* @property {number} keySize This cipher's key size. Default: 4 (128 bits)
* @property {number} ivSize This cipher's IV size. Default: 4 (128 bits)
* @property {number} _ENC_XFORM_MODE A constant representing encryption mode.
* @property {number} _DEC_XFORM_MODE A constant representing decryption mode.
*/
var Cipher = C_lib.Cipher = BufferedBlockAlgorithm.extend({
/**
* Configuration options.
*
* @property {WordArray} iv The IV to use for this operation.
*/
cfg: Base.extend(),
/**
* Creates this cipher in encryption mode.
*
* @param {WordArray} key The key.
* @param {Object} cfg (Optional) The configuration options to use for this operation.
*
* @return {Cipher} A cipher instance.
*
* @static
*
* @example
*
* var cipher = CryptoJS.algo.AES.createEncryptor(keyWordArray, { iv: ivWordArray });
*/
createEncryptor: function (key, cfg) {
return this.create(this._ENC_XFORM_MODE, key, cfg);
},
/**
* Creates this cipher in decryption mode.
*
* @param {WordArray} key The key.
* @param {Object} cfg (Optional) The configuration options to use for this operation.
*
* @return {Cipher} A cipher instance.
*
* @static
*
* @example
*
* var cipher = CryptoJS.algo.AES.createDecryptor(keyWordArray, { iv: ivWordArray });
*/
createDecryptor: function (key, cfg) {
return this.create(this._DEC_XFORM_MODE, key, cfg);
},
/**
* Initializes a newly created cipher.
*
* @param {number} xformMode Either the encryption or decryption transormation mode constant.
* @param {WordArray} key The key.
* @param {Object} cfg (Optional) The configuration options to use for this operation.
*
* @example
*
* var cipher = CryptoJS.algo.AES.create(CryptoJS.algo.AES._ENC_XFORM_MODE, keyWordArray, { iv: ivWordArray });
*/
init: function (xformMode, key, cfg) {
// Apply config defaults
this.cfg = this.cfg.extend(cfg);
// Store transform mode and key
this._xformMode = xformMode;
this._key = key;
// Set initial values
this.reset();
},
/**
* Resets this cipher to its initial state.
*
* @example
*
* cipher.reset();
*/
reset: function () {
// Reset data buffer
BufferedBlockAlgorithm.reset.call(this);
// Perform concrete-cipher logic
this._doReset();
},
/**
* Adds data to be encrypted or decrypted.
*
* @param {WordArray|string} dataUpdate The data to encrypt or decrypt.
*
* @return {WordArray} The data after processing.
*
* @example
*
* var encrypted = cipher.process('data');
* var encrypted = cipher.process(wordArray);
*/
process: function (dataUpdate) {
// Append
this._append(dataUpdate);
// Process available blocks
return this._process();
},
/**
* Finalizes the encryption or decryption process.
* Note that the finalize operation is effectively a destructive, read-once operation.
*
* @param {WordArray|string} dataUpdate The final data to encrypt or decrypt.
*
* @return {WordArray} The data after final processing.
*
* @example
*
* var encrypted = cipher.finalize();
* var encrypted = cipher.finalize('data');
* var encrypted = cipher.finalize(wordArray);
*/
finalize: function (dataUpdate) {
// Final data update
if (dataUpdate) {
this._append(dataUpdate);
}
// Perform concrete-cipher logic
var finalProcessedData = this._doFinalize();
return finalProcessedData;
},
keySize: 128/32,
ivSize: 128/32,
_ENC_XFORM_MODE: 1,
_DEC_XFORM_MODE: 2,
/**
* Creates shortcut functions to a cipher's object interface.
*
* @param {Cipher} cipher The cipher to create a helper for.
*
* @return {Object} An object with encrypt and decrypt shortcut functions.
*
* @static
*
* @example
*
* var AES = CryptoJS.lib.Cipher._createHelper(CryptoJS.algo.AES);
*/
_createHelper: (function () {
function selectCipherStrategy(key) {
if (typeof key == 'string') {
return PasswordBasedCipher;
} else {
return SerializableCipher;
}
}
return function (cipher) {
return {
encrypt: function (message, key, cfg) {
return selectCipherStrategy(key).encrypt(cipher, message, key, cfg);
},
decrypt: function (ciphertext, key, cfg) {
return selectCipherStrategy(key).decrypt(cipher, ciphertext, key, cfg);
}
};
};
}())
});
/**
* Abstract base stream cipher template.
*
* @property {number} blockSize The number of 32-bit words this cipher operates on. Default: 1 (32 bits)
*/
var StreamCipher = C_lib.StreamCipher = Cipher.extend({
_doFinalize: function () {
// Process partial blocks
var finalProcessedBlocks = this._process(!!'flush');
return finalProcessedBlocks;
},
blockSize: 1
});
/**
* Mode namespace.
*/
var C_mode = C.mode = {};
/**
* Abstract base block cipher mode template.
*/
var BlockCipherMode = C_lib.BlockCipherMode = Base.extend({
/**
* Creates this mode for encryption.
*
* @param {Cipher} cipher A block cipher instance.
* @param {Array} iv The IV words.
*
* @static
*
* @example
*
* var mode = CryptoJS.mode.CBC.createEncryptor(cipher, iv.words);
*/
createEncryptor: function (cipher, iv) {
return this.Encryptor.create(cipher, iv);
},
/**
* Creates this mode for decryption.
*
* @param {Cipher} cipher A block cipher instance.
* @param {Array} iv The IV words.
*
* @static
*
* @example
*
* var mode = CryptoJS.mode.CBC.createDecryptor(cipher, iv.words);
*/
createDecryptor: function (cipher, iv) {
return this.Decryptor.create(cipher, iv);
},
/**
* Initializes a newly created mode.
*
* @param {Cipher} cipher A block cipher instance.
* @param {Array} iv The IV words.
*
* @example
*
* var mode = CryptoJS.mode.CBC.Encryptor.create(cipher, iv.words);
*/
init: function (cipher, iv) {
this._cipher = cipher;
this._iv = iv;
}
});
/**
* Cipher Block Chaining mode.
*/
var CBC = C_mode.CBC = (function () {
/**
* Abstract base CBC mode.
*/
var CBC = BlockCipherMode.extend();
/**
* CBC encryptor.
*/
CBC.Encryptor = CBC.extend({
/**
* Processes the data block at offset.
*
* @param {Array} words The data words to operate on.
* @param {number} offset The offset where the block starts.
*
* @example
*
* mode.processBlock(data.words, offset);
*/
processBlock: function (words, offset) {
// Shortcuts
var cipher = this._cipher;
var blockSize = cipher.blockSize;
// XOR and encrypt
xorBlock.call(this, words, offset, blockSize);
cipher.encryptBlock(words, offset);
// Remember this block to use with next block
this._prevBlock = words.slice(offset, offset + blockSize);
}
});
/**
* CBC decryptor.
*/
CBC.Decryptor = CBC.extend({
/**
* Processes the data block at offset.
*
* @param {Array} words The data words to operate on.
* @param {number} offset The offset where the block starts.
*
* @example
*
* mode.processBlock(data.words, offset);
*/
processBlock: function (words, offset) {
// Shortcuts
var cipher = this._cipher;
var blockSize = cipher.blockSize;
// Remember this block to use with next block
var thisBlock = words.slice(offset, offset + blockSize);
// Decrypt and XOR
cipher.decryptBlock(words, offset);
xorBlock.call(this, words, offset, blockSize);
// This block becomes the previous block
this._prevBlock = thisBlock;
}
});
function xorBlock(words, offset, blockSize) {
// Shortcut
var iv = this._iv;
// Choose mixing block
if (iv) {
var block = iv;
// Remove IV for subsequent blocks
this._iv = undefined;
} else {
var block = this._prevBlock;
}
// XOR blocks
for (var i = 0; i < blockSize; i++) {
words[offset + i] ^= block[i];
}
}
return CBC;
}());
/**
* Padding namespace.
*/
var C_pad = C.pad = {};
/**
* PKCS #5/7 padding strategy.
*/
var Pkcs7 = C_pad.Pkcs7 = {
/**
* Pads data using the algorithm defined in PKCS #5/7.
*
* @param {WordArray} data The data to pad.
* @param {number} blockSize The multiple that the data should be padded to.
*
* @static
*
* @example
*
* CryptoJS.pad.Pkcs7.pad(wordArray, 4);
*/
pad: function (data, blockSize) {
// Shortcut
var blockSizeBytes = blockSize * 4;
// Count padding bytes
var nPaddingBytes = blockSizeBytes - data.sigBytes % blockSizeBytes;
// Create padding word
var paddingWord = (nPaddingBytes << 24) | (nPaddingBytes << 16) | (nPaddingBytes << 8) | nPaddingBytes;
// Create padding
var paddingWords = [];
for (var i = 0; i < nPaddingBytes; i += 4) {
paddingWords.push(paddingWord);
}
var padding = WordArray.create(paddingWords, nPaddingBytes);
// Add padding
data.concat(padding);
},
/**
* Unpads data that had been padded using the algorithm defined in PKCS #5/7.
*
* @param {WordArray} data The data to unpad.
*
* @static
*
* @example
*
* CryptoJS.pad.Pkcs7.unpad(wordArray);
*/
unpad: function (data) {
// Get number of padding bytes from last byte
var nPaddingBytes = data.words[(data.sigBytes - 1) >>> 2] & 0xff;
// Remove padding
data.sigBytes -= nPaddingBytes;
}
};
/**
* Abstract base block cipher template.
*
* @property {number} blockSize The number of 32-bit words this cipher operates on. Default: 4 (128 bits)
*/
var BlockCipher = C_lib.BlockCipher = Cipher.extend({
/**
* Configuration options.
*
* @property {Mode} mode The block mode to use. Default: CBC
* @property {Padding} padding The padding strategy to use. Default: Pkcs7
*/
cfg: Cipher.cfg.extend({
mode: CBC,
padding: Pkcs7
}),
reset: function () {
// Reset cipher
Cipher.reset.call(this);
// Shortcuts
var cfg = this.cfg;
var iv = cfg.iv;
var mode = cfg.mode;
// Reset block mode
if (this._xformMode == this._ENC_XFORM_MODE) {
var modeCreator = mode.createEncryptor;
} else /* if (this._xformMode == this._DEC_XFORM_MODE) */ {
var modeCreator = mode.createDecryptor;
// Keep at least one block in the buffer for unpadding
this._minBufferSize = 1;
}
if (this._mode && this._mode.__creator == modeCreator) {
this._mode.init(this, iv && iv.words);
} else {
this._mode = modeCreator.call(mode, this, iv && iv.words);
this._mode.__creator = modeCreator;
}
},
_doProcessBlock: function (words, offset) {
this._mode.processBlock(words, offset);
},
_doFinalize: function () {
// Shortcut
var padding = this.cfg.padding;
// Finalize
if (this._xformMode == this._ENC_XFORM_MODE) {
// Pad data
padding.pad(this._data, this.blockSize);
// Process final blocks
var finalProcessedBlocks = this._process(!!'flush');
} else /* if (this._xformMode == this._DEC_XFORM_MODE) */ {
// Process final blocks
var finalProcessedBlocks = this._process(!!'flush');
// Unpad data
padding.unpad(finalProcessedBlocks);
}
return finalProcessedBlocks;
},
blockSize: 128/32
});
/**
* A collection of cipher parameters.
*
* @property {WordArray} ciphertext The raw ciphertext.
* @property {WordArray} key The key to this ciphertext.
* @property {WordArray} iv The IV used in the ciphering operation.
* @property {WordArray} salt The salt used with a key derivation function.
* @property {Cipher} algorithm The cipher algorithm.
* @property {Mode} mode The block mode used in the ciphering operation.
* @property {Padding} padding The padding scheme used in the ciphering operation.
* @property {number} blockSize The block size of the cipher.
* @property {Format} formatter The default formatting strategy to convert this cipher params object to a string.
*/
var CipherParams = C_lib.CipherParams = Base.extend({
/**
* Initializes a newly created cipher params object.
*
* @param {Object} cipherParams An object with any of the possible cipher parameters.
*
* @example
*
* var cipherParams = CryptoJS.lib.CipherParams.create({
* ciphertext: ciphertextWordArray,
* key: keyWordArray,
* iv: ivWordArray,
* salt: saltWordArray,
* algorithm: CryptoJS.algo.AES,
* mode: CryptoJS.mode.CBC,
* padding: CryptoJS.pad.PKCS7,
* blockSize: 4,
* formatter: CryptoJS.format.OpenSSL
* });
*/
init: function (cipherParams) {
this.mixIn(cipherParams);
},
/**
* Converts this cipher params object to a string.
*
* @param {Format} formatter (Optional) The formatting strategy to use.
*
* @return {string} The stringified cipher params.
*
* @throws Error If neither the formatter nor the default formatter is set.
*
* @example
*
* var string = cipherParams + '';
* var string = cipherParams.toString();
* var string = cipherParams.toString(CryptoJS.format.OpenSSL);
*/
toString: function (formatter) {
return (formatter || this.formatter).stringify(this);
}
});
/**
* Format namespace.
*/
var C_format = C.format = {};
/**
* OpenSSL formatting strategy.
*/
var OpenSSLFormatter = C_format.OpenSSL = {
/**
* Converts a cipher params object to an OpenSSL-compatible string.
*
* @param {CipherParams} cipherParams The cipher params object.
*
* @return {string} The OpenSSL-compatible string.
*
* @static
*
* @example
*
* var openSSLString = CryptoJS.format.OpenSSL.stringify(cipherParams);
*/
stringify: function (cipherParams) {
// Shortcuts
var ciphertext = cipherParams.ciphertext;
var salt = cipherParams.salt;
// Format
if (salt) {
var wordArray = WordArray.create([0x53616c74, 0x65645f5f]).concat(salt).concat(ciphertext);
} else {
var wordArray = ciphertext;
}
return wordArray.toString(Base64);
},
/**
* Converts an OpenSSL-compatible string to a cipher params object.
*
* @param {string} openSSLStr The OpenSSL-compatible string.
*
* @return {CipherParams} The cipher params object.
*
* @static
*
* @example
*
* var cipherParams = CryptoJS.format.OpenSSL.parse(openSSLString);
*/
parse: function (openSSLStr) {
// Parse base64
var ciphertext = Base64.parse(openSSLStr);
// Shortcut
var ciphertextWords = ciphertext.words;
// Test for salt
if (ciphertextWords[0] == 0x53616c74 && ciphertextWords[1] == 0x65645f5f) {
// Extract salt
var salt = WordArray.create(ciphertextWords.slice(2, 4));
// Remove salt from ciphertext
ciphertextWords.splice(0, 4);
ciphertext.sigBytes -= 16;
}
return CipherParams.create({ ciphertext: ciphertext, salt: salt });
}
};
/**
* A cipher wrapper that returns ciphertext as a serializable cipher params object.
*/
var SerializableCipher = C_lib.SerializableCipher = Base.extend({
/**
* Configuration options.
*
* @property {Formatter} format The formatting strategy to convert cipher param objects to and from a string. Default: OpenSSL
*/
cfg: Base.extend({
format: OpenSSLFormatter
}),
/**
* Encrypts a message.
*
* @param {Cipher} cipher The cipher algorithm to use.
* @param {WordArray|string} message The message to encrypt.
* @param {WordArray} key The key.
* @param {Object} cfg (Optional) The configuration options to use for this operation.
*
* @return {CipherParams} A cipher params object.
*
* @static
*
* @example
*
* var ciphertextParams = CryptoJS.lib.SerializableCipher.encrypt(CryptoJS.algo.AES, message, key);
* var ciphertextParams = CryptoJS.lib.SerializableCipher.encrypt(CryptoJS.algo.AES, message, key, { iv: iv });
* var ciphertextParams = CryptoJS.lib.SerializableCipher.encrypt(CryptoJS.algo.AES, message, key, { iv: iv, format: CryptoJS.format.OpenSSL });
*/
encrypt: function (cipher, message, key, cfg) {
// Apply config defaults
cfg = this.cfg.extend(cfg);
// Encrypt
var encryptor = cipher.createEncryptor(key, cfg);
var ciphertext = encryptor.finalize(message);
// Shortcut
var cipherCfg = encryptor.cfg;
// Create and return serializable cipher params
return CipherParams.create({
ciphertext: ciphertext,
key: key,
iv: cipherCfg.iv,
algorithm: cipher,
mode: cipherCfg.mode,
padding: cipherCfg.padding,
blockSize: cipher.blockSize,
formatter: cfg.format
});
},
/**
* Decrypts serialized ciphertext.
*
* @param {Cipher} cipher The cipher algorithm to use.
* @param {CipherParams|string} ciphertext The ciphertext to decrypt.
* @param {WordArray} key The key.
* @param {Object} cfg (Optional) The configuration options to use for this operation.
*
* @return {WordArray} The plaintext.
*
* @static
*
* @example
*
* var plaintext = CryptoJS.lib.SerializableCipher.decrypt(CryptoJS.algo.AES, formattedCiphertext, key, { iv: iv, format: CryptoJS.format.OpenSSL });
* var plaintext = CryptoJS.lib.SerializableCipher.decrypt(CryptoJS.algo.AES, ciphertextParams, key, { iv: iv, format: CryptoJS.format.OpenSSL });
*/
decrypt: function (cipher, ciphertext, key, cfg) {
// Apply config defaults
cfg = this.cfg.extend(cfg);
// Convert string to CipherParams
ciphertext = this._parse(ciphertext, cfg.format);
// Decrypt
var plaintext = cipher.createDecryptor(key, cfg).finalize(ciphertext.ciphertext);
return plaintext;
},
/**
* Converts serialized ciphertext to CipherParams,
* else assumed CipherParams already and returns ciphertext unchanged.
*
* @param {CipherParams|string} ciphertext The ciphertext.
* @param {Formatter} format The formatting strategy to use to parse serialized ciphertext.
*
* @return {CipherParams} The unserialized ciphertext.
*
* @static
*
* @example
*
* var ciphertextParams = CryptoJS.lib.SerializableCipher._parse(ciphertextStringOrParams, format);
*/
_parse: function (ciphertext, format) {
if (typeof ciphertext == 'string') {
return format.parse(ciphertext, this);
} else {
return ciphertext;
}
}
});
/**
* Key derivation function namespace.
*/
var C_kdf = C.kdf = {};
/**
* OpenSSL key derivation function.
*/
var OpenSSLKdf = C_kdf.OpenSSL = {
/**
* Derives a key and IV from a password.
*
* @param {string} password The password to derive from.
* @param {number} keySize The size in words of the key to generate.
* @param {number} ivSize The size in words of the IV to generate.
* @param {WordArray|string} salt (Optional) A 64-bit salt to use. If omitted, a salt will be generated randomly.
*
* @return {CipherParams} A cipher params object with the key, IV, and salt.
*
* @static
*
* @example
*
* var derivedParams = CryptoJS.kdf.OpenSSL.execute('Password', 256/32, 128/32);
* var derivedParams = CryptoJS.kdf.OpenSSL.execute('Password', 256/32, 128/32, 'saltsalt');
*/
execute: function (password, keySize, ivSize, salt) {
// Generate random salt
if (!salt) {
salt = WordArray.random(64/8);
}
// Derive key and IV
var key = EvpKDF.create({ keySize: keySize + ivSize }).compute(password, salt);
// Separate key and IV
var iv = WordArray.create(key.words.slice(keySize), ivSize * 4);
key.sigBytes = keySize * 4;
// Return params
return CipherParams.create({ key: key, iv: iv, salt: salt });
}
};
/**
* A serializable cipher wrapper that derives the key from a password,
* and returns ciphertext as a serializable cipher params object.
*/
var PasswordBasedCipher = C_lib.PasswordBasedCipher = SerializableCipher.extend({
/**
* Configuration options.
*
* @property {KDF} kdf The key derivation function to use to generate a key and IV from a password. Default: OpenSSL
*/
cfg: SerializableCipher.cfg.extend({
kdf: OpenSSLKdf
}),
/**
* Encrypts a message using a password.
*
* @param {Cipher} cipher The cipher algorithm to use.
* @param {WordArray|string} message The message to encrypt.
* @param {string} password The password.
* @param {Object} cfg (Optional) The configuration options to use for this operation.
*
* @return {CipherParams} A cipher params object.
*
* @static
*
* @example
*
* var ciphertextParams = CryptoJS.lib.PasswordBasedCipher.encrypt(CryptoJS.algo.AES, message, 'password');
* var ciphertextParams = CryptoJS.lib.PasswordBasedCipher.encrypt(CryptoJS.algo.AES, message, 'password', { format: CryptoJS.format.OpenSSL });
*/
encrypt: function (cipher, message, password, cfg) {
// Apply config defaults
cfg = this.cfg.extend(cfg);
// Derive key and other params
var derivedParams = cfg.kdf.execute(password, cipher.keySize, cipher.ivSize);
// Add IV to config
cfg.iv = derivedParams.iv;
// Encrypt
var ciphertext = SerializableCipher.encrypt.call(this, cipher, message, derivedParams.key, cfg);
// Mix in derived params
ciphertext.mixIn(derivedParams);
return ciphertext;
},
/**
* Decrypts serialized ciphertext using a password.
*
* @param {Cipher} cipher The cipher algorithm to use.
* @param {CipherParams|string} ciphertext The ciphertext to decrypt.
* @param {string} password The password.
* @param {Object} cfg (Optional) The configuration options to use for this operation.
*
* @return {WordArray} The plaintext.
*
* @static
*
* @example
*
* var plaintext = CryptoJS.lib.PasswordBasedCipher.decrypt(CryptoJS.algo.AES, formattedCiphertext, 'password', { format: CryptoJS.format.OpenSSL });
* var plaintext = CryptoJS.lib.PasswordBasedCipher.decrypt(CryptoJS.algo.AES, ciphertextParams, 'password', { format: CryptoJS.format.OpenSSL });
*/
decrypt: function (cipher, ciphertext, password, cfg) {
// Apply config defaults
cfg = this.cfg.extend(cfg);
// Convert string to CipherParams
ciphertext = this._parse(ciphertext, cfg.format);
// Derive key and other params
var derivedParams = cfg.kdf.execute(password, cipher.keySize, cipher.ivSize, ciphertext.salt);
// Add IV to config
cfg.iv = derivedParams.iv;
// Decrypt
var plaintext = SerializableCipher.decrypt.call(this, cipher, ciphertext, derivedParams.key, cfg);
return plaintext;
}
});
}());
}));
``` | /content/code_sandbox/node_modules/crypto-js/cipher-core.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 6,165 |
```javascript
"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __exportStar = (this && this.__exportStar) || function(m, exports) {
for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
};
Object.defineProperty(exports, "__esModule", { value: true });
__exportStar(require("./client/socksclient"), exports);
//# sourceMappingURL=index.js.map
``` | /content/code_sandbox/node_modules/socks/build/index.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 193 |
```javascript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.validateSocksClientChainOptions = exports.validateSocksClientOptions = void 0;
const util_1 = require("./util");
const constants_1 = require("./constants");
const stream = require("stream");
/**
* Validates the provided SocksClientOptions
* @param options { SocksClientOptions }
* @param acceptedCommands { string[] } A list of accepted SocksProxy commands.
*/
function validateSocksClientOptions(options, acceptedCommands = ['connect', 'bind', 'associate']) {
// Check SOCKs command option.
if (!constants_1.SocksCommand[options.command]) {
throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksCommand, options);
}
// Check SocksCommand for acceptable command.
if (acceptedCommands.indexOf(options.command) === -1) {
throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksCommandForOperation, options);
}
// Check destination
if (!isValidSocksRemoteHost(options.destination)) {
throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksClientOptionsDestination, options);
}
// Check SOCKS proxy to use
if (!isValidSocksProxy(options.proxy)) {
throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksClientOptionsProxy, options);
}
// Validate custom auth (if set)
validateCustomProxyAuth(options.proxy, options);
// Check timeout
if (options.timeout && !isValidTimeoutValue(options.timeout)) {
throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksClientOptionsTimeout, options);
}
// Check existing_socket (if provided)
if (options.existing_socket &&
!(options.existing_socket instanceof stream.Duplex)) {
throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksClientOptionsExistingSocket, options);
}
}
exports.validateSocksClientOptions = validateSocksClientOptions;
/**
* Validates the SocksClientChainOptions
* @param options { SocksClientChainOptions }
*/
function validateSocksClientChainOptions(options) {
// Only connect is supported when chaining.
if (options.command !== 'connect') {
throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksCommandChain, options);
}
// Check destination
if (!isValidSocksRemoteHost(options.destination)) {
throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksClientOptionsDestination, options);
}
// Validate proxies (length)
if (!(options.proxies &&
Array.isArray(options.proxies) &&
options.proxies.length >= 2)) {
throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksClientOptionsProxiesLength, options);
}
// Validate proxies
options.proxies.forEach((proxy) => {
if (!isValidSocksProxy(proxy)) {
throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksClientOptionsProxy, options);
}
// Validate custom auth (if set)
validateCustomProxyAuth(proxy, options);
});
// Check timeout
if (options.timeout && !isValidTimeoutValue(options.timeout)) {
throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksClientOptionsTimeout, options);
}
}
exports.validateSocksClientChainOptions = validateSocksClientChainOptions;
function validateCustomProxyAuth(proxy, options) {
if (proxy.custom_auth_method !== undefined) {
// Invalid auth method range
if (proxy.custom_auth_method < constants_1.SOCKS5_CUSTOM_AUTH_START ||
proxy.custom_auth_method > constants_1.SOCKS5_CUSTOM_AUTH_END) {
throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksClientOptionsCustomAuthRange, options);
}
// Missing custom_auth_request_handler
if (proxy.custom_auth_request_handler === undefined ||
typeof proxy.custom_auth_request_handler !== 'function') {
throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksClientOptionsCustomAuthOptions, options);
}
// Missing custom_auth_response_size
if (proxy.custom_auth_response_size === undefined) {
throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksClientOptionsCustomAuthOptions, options);
}
// Missing/invalid custom_auth_response_handler
if (proxy.custom_auth_response_handler === undefined ||
typeof proxy.custom_auth_response_handler !== 'function') {
throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksClientOptionsCustomAuthOptions, options);
}
}
}
/**
* Validates a SocksRemoteHost
* @param remoteHost { SocksRemoteHost }
*/
function isValidSocksRemoteHost(remoteHost) {
return (remoteHost &&
typeof remoteHost.host === 'string' &&
typeof remoteHost.port === 'number' &&
remoteHost.port >= 0 &&
remoteHost.port <= 65535);
}
/**
* Validates a SocksProxy
* @param proxy { SocksProxy }
*/
function isValidSocksProxy(proxy) {
return (proxy &&
(typeof proxy.host === 'string' || typeof proxy.ipaddress === 'string') &&
typeof proxy.port === 'number' &&
proxy.port >= 0 &&
proxy.port <= 65535 &&
(proxy.type === 4 || proxy.type === 5));
}
/**
* Validates a timeout value.
* @param value { Number }
*/
function isValidTimeoutValue(value) {
return typeof value === 'number' && value > 0;
}
//# sourceMappingURL=helpers.js.map
``` | /content/code_sandbox/node_modules/socks/build/common/helpers.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 1,220 |
```javascript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.ReceiveBuffer = void 0;
class ReceiveBuffer {
constructor(size = 4096) {
this.buffer = Buffer.allocUnsafe(size);
this.offset = 0;
this.originalSize = size;
}
get length() {
return this.offset;
}
append(data) {
if (!Buffer.isBuffer(data)) {
throw new Error('Attempted to append a non-buffer instance to ReceiveBuffer.');
}
if (this.offset + data.length >= this.buffer.length) {
const tmp = this.buffer;
this.buffer = Buffer.allocUnsafe(Math.max(this.buffer.length + this.originalSize, this.buffer.length + data.length));
tmp.copy(this.buffer);
}
data.copy(this.buffer, this.offset);
return (this.offset += data.length);
}
peek(length) {
if (length > this.offset) {
throw new Error('Attempted to read beyond the bounds of the managed internal data.');
}
return this.buffer.slice(0, length);
}
get(length) {
if (length > this.offset) {
throw new Error('Attempted to read beyond the bounds of the managed internal data.');
}
const value = Buffer.allocUnsafe(length);
this.buffer.slice(0, length).copy(value);
this.buffer.copyWithin(0, length, length + this.offset - length);
this.offset -= length;
return value;
}
}
exports.ReceiveBuffer = ReceiveBuffer;
//# sourceMappingURL=receivebuffer.js.map
``` | /content/code_sandbox/node_modules/socks/build/common/receivebuffer.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 325 |
```javascript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.shuffleArray = exports.SocksClientError = void 0;
/**
* Error wrapper for SocksClient
*/
class SocksClientError extends Error {
constructor(message, options) {
super(message);
this.options = options;
}
}
exports.SocksClientError = SocksClientError;
/**
* Shuffles a given array.
* @param array The array to shuffle.
*/
function shuffleArray(array) {
// tslint:disable-next-line:no-increment-decrement
for (let i = array.length - 1; i > 0; i--) {
const j = Math.floor(Math.random() * (i + 1));
[array[i], array[j]] = [array[j], array[i]];
}
}
exports.shuffleArray = shuffleArray;
//# sourceMappingURL=util.js.map
``` | /content/code_sandbox/node_modules/socks/build/common/util.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 183 |
```javascript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.SOCKS5_NO_ACCEPTABLE_AUTH = exports.SOCKS5_CUSTOM_AUTH_END = exports.SOCKS5_CUSTOM_AUTH_START = exports.SOCKS_INCOMING_PACKET_SIZES = exports.SocksClientState = exports.Socks5Response = exports.Socks5HostType = exports.Socks5Auth = exports.Socks4Response = exports.SocksCommand = exports.ERRORS = exports.DEFAULT_TIMEOUT = void 0;
const DEFAULT_TIMEOUT = 30000;
exports.DEFAULT_TIMEOUT = DEFAULT_TIMEOUT;
// prettier-ignore
const ERRORS = {
InvalidSocksCommand: 'An invalid SOCKS command was provided. Valid options are connect, bind, and associate.',
InvalidSocksCommandForOperation: 'An invalid SOCKS command was provided. Only a subset of commands are supported for this operation.',
InvalidSocksCommandChain: 'An invalid SOCKS command was provided. Chaining currently only supports the connect command.',
InvalidSocksClientOptionsDestination: 'An invalid destination host was provided.',
InvalidSocksClientOptionsExistingSocket: 'An invalid existing socket was provided. This should be an instance of stream.Duplex.',
InvalidSocksClientOptionsProxy: 'Invalid SOCKS proxy details were provided.',
InvalidSocksClientOptionsTimeout: 'An invalid timeout value was provided. Please enter a value above 0 (in ms).',
InvalidSocksClientOptionsProxiesLength: 'At least two socks proxies must be provided for chaining.',
InvalidSocksClientOptionsCustomAuthRange: 'Custom auth must be a value between 0x80 and 0xFE.',
InvalidSocksClientOptionsCustomAuthOptions: 'When a custom_auth_method is provided, custom_auth_request_handler, custom_auth_response_size, and custom_auth_response_handler must also be provided and valid.',
NegotiationError: 'Negotiation error',
SocketClosed: 'Socket closed',
ProxyConnectionTimedOut: 'Proxy connection timed out',
InternalError: 'SocksClient internal error (this should not happen)',
InvalidSocks4HandshakeResponse: 'Received invalid Socks4 handshake response',
Socks4ProxyRejectedConnection: 'Socks4 Proxy rejected connection',
InvalidSocks4IncomingConnectionResponse: 'Socks4 invalid incoming connection response',
Socks4ProxyRejectedIncomingBoundConnection: 'Socks4 Proxy rejected incoming bound connection',
InvalidSocks5InitialHandshakeResponse: 'Received invalid Socks5 initial handshake response',
InvalidSocks5IntiailHandshakeSocksVersion: 'Received invalid Socks5 initial handshake (invalid socks version)',
InvalidSocks5InitialHandshakeNoAcceptedAuthType: 'Received invalid Socks5 initial handshake (no accepted authentication type)',
InvalidSocks5InitialHandshakeUnknownAuthType: 'Received invalid Socks5 initial handshake (unknown authentication type)',
Socks5AuthenticationFailed: 'Socks5 Authentication failed',
InvalidSocks5FinalHandshake: 'Received invalid Socks5 final handshake response',
InvalidSocks5FinalHandshakeRejected: 'Socks5 proxy rejected connection',
InvalidSocks5IncomingConnectionResponse: 'Received invalid Socks5 incoming connection response',
Socks5ProxyRejectedIncomingBoundConnection: 'Socks5 Proxy rejected incoming bound connection',
};
exports.ERRORS = ERRORS;
const SOCKS_INCOMING_PACKET_SIZES = {
Socks5InitialHandshakeResponse: 2,
Socks5UserPassAuthenticationResponse: 2,
// Command response + incoming connection (bind)
Socks5ResponseHeader: 5,
Socks5ResponseIPv4: 10,
Socks5ResponseIPv6: 22,
Socks5ResponseHostname: (hostNameLength) => hostNameLength + 7,
// Command response + incoming connection (bind)
Socks4Response: 8, // 2 header + 2 port + 4 ip
};
exports.SOCKS_INCOMING_PACKET_SIZES = SOCKS_INCOMING_PACKET_SIZES;
var SocksCommand;
(function (SocksCommand) {
SocksCommand[SocksCommand["connect"] = 1] = "connect";
SocksCommand[SocksCommand["bind"] = 2] = "bind";
SocksCommand[SocksCommand["associate"] = 3] = "associate";
})(SocksCommand || (SocksCommand = {}));
exports.SocksCommand = SocksCommand;
var Socks4Response;
(function (Socks4Response) {
Socks4Response[Socks4Response["Granted"] = 90] = "Granted";
Socks4Response[Socks4Response["Failed"] = 91] = "Failed";
Socks4Response[Socks4Response["Rejected"] = 92] = "Rejected";
Socks4Response[Socks4Response["RejectedIdent"] = 93] = "RejectedIdent";
})(Socks4Response || (Socks4Response = {}));
exports.Socks4Response = Socks4Response;
var Socks5Auth;
(function (Socks5Auth) {
Socks5Auth[Socks5Auth["NoAuth"] = 0] = "NoAuth";
Socks5Auth[Socks5Auth["GSSApi"] = 1] = "GSSApi";
Socks5Auth[Socks5Auth["UserPass"] = 2] = "UserPass";
})(Socks5Auth || (Socks5Auth = {}));
exports.Socks5Auth = Socks5Auth;
const SOCKS5_CUSTOM_AUTH_START = 0x80;
exports.SOCKS5_CUSTOM_AUTH_START = SOCKS5_CUSTOM_AUTH_START;
const SOCKS5_CUSTOM_AUTH_END = 0xfe;
exports.SOCKS5_CUSTOM_AUTH_END = SOCKS5_CUSTOM_AUTH_END;
const SOCKS5_NO_ACCEPTABLE_AUTH = 0xff;
exports.SOCKS5_NO_ACCEPTABLE_AUTH = SOCKS5_NO_ACCEPTABLE_AUTH;
var Socks5Response;
(function (Socks5Response) {
Socks5Response[Socks5Response["Granted"] = 0] = "Granted";
Socks5Response[Socks5Response["Failure"] = 1] = "Failure";
Socks5Response[Socks5Response["NotAllowed"] = 2] = "NotAllowed";
Socks5Response[Socks5Response["NetworkUnreachable"] = 3] = "NetworkUnreachable";
Socks5Response[Socks5Response["HostUnreachable"] = 4] = "HostUnreachable";
Socks5Response[Socks5Response["ConnectionRefused"] = 5] = "ConnectionRefused";
Socks5Response[Socks5Response["TTLExpired"] = 6] = "TTLExpired";
Socks5Response[Socks5Response["CommandNotSupported"] = 7] = "CommandNotSupported";
Socks5Response[Socks5Response["AddressNotSupported"] = 8] = "AddressNotSupported";
})(Socks5Response || (Socks5Response = {}));
exports.Socks5Response = Socks5Response;
var Socks5HostType;
(function (Socks5HostType) {
Socks5HostType[Socks5HostType["IPv4"] = 1] = "IPv4";
Socks5HostType[Socks5HostType["Hostname"] = 3] = "Hostname";
Socks5HostType[Socks5HostType["IPv6"] = 4] = "IPv6";
})(Socks5HostType || (Socks5HostType = {}));
exports.Socks5HostType = Socks5HostType;
var SocksClientState;
(function (SocksClientState) {
SocksClientState[SocksClientState["Created"] = 0] = "Created";
SocksClientState[SocksClientState["Connecting"] = 1] = "Connecting";
SocksClientState[SocksClientState["Connected"] = 2] = "Connected";
SocksClientState[SocksClientState["SentInitialHandshake"] = 3] = "SentInitialHandshake";
SocksClientState[SocksClientState["ReceivedInitialHandshakeResponse"] = 4] = "ReceivedInitialHandshakeResponse";
SocksClientState[SocksClientState["SentAuthentication"] = 5] = "SentAuthentication";
SocksClientState[SocksClientState["ReceivedAuthenticationResponse"] = 6] = "ReceivedAuthenticationResponse";
SocksClientState[SocksClientState["SentFinalHandshake"] = 7] = "SentFinalHandshake";
SocksClientState[SocksClientState["ReceivedFinalResponse"] = 8] = "ReceivedFinalResponse";
SocksClientState[SocksClientState["BoundWaitingForConnection"] = 9] = "BoundWaitingForConnection";
SocksClientState[SocksClientState["Established"] = 10] = "Established";
SocksClientState[SocksClientState["Disconnected"] = 11] = "Disconnected";
SocksClientState[SocksClientState["Error"] = 99] = "Error";
})(SocksClientState || (SocksClientState = {}));
exports.SocksClientState = SocksClientState;
//# sourceMappingURL=constants.js.map
``` | /content/code_sandbox/node_modules/socks/build/common/constants.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 1,942 |
```javascript
"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.SocksClientError = exports.SocksClient = void 0;
const events_1 = require("events");
const net = require("net");
const ip = require("ip");
const smart_buffer_1 = require("smart-buffer");
const constants_1 = require("../common/constants");
const helpers_1 = require("../common/helpers");
const receivebuffer_1 = require("../common/receivebuffer");
const util_1 = require("../common/util");
Object.defineProperty(exports, "SocksClientError", { enumerable: true, get: function () { return util_1.SocksClientError; } });
class SocksClient extends events_1.EventEmitter {
constructor(options) {
super();
this.options = Object.assign({}, options);
// Validate SocksClientOptions
(0, helpers_1.validateSocksClientOptions)(options);
// Default state
this.setState(constants_1.SocksClientState.Created);
}
/**
* Creates a new SOCKS connection.
*
* Note: Supports callbacks and promises. Only supports the connect command.
* @param options { SocksClientOptions } Options.
* @param callback { Function } An optional callback function.
* @returns { Promise }
*/
static createConnection(options, callback) {
return new Promise((resolve, reject) => {
// Validate SocksClientOptions
try {
(0, helpers_1.validateSocksClientOptions)(options, ['connect']);
}
catch (err) {
if (typeof callback === 'function') {
callback(err);
return resolve(err); // Resolves pending promise (prevents memory leaks).
}
else {
return reject(err);
}
}
const client = new SocksClient(options);
client.connect(options.existing_socket);
client.once('established', (info) => {
client.removeAllListeners();
if (typeof callback === 'function') {
callback(null, info);
resolve(info); // Resolves pending promise (prevents memory leaks).
}
else {
resolve(info);
}
});
// Error occurred, failed to establish connection.
client.once('error', (err) => {
client.removeAllListeners();
if (typeof callback === 'function') {
callback(err);
resolve(err); // Resolves pending promise (prevents memory leaks).
}
else {
reject(err);
}
});
});
}
/**
* Creates a new SOCKS connection chain to a destination host through 2 or more SOCKS proxies.
*
* Note: Supports callbacks and promises. Only supports the connect method.
* Note: Implemented via createConnection() factory function.
* @param options { SocksClientChainOptions } Options
* @param callback { Function } An optional callback function.
* @returns { Promise }
*/
static createConnectionChain(options, callback) {
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
// Validate SocksClientChainOptions
try {
(0, helpers_1.validateSocksClientChainOptions)(options);
}
catch (err) {
if (typeof callback === 'function') {
callback(err);
return resolve(err); // Resolves pending promise (prevents memory leaks).
}
else {
return reject(err);
}
}
let sock;
// Shuffle proxies
if (options.randomizeChain) {
(0, util_1.shuffleArray)(options.proxies);
}
try {
// tslint:disable-next-line:no-increment-decrement
for (let i = 0; i < options.proxies.length; i++) {
const nextProxy = options.proxies[i];
// If we've reached the last proxy in the chain, the destination is the actual destination, otherwise it's the next proxy.
const nextDestination = i === options.proxies.length - 1
? options.destination
: {
host: options.proxies[i + 1].host ||
options.proxies[i + 1].ipaddress,
port: options.proxies[i + 1].port,
};
// Creates the next connection in the chain.
const result = yield SocksClient.createConnection({
command: 'connect',
proxy: nextProxy,
destination: nextDestination,
// Initial connection ignores this as sock is undefined. Subsequent connections re-use the first proxy socket to form a chain.
});
// If sock is undefined, assign it here.
if (!sock) {
sock = result.socket;
}
}
if (typeof callback === 'function') {
callback(null, { socket: sock });
resolve({ socket: sock }); // Resolves pending promise (prevents memory leaks).
}
else {
resolve({ socket: sock });
}
}
catch (err) {
if (typeof callback === 'function') {
callback(err);
resolve(err); // Resolves pending promise (prevents memory leaks).
}
else {
reject(err);
}
}
}));
}
/**
* Creates a SOCKS UDP Frame.
* @param options
*/
static createUDPFrame(options) {
const buff = new smart_buffer_1.SmartBuffer();
buff.writeUInt16BE(0);
buff.writeUInt8(options.frameNumber || 0);
// IPv4/IPv6/Hostname
if (net.isIPv4(options.remoteHost.host)) {
buff.writeUInt8(constants_1.Socks5HostType.IPv4);
buff.writeUInt32BE(ip.toLong(options.remoteHost.host));
}
else if (net.isIPv6(options.remoteHost.host)) {
buff.writeUInt8(constants_1.Socks5HostType.IPv6);
buff.writeBuffer(ip.toBuffer(options.remoteHost.host));
}
else {
buff.writeUInt8(constants_1.Socks5HostType.Hostname);
buff.writeUInt8(Buffer.byteLength(options.remoteHost.host));
buff.writeString(options.remoteHost.host);
}
// Port
buff.writeUInt16BE(options.remoteHost.port);
// Data
buff.writeBuffer(options.data);
return buff.toBuffer();
}
/**
* Parses a SOCKS UDP frame.
* @param data
*/
static parseUDPFrame(data) {
const buff = smart_buffer_1.SmartBuffer.fromBuffer(data);
buff.readOffset = 2;
const frameNumber = buff.readUInt8();
const hostType = buff.readUInt8();
let remoteHost;
if (hostType === constants_1.Socks5HostType.IPv4) {
remoteHost = ip.fromLong(buff.readUInt32BE());
}
else if (hostType === constants_1.Socks5HostType.IPv6) {
remoteHost = ip.toString(buff.readBuffer(16));
}
else {
remoteHost = buff.readString(buff.readUInt8());
}
const remotePort = buff.readUInt16BE();
return {
frameNumber,
remoteHost: {
host: remoteHost,
port: remotePort,
},
data: buff.readBuffer(),
};
}
/**
* Internal state setter. If the SocksClient is in an error state, it cannot be changed to a non error state.
*/
setState(newState) {
if (this.state !== constants_1.SocksClientState.Error) {
this.state = newState;
}
}
/**
* Starts the connection establishment to the proxy and destination.
* @param existingSocket Connected socket to use instead of creating a new one (internal use).
*/
connect(existingSocket) {
this.onDataReceived = (data) => this.onDataReceivedHandler(data);
this.onClose = () => this.onCloseHandler();
this.onError = (err) => this.onErrorHandler(err);
this.onConnect = () => this.onConnectHandler();
// Start timeout timer (defaults to 30 seconds)
const timer = setTimeout(() => this.onEstablishedTimeout(), this.options.timeout || constants_1.DEFAULT_TIMEOUT);
// check whether unref is available as it differs from browser to NodeJS (#33)
if (timer.unref && typeof timer.unref === 'function') {
timer.unref();
}
// If an existing socket is provided, use it to negotiate SOCKS handshake. Otherwise create a new Socket.
if (existingSocket) {
this.socket = existingSocket;
}
else {
this.socket = new net.Socket();
}
// Attach Socket error handlers.
this.socket.once('close', this.onClose);
this.socket.once('error', this.onError);
this.socket.once('connect', this.onConnect);
this.socket.on('data', this.onDataReceived);
this.setState(constants_1.SocksClientState.Connecting);
this.receiveBuffer = new receivebuffer_1.ReceiveBuffer();
if (existingSocket) {
this.socket.emit('connect');
}
else {
this.socket.connect(this.getSocketOptions());
if (this.options.set_tcp_nodelay !== undefined &&
this.options.set_tcp_nodelay !== null) {
this.socket.setNoDelay(!!this.options.set_tcp_nodelay);
}
}
// Listen for established event so we can re-emit any excess data received during handshakes.
this.prependOnceListener('established', (info) => {
setImmediate(() => {
if (this.receiveBuffer.length > 0) {
const excessData = this.receiveBuffer.get(this.receiveBuffer.length);
info.socket.emit('data', excessData);
}
info.socket.resume();
});
});
}
// Socket options (defaults host/port to options.proxy.host/options.proxy.port)
getSocketOptions() {
return Object.assign(Object.assign({}, this.options.socket_options), { host: this.options.proxy.host || this.options.proxy.ipaddress, port: this.options.proxy.port });
}
/**
* Handles internal Socks timeout callback.
* Note: If the Socks client is not BoundWaitingForConnection or Established, the connection will be closed.
*/
onEstablishedTimeout() {
if (this.state !== constants_1.SocksClientState.Established &&
this.state !== constants_1.SocksClientState.BoundWaitingForConnection) {
this.closeSocket(constants_1.ERRORS.ProxyConnectionTimedOut);
}
}
/**
* Handles Socket connect event.
*/
onConnectHandler() {
this.setState(constants_1.SocksClientState.Connected);
// Send initial handshake.
if (this.options.proxy.type === 4) {
this.sendSocks4InitialHandshake();
}
else {
this.sendSocks5InitialHandshake();
}
this.setState(constants_1.SocksClientState.SentInitialHandshake);
}
/**
* Handles Socket data event.
* @param data
*/
onDataReceivedHandler(data) {
/*
All received data is appended to a ReceiveBuffer.
This makes sure that all the data we need is received before we attempt to process it.
*/
this.receiveBuffer.append(data);
// Process data that we have.
this.processData();
}
/**
* Handles processing of the data we have received.
*/
processData() {
// If we have enough data to process the next step in the SOCKS handshake, proceed.
while (this.state !== constants_1.SocksClientState.Established &&
this.state !== constants_1.SocksClientState.Error &&
this.receiveBuffer.length >= this.nextRequiredPacketBufferSize) {
// Sent initial handshake, waiting for response.
if (this.state === constants_1.SocksClientState.SentInitialHandshake) {
if (this.options.proxy.type === 4) {
// Socks v4 only has one handshake response.
this.handleSocks4FinalHandshakeResponse();
}
else {
// Socks v5 has two handshakes, handle initial one here.
this.handleInitialSocks5HandshakeResponse();
}
// Sent auth request for Socks v5, waiting for response.
}
else if (this.state === constants_1.SocksClientState.SentAuthentication) {
this.handleInitialSocks5AuthenticationHandshakeResponse();
// Sent final Socks v5 handshake, waiting for final response.
}
else if (this.state === constants_1.SocksClientState.SentFinalHandshake) {
this.handleSocks5FinalHandshakeResponse();
// Socks BIND established. Waiting for remote connection via proxy.
}
else if (this.state === constants_1.SocksClientState.BoundWaitingForConnection) {
if (this.options.proxy.type === 4) {
this.handleSocks4IncomingConnectionResponse();
}
else {
this.handleSocks5IncomingConnectionResponse();
}
}
else {
this.closeSocket(constants_1.ERRORS.InternalError);
break;
}
}
}
/**
* Handles Socket close event.
* @param had_error
*/
onCloseHandler() {
this.closeSocket(constants_1.ERRORS.SocketClosed);
}
/**
* Handles Socket error event.
* @param err
*/
onErrorHandler(err) {
this.closeSocket(err.message);
}
/**
* Removes internal event listeners on the underlying Socket.
*/
removeInternalSocketHandlers() {
// Pauses data flow of the socket (this is internally resumed after 'established' is emitted)
this.socket.pause();
this.socket.removeListener('data', this.onDataReceived);
this.socket.removeListener('close', this.onClose);
this.socket.removeListener('error', this.onError);
this.socket.removeListener('connect', this.onConnect);
}
/**
* Closes and destroys the underlying Socket. Emits an error event.
* @param err { String } An error string to include in error event.
*/
closeSocket(err) {
// Make sure only one 'error' event is fired for the lifetime of this SocksClient instance.
if (this.state !== constants_1.SocksClientState.Error) {
// Set internal state to Error.
this.setState(constants_1.SocksClientState.Error);
// Destroy Socket
this.socket.destroy();
// Remove internal listeners
this.removeInternalSocketHandlers();
// Fire 'error' event.
this.emit('error', new util_1.SocksClientError(err, this.options));
}
}
/**
* Sends initial Socks v4 handshake request.
*/
sendSocks4InitialHandshake() {
const userId = this.options.proxy.userId || '';
const buff = new smart_buffer_1.SmartBuffer();
buff.writeUInt8(0x04);
buff.writeUInt8(constants_1.SocksCommand[this.options.command]);
buff.writeUInt16BE(this.options.destination.port);
// Socks 4 (IPv4)
if (net.isIPv4(this.options.destination.host)) {
buff.writeBuffer(ip.toBuffer(this.options.destination.host));
buff.writeStringNT(userId);
// Socks 4a (hostname)
}
else {
buff.writeUInt8(0x00);
buff.writeUInt8(0x00);
buff.writeUInt8(0x00);
buff.writeUInt8(0x01);
buff.writeStringNT(userId);
buff.writeStringNT(this.options.destination.host);
}
this.nextRequiredPacketBufferSize =
constants_1.SOCKS_INCOMING_PACKET_SIZES.Socks4Response;
this.socket.write(buff.toBuffer());
}
/**
* Handles Socks v4 handshake response.
* @param data
*/
handleSocks4FinalHandshakeResponse() {
const data = this.receiveBuffer.get(8);
if (data[1] !== constants_1.Socks4Response.Granted) {
this.closeSocket(`${constants_1.ERRORS.Socks4ProxyRejectedConnection} - (${constants_1.Socks4Response[data[1]]})`);
}
else {
// Bind response
if (constants_1.SocksCommand[this.options.command] === constants_1.SocksCommand.bind) {
const buff = smart_buffer_1.SmartBuffer.fromBuffer(data);
buff.readOffset = 2;
const remoteHost = {
port: buff.readUInt16BE(),
host: ip.fromLong(buff.readUInt32BE()),
};
// If host is 0.0.0.0, set to proxy host.
if (remoteHost.host === '0.0.0.0') {
remoteHost.host = this.options.proxy.ipaddress;
}
this.setState(constants_1.SocksClientState.BoundWaitingForConnection);
this.emit('bound', { remoteHost, socket: this.socket });
// Connect response
}
else {
this.setState(constants_1.SocksClientState.Established);
this.removeInternalSocketHandlers();
this.emit('established', { socket: this.socket });
}
}
}
/**
* Handles Socks v4 incoming connection request (BIND)
* @param data
*/
handleSocks4IncomingConnectionResponse() {
const data = this.receiveBuffer.get(8);
if (data[1] !== constants_1.Socks4Response.Granted) {
this.closeSocket(`${constants_1.ERRORS.Socks4ProxyRejectedIncomingBoundConnection} - (${constants_1.Socks4Response[data[1]]})`);
}
else {
const buff = smart_buffer_1.SmartBuffer.fromBuffer(data);
buff.readOffset = 2;
const remoteHost = {
port: buff.readUInt16BE(),
host: ip.fromLong(buff.readUInt32BE()),
};
this.setState(constants_1.SocksClientState.Established);
this.removeInternalSocketHandlers();
this.emit('established', { remoteHost, socket: this.socket });
}
}
/**
* Sends initial Socks v5 handshake request.
*/
sendSocks5InitialHandshake() {
const buff = new smart_buffer_1.SmartBuffer();
// By default we always support no auth.
const supportedAuthMethods = [constants_1.Socks5Auth.NoAuth];
// We should only tell the proxy we support user/pass auth if auth info is actually provided.
// Note: As of Tor v0.3.5.7+, if user/pass auth is an option from the client, by default it will always take priority.
if (this.options.proxy.userId || this.options.proxy.password) {
supportedAuthMethods.push(constants_1.Socks5Auth.UserPass);
}
// Custom auth method?
if (this.options.proxy.custom_auth_method !== undefined) {
supportedAuthMethods.push(this.options.proxy.custom_auth_method);
}
// Build handshake packet
buff.writeUInt8(0x05);
buff.writeUInt8(supportedAuthMethods.length);
for (const authMethod of supportedAuthMethods) {
buff.writeUInt8(authMethod);
}
this.nextRequiredPacketBufferSize =
constants_1.SOCKS_INCOMING_PACKET_SIZES.Socks5InitialHandshakeResponse;
this.socket.write(buff.toBuffer());
this.setState(constants_1.SocksClientState.SentInitialHandshake);
}
/**
* Handles initial Socks v5 handshake response.
* @param data
*/
handleInitialSocks5HandshakeResponse() {
const data = this.receiveBuffer.get(2);
if (data[0] !== 0x05) {
this.closeSocket(constants_1.ERRORS.InvalidSocks5IntiailHandshakeSocksVersion);
}
else if (data[1] === constants_1.SOCKS5_NO_ACCEPTABLE_AUTH) {
this.closeSocket(constants_1.ERRORS.InvalidSocks5InitialHandshakeNoAcceptedAuthType);
}
else {
// If selected Socks v5 auth method is no auth, send final handshake request.
if (data[1] === constants_1.Socks5Auth.NoAuth) {
this.socks5ChosenAuthType = constants_1.Socks5Auth.NoAuth;
this.sendSocks5CommandRequest();
// If selected Socks v5 auth method is user/password, send auth handshake.
}
else if (data[1] === constants_1.Socks5Auth.UserPass) {
this.socks5ChosenAuthType = constants_1.Socks5Auth.UserPass;
this.sendSocks5UserPassAuthentication();
// If selected Socks v5 auth method is the custom_auth_method, send custom handshake.
}
else if (data[1] === this.options.proxy.custom_auth_method) {
this.socks5ChosenAuthType = this.options.proxy.custom_auth_method;
this.sendSocks5CustomAuthentication();
}
else {
this.closeSocket(constants_1.ERRORS.InvalidSocks5InitialHandshakeUnknownAuthType);
}
}
}
/**
* Sends Socks v5 user & password auth handshake.
*
* Note: No auth and user/pass are currently supported.
*/
sendSocks5UserPassAuthentication() {
const userId = this.options.proxy.userId || '';
const password = this.options.proxy.password || '';
const buff = new smart_buffer_1.SmartBuffer();
buff.writeUInt8(0x01);
buff.writeUInt8(Buffer.byteLength(userId));
buff.writeString(userId);
buff.writeUInt8(Buffer.byteLength(password));
buff.writeString(password);
this.nextRequiredPacketBufferSize =
constants_1.SOCKS_INCOMING_PACKET_SIZES.Socks5UserPassAuthenticationResponse;
this.socket.write(buff.toBuffer());
this.setState(constants_1.SocksClientState.SentAuthentication);
}
sendSocks5CustomAuthentication() {
return __awaiter(this, void 0, void 0, function* () {
this.nextRequiredPacketBufferSize =
this.options.proxy.custom_auth_response_size;
this.socket.write(yield this.options.proxy.custom_auth_request_handler());
this.setState(constants_1.SocksClientState.SentAuthentication);
});
}
handleSocks5CustomAuthHandshakeResponse(data) {
return __awaiter(this, void 0, void 0, function* () {
return yield this.options.proxy.custom_auth_response_handler(data);
});
}
handleSocks5AuthenticationNoAuthHandshakeResponse(data) {
return __awaiter(this, void 0, void 0, function* () {
return data[1] === 0x00;
});
}
handleSocks5AuthenticationUserPassHandshakeResponse(data) {
return __awaiter(this, void 0, void 0, function* () {
return data[1] === 0x00;
});
}
/**
* Handles Socks v5 auth handshake response.
* @param data
*/
handleInitialSocks5AuthenticationHandshakeResponse() {
return __awaiter(this, void 0, void 0, function* () {
this.setState(constants_1.SocksClientState.ReceivedAuthenticationResponse);
let authResult = false;
if (this.socks5ChosenAuthType === constants_1.Socks5Auth.NoAuth) {
authResult = yield this.handleSocks5AuthenticationNoAuthHandshakeResponse(this.receiveBuffer.get(2));
}
else if (this.socks5ChosenAuthType === constants_1.Socks5Auth.UserPass) {
authResult =
yield this.handleSocks5AuthenticationUserPassHandshakeResponse(this.receiveBuffer.get(2));
}
else if (this.socks5ChosenAuthType === this.options.proxy.custom_auth_method) {
authResult = yield this.handleSocks5CustomAuthHandshakeResponse(this.receiveBuffer.get(this.options.proxy.custom_auth_response_size));
}
if (!authResult) {
this.closeSocket(constants_1.ERRORS.Socks5AuthenticationFailed);
}
else {
this.sendSocks5CommandRequest();
}
});
}
/**
* Sends Socks v5 final handshake request.
*/
sendSocks5CommandRequest() {
const buff = new smart_buffer_1.SmartBuffer();
buff.writeUInt8(0x05);
buff.writeUInt8(constants_1.SocksCommand[this.options.command]);
buff.writeUInt8(0x00);
// ipv4, ipv6, domain?
if (net.isIPv4(this.options.destination.host)) {
buff.writeUInt8(constants_1.Socks5HostType.IPv4);
buff.writeBuffer(ip.toBuffer(this.options.destination.host));
}
else if (net.isIPv6(this.options.destination.host)) {
buff.writeUInt8(constants_1.Socks5HostType.IPv6);
buff.writeBuffer(ip.toBuffer(this.options.destination.host));
}
else {
buff.writeUInt8(constants_1.Socks5HostType.Hostname);
buff.writeUInt8(this.options.destination.host.length);
buff.writeString(this.options.destination.host);
}
buff.writeUInt16BE(this.options.destination.port);
this.nextRequiredPacketBufferSize =
constants_1.SOCKS_INCOMING_PACKET_SIZES.Socks5ResponseHeader;
this.socket.write(buff.toBuffer());
this.setState(constants_1.SocksClientState.SentFinalHandshake);
}
/**
* Handles Socks v5 final handshake response.
* @param data
*/
handleSocks5FinalHandshakeResponse() {
// Peek at available data (we need at least 5 bytes to get the hostname length)
const header = this.receiveBuffer.peek(5);
if (header[0] !== 0x05 || header[1] !== constants_1.Socks5Response.Granted) {
this.closeSocket(`${constants_1.ERRORS.InvalidSocks5FinalHandshakeRejected} - ${constants_1.Socks5Response[header[1]]}`);
}
else {
// Read address type
const addressType = header[3];
let remoteHost;
let buff;
// IPv4
if (addressType === constants_1.Socks5HostType.IPv4) {
// Check if data is available.
const dataNeeded = constants_1.SOCKS_INCOMING_PACKET_SIZES.Socks5ResponseIPv4;
if (this.receiveBuffer.length < dataNeeded) {
this.nextRequiredPacketBufferSize = dataNeeded;
return;
}
buff = smart_buffer_1.SmartBuffer.fromBuffer(this.receiveBuffer.get(dataNeeded).slice(4));
remoteHost = {
host: ip.fromLong(buff.readUInt32BE()),
port: buff.readUInt16BE(),
};
// If given host is 0.0.0.0, assume remote proxy ip instead.
if (remoteHost.host === '0.0.0.0') {
remoteHost.host = this.options.proxy.ipaddress;
}
// Hostname
}
else if (addressType === constants_1.Socks5HostType.Hostname) {
const hostLength = header[4];
const dataNeeded = constants_1.SOCKS_INCOMING_PACKET_SIZES.Socks5ResponseHostname(hostLength); // header + host length + host + port
// Check if data is available.
if (this.receiveBuffer.length < dataNeeded) {
this.nextRequiredPacketBufferSize = dataNeeded;
return;
}
buff = smart_buffer_1.SmartBuffer.fromBuffer(this.receiveBuffer.get(dataNeeded).slice(5));
remoteHost = {
host: buff.readString(hostLength),
port: buff.readUInt16BE(),
};
// IPv6
}
else if (addressType === constants_1.Socks5HostType.IPv6) {
// Check if data is available.
const dataNeeded = constants_1.SOCKS_INCOMING_PACKET_SIZES.Socks5ResponseIPv6;
if (this.receiveBuffer.length < dataNeeded) {
this.nextRequiredPacketBufferSize = dataNeeded;
return;
}
buff = smart_buffer_1.SmartBuffer.fromBuffer(this.receiveBuffer.get(dataNeeded).slice(4));
remoteHost = {
host: ip.toString(buff.readBuffer(16)),
port: buff.readUInt16BE(),
};
}
// We have everything we need
this.setState(constants_1.SocksClientState.ReceivedFinalResponse);
// If using CONNECT, the client is now in the established state.
if (constants_1.SocksCommand[this.options.command] === constants_1.SocksCommand.connect) {
this.setState(constants_1.SocksClientState.Established);
this.removeInternalSocketHandlers();
this.emit('established', { remoteHost, socket: this.socket });
}
else if (constants_1.SocksCommand[this.options.command] === constants_1.SocksCommand.bind) {
/* If using BIND, the Socks client is now in BoundWaitingForConnection state.
This means that the remote proxy server is waiting for a remote connection to the bound port. */
this.setState(constants_1.SocksClientState.BoundWaitingForConnection);
this.nextRequiredPacketBufferSize =
constants_1.SOCKS_INCOMING_PACKET_SIZES.Socks5ResponseHeader;
this.emit('bound', { remoteHost, socket: this.socket });
/*
If using Associate, the Socks client is now Established. And the proxy server is now accepting UDP packets at the
given bound port. This initial Socks TCP connection must remain open for the UDP relay to continue to work.
*/
}
else if (constants_1.SocksCommand[this.options.command] === constants_1.SocksCommand.associate) {
this.setState(constants_1.SocksClientState.Established);
this.removeInternalSocketHandlers();
this.emit('established', {
remoteHost,
socket: this.socket,
});
}
}
}
/**
* Handles Socks v5 incoming connection request (BIND).
*/
handleSocks5IncomingConnectionResponse() {
// Peek at available data (we need at least 5 bytes to get the hostname length)
const header = this.receiveBuffer.peek(5);
if (header[0] !== 0x05 || header[1] !== constants_1.Socks5Response.Granted) {
this.closeSocket(`${constants_1.ERRORS.Socks5ProxyRejectedIncomingBoundConnection} - ${constants_1.Socks5Response[header[1]]}`);
}
else {
// Read address type
const addressType = header[3];
let remoteHost;
let buff;
// IPv4
if (addressType === constants_1.Socks5HostType.IPv4) {
// Check if data is available.
const dataNeeded = constants_1.SOCKS_INCOMING_PACKET_SIZES.Socks5ResponseIPv4;
if (this.receiveBuffer.length < dataNeeded) {
this.nextRequiredPacketBufferSize = dataNeeded;
return;
}
buff = smart_buffer_1.SmartBuffer.fromBuffer(this.receiveBuffer.get(dataNeeded).slice(4));
remoteHost = {
host: ip.fromLong(buff.readUInt32BE()),
port: buff.readUInt16BE(),
};
// If given host is 0.0.0.0, assume remote proxy ip instead.
if (remoteHost.host === '0.0.0.0') {
remoteHost.host = this.options.proxy.ipaddress;
}
// Hostname
}
else if (addressType === constants_1.Socks5HostType.Hostname) {
const hostLength = header[4];
const dataNeeded = constants_1.SOCKS_INCOMING_PACKET_SIZES.Socks5ResponseHostname(hostLength); // header + host length + port
// Check if data is available.
if (this.receiveBuffer.length < dataNeeded) {
this.nextRequiredPacketBufferSize = dataNeeded;
return;
}
buff = smart_buffer_1.SmartBuffer.fromBuffer(this.receiveBuffer.get(dataNeeded).slice(5));
remoteHost = {
host: buff.readString(hostLength),
port: buff.readUInt16BE(),
};
// IPv6
}
else if (addressType === constants_1.Socks5HostType.IPv6) {
// Check if data is available.
const dataNeeded = constants_1.SOCKS_INCOMING_PACKET_SIZES.Socks5ResponseIPv6;
if (this.receiveBuffer.length < dataNeeded) {
this.nextRequiredPacketBufferSize = dataNeeded;
return;
}
buff = smart_buffer_1.SmartBuffer.fromBuffer(this.receiveBuffer.get(dataNeeded).slice(4));
remoteHost = {
host: ip.toString(buff.readBuffer(16)),
port: buff.readUInt16BE(),
};
}
this.setState(constants_1.SocksClientState.Established);
this.removeInternalSocketHandlers();
this.emit('established', { remoteHost, socket: this.socket });
}
}
get socksClientOptions() {
return Object.assign({}, this.options);
}
}
exports.SocksClient = SocksClient;
//# sourceMappingURL=socksclient.js.map
``` | /content/code_sandbox/node_modules/socks/build/client/socksclient.js | javascript | 2016-03-11T09:28:00 | 2024-08-16T17:55:54 | antSword | AntSwordProject/antSword | 3,579 | 7,227 |
```cmake
#.rst:
# FindSDL2
# -------
#
# Locate SDL2 library
#
# This module defines
#
# ::
#
# SDL2_LIBRARY, the name of the library to link against
# SDL2_FOUND, if false, do not try to link to SDL
# SDL2_INCLUDE_DIR, where to find SDL.h
# SDL2_VERSION_STRING, human-readable string containing the version of SDL
#
#
#
# This module responds to the flag:
#
# ::
#
# SDL2_BUILDING_LIBRARY
# If this is defined, then no SDL2_main will be linked in because
# only applications need main().
# Otherwise, it is assumed you are building an application and this
# module will attempt to locate and set the proper link flags
# as part of the returned SDL2_LIBRARY variable.
#
#
#
# Don't forget to include SDLmain.h and SDLmain.m your project for the
# OS X framework based version. (Other versions link to -lSDLmain which
# this module will try to find on your behalf.) Also for OS X, this
# module will automatically add the -framework Cocoa on your behalf.
#
#
#
# Additional Note: If you see an empty SDL2_LIBRARY_TEMP in your
# configuration and no SDL2_LIBRARY, it means CMake did not find your SDL
# library (SDL.dll, libsdl.so, SDL.framework, etc). Set
# SDL2_LIBRARY_TEMP to point to your SDL library, and configure again.
# Similarly, if you see an empty SDLMAIN_LIBRARY, you should set this
# value as appropriate. These values are used to generate the final
# SDL2_LIBRARY variable, but when these values are unset, SDL2_LIBRARY
# does not get created.
#
#
#
# $SDL2DIR is an environment variable that would correspond to the
# ./configure --prefix=$SDL2DIR used in building SDL. l.e.galup 9-20-02
#
# Modified by Eric Wing. Added code to assist with automated building
# by using environmental variables and providing a more
# controlled/consistent search behavior. Added new modifications to
# recognize OS X frameworks and additional Unix paths (FreeBSD, etc).
# Also corrected the header search path to follow "proper" SDL
# guidelines. Added a search for SDLmain which is needed by some
# platforms. Added a search for threads which is needed by some
# platforms. Added needed compile switches for MinGW.
#
# On OSX, this will prefer the Framework version (if found) over others.
# People will have to manually change the cache values of SDL2_LIBRARY to
# override this selection or set the CMake environment
# CMAKE_INCLUDE_PATH to modify the search paths.
#
# Note that the header path has changed from SDL/SDL.h to just SDL.h
# This needed to change because "proper" SDL convention is #include
# "SDL.h", not <SDL/SDL.h>. This is done for portability reasons
# because not all systems place things in SDL/ (see FreeBSD).
if(NOT SDL2_DIR)
set(SDL2_DIR "" CACHE PATH "SDL2 directory")
endif()
# modified to SDL2/ prefix
find_path(SDL2_INCLUDE_DIR SDL2/SDL.h
HINTS
ENV SDL2DIR
${SDL2_DIR}
PATH_SUFFIXES SDL2
# path suffixes to search inside ENV{SDL2DIR}
include/SDL2 include
)
if(CMAKE_SIZEOF_VOID_P EQUAL 8)
set(VC_LIB_PATH_SUFFIX lib/x64)
else()
set(VC_LIB_PATH_SUFFIX lib/x86)
endif()
find_library(SDL2_LIBRARY_TEMP
NAMES SDL2
HINTS
ENV SDL2DIR
${SDL2_DIR}
PATH_SUFFIXES lib ${VC_LIB_PATH_SUFFIX}
)
# Hide this cache variable from the user, it's an internal implementation
# detail. The documented library variable for the user is SDL2_LIBRARY
# which is derived from SDL2_LIBRARY_TEMP further below.
set_property(CACHE SDL2_LIBRARY_TEMP PROPERTY TYPE INTERNAL)
if(NOT SDL2_BUILDING_LIBRARY)
if(NOT SDL2_INCLUDE_DIR MATCHES ".framework")
# Non-OS X framework versions expect you to also dynamically link to
# SDLmain. This is mainly for Windows and OS X. Other (Unix) platforms
# seem to provide SDLmain for compatibility even though they don't
# necessarily need it.
find_library(SDL2MAIN_LIBRARY
NAMES SDL2main
HINTS
ENV SDL2DIR
${SDL2_DIR}
PATH_SUFFIXES lib ${VC_LIB_PATH_SUFFIX}
PATHS
/sw
/opt/local
/opt/csw
/opt
)
endif()
endif()
# SDL may require threads on your system.
# The Apple build may not need an explicit flag because one of the
# frameworks may already provide it.
# But for non-OSX systems, I will use the CMake Threads package.
if(NOT APPLE)
find_package(Threads)
endif()
# MinGW needs an additional link flag, -mwindows
# It's total link flags should look like -lmingw32 -lSDLmain -lSDL -mwindows
if(MINGW)
set(MINGW32_LIBRARY mingw32 "-mwindows" CACHE STRING "link flags for MinGW")
endif()
if(SDL2_LIBRARY_TEMP)
# For SDLmain
if(SDL2MAIN_LIBRARY AND NOT SDL2_BUILDING_LIBRARY)
list(FIND SDL2_LIBRARY_TEMP "${SDLMAIN_LIBRARY}" _SDL2_MAIN_INDEX)
if(_SDL2_MAIN_INDEX EQUAL -1)
set(SDL2_LIBRARY_TEMP "${SDLMAIN_LIBRARY}" ${SDL2_LIBRARY_TEMP})
endif()
unset(_SDL2_MAIN_INDEX)
endif()
# For OS X, SDL uses Cocoa as a backend so it must link to Cocoa.
# CMake doesn't display the -framework Cocoa string in the UI even
# though it actually is there if I modify a pre-used variable.
# I think it has something to do with the CACHE STRING.
# So I use a temporary variable until the end so I can set the
# "real" variable in one-shot.
if(APPLE)
set(SDL2_LIBRARY_TEMP ${SDL2_LIBRARY_TEMP} "-framework Cocoa")
endif()
# For threads, as mentioned Apple doesn't need this.
# In fact, there seems to be a problem if I used the Threads package
# and try using this line, so I'm just skipping it entirely for OS X.
if(NOT APPLE)
set(SDL2_LIBRARY_TEMP ${SDL2_LIBRARY_TEMP} ${CMAKE_THREAD_LIBS_INIT})
endif()
# For MinGW library
if(MINGW)
set(SDL2_LIBRARY_TEMP ${MINGW32_LIBRARY} ${SDL2_LIBRARY_TEMP})
endif()
# Set the final string here so the GUI reflects the final state.
set(SDL2_LIBRARY ${SDL2_LIBRARY_TEMP} CACHE STRING "Where the SDL Library can be found")
endif()
if(SDL2_INCLUDE_DIR AND EXISTS "${SDL2_INCLUDE_DIR}/SDL2_version.h")
file(STRINGS "${SDL2_INCLUDE_DIR}/SDL2_version.h" SDL2_VERSION_MAJOR_LINE REGEX "^#define[ \t]+SDL2_MAJOR_VERSION[ \t]+[0-9]+$")
file(STRINGS "${SDL2_INCLUDE_DIR}/SDL2_version.h" SDL2_VERSION_MINOR_LINE REGEX "^#define[ \t]+SDL2_MINOR_VERSION[ \t]+[0-9]+$")
file(STRINGS "${SDL2_INCLUDE_DIR}/SDL2_version.h" SDL2_VERSION_PATCH_LINE REGEX "^#define[ \t]+SDL2_PATCHLEVEL[ \t]+[0-9]+$")
string(REGEX REPLACE "^#define[ \t]+SDL2_MAJOR_VERSION[ \t]+([0-9]+)$" "\\1" SDL2_VERSION_MAJOR "${SDL2_VERSION_MAJOR_LINE}")
string(REGEX REPLACE "^#define[ \t]+SDL2_MINOR_VERSION[ \t]+([0-9]+)$" "\\1" SDL2_VERSION_MINOR "${SDL2_VERSION_MINOR_LINE}")
string(REGEX REPLACE "^#define[ \t]+SDL2_PATCHLEVEL[ \t]+([0-9]+)$" "\\1" SDL2_VERSION_PATCH "${SDL2_VERSION_PATCH_LINE}")
set(SDL2_VERSION_STRING ${SDL2_VERSION_MAJOR}.${SDL2_VERSION_MINOR}.${SDL2_VERSION_PATCH})
unset(SDL2_VERSION_MAJOR_LINE)
unset(SDL2_VERSION_MINOR_LINE)
unset(SDL2_VERSION_PATCH_LINE)
unset(SDL2_VERSION_MAJOR)
unset(SDL2_VERSION_MINOR)
unset(SDL2_VERSION_PATCH)
endif()
set(SDL2_LIBRARIES ${SDL2_LIBRARY} ${SDL2MAIN_LIBRARY})
set(SDL2_INCLUDE_DIRS ${SDL2_INCLUDE_DIR})
include(FindPackageHandleStandardArgs)
FIND_PACKAGE_HANDLE_STANDARD_ARGS(SDL2
REQUIRED_VARS SDL2_LIBRARY SDL2_INCLUDE_DIR
VERSION_VAR SDL2_VERSION_STRING)
``` | /content/code_sandbox/cmake/FindSDL2.cmake | cmake | 2016-05-24T23:59:31 | 2024-08-11T02:46:48 | antimicro | AntiMicro/antimicro | 1,788 | 1,919 |
```desktop
[Desktop Entry]
Name=AntiMicro
Comment=Use a gamepad to control a variety of programs
Name[sr]=-
Comment[sr]=
Name[fr]=AntiMicro
Comment[fr]=Utilisez une manette de jeu pour commander un logiciel
Name[de]=AntiMicro
Comment[de]=Nutze ein Gamepad, um Programme/Spiele zu steuern
Comment[uk]=
Exec=antimicro %f
Icon=antimicro
StartupNotify=true
Terminal=false
Type=Application
Categories=Qt;Utility;
MimeType=application/x-amgp;
Keywords=game;controller;keyboard;joystick;mouse;
``` | /content/code_sandbox/other/antimicro.desktop | desktop | 2016-05-24T23:59:31 | 2024-08-11T02:46:48 | antimicro | AntiMicro/antimicro | 1,788 | 141 |
```groff
.\" Manpage for antimicro.
.\" Contact jeff@jsbackus to correct errors or typos.
.TH ANTIMICRO "1" "05 November 2016" "antimicro 2.23" "User Commands"
.SH NAME
antimicro \- map keyboard keys and mouse controls to a gamepad
.SH SYNOPSIS
.B antimicro
[\fIOPTION\fR] [\fIPROFILE\fR]
.SH DESCRIPTION
.PP
antimicro is a graphical program used to map keyboard keys and mouse controls to a gamepad. This program is useful for playing PC games using a gamepad that do not have any form of built-in gamepad support. However, you can use this program to control any desktop application with a gamepad.
.TP
\fB\-\-tray\fR
launch program in system tray only
.TP
\fB\-\-no\-tray\fR
launch program with the tray menu disabled
.TP
\fB\-h\fR, \fB\-\-help\fR
display this help and exit
.TP
\fB\-v\fR, \fB\-\-version\fR
output version information and exit
.TP
\fB\-\-profile\fR \fI<location>\fR
use specified profile as default for selected controllers. Defaults to all controllers.
.TP
\fB\-\-profile\-controller\fR \fI<value>\fR
apply configuration file to a specific controller. <value> can be an controller index, name, or GUID.
.TP
\fB\-\-hidden\fR
launch program without the main window
.TP
\fB\-\-unload\fR \fI[<value>]\fR
unload currently enabled profile(s). Value can be a controller index, name, or GUID.
.TP
\fB\-\-startSet\fR \fI<number>\fR \fI[<value>]\fR
start joysticks on a specific set. Value can be a controller index, name, or GUID.
.TP
\fB\-\-next\fR
Advance profile loading set options.
.TP
\fB\-d\fR, \fB\-\-daemon\fR
launch program as a daemon.
.TP
\fB\-\-log\-level\fR \fI{debug,info}\fR
Enable logging.
.TP
\fB\-l\fR, \fB\-\-list\fR
Print information about joysticks detected by SDL.
.TP
\fB\-\-map\fR \fI<value>\fR
Open game controller mapping window of selected controller. Value can be a controller index or GUID.
.TP
\fB\-\-eventgen\fR \fI{xtest,uinput}\fR
Choose between using XTest support and uinput support for event generation. Default: xtest.
.SH BUGS
No known bugs.
.SH AUTHOR
Jeff Backus (jeff@jsbackus.com)
Travis Nickles (nickles.travis@gmail.com)
.SH "REPORTING BUGS"
Report dir bugs to antimicro home page: path_to_url
``` | /content/code_sandbox/other/antimicro.1 | groff | 2016-05-24T23:59:31 | 2024-08-11T02:46:48 | antimicro | AntiMicro/antimicro | 1,788 | 677 |
```batchfile
REM Build script used to compile SDL2. It is mainly a reference for which
REM options need to be used in order to compile.
REM Move to directory that contains the SDL source directory.
REM Just use a static location for now.
cd "C:\Users\Travis\Downloads\SDL2-Source"
REM Make build directory and change cwd to build
mkdir build
cd build
REM Generate Makefile with specific options
cmake -G "MinGW Makefiles" -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX="%TEMP%\SDL2" -DSDL_STATIC=OFF -DVIDEO_OPENGLES=OFF -DRENDER_D3D=OFF ..\SDL2-2.0.4
REM Compile
mingw32-make
mingw32-make install
REM Get out of build directory
cd ..
``` | /content/code_sandbox/other/scripts/build-sdl-lib.bat | batchfile | 2016-05-24T23:59:31 | 2024-08-11T02:46:48 | antimicro | AntiMicro/antimicro | 1,788 | 174 |
```objective-c
/* antimicro Gamepad to KB+M event mapper
*
* This program is free software: you can redistribute it and/or modify
* (at your option) any later version.
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* along with this program. If not, see <path_to_url
*/
#ifndef QTWINKEYMAPPER_H
#define QTWINKEYMAPPER_H
#include <QObject>
#include <QHash>
#include <QChar>
#include "qtkeymapperbase.h"
class QtWinKeyMapper : public QtKeyMapperBase
{
Q_OBJECT
public:
explicit QtWinKeyMapper(QObject *parent = 0);
virtual unsigned int returnQtKey(unsigned int key, unsigned int scancode=0);
protected:
void populateMappingHashes();
void populateCharKeyInformation();
signals:
public slots:
};
#endif // QTWINKEYMAPPER_H
``` | /content/code_sandbox/src/qtwinkeymapper.h | objective-c | 2016-05-24T23:59:31 | 2024-08-11T02:46:48 | antimicro | AntiMicro/antimicro | 1,788 | 215 |
```c++
/* antimicro Gamepad to KB+M event mapper
*
* This program is free software: you can redistribute it and/or modify
* (at your option) any later version.
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* along with this program. If not, see <path_to_url
*/
#include <QPushButton>
#include "unixwindowinfodialog.h"
#include "ui_unixwindowinfodialog.h"
#include "x11info.h"
UnixWindowInfoDialog::UnixWindowInfoDialog(unsigned long window, QWidget *parent) :
QDialog(parent),
ui(new Ui::UnixWindowInfoDialog)
{
ui->setupUi(this);
setAttribute(Qt::WA_DeleteOnClose);
X11Info *info = X11Info::getInstance();
bool setRadioDefault = false;
winClass = info->getWindowClass(window);
ui->winClassLabel->setText(winClass);
if (winClass.isEmpty())
{
ui->winClassCheckBox->setEnabled(false);
ui->winClassCheckBox->setChecked(false);
}
else
{
ui->winClassCheckBox->setChecked(true);
setRadioDefault = true;
}
winName = info->getWindowTitle(window);
ui->winTitleLabel->setText(winName);
if (winName.isEmpty())
{
ui->winTitleCheckBox->setEnabled(false);
ui->winTitleCheckBox->setChecked(false);
}
else if (!setRadioDefault)
{
ui->winTitleCheckBox->setChecked(true);
setRadioDefault = true;
}
ui->winPathLabel->clear();
int pid = info->getApplicationPid(window);
if (pid > 0)
{
QString exepath = X11Info::getInstance()->getApplicationLocation(pid);
if (!exepath.isEmpty())
{
ui->winPathLabel->setText(exepath);
winPath = exepath;
if (!setRadioDefault)
{
ui->winTitleCheckBox->setChecked(true);
setRadioDefault = true;
}
}
else
{
ui->winPathCheckBox->setEnabled(false);
ui->winPathCheckBox->setChecked(false);
}
}
else
{
ui->winPathCheckBox->setEnabled(false);
ui->winPathCheckBox->setChecked(false);
}
if (winClass.isEmpty() && winName.isEmpty() &&
winPath.isEmpty())
{
QPushButton *button = ui->buttonBox->button(QDialogButtonBox::Ok);
button->setEnabled(false);
}
connect(this, SIGNAL(accepted()), this, SLOT(populateOption()));
}
void UnixWindowInfoDialog::populateOption()
{
if (ui->winClassCheckBox->isChecked())
{
selectedMatch = selectedMatch | WindowClass;
}
if (ui->winTitleCheckBox->isChecked())
{
selectedMatch = selectedMatch | WindowName;
}
if (ui->winPathCheckBox->isChecked())
{
selectedMatch = selectedMatch | WindowPath;
}
}
UnixWindowInfoDialog::DialogWindowOption UnixWindowInfoDialog::getSelectedOptions()
{
return selectedMatch;
}
QString UnixWindowInfoDialog::getWindowClass()
{
return winClass;
}
QString UnixWindowInfoDialog::getWindowName()
{
return winName;
}
QString UnixWindowInfoDialog::getWindowPath()
{
return winPath;
}
UnixWindowInfoDialog::~UnixWindowInfoDialog()
{
delete ui;
}
``` | /content/code_sandbox/src/unixwindowinfodialog.cpp | c++ | 2016-05-24T23:59:31 | 2024-08-11T02:46:48 | antimicro | AntiMicro/antimicro | 1,788 | 751 |
```objective-c
/* antimicro Gamepad to KB+M event mapper
*
* This program is free software: you can redistribute it and/or modify
* (at your option) any later version.
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* along with this program. If not, see <path_to_url
*/
#ifndef AXISEDITDIALOG_H
#define AXISEDITDIALOG_H
#include <QDialog>
#include "joyaxis.h"
#include "axisvaluebox.h"
#include "setaxisthrottledialog.h"
namespace Ui {
class AxisEditDialog;
}
class AxisEditDialog : public QDialog
{
Q_OBJECT
public:
explicit AxisEditDialog(JoyAxis *axis, QWidget *parent=0);
~AxisEditDialog();
protected:
void selectAxisCurrentPreset();
void selectTriggerPreset();
void buildTriggerPresetsMenu();
void buildAxisPresetsMenu();
JoyAxis *axis;
SetAxisThrottleDialog *setAxisThrottleConfirm;
int initialThrottleState;
private:
Ui::AxisEditDialog *ui;
private slots:
void implementAxisPresets(int index);
void implementTriggerPresets(int index);
void implementPresets(int index);
void presetForThrottleChange(int index);
void updateDeadZoneBox(int value);
void updateMaxZoneBox(int value);
void updateThrottleUi(int index);
void updateJoyValue(int value);
void updateDeadZoneSlider(QString value);
void updateMaxZoneSlider(QString value);
void openAdvancedPDialog();
void openAdvancedNDialog();
void refreshPButtonLabel();
void refreshNButtonLabel();
void refreshPreset();
void checkFinalSettings();
void openMouseSettingsDialog();
void enableMouseSettingButton();
void updateWindowTitleAxisName();
};
#endif // AXISEDITDIALOG_H
``` | /content/code_sandbox/src/axiseditdialog.h | objective-c | 2016-05-24T23:59:31 | 2024-08-11T02:46:48 | antimicro | AntiMicro/antimicro | 1,788 | 421 |
```c++
/* antimicro Gamepad to KB+M event mapper
*
* This program is free software: you can redistribute it and/or modify
* (at your option) any later version.
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* along with this program. If not, see <path_to_url
*/
//#include <QDebug>
#include <QDir>
#include <QStringList>
#include "xmlconfigreader.h"
#include "xmlconfigmigration.h"
#include "xmlconfigwriter.h"
#include "common.h"
XMLConfigReader::XMLConfigReader(QObject *parent) :
QObject(parent)
{
xml = new QXmlStreamReader();
configFile = 0;
joystick = 0;
initDeviceTypes();
}
XMLConfigReader::~XMLConfigReader()
{
if (configFile)
{
if (configFile->isOpen())
{
configFile->close();
}
delete configFile;
configFile = 0;
}
if (xml)
{
delete xml;
xml = 0;
}
}
void XMLConfigReader::setJoystick(InputDevice *joystick)
{
this->joystick = joystick;
}
void XMLConfigReader::setFileName(QString filename)
{
QFile *temp = new QFile(filename);
if (temp->exists())
{
configFile = temp;
}
else
{
delete temp;
temp = 0;
}
}
void XMLConfigReader::configJoystick(InputDevice *joystick)
{
this->joystick = joystick;
read();
}
bool XMLConfigReader::read()
{
bool error = false;
if (configFile && configFile->exists() && joystick)
{
xml->clear();
if (!configFile->isOpen())
{
configFile->open(QFile::ReadOnly | QFile::Text);
xml->setDevice(configFile);
}
xml->readNextStartElement();
if (!deviceTypes.contains(xml->name().toString()))
{
xml->raiseError("Root node is not a joystick or controller");
}
else if (xml->name() == Joystick::xmlName)
{
XMLConfigMigration migration(xml);
if (migration.requiresMigration())
{
QString migrationString = migration.migrate();
if (migrationString.length() > 0)
{
// Remove QFile from reader and clear state
xml->clear();
// Add converted XML string to reader
xml->addData(migrationString);
// Skip joystick root node
xml->readNextStartElement();
// Close current config file
configFile->close();
// Write converted XML to file
configFile->open(QFile::WriteOnly | QFile::Text);
if (configFile->isOpen())
{
configFile->write(migrationString.toLocal8Bit());
configFile->close();
}
else
{
xml->raiseError(tr("Could not write updated profile XML to file %1.").arg(configFile->fileName()));
}
}
}
}
while (!xml->atEnd())
{
if (xml->isStartElement() && deviceTypes.contains(xml->name().toString()))
{
joystick->readConfig(xml);
}
else
{
// If none of the above, skip the element
xml->skipCurrentElement();
}
xml->readNextStartElement();
}
if (configFile->isOpen())
{
configFile->close();
}
if (xml->hasError() && xml->error() != QXmlStreamReader::PrematureEndOfDocumentError)
{
error = true;
}
else if (xml->hasError() && xml->error() == QXmlStreamReader::PrematureEndOfDocumentError)
{
xml->clear();
}
}
return error;
}
QString XMLConfigReader::getErrorString()
{
QString temp;
if (xml->hasError())
{
temp = xml->errorString();
}
return temp;
}
bool XMLConfigReader::hasError()
{
return xml->hasError();
}
void XMLConfigReader::initDeviceTypes()
{
deviceTypes.clear();
deviceTypes.append(Joystick::xmlName);
#ifdef USE_SDL_2
deviceTypes.append(GameController::xmlName);
#endif
}
``` | /content/code_sandbox/src/xmlconfigreader.cpp | c++ | 2016-05-24T23:59:31 | 2024-08-11T02:46:48 | antimicro | AntiMicro/antimicro | 1,788 | 925 |
```c++
/* antimicro Gamepad to KB+M event mapper
*
* This program is free software: you can redistribute it and/or modify
* (at your option) any later version.
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* along with this program. If not, see <path_to_url
*/
#include <linux/input.h>
#include <linux/uinput.h>
//#include <QDebug>
#include <QChar>
#include <QList>
#include <QListIterator>
#include "qtuinputkeymapper.h"
QtUInputKeyMapper::QtUInputKeyMapper(QObject *parent) :
QtKeyMapperBase(parent)
{
identifier = "uinput";
populateMappingHashes();
populateCharKeyInformation();
}
void QtUInputKeyMapper::populateAlphaHashes()
{
// Map lowercase alpha keys
qtKeyToVirtualKey[Qt::Key_A] = KEY_A;
qtKeyToVirtualKey[Qt::Key_B] = KEY_B;
qtKeyToVirtualKey[Qt::Key_C] = KEY_C;
qtKeyToVirtualKey[Qt::Key_D] = KEY_D;
qtKeyToVirtualKey[Qt::Key_E] = KEY_E;
qtKeyToVirtualKey[Qt::Key_F] = KEY_F;
qtKeyToVirtualKey[Qt::Key_G] = KEY_G;
qtKeyToVirtualKey[Qt::Key_H] = KEY_H;
qtKeyToVirtualKey[Qt::Key_I] = KEY_I;
qtKeyToVirtualKey[Qt::Key_J] = KEY_J;
qtKeyToVirtualKey[Qt::Key_K] = KEY_K;
qtKeyToVirtualKey[Qt::Key_L] = KEY_L;
qtKeyToVirtualKey[Qt::Key_M] = KEY_M;
qtKeyToVirtualKey[Qt::Key_N] = KEY_N;
qtKeyToVirtualKey[Qt::Key_O] = KEY_O;
qtKeyToVirtualKey[Qt::Key_P] = KEY_P;
qtKeyToVirtualKey[Qt::Key_Q] = KEY_Q;
qtKeyToVirtualKey[Qt::Key_R] = KEY_R;
qtKeyToVirtualKey[Qt::Key_S] = KEY_S;
qtKeyToVirtualKey[Qt::Key_T] = KEY_T;
qtKeyToVirtualKey[Qt::Key_U] = KEY_U;
qtKeyToVirtualKey[Qt::Key_V] = KEY_V;
qtKeyToVirtualKey[Qt::Key_W] = KEY_W;
qtKeyToVirtualKey[Qt::Key_X] = KEY_X;
qtKeyToVirtualKey[Qt::Key_Y] = KEY_Y;
qtKeyToVirtualKey[Qt::Key_Z] = KEY_Z;
}
void QtUInputKeyMapper::populateFKeyHashes()
{
// Map F1 - F10
for (int i=0; i <= (KEY_F10 - KEY_F1); i++)
{
qtKeyToVirtualKey[Qt::Key_F1 + i] = KEY_F1 + i;
}
// Map F11 and F12
for (int i=0; i <= (KEY_F12 - KEY_F11); i++)
{
qtKeyToVirtualKey[Qt::Key_F11 + i] = KEY_F11 + i;
}
// Map F13 - F24
for (int i=0; i <= (KEY_F24 - KEY_F13); i++)
{
qtKeyToVirtualKey[Qt::Key_F13 + i] = KEY_F13 + i;
}
}
void QtUInputKeyMapper::populateNumPadHashes()
{
// Map Numpad 0
qtKeyToVirtualKey[AntKey_KP_0] = KEY_KP0;
// Map Numpad 1 - 3
for (int i=0; i <= (KEY_KP3 - KEY_KP1); i++)
{
qtKeyToVirtualKey[AntKey_KP_1 + i] = KEY_KP1 + i;
}
// Map Numpad 4 - 6
for (int i=0; i <= (KEY_KP6 - KEY_KP4); i++)
{
qtKeyToVirtualKey[AntKey_KP_4 + i] = KEY_KP4 + i;
}
// Map Numpad 7 - 9
for (int i=0; i <= (KEY_KP9 - KEY_KP7); i++)
{
qtKeyToVirtualKey[AntKey_KP_7 + i] = KEY_KP7 + i;
}
}
void QtUInputKeyMapper::populateSpecialCharHashes()
{
qtKeyToVirtualKey[Qt::Key_QuoteLeft] = KEY_GRAVE;
qtKeyToVirtualKey[Qt::Key_Minus] = KEY_MINUS;
qtKeyToVirtualKey[Qt::Key_Equal] = KEY_EQUAL;
qtKeyToVirtualKey[Qt::Key_BracketLeft] = KEY_LEFTBRACE;
qtKeyToVirtualKey[Qt::Key_BracketRight] = KEY_RIGHTBRACE;
qtKeyToVirtualKey[Qt::Key_Semicolon] = KEY_SEMICOLON;
qtKeyToVirtualKey[Qt::Key_Apostrophe] = KEY_APOSTROPHE;
qtKeyToVirtualKey[Qt::Key_Comma] = KEY_COMMA;
qtKeyToVirtualKey[Qt::Key_Period] = KEY_DOT;
qtKeyToVirtualKey[Qt::Key_Slash] = KEY_SLASH;
qtKeyToVirtualKey[Qt::Key_Backslash] = KEY_BACKSLASH;
}
void QtUInputKeyMapper::populateMappingHashes()
{
if (qtKeyToVirtualKey.isEmpty())
{
// misc keys
qtKeyToVirtualKey[Qt::Key_Escape] = KEY_ESC;
qtKeyToVirtualKey[Qt::Key_Tab] = KEY_TAB;
qtKeyToVirtualKey[Qt::Key_Backspace] = KEY_BACKSPACE;
qtKeyToVirtualKey[Qt::Key_Return] = KEY_ENTER;
qtKeyToVirtualKey[Qt::Key_Insert] = KEY_INSERT;
qtKeyToVirtualKey[Qt::Key_Delete] = KEY_DELETE;
qtKeyToVirtualKey[Qt::Key_Pause] = KEY_PAUSE;
qtKeyToVirtualKey[Qt::Key_Print] = KEY_PRINT;
qtKeyToVirtualKey[Qt::Key_Space] = KEY_SPACE;
qtKeyToVirtualKey[Qt::Key_SysReq] = KEY_SYSRQ;
qtKeyToVirtualKey[Qt::Key_PowerOff] = KEY_POWER;
qtKeyToVirtualKey[Qt::Key_Stop] = KEY_STOP;
qtKeyToVirtualKey[Qt::Key_Refresh] = KEY_REFRESH;
qtKeyToVirtualKey[Qt::Key_Copy] = KEY_COPY;
qtKeyToVirtualKey[Qt::Key_Paste] = KEY_PASTE;
//qtKeyToVirtualKey[Qt::Key_Search] = KEY_FIND;
qtKeyToVirtualKey[Qt::Key_Cut] = KEY_CUT;
qtKeyToVirtualKey[Qt::Key_Sleep] = KEY_SLEEP;
//qtKeyToVirtualKey[Qt::Key_Calculator] = KEY_CALC;
qtKeyToVirtualKey[Qt::Key_Launch0] = KEY_COMPUTER;
qtKeyToVirtualKey[Qt::Key_Launch1] = KEY_CALC;
qtKeyToVirtualKey[Qt::Key_Launch2] = KEY_PROG1;
qtKeyToVirtualKey[Qt::Key_Launch3] = KEY_PROG2;
qtKeyToVirtualKey[Qt::Key_Launch4] = KEY_PROG3;
qtKeyToVirtualKey[Qt::Key_Launch5] = KEY_PROG4;
qtKeyToVirtualKey[Qt::Key_HomePage] = KEY_HOMEPAGE;
qtKeyToVirtualKey[Qt::Key_LaunchMail] = KEY_MAIL;
qtKeyToVirtualKey[Qt::Key_Back] = KEY_BACK;
qtKeyToVirtualKey[Qt::Key_Favorites] = KEY_FAVORITES;
qtKeyToVirtualKey[Qt::Key_Forward] = KEY_FORWARD;
qtKeyToVirtualKey[Qt::Key_Suspend] = KEY_SUSPEND;
qtKeyToVirtualKey[Qt::Key_Close] = KEY_CLOSE;
//qtKeyToVirtualKey[Qt::Key_Search] = KEY_SEARCH;
qtKeyToVirtualKey[Qt::Key_Camera] = KEY_CAMERA;
qtKeyToVirtualKey[Qt::Key_MonBrightnessUp] = KEY_BRIGHTNESSUP;
qtKeyToVirtualKey[Qt::Key_MonBrightnessDown] = KEY_BRIGHTNESSDOWN;
qtKeyToVirtualKey[Qt::Key_Send] = KEY_SEND;
qtKeyToVirtualKey[Qt::Key_Reply] = KEY_REPLY;
qtKeyToVirtualKey[Qt::Key_Forward] = KEY_FORWARDMAIL;
qtKeyToVirtualKey[Qt::Key_Save] = KEY_SAVE;
qtKeyToVirtualKey[Qt::Key_Documents] = KEY_DOCUMENTS;
qtKeyToVirtualKey[Qt::Key_Battery] = KEY_BATTERY;
qtKeyToVirtualKey[Qt::Key_Bluetooth] = KEY_BLUETOOTH;
qtKeyToVirtualKey[Qt::Key_WLAN] = KEY_WLAN;
qtKeyToVirtualKey[Qt::Key_Cancel] = KEY_CANCEL;
qtKeyToVirtualKey[Qt::Key_Shop] = KEY_SHOP;
qtKeyToVirtualKey[Qt::Key_Finance] = KEY_FINANCE;
qtKeyToVirtualKey[Qt::Key_Question] = KEY_QUESTION;
qtKeyToVirtualKey[Qt::Key_BassBoost] = KEY_BASSBOOST;
// cursor movement
qtKeyToVirtualKey[Qt::Key_Home] = KEY_HOME;
qtKeyToVirtualKey[Qt::Key_End] = KEY_END;
qtKeyToVirtualKey[Qt::Key_Left] = KEY_LEFT;
qtKeyToVirtualKey[Qt::Key_Up] = KEY_UP;
qtKeyToVirtualKey[Qt::Key_Right] = KEY_RIGHT;
qtKeyToVirtualKey[Qt::Key_Down] = KEY_DOWN;
qtKeyToVirtualKey[Qt::Key_PageUp] = KEY_PAGEUP;
qtKeyToVirtualKey[Qt::Key_PageDown] = KEY_PAGEDOWN;
// modifiers
qtKeyToVirtualKey[Qt::Key_Shift] = KEY_LEFTSHIFT;
qtKeyToVirtualKey[Qt::Key_Control] = KEY_LEFTCTRL;
qtKeyToVirtualKey[Qt::Key_Alt] = KEY_LEFTALT;
qtKeyToVirtualKey[Qt::Key_CapsLock] = KEY_CAPSLOCK;
qtKeyToVirtualKey[Qt::Key_NumLock] = KEY_NUMLOCK;
qtKeyToVirtualKey[Qt::Key_ScrollLock] = KEY_SCROLLLOCK;
qtKeyToVirtualKey[Qt::Key_Meta] = KEY_LEFTMETA;
qtKeyToVirtualKey[AntKey_Meta_R] = KEY_RIGHTMETA;
qtKeyToVirtualKey[Qt::Key_Menu] = KEY_COMPOSE;
qtKeyToVirtualKey[Qt::Key_Help] = KEY_HELP;
// media keys
qtKeyToVirtualKey[Qt::Key_VolumeDown] = KEY_VOLUMEDOWN;
qtKeyToVirtualKey[Qt::Key_VolumeMute] = KEY_MUTE;
qtKeyToVirtualKey[Qt::Key_VolumeUp] = KEY_VOLUMEUP;
qtKeyToVirtualKey[Qt::Key_MediaPlay] = KEY_PLAYPAUSE;
qtKeyToVirtualKey[Qt::Key_MediaStop] = KEY_STOPCD;
qtKeyToVirtualKey[Qt::Key_MediaPrevious] = KEY_PREVIOUSSONG;
qtKeyToVirtualKey[Qt::Key_MediaNext] = KEY_NEXTSONG;
qtKeyToVirtualKey[Qt::Key_MediaRecord] = KEY_RECORD;
qtKeyToVirtualKey[Qt::Key_LaunchMedia] = KEY_MEDIA;
// Map 0-9 keys
for (unsigned int i=0; i <= (KEY_9 - KEY_1); i++)
{
qtKeyToVirtualKey[Qt::Key_1 + i] = KEY_1 + i;
}
qtKeyToVirtualKey[Qt::Key_0] = KEY_0;
populateSpecialCharHashes();
populateAlphaHashes();
populateFKeyHashes();
populateNumPadHashes();
// Map custom defined keys
qtKeyToVirtualKey[AntKey_Shift_R] = KEY_RIGHTSHIFT;
qtKeyToVirtualKey[AntKey_Control_R] = KEY_RIGHTCTRL;
qtKeyToVirtualKey[AntKey_Alt_R] = KEY_RIGHTALT;
qtKeyToVirtualKey[AntKey_KP_Multiply] = KEY_KPASTERISK;
// numeric and function keypad keys
qtKeyToVirtualKey[Qt::Key_Enter] = KEY_KPENTER;
qtKeyToVirtualKey[AntKey_KP_Home] = KEY_KP7;
qtKeyToVirtualKey[AntKey_KP_Left] = KEY_KP4;
qtKeyToVirtualKey[AntKey_KP_Up] = KEY_KP8;
qtKeyToVirtualKey[AntKey_KP_Right] = KEY_KP6;
qtKeyToVirtualKey[AntKey_KP_Down] = KEY_KP2;
qtKeyToVirtualKey[AntKey_KP_Prior] = KEY_KP9;
qtKeyToVirtualKey[AntKey_KP_Next] = KEY_KP3;
qtKeyToVirtualKey[AntKey_KP_End] = KEY_KP1;
qtKeyToVirtualKey[AntKey_KP_Begin] = KEY_KP5;
qtKeyToVirtualKey[AntKey_KP_Insert] = KEY_KP0;
qtKeyToVirtualKey[AntKey_KP_Add] = KEY_KPPLUS;
qtKeyToVirtualKey[AntKey_KP_Subtract] = KEY_KPMINUS;
qtKeyToVirtualKey[AntKey_KP_Decimal] = KEY_KPDOT;
qtKeyToVirtualKey[AntKey_KP_Divide] = KEY_KPSLASH;
/*
// International input method support keys
// International & multi-key character composition
qtKeyToVirtualKey[Qt::Key_AltGr] = XK_ISO_Level3_Shift;
qtKeyToVirtualKey[Qt::Key_Multi_key] = XK_Multi_key;
qtKeyToVirtualKey[Qt::Key_Codeinput] = XK_Codeinput;
qtKeyToVirtualKey[Qt::Key_SingleCandidate] = XK_SingleCandidate;
qtKeyToVirtualKey[Qt::Key_MultipleCandidate] = XK_MultipleCandidate;
qtKeyToVirtualKey[Qt::Key_PreviousCandidate] = XK_PreviousCandidate;
// Misc Functions
qtKeyToVirtualKey[Qt::Key_Mode_switch] = XK_Mode_switch;
//qtKeyToX11KeySym[Qt::Key_Mode_switch] = XK_script_switch;
// Japanese keyboard support
qtKeyToVirtualKey[Qt::Key_Kanji] = XK_Kanji;
qtKeyToVirtualKey[Qt::Key_Muhenkan] = XK_Muhenkan;
qtKeyToVirtualKey[Qt::Key_Henkan] = XK_Henkan_Mode;
//qtKeyToX11KeySym[Qt::Key_Henkan] = XK_Henkan;
qtKeyToVirtualKey[Qt::Key_Romaji] = XK_Romaji;
qtKeyToVirtualKey[Qt::Key_Hiragana] = XK_Hiragana;
qtKeyToVirtualKey[Qt::Key_Katakana] = XK_Katakana;
qtKeyToVirtualKey[Qt::Key_Hiragana_Katakana] = XK_Hiragana_Katakana;
qtKeyToVirtualKey[Qt::Key_Zenkaku] = XK_Zenkaku;
qtKeyToVirtualKey[Qt::Key_Hankaku] = XK_Hankaku;
qtKeyToVirtualKey[Qt::Key_Zenkaku_Hankaku] = XK_Zenkaku_Hankaku;
qtKeyToVirtualKey[Qt::Key_Touroku] = XK_Touroku;
qtKeyToVirtualKey[Qt::Key_Massyo] = XK_Massyo;
qtKeyToVirtualKey[Qt::Key_Kana_Lock] = XK_Kana_Lock;
qtKeyToVirtualKey[Qt::Key_Kana_Shift] = XK_Kana_Shift;
qtKeyToVirtualKey[Qt::Key_Eisu_Shift] = XK_Eisu_Shift;
qtKeyToVirtualKey[Qt::Key_Eisu_toggle] = XK_Eisu_toggle;
qtKeyToVirtualKey[Qt::Key_Codeinput] = XK_Kanji_Bangou;
//qtKeyToX11KeySym[Qt::Key_MultipleCandidate] = XK_Zen_Koho;
//qtKeyToX11KeySym[Qt::Key_PreviousCandidate] = XK_Mae_Koho;
#ifdef XK_KOREAN
qtKeyToVirtualKey[Qt::Key_Hangul] = XK_Hangul;
qtKeyToVirtualKey[Qt::Key_Hangul_Start] = XK_Hangul_Start;
qtKeyToVirtualKey[Qt::Key_Hangul_End] = XK_Hangul_End;
qtKeyToVirtualKey[Qt::Key_Hangul_Hanja] = XK_Hangul_Hanja;
qtKeyToVirtualKey[Qt::Key_Hangul_Jamo] = XK_Hangul_Jamo;
qtKeyToVirtualKey[Qt::Key_Hangul_Romaja] = XK_Hangul_Romaja;
//qtKeyToX11KeySym[Qt::Key_Codeinput] = XK_Hangul_Codeinput;
qtKeyToVirtualKey[Qt::Key_Hangul_Jeonja] = XK_Hangul_Jeonja;
qtKeyToVirtualKey[Qt::Key_Hangul_Banja] = XK_Hangul_Banja;
qtKeyToVirtualKey[Qt::Key_Hangul_PreHanja] = XK_Hangul_PreHanja;
qtKeyToVirtualKey[Qt::Key_Hangul_PostHanja] = XK_Hangul_PostHanja;
//qtKeyToX11KeySym[Qt::Key_SingleCandidate] = XK_Hangul_SingleCandidate;
//qtKeyToX11KeySym[Qt::Key_MultipleCandidate] = XK_Hangul_MultipleCandidate;
//qtKeyToX11KeySym[Qt::Key_PreviousCandidate] = XK_Hangul_PreviousCandidate;
qtKeyToVirtualKey[Qt::Key_Hangul_Special] = XK_Hangul_Special;
//qtKeyToX11KeySym[Qt::Key_Mode_switch] = XK_Hangul_switch;
#endif // XK_KOREAN
// Special multimedia keys
// currently only tested with MS internet keyboard
// browsing keys
qtKeyToVirtualKey[Qt::Key_Back] = XF86XK_Back;
qtKeyToVirtualKey[Qt::Key_Forward] = XF86XK_Forward;
qtKeyToVirtualKey[Qt::Key_Stop] = XF86XK_Stop;
qtKeyToVirtualKey[Qt::Key_Refresh] = XF86XK_Refresh;
qtKeyToVirtualKey[Qt::Key_Favorites] = XF86XK_Favorites;
qtKeyToVirtualKey[Qt::Key_LaunchMedia] = XF86XK_AudioMedia;
qtKeyToVirtualKey[Qt::Key_OpenUrl] = XF86XK_OpenURL;
qtKeyToVirtualKey[Qt::Key_HomePage] = XF86XK_HomePage;
qtKeyToVirtualKey[Qt::Key_Search] = XF86XK_Search;
*/
// Populate other hash. Flip key and value so mapping
// goes VK -> Qt Key.
QHashIterator<unsigned int, unsigned int> iter(qtKeyToVirtualKey);
while (iter.hasNext())
{
iter.next();
virtualKeyToQtKey[iter.value()] = iter.key();
}
/*int j = 0;
for (int i=KEY_ESC; i < KEY_UNKNOWN; i++)
{
if (!virtualKeyToQtKey.contains(i) && i != 84)
{
qDebug() << "KEY MISSING: " << QString::number(i);
j++;
}
}
qDebug() << "TOTAL MISSING: " << j;
*/
// Override some entries.
virtualKeyToQtKey[KEY_KP0] = AntKey_KP_0;
virtualKeyToQtKey[KEY_KP1] = AntKey_KP_1;
virtualKeyToQtKey[KEY_KP2] = AntKey_KP_2;
virtualKeyToQtKey[KEY_KP3] = AntKey_KP_3;
virtualKeyToQtKey[KEY_KP4] = AntKey_KP_4;
virtualKeyToQtKey[KEY_KP5] = AntKey_KP_5;
virtualKeyToQtKey[KEY_KP6] = AntKey_KP_6;
virtualKeyToQtKey[KEY_KP7] = AntKey_KP_7;
virtualKeyToQtKey[KEY_KP8] = AntKey_KP_8;
virtualKeyToQtKey[KEY_KP9] = AntKey_KP_9;
virtualKeyToQtKey[KEY_CALC] = Qt::Key_Launch1;
}
}
void QtUInputKeyMapper::populateCharKeyInformation()
{
virtualkeyToCharKeyInformation.clear();
unsigned int unicodeTempValue = 0;
unsigned int listIndex = 0;
charKeyInformation temp;
temp.modifiers = Qt::NoModifier;
temp.virtualkey = 0;
// Map 0-9 keys
for (unsigned int i=QChar('1').unicode(); i <= QChar('9').unicode(); i++)
{
temp.virtualkey = KEY_1 + i;
virtualkeyToCharKeyInformation.insert(i, temp);
}
temp.virtualkey = KEY_0;
virtualkeyToCharKeyInformation.insert(QChar('0').unicode(), temp);
temp.virtualkey = KEY_MINUS;
virtualkeyToCharKeyInformation.insert(QChar('-').unicode(), temp);
temp.virtualkey = KEY_EQUAL;
virtualkeyToCharKeyInformation.insert(QChar('=').unicode(), temp);
QList<unsigned int> tempKeys;
tempKeys.append(KEY_A);
tempKeys.append(KEY_B);
tempKeys.append(KEY_C);
tempKeys.append(KEY_D);
tempKeys.append(KEY_E);
tempKeys.append(KEY_F);
tempKeys.append(KEY_G);
tempKeys.append(KEY_H);
tempKeys.append(KEY_I);
tempKeys.append(KEY_J);
tempKeys.append(KEY_K);
tempKeys.append(KEY_L);
tempKeys.append(KEY_M);
tempKeys.append(KEY_N);
tempKeys.append(KEY_O);
tempKeys.append(KEY_P);
tempKeys.append(KEY_Q);
tempKeys.append(KEY_R);
tempKeys.append(KEY_S);
tempKeys.append(KEY_T);
tempKeys.append(KEY_U);
tempKeys.append(KEY_V);
tempKeys.append(KEY_W);
tempKeys.append(KEY_X);
tempKeys.append(KEY_Y);
tempKeys.append(KEY_Z);
unicodeTempValue = QChar('a').unicode();
QListIterator<unsigned int> tempIter(tempKeys);
while (tempIter.hasNext())
{
temp.virtualkey = tempIter.next();
virtualkeyToCharKeyInformation.insert(unicodeTempValue, temp);
unicodeTempValue++;
}
tempIter.toFront();
temp.modifiers = Qt::ShiftModifier;
unicodeTempValue = QChar('A').unicode();
while (tempIter.hasNext())
{
temp.virtualkey = tempIter.next();
virtualkeyToCharKeyInformation.insert(unicodeTempValue, temp);
unicodeTempValue++;
}
tempKeys.clear();
temp.modifiers = Qt::ShiftModifier;
tempKeys.append(QChar('!').unicode());
tempKeys.append(QChar('@').unicode());
tempKeys.append(QChar('#').unicode());
tempKeys.append(QChar('$').unicode());
tempKeys.append(QChar('%').unicode());
tempKeys.append(QChar('^').unicode());
tempKeys.append(QChar('&').unicode());
tempKeys.append(QChar('*').unicode());
tempKeys.append(QChar('(').unicode());
tempKeys.append(QChar(')').unicode());
tempKeys.append(QChar('_').unicode());
tempKeys.append(QChar('+').unicode());
tempIter = QListIterator<unsigned int>(tempKeys);
listIndex = 0;
while (tempIter.hasNext())
{
unicodeTempValue = tempIter.next();
temp.virtualkey = KEY_1 + listIndex;
virtualkeyToCharKeyInformation.insert(unicodeTempValue, temp);
listIndex++;
}
tempKeys.clear();
temp.modifiers = Qt::NoModifier;
temp.virtualkey = KEY_SPACE;
unicodeTempValue = QChar(' ').unicode();
virtualkeyToCharKeyInformation.insert(unicodeTempValue, temp);
temp.virtualkey = KEY_LEFTBRACE;
unicodeTempValue = QChar('[').unicode();
virtualkeyToCharKeyInformation.insert(unicodeTempValue, temp);
temp.virtualkey = KEY_RIGHTBRACE;
unicodeTempValue = QChar(']').unicode();
virtualkeyToCharKeyInformation.insert(unicodeTempValue, temp);
temp.virtualkey = KEY_BACKSLASH;
unicodeTempValue = QChar('\\').unicode();
virtualkeyToCharKeyInformation.insert(unicodeTempValue, temp);
temp.virtualkey = KEY_SEMICOLON;
unicodeTempValue = QChar(';').unicode();
virtualkeyToCharKeyInformation.insert(unicodeTempValue, temp);
temp.virtualkey = KEY_APOSTROPHE;
unicodeTempValue = QChar('\'').unicode();
virtualkeyToCharKeyInformation.insert(unicodeTempValue, temp);
temp.virtualkey = KEY_COMMA;
unicodeTempValue = QChar(',').unicode();
virtualkeyToCharKeyInformation.insert(unicodeTempValue, temp);
temp.virtualkey = KEY_DOT;
unicodeTempValue = QChar('.').unicode();
virtualkeyToCharKeyInformation.insert(unicodeTempValue, temp);
temp.virtualkey = KEY_SLASH;
unicodeTempValue = QChar('/').unicode();
virtualkeyToCharKeyInformation.insert(unicodeTempValue, temp);
temp.modifiers = Qt::ShiftModifier;
temp.virtualkey = KEY_LEFTBRACE;
unicodeTempValue = QChar('{').unicode();
virtualkeyToCharKeyInformation.insert(unicodeTempValue, temp);
temp.virtualkey = KEY_RIGHTBRACE;
unicodeTempValue = QChar('}').unicode();
virtualkeyToCharKeyInformation.insert(unicodeTempValue, temp);
temp.virtualkey = KEY_BACKSLASH;
unicodeTempValue = QChar('|').unicode();
virtualkeyToCharKeyInformation.insert(unicodeTempValue, temp);
temp.virtualkey = KEY_SEMICOLON;
unicodeTempValue = QChar(':').unicode();
virtualkeyToCharKeyInformation.insert(unicodeTempValue, temp);
temp.virtualkey = KEY_APOSTROPHE;
unicodeTempValue = QChar('"').unicode();
virtualkeyToCharKeyInformation.insert(unicodeTempValue, temp);
temp.virtualkey = KEY_COMMA;
unicodeTempValue = QChar('<').unicode();
virtualkeyToCharKeyInformation.insert(unicodeTempValue, temp);
temp.virtualkey = KEY_DOT;
unicodeTempValue = QChar('>').unicode();
virtualkeyToCharKeyInformation.insert(unicodeTempValue, temp);
temp.virtualkey = KEY_SLASH;
unicodeTempValue = QChar('?').unicode();
virtualkeyToCharKeyInformation.insert(unicodeTempValue, temp);
}
``` | /content/code_sandbox/src/qtuinputkeymapper.cpp | c++ | 2016-05-24T23:59:31 | 2024-08-11T02:46:48 | antimicro | AntiMicro/antimicro | 1,788 | 6,070 |
```objective-c
/* antimicro Gamepad to KB+M event mapper
*
* This program is free software: you can redistribute it and/or modify
* (at your option) any later version.
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* along with this program. If not, see <path_to_url
*/
#ifndef JOYTABWIDGET_H
#define JOYTABWIDGET_H
#include <QWidget>
#include <QVBoxLayout>
#include <QHBoxLayout>
#include <QGridLayout>
#include <QPushButton>
#include <QComboBox>
#include <QSpacerItem>
#include <QFileDialog>
#include <QHash>
#include <QStackedWidget>
#include <QScrollArea>
#include <QIcon>
#include "uihelpers/joytabwidgethelper.h"
#include "joystick.h"
#include "axiseditdialog.h"
#include "inputdevice.h"
#include "antimicrosettings.h"
class JoyTabWidget : public QWidget
{
Q_OBJECT
public:
explicit JoyTabWidget(InputDevice *joystick, AntiMicroSettings *settings, QWidget *parent = 0);
void saveSettings();
void loadSettings(bool forceRefresh=false);
QHash<int, QString>* recentConfigs();
void setCurrentConfig(int index);
int getCurrentConfigIndex();
QString getCurrentConfigName();
QString getConfigName(int index);
InputDevice *getJoystick();
void unloadConfig();
bool isDisplayingNames();
bool discardUnsavedProfileChanges();
void checkHideEmptyOption();
void refreshHelperThread();
#ifdef Q_OS_WIN
void deviceKeyRepeatSettings();
#endif
protected:
virtual void changeEvent(QEvent *event);
void removeCurrentButtons();
void retranslateUi();
void disconnectMainComboBoxEvents();
void reconnectMainComboBoxEvents();
void disconnectCheckUnsavedEvent();
void reconnectCheckUnsavedEvent();
void fillSetButtons(SetJoystick *set);
void removeSetButtons(SetJoystick *set);
QVBoxLayout *verticalLayout;
QHBoxLayout *configHorizontalLayout;
QPushButton *removeButton;
QPushButton *loadButton;
QPushButton *saveButton;
QPushButton *resetButton;
QPushButton *namesPushButton;
QPushButton *saveAsButton;
QPushButton *delayButton;
QComboBox *configBox;
QGridLayout *gridLayout;
QGridLayout *gridLayout2;
QGridLayout *gridLayout3;
QGridLayout *gridLayout4;
QGridLayout *gridLayout5;
QGridLayout *gridLayout6;
QGridLayout *gridLayout7;
QGridLayout *gridLayout8;
QSpacerItem *spacer1;
QSpacerItem *spacer2;
QSpacerItem *spacer3;
AxisEditDialog *axisDialog;
QPushButton *setPushButton1;
QPushButton *setPushButton2;
QPushButton *setPushButton3;
QPushButton *setPushButton4;
QPushButton *setPushButton5;
QPushButton *setPushButton6;
QPushButton *setPushButton7;
QPushButton *setPushButton8;
QPushButton *setsMenuButton;
QAction *setAction1;
QAction *setAction2;
QAction *setAction3;
QAction *setAction4;
QAction *setAction5;
QAction *setAction6;
QAction *setAction7;
QAction *setAction8;
QMenu *copySetMenu;
QHBoxLayout *horizontalLayout_2;
QHBoxLayout *horizontalLayout_3;
QPushButton *stickAssignPushButton;
QPushButton *quickSetPushButton;
QPushButton *gameControllerMappingPushButton;
QSpacerItem *verticalSpacer_2;
QStackedWidget *stackedWidget_2;
QWidget *page;
QWidget *page_2;
QWidget *page_3;
QWidget *page_4;
QWidget *page_5;
QWidget *page_6;
QWidget *page_7;
QWidget *page_8;
QPushButton *pushButton;
QSpacerItem *verticalSpacer_3;
InputDevice *joystick;
bool displayingNames;
AntiMicroSettings *settings;
int comboBoxIndex;
bool hideEmptyButtons;
QString oldProfileName;
JoyTabWidgetHelper tabHelper;
static const int DEFAULTNUMBERPROFILES = 5;
signals:
void joystickConfigChanged(int index);
void joystickAxisRefreshLabels(int axisIndex);
void namesDisplayChanged(bool status);
void forceTabUnflash(JoyTabWidget *tabWidget);
#ifdef USE_SDL_2
void mappingUpdated(QString mapping, InputDevice *device);
#endif
public slots:
void openConfigFileDialog();
void fillButtons();
void saveDeviceSettings(bool sync=false);
void loadDeviceSettings();
void changeNameDisplay(bool displayNames);
void changeCurrentSet(int index);
void loadConfigFile(QString fileLocation);
void refreshButtons();
private slots:
void saveConfigFile();
void resetJoystick();
void saveAsConfig();
void removeConfig();
void changeJoyConfig(int index);
void showAxisDialog();
void showButtonDialog();
void showStickAssignmentDialog();
void showQuickSetDialog();
void showKeyDelayDialog();
void showSetNamesDialog();
void toggleNames();
void changeSetOne();
void changeSetTwo();
void changeSetThree();
void changeSetFour();
void changeSetFive();
void changeSetSix();
void changeSetSeven();
void changeSetEight();
void displayProfileEditNotification();
void removeProfileEditNotification();
void checkForUnsavedProfile(int newindex=-1);
void checkStickDisplay();
void checkDPadButtonDisplay();
void checkAxisButtonDisplay();
void checkButtonDisplay();
void checkStickEmptyDisplay();
void checkDPadButtonEmptyDisplay();
void checkAxisButtonEmptyDisplay();
void checkButtonEmptyDisplay();
void editCurrentProfileItemText(QString text);
void refreshCopySetActions();
void performSetCopy();
void disableCopyCurrentSet();
void refreshSetButtons();
#ifdef USE_SDL_2
void openGameControllerMappingWindow();
void propogateMappingUpdate(QString mapping, InputDevice *device);
#endif
};
#endif // JOYTABWIDGET_H
``` | /content/code_sandbox/src/joytabwidget.h | objective-c | 2016-05-24T23:59:31 | 2024-08-11T02:46:48 | antimicro | AntiMicro/antimicro | 1,788 | 1,316 |
```c++
/* antimicro Gamepad to KB+M event mapper
*
* This program is free software: you can redistribute it and/or modify
* (at your option) any later version.
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* along with this program. If not, see <path_to_url
*/
//#include <QDebug>
#include <QStringListIterator>
#include <QFileInfo>
#include <QTextStream>
#ifdef Q_OS_UNIX
#if (QT_VERSION >= QT_VERSION_CHECK(5, 0, 0))
#include <QApplication>
#endif
#endif
#include "commandlineutility.h"
#include "common.h"
#include "eventhandlerfactory.h"
QRegExp CommandLineUtility::trayRegexp = QRegExp("--tray");
QRegExp CommandLineUtility::helpRegexp = QRegExp("(-h|--help)");
QRegExp CommandLineUtility::versionRegexp = QRegExp("(-v|--version)");
QRegExp CommandLineUtility::noTrayRegexp = QRegExp("--no-tray");
QRegExp CommandLineUtility::loadProfileRegexp = QRegExp("--profile");
QRegExp CommandLineUtility::loadProfileForControllerRegexp = QRegExp("--profile-controller");
QRegExp CommandLineUtility::hiddenRegexp = QRegExp("--hidden");
QRegExp CommandLineUtility::unloadRegexp = QRegExp("--unload");
QRegExp CommandLineUtility::startSetRegexp = QRegExp("--startSet");
QRegExp CommandLineUtility::gamepadListRegexp = QRegExp("(-l|--list)");
QRegExp CommandLineUtility::mappingRegexp = QRegExp("--map");
QRegExp CommandLineUtility::qtStyleRegexp = QRegExp("-style");
QRegExp CommandLineUtility::logLevelRegexp = QRegExp("--log-level");
QRegExp CommandLineUtility::logFileRegexp = QRegExp("--log-file");
QRegExp CommandLineUtility::eventgenRegexp = QRegExp("--eventgen");
QRegExp CommandLineUtility::nextRegexp = QRegExp("--next");
#ifdef Q_OS_UNIX
QRegExp CommandLineUtility::daemonRegexp = QRegExp("--daemon|-d");
#ifdef WITH_X11
QRegExp CommandLineUtility::displayRegexp = QRegExp("--display");
#endif
#endif
QStringList CommandLineUtility::eventGeneratorsList = EventHandlerFactory::buildEventGeneratorList();
CommandLineUtility::CommandLineUtility(QObject *parent) :
QObject(parent)
{
launchInTray = false;
helpRequest = false;
versionRequest = false;
hideTrayIcon = false;
profileLocation = "";
controllerNumber = 0;
encounteredError = false;
hiddenRequest = false;
unloadProfile = false;
startSetNumber = 0;
daemonMode = false;
displayString = "";
listControllers = false;
mappingController = false;
currentLogLevel = Logger::LOG_NONE;
currentListsIndex = 0;
ControllerOptionsInfo tempInfo;
controllerOptionsList.append(tempInfo);
eventGenerator = EventHandlerFactory::fallBackIdentifier();
}
void CommandLineUtility::parseArguments(QStringList &arguments)
{
QStringListIterator iter(arguments);
while (iter.hasNext() && !encounteredError)
{
QString temp = iter.next();
if (helpRegexp.exactMatch(temp))
{
helpRequest = true;
}
else if (versionRegexp.exactMatch(temp))
{
versionRequest = true;
}
else if (trayRegexp.exactMatch(temp))
{
launchInTray = true;
hideTrayIcon = false;
}
else if (noTrayRegexp.exactMatch(temp))
{
hideTrayIcon = true;
launchInTray = false;
}
else if (loadProfileRegexp.exactMatch(temp))
{
if (iter.hasNext())
{
temp = iter.next();
QFileInfo fileInfo(temp);
if (fileInfo.exists())
{
if (fileInfo.suffix() != "amgp" && fileInfo.suffix() != "xml")
{
setErrorMessage(tr("Profile location %1 is not an XML file.").arg(temp));
}
else
{
QString tempProfileLocation = fileInfo.absoluteFilePath();
ControllerOptionsInfo tempInfo = controllerOptionsList.at(currentListsIndex);
tempInfo.setProfileLocation(tempProfileLocation);
controllerOptionsList.replace(currentListsIndex, tempInfo);
}
}
else
{
setErrorMessage(tr("Profile location %1 does not exist.").arg(temp));
}
}
}
else if (loadProfileForControllerRegexp.exactMatch(temp))
{
if (iter.hasNext())
{
temp = iter.next();
bool validNumber = false;
int tempNumber = temp.toInt(&validNumber);
if (validNumber)
{
if (controllerNumber == 0)
{
controllerNumber = tempNumber;
}
ControllerOptionsInfo tempInfo = controllerOptionsList.at(currentListsIndex);
tempInfo.setControllerNumber(tempNumber);
controllerOptionsList.replace(currentListsIndex, tempInfo);
}
else if (!temp.isEmpty())
{
if (controllerIDString.isEmpty())
{
controllerIDString = temp;
}
ControllerOptionsInfo tempInfo = controllerOptionsList.at(currentListsIndex);
tempInfo.setControllerID(temp);
controllerOptionsList.replace(currentListsIndex, tempInfo);
}
else
{
setErrorMessage(tr("Controller identifier is not a valid value."));
}
}
}
else if (hiddenRegexp.exactMatch(temp))
{
hiddenRequest = true;
}
else if (unloadRegexp.exactMatch(temp))
{
ControllerOptionsInfo tempInfo = controllerOptionsList.at(currentListsIndex);
tempInfo.setProfileLocation("");
tempInfo.setUnloadRequest(true);
controllerOptionsList.replace(currentListsIndex, tempInfo);
if (iter.hasNext())
{
temp = iter.next();
if (!isPossibleCommand(temp))
{
// A value has been passed. Attempt
// to validate the value.
bool validNumber = false;
int tempNumber = temp.toInt(&validNumber);
if (validNumber)
{
controllerNumber = tempNumber;
tempInfo = controllerOptionsList.at(currentListsIndex);
tempInfo.setControllerNumber(controllerNumber);
controllerOptionsList.replace(currentListsIndex, tempInfo);
}
else if (!temp.isEmpty())
{
controllerIDString = temp;
tempInfo = controllerOptionsList.at(currentListsIndex);
tempInfo.setControllerID(controllerIDString);
controllerOptionsList.replace(currentListsIndex, tempInfo);
}
else
{
setErrorMessage(tr("Controller identifier is not a valid value."));
}
}
else
{
// Grabbed a possible command-line option.
// Move iterator back to previous item.
iter.previous();
}
}
else
{
unloadProfile = true;
profileLocation = "";
}
}
else if (startSetRegexp.exactMatch(temp))
{
if (iter.hasNext())
{
temp = iter.next();
bool validNumber = false;
int tempNumber = temp.toInt(&validNumber);
if (validNumber && tempNumber >= 1 && tempNumber <= 8)
{
startSetNumber = tempNumber;
ControllerOptionsInfo tempInfo = controllerOptionsList.at(currentListsIndex);
tempInfo.setStartSetNumber(startSetNumber);
controllerOptionsList.replace(currentListsIndex, tempInfo);
}
else if (validNumber)
{
setErrorMessage(tr("An invalid set number '%1' was specified.").arg(tempNumber));
}
if (iter.hasNext())
{
temp = iter.next();
if (!isPossibleCommand(temp))
{
if (validNumber)
{
controllerNumber = tempNumber;
ControllerOptionsInfo tempInfo = controllerOptionsList.at(currentListsIndex);
tempInfo.setControllerNumber(controllerNumber);
controllerOptionsList.replace(currentListsIndex, tempInfo);
}
else if (!temp.isEmpty())
{
controllerIDString = temp;
ControllerOptionsInfo tempInfo = controllerOptionsList.at(currentListsIndex);
tempInfo.setControllerID(controllerIDString);
controllerOptionsList.replace(currentListsIndex, tempInfo);
}
else
{
setErrorMessage(tr("Controller identifier '%s'' is not a valid value.").arg(temp));
}
}
else
{
// Grabbed a possible command-line option.
// Move iterator back to previous item.
iter.previous();
}
}
}
else
{
setErrorMessage(tr("No set number was specified."));
}
}
else if (nextRegexp.exactMatch(temp))
{
currentListsIndex++;
ControllerOptionsInfo tempInfo;
controllerOptionsList.append(tempInfo);
}
#ifdef USE_SDL_2
else if (gamepadListRegexp.exactMatch(temp))
{
listControllers = true;
}
else if (mappingRegexp.exactMatch(temp))
{
if (iter.hasNext())
{
temp = iter.next();
bool validNumber = false;
int tempNumber = temp.toInt(&validNumber);
if (validNumber)
{
controllerNumber = tempNumber;
mappingController = true;
}
else if (!temp.isEmpty())
{
controllerIDString = temp;
mappingController = true;
}
else
{
setErrorMessage(tr("Controller identifier is not a valid value."));
}
}
else
{
setErrorMessage(tr("No controller was specified."));
}
}
#endif
#ifdef Q_OS_UNIX
else if (daemonRegexp.exactMatch(temp))
{
daemonMode = true;
}
#ifdef WITH_X11
else if (displayRegexp.exactMatch(temp))
{
if (iter.hasNext())
{
displayString = iter.next();
}
else
{
setErrorMessage(tr("No display string was specified."));
//errorsteam << tr("No display string was specified.") << endl;
//encounteredError = true;
}
}
#endif
#endif
#if (defined (Q_OS_UNIX) && defined(WITH_UINPUT) && defined(WITH_XTEST)) \
|| (defined(Q_OS_WIN) && defined(WITH_VMULTI))
else if (eventgenRegexp.exactMatch(temp))
{
if (iter.hasNext())
{
QString temp = iter.next();
if (!eventGeneratorsList.contains(temp))
{
eventGenerator = "";
setErrorMessage(tr("An invalid event generator was specified."));
//errorsteam << tr("An invalid event generator was specified.") << endl;
//encounteredError = true;
}
else
{
eventGenerator = temp;
}
}
else
{
setErrorMessage(tr("No event generator string was specified."));
//errorsteam << tr("No event generator string was specified.") << endl;
//encounteredError = true;
}
}
#endif
else if (qtStyleRegexp.exactMatch(temp))
{
if (iter.hasNext())
{
// Skip over argument
iter.next();
}
else
{
setErrorMessage(tr("Qt style flag was detected but no style was specified."));
//errorsteam << tr("Qt style flag was detected but no style was specified.") << endl;
//encounteredError = true;
}
}
else if (logLevelRegexp.exactMatch(temp))
{
if (iter.hasNext())
{
QString temp = iter.next();
if (temp == "debug")
{
currentLogLevel = Logger::LOG_DEBUG;
}
else if (temp == "info")
{
currentLogLevel = Logger::LOG_INFO;
}
/*else if (temp == "warn")
{
currentLogLevel = Logger::LOG_WARNING;
}
else if (temp == "error")
{
currentLogLevel = Logger::LOG_ERROR;
}
*/
}
}
else if (logFileRegexp.exactMatch(temp))
{
if (iter.hasNext())
{
currentLogFile = iter.next();
}
else
{
setErrorMessage(tr("No log file specified."));
//errorsteam << tr("No log level specified.") << endl;
//encounteredError = true;
}
}
else if (isPossibleCommand(temp))
{
// Flag is unrecognized. Assume that it is a Qt option.
if (iter.hasNext())
{
// Check next argument
QString nextarg = iter.next();
if (isPossibleCommand(nextarg))
{
// Flag likely didn't take an argument. Move iterator
// back.
iter.previous();
}
}
}
// Check if this is the last argument. If it is and no command line flag
// is active, the final argument is likely a profile that has
// been specified.
else if (!temp.isEmpty() && !iter.hasNext())
{
// If the file exists and it is an xml file, assume that it is a
// profile.
QFileInfo fileInfo(temp);
if (fileInfo.exists())
{
if (fileInfo.suffix() != "amgp" && fileInfo.suffix() != "xml")
{
setErrorMessage(tr("Profile location %1 is not an XML file.").arg(temp));
}
else
{
profileLocation = fileInfo.absoluteFilePath();
// Only use properties if no other OptionsInfo lines have
// been defined.
if (currentListsIndex > 0)
{
controllerNumber = 0;
controllerIDString.clear();
}
}
}
else
{
setErrorMessage(tr("Profile location %1 does not exist.").arg(temp));
}
}
}
}
bool CommandLineUtility::isLaunchInTrayEnabled()
{
return launchInTray;
}
void CommandLineUtility::printHelp()
{
QTextStream out(stdout);
out << tr("antimicro version") << " " << PadderCommon::programVersion << endl;
out << tr("Usage: antimicro [options...] [profile]") << endl;
out << endl;
out << tr("Options") << ":" << endl;
out << "-h, --help " << " " << tr("Print help text.") << endl;
out << "-v, --version " << " " << tr("Print version information.") << endl;
out << "--tray " << " " << tr("Launch program in system tray only.") << endl;
out << "--no-tray " << " " << tr("Launch program with the tray menu disabled.") << endl;
out << "--hidden " << " " << tr("Launch program without the main window\n displayed.") << endl;
out << "--profile <location> " << " " <<
tr("Launch program with the configuration file\n selected as the default for selected\n controllers. Defaults to all controllers.")
<< endl;
out << "--profile-controller <value> " << " "
<< tr("Apply configuration file to a specific\n controller. Value can be a\n controller index, name, or GUID.")
<< endl;
out << "--unload [<value>] " << " " << tr("Unload currently enabled profile(s). \n Value can be a controller index, name, or GUID.")
<< endl;
out << "--startSet <number> [<value>] " << " " << tr("Start joysticks on a specific set. \n Value can be a controller index, name, or GUID.")
<< endl;
out << "--next " << " " << tr("Advance profile loading set options.")
<< endl;
#ifdef Q_OS_UNIX
out << "-d, --daemon " << " "
<< tr("Launch program as a daemon.") << endl;
out << "--log-level {debug,info} " << " " << tr("Enable logging.") << endl;
#ifdef WITH_X11
#if (QT_VERSION >= QT_VERSION_CHECK(5, 0, 0))
if (QApplication::platformName() == QStringLiteral("xcb"))
{
#endif
out << "--display <value> " << " "
<< tr("Use specified display for X11 calls.\n"
" Useful for ssh.")
<< endl;
#if (QT_VERSION >= QT_VERSION_CHECK(5, 0, 0))
}
#endif
#endif
#endif
#if defined(Q_OS_UNIX) && defined(WITH_UINPUT) && defined(WITH_XTEST)
out << "--eventgen {xtest,uinput} " << " "
<< tr("Choose between using XTest support and uinput\n"
" support for event generation. Default: xtest.")
<< endl;
#elif defined(Q_OS_WIN) && defined(WITH_VMULTI)
out << "--eventgen {sendinput,vmulti} " << " "
<< tr("Choose between using SendInput and vmulti\n"
" support for event generation. Default: sendinput.")
<< endl;
#endif
#ifdef USE_SDL_2
out << "-l, --list " << " "
<< tr("Print information about joysticks detected by \n"
" SDL.") << endl;
out << "--map <value> " << " "
<< tr("Open game controller mapping window of selected\n"
" controller. Value can be a controller index or\n"
" GUID.")
<< endl;
#endif
}
QString CommandLineUtility::generateHelpString()
{
QString temp;
QTextStream out(&temp);
out << tr("antimicro version") << " " << PadderCommon::programVersion << endl;
out << tr("Usage: antimicro [options...] [profile]") << endl;
out << endl;
out << tr("Options") << ":" << endl;
out << "-h, --help " << " " << tr("Print help text.") << endl;
out << "-v, --version " << " " << tr("Print version information.") << endl;
out << "--tray " << " " << tr("Launch program in system tray only.") << endl;
out << "--no-tray " << " " << tr("Launch program with the tray menu disabled.") << endl;
out << "--hidden " << " " << tr("Launch program without the main window\n displayed.") << endl;
out << "--profile <location> " << " " <<
tr("Launch program with the configuration file\n selected as the default for selected\n controllers. Defaults to all controllers.")
<< endl;
out << "--profile-controller <value> " << " "
<< tr("Apply configuration file to a specific\n controller. Value can be a\n controller index, name, or GUID.")
<< endl;
out << "--unload [<value>] " << " " << tr("Unload currently enabled profile(s). \n Value can be a controller index, name, or GUID.")
<< endl;
out << "--startSet <number> [<value>] " << " " << tr("Start joysticks on a specific set. \n Value can be a controller index, name, or GUID.")
<< endl;
out << "--next " << " " << tr("Advance profile loading set options.")
<< endl;
#ifdef Q_OS_UNIX
out << "-d, --daemon " << " "
<< tr("Launch program as a daemon.") << endl;
out << "--log-level {debug,info} " << " " << tr("Enable logging.") << endl;
#ifdef WITH_X11
#if (QT_VERSION >= QT_VERSION_CHECK(5, 0, 0))
if (QApplication::platformName() == QStringLiteral("xcb"))
{
#endif
out << "--display <value> " << " "
<< tr("Use specified display for X11 calls.\n"
" Useful for ssh.")
<< endl;
#if (QT_VERSION >= QT_VERSION_CHECK(5, 0, 0))
}
#endif
#endif
#endif
#if defined(Q_OS_UNIX) && defined(WITH_UINPUT) && defined(WITH_XTEST)
out << "--eventgen {xtest,uinput} " << " "
<< tr("Choose between using XTest support and uinput\n"
" support for event generation. Default: xtest.")
<< endl;
#elif defined(Q_OS_WIN) && defined(WITH_VMULTI)
out << "--eventgen {sendinput,vmulti} " << " "
<< tr("Choose between using SendInput and vmulti\n"
" support for event generation. Default: sendinput.")
<< endl;
#endif
#ifdef USE_SDL_2
out << "-l, --list " << " "
<< tr("Print information about joysticks detected by \n"
" SDL.") << endl;
out << "--map <value> " << " "
<< tr("Open game controller mapping window of selected\n"
" controller. Value can be a controller index or\n"
" GUID.")
<< endl;
#endif
return temp;
}
bool CommandLineUtility::isHelpRequested()
{
return helpRequest;
}
bool CommandLineUtility::isVersionRequested()
{
return versionRequest;
}
void CommandLineUtility::printVersionString()
{
QTextStream out(stdout);
out << tr("antimicro version") << " " << PadderCommon::programVersion << endl;
}
QString CommandLineUtility::generateVersionString()
{
QString temp;
QTextStream out(&temp);
out << tr("antimicro version") << " " << PadderCommon::programVersion;
return temp;
}
bool CommandLineUtility::isTrayHidden()
{
return hideTrayIcon;
}
bool CommandLineUtility::hasProfile()
{
return !profileLocation.isEmpty();
}
bool CommandLineUtility::hasControllerNumber()
{
return (controllerNumber > 0);
}
QString CommandLineUtility::getProfileLocation()
{
return profileLocation;
}
unsigned int CommandLineUtility::getControllerNumber()
{
return controllerNumber;
}
bool CommandLineUtility::hasError()
{
return encounteredError;
}
bool CommandLineUtility::isHiddenRequested()
{
return hiddenRequest;
}
bool CommandLineUtility::hasControllerID()
{
return !controllerIDString.isEmpty();
}
QString CommandLineUtility::getControllerID()
{
return controllerIDString;
}
bool CommandLineUtility::isUnloadRequested()
{
return unloadProfile;
}
unsigned int CommandLineUtility::getStartSetNumber()
{
return startSetNumber;
}
unsigned int CommandLineUtility::getJoyStartSetNumber()
{
return startSetNumber - 1;
}
bool CommandLineUtility::isPossibleCommand(QString temp)
{
bool result = false;
if (temp.startsWith("--") || temp.startsWith("-"))
{
result = true;
}
return result;
}
bool CommandLineUtility::shouldListControllers()
{
return listControllers;
}
bool CommandLineUtility::shouldMapController()
{
return mappingController;
}
QString CommandLineUtility::getEventGenerator()
{
return eventGenerator;
}
#ifdef Q_OS_UNIX
bool CommandLineUtility::launchAsDaemon()
{
return daemonMode;
}
QString CommandLineUtility::getDisplayString()
{
return displayString;
}
#endif
Logger::LogLevel CommandLineUtility::getCurrentLogLevel()
{
return currentLogLevel;
}
QString CommandLineUtility::getCurrentLogFile() {
return currentLogFile;
}
QString CommandLineUtility::getErrorText()
{
return errorText;
}
void CommandLineUtility::setErrorMessage(QString temp)
{
errorText = temp;
encounteredError = true;
}
QList<ControllerOptionsInfo>* CommandLineUtility::getControllerOptionsList()
{
return &controllerOptionsList;
}
bool CommandLineUtility::hasProfileInOptions()
{
bool result = false;
QListIterator<ControllerOptionsInfo> iter(controllerOptionsList);
while (iter.hasNext())
{
ControllerOptionsInfo temp = iter.next();
if (temp.hasProfile())
{
result = true;
iter.toBack();
}
}
return result;
}
``` | /content/code_sandbox/src/commandlineutility.cpp | c++ | 2016-05-24T23:59:31 | 2024-08-11T02:46:48 | antimicro | AntiMicro/antimicro | 1,788 | 5,173 |
```c++
/* antimicro Gamepad to KB+M event mapper
*
* This program is free software: you can redistribute it and/or modify
* (at your option) any later version.
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* along with this program. If not, see <path_to_url
*/
#include <QHash>
#include "eventhandlerfactory.h"
static QHash<QString, QString> buildDisplayNames()
{
QHash<QString, QString> temp;
#ifdef Q_OS_WIN
temp.insert("sendinput", "SendInput");
#ifdef WITH_VMULTI
temp.insert("vmulti", "Vmulti");
#endif
#else
temp.insert("xtest", "Xtest");
temp.insert("uinput", "uinput");
#endif
return temp;
}
QHash<QString, QString> handlerDisplayNames = buildDisplayNames();
EventHandlerFactory* EventHandlerFactory::instance = 0;
EventHandlerFactory::EventHandlerFactory(QString handler, QObject *parent) :
QObject(parent)
{
#ifdef Q_OS_UNIX
#ifdef WITH_UINPUT
if (handler == "uinput")
{
eventHandler = new UInputEventHandler(this);
}
#endif
#ifdef WITH_XTEST
if (handler == "xtest")
{
eventHandler = new XTestEventHandler(this);
}
#endif
#elif defined(Q_OS_WIN)
if (handler == "sendinput")
{
eventHandler = new WinSendInputEventHandler(this);
}
#ifdef WITH_VMULTI
else if (handler == "vmulti")
{
eventHandler = new WinVMultiEventHandler(this);
}
#endif
#endif
}
EventHandlerFactory::~EventHandlerFactory()
{
if (eventHandler)
{
delete eventHandler;
eventHandler = 0;
}
}
EventHandlerFactory* EventHandlerFactory::getInstance(QString handler)
{
if (!instance)
{
QStringList temp = buildEventGeneratorList();
if (!handler.isEmpty() && temp.contains(handler))
{
instance = new EventHandlerFactory(handler);
}
else
{
instance = new EventHandlerFactory(fallBackIdentifier());
}
}
return instance;
}
void EventHandlerFactory::deleteInstance()
{
if (instance)
{
delete instance;
instance = 0;
}
}
BaseEventHandler* EventHandlerFactory::handler()
{
return eventHandler;
}
QString EventHandlerFactory::fallBackIdentifier()
{
QString temp;
#ifdef Q_OS_UNIX
#if defined(WITH_XTEST)
temp = "xtest";
#elif defined(WITH_UINPUT)
temp = "uinput";
#else
temp = "xtest";
#endif
#elif defined(Q_OS_WIN)
temp = "sendinput";
#endif
return temp;
}
QStringList EventHandlerFactory::buildEventGeneratorList()
{
QStringList temp;
#ifdef Q_OS_WIN
temp.append("sendinput");
#ifdef WITH_VMULTI
temp.append("vmulti");
#endif
#else
temp.append("xtest");
temp.append("uinput");
#endif
return temp;
}
QString EventHandlerFactory::handlerDisplayName(QString handler)
{
QString temp;
if (handlerDisplayNames.contains(handler))
{
temp = handlerDisplayNames.value(handler);
}
return temp;
}
``` | /content/code_sandbox/src/eventhandlerfactory.cpp | c++ | 2016-05-24T23:59:31 | 2024-08-11T02:46:48 | antimicro | AntiMicro/antimicro | 1,788 | 728 |
```c++
/* antimicro Gamepad to KB+M event mapper
*
* This program is free software: you can redistribute it and/or modify
* (at your option) any later version.
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* along with this program. If not, see <path_to_url
*/
//#include <QDebug>
#include <QStyle>
#include <QFontMetrics>
#include <QPainter>
#include "flashbuttonwidget.h"
FlashButtonWidget::FlashButtonWidget(QWidget *parent) :
QPushButton(parent)
{
isflashing = false;
displayNames = false;
leftAlignText = false;
}
FlashButtonWidget::FlashButtonWidget(bool displayNames, QWidget *parent) :
QPushButton(parent)
{
isflashing = false;
this->displayNames = displayNames;
leftAlignText = false;
}
void FlashButtonWidget::flash()
{
isflashing = true;
this->style()->unpolish(this);
this->style()->polish(this);
emit flashed(isflashing);
}
void FlashButtonWidget::unflash()
{
isflashing = false;
this->style()->unpolish(this);
this->style()->polish(this);
emit flashed(isflashing);
}
void FlashButtonWidget::refreshLabel()
{
setText(generateLabel());
}
bool FlashButtonWidget::isButtonFlashing()
{
return isflashing;
}
void FlashButtonWidget::toggleNameDisplay()
{
displayNames = !displayNames;
refreshLabel();
}
void FlashButtonWidget::setDisplayNames(bool display)
{
displayNames = display;
}
bool FlashButtonWidget::isDisplayingNames()
{
return displayNames;
}
void FlashButtonWidget::paintEvent(QPaintEvent *event)
{
QPainter painter(this);
QFont tempScaledFont = painter.font();
QFont temp;
tempScaledFont.setPointSize(temp.pointSize());
QFontMetrics fm(tempScaledFont);
bool reduce = false;
while ((this->width() < fm.width(text())) && tempScaledFont.pointSize() >= 7)
{
tempScaledFont.setPointSize(tempScaledFont.pointSize()-1);
painter.setFont(tempScaledFont);
fm = painter.fontMetrics();
reduce = true;
}
bool changeFontSize = this->font().pointSize() != tempScaledFont.pointSize();
if (changeFontSize)
{
if (reduce && !leftAlignText)
{
leftAlignText = !leftAlignText;
setStyleSheet("text-align: left;");
this->style()->unpolish(this);
this->style()->polish(this);
}
else if (!reduce && leftAlignText)
{
leftAlignText = !leftAlignText;
setStyleSheet("text-align: center;");
this->style()->unpolish(this);
this->style()->polish(this);
}
this->setFont(tempScaledFont);
}
QPushButton::paintEvent(event);
}
void FlashButtonWidget::retranslateUi()
{
refreshLabel();
}
``` | /content/code_sandbox/src/flashbuttonwidget.cpp | c++ | 2016-05-24T23:59:31 | 2024-08-11T02:46:48 | antimicro | AntiMicro/antimicro | 1,788 | 664 |
```c++
/* antimicro Gamepad to KB+M event mapper
*
* This program is free software: you can redistribute it and/or modify
* (at your option) any later version.
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* along with this program. If not, see <path_to_url
*/
//#include <QDebug>
#include <QHashIterator>
#include <QStringList>
#include <cmath>
#include "joycontrolstick.h"
#include "inputdevice.h"
// Define Pi here.
const double JoyControlStick::PI = acos(-1.0);
// Set default values used for stick properties.
const int JoyControlStick::DEFAULTDEADZONE = 8000;
const int JoyControlStick::DEFAULTMAXZONE = JoyAxis::AXISMAXZONE;
const int JoyControlStick::DEFAULTDIAGONALRANGE = 45;
const JoyControlStick::JoyMode JoyControlStick::DEFAULTMODE = JoyControlStick::StandardMode;
const double JoyControlStick::DEFAULTCIRCLE = 0.0;
const unsigned int JoyControlStick::DEFAULTSTICKDELAY = 0;
JoyControlStick::JoyControlStick(JoyAxis *axis1, JoyAxis *axis2,
int index, int originset, QObject *parent) :
QObject(parent)
{
this->axisX = axis1;
this->axisX->setControlStick(this);
this->axisY = axis2;
this->axisY->setControlStick(this);
this->index = index;
this->originset = originset;
this->modifierButton = 0;
reset();
populateButtons();
directionDelayTimer.setSingleShot(true);
connect(&directionDelayTimer, SIGNAL(timeout()), this, SLOT(stickDirectionChangeEvent()));
}
JoyControlStick::~JoyControlStick()
{
axisX->removeControlStick(false);
axisY->removeControlStick(false);
deleteButtons();
}
/**
* @brief Take the input value for the two axes that make up a stick and
* activate the proper event based on the current values.
* @param Should set changing routines be ignored.
*/
void JoyControlStick::joyEvent(bool ignoresets)
{
safezone = !inDeadZone();
if (safezone && !isActive)
{
isActive = true;
emit active(axisX->getCurrentRawValue(), axisY->getCurrentRawValue());
if (ignoresets || stickDelay == 0)
{
if (directionDelayTimer.isActive())
{
directionDelayTimer.stop();
}
createDeskEvent(ignoresets);
}
else
{
if (!directionDelayTimer.isActive())
{
directionDelayTimer.start(stickDelay);
}
}
}
else if (!safezone && isActive)
{
isActive = false;
emit released(axisX->getCurrentRawValue(), axisY->getCurrentRawValue());
if (ignoresets || stickDelay == 0)
{
if (directionDelayTimer.isActive())
{
directionDelayTimer.stop();
}
createDeskEvent(ignoresets);
}
else
{
if (!directionDelayTimer.isActive())
{
directionDelayTimer.start(stickDelay);
}
}
}
else if (isActive)
{
if (ignoresets || stickDelay == 0)
{
if (directionDelayTimer.isActive())
{
directionDelayTimer.stop();
}
createDeskEvent(ignoresets);
}
else
{
JoyStickDirections pendingDirection = calculateStickDirection();
if (currentDirection != pendingDirection)
{
if (!directionDelayTimer.isActive())
{
directionDelayTimer.start(stickDelay);
}
}
else
{
if (directionDelayTimer.isActive())
{
directionDelayTimer.stop();
}
createDeskEvent(ignoresets);
}
}
}
emit moved(axisX->getCurrentRawValue(), axisY->getCurrentRawValue());
pendingStickEvent = false;
}
/**
* @brief Check the current stick position to see if it lies in
* the assigned dead zone.
* @return If stick position is in the assigned dead zone
*/
bool JoyControlStick::inDeadZone()
{
int axis1Value = axisX->getCurrentRawValue();
int axis2Value = axisY->getCurrentRawValue();
unsigned int squareDist = static_cast<unsigned int>(axis1Value*axis1Value) +
static_cast<unsigned int>(axis2Value*axis2Value);
return squareDist <= static_cast<unsigned int>(deadZone*deadZone);
}
/**
* @brief Populate the virtual buttons assigned to an analog stick.
*/
void JoyControlStick::populateButtons()
{
JoyControlStickButton *button = new JoyControlStickButton(this, StickUp,
originset, getParentSet(), this);
buttons.insert(StickUp, button);
button = new JoyControlStickButton(this, StickDown, originset,
getParentSet(), this);
buttons.insert(StickDown, button);
button = new JoyControlStickButton(this, StickLeft, originset,
getParentSet(), this);
buttons.insert(StickLeft, button);
button = new JoyControlStickButton(this, StickRight, originset,
getParentSet(), this);
buttons.insert(StickRight, button);
button = new JoyControlStickButton(this, StickLeftUp, originset,
getParentSet(), this);
buttons.insert(StickLeftUp, button);
button = new JoyControlStickButton(this, StickLeftDown, originset,
getParentSet(), this);
buttons.insert(StickLeftDown, button);
button = new JoyControlStickButton(this, StickRightDown, originset,
getParentSet(), this);
buttons.insert(StickRightDown, button);
button = new JoyControlStickButton(this, StickRightUp, originset,
getParentSet(), this);
buttons.insert(StickRightUp, button);
modifierButton = new JoyControlStickModifierButton(this, originset,
getParentSet(), this);
}
/**
* @brief Get the assigned dead zone value.
* @return Assigned dead zone value
*/
int JoyControlStick::getDeadZone()
{
return deadZone;
}
/**
* @brief Get the assigned diagonal range value.
* @return Assigned diagonal range.
*/
int JoyControlStick::getDiagonalRange()
{
return diagonalRange;
}
/**
* @brief Find the position of the two stick axes, deactivate no longer used
* stick direction button and then activate direction buttons for new
* direction.
* @param Should set changing operations be ignored. Necessary in the middle
* of a set change.
*/
void JoyControlStick::createDeskEvent(bool ignoresets)
{
JoyControlStickButton *eventbutton1 = 0;
JoyControlStickButton *eventbutton2 = 0;
JoyControlStickButton *eventbutton3 = 0;
if (safezone)
{
if (currentMode == StandardMode)
{
determineStandardModeEvent(eventbutton1, eventbutton2);
}
else if (currentMode == EightWayMode)
{
determineEightWayModeEvent(eventbutton1, eventbutton2, eventbutton3);
}
else if (currentMode == FourWayCardinal)
{
determineFourWayCardinalEvent(eventbutton1, eventbutton2);
}
else if (currentMode == FourWayDiagonal)
{
determineFourWayDiagonalEvent(eventbutton3);
}
}
else
{
currentDirection = StickCentered;
}
/*
* Release any currently active stick buttons.
*/
if (!eventbutton1 && activeButton1)
{
// Currently in deadzone. Disable currently active button.
performButtonRelease(activeButton1, ignoresets);
}
else if (eventbutton1 && activeButton1 && eventbutton1 != activeButton1)
{
// Deadzone skipped. Button for new event is not the currently
// active button. Disable the active button.
performButtonRelease(activeButton1, ignoresets);
}
if (!eventbutton2 && activeButton2)
{
// Currently in deadzone. Disable currently active button.
performButtonRelease(activeButton2, ignoresets);
}
else if (eventbutton2 && activeButton2 && eventbutton2 != activeButton2)
{
// Deadzone skipped. Button for new event is not the currently
// active button. Disable the active button.
performButtonRelease(activeButton2, ignoresets);
}
if (!eventbutton3 && activeButton3)
{
// Currently in deadzone. Disable currently active button.
performButtonRelease(activeButton3, ignoresets);
}
else if (eventbutton3 && activeButton3 && eventbutton3 != activeButton3)
{
// Deadzone skipped. Button for new event is not the currently
// active button. Disable the active button.
performButtonRelease(activeButton3, ignoresets);
}
if (safezone)
{
// Activate modifier button before activating directional buttons.
// Value from the new stick event will be used to determine
// distance events.
modifierButton->joyEvent(true, ignoresets);
}
else
{
// Release modifier button after releasing directional buttons.
modifierButton->joyEvent(false, ignoresets);
}
/*
* Enable stick buttons.
*/
if (eventbutton1 && !activeButton1)
{
// There is no active button. Call joyEvent and set current
// button as active button
performButtonPress(eventbutton1, activeButton1, ignoresets);
}
else if (eventbutton1 && activeButton1 && eventbutton1 == activeButton1)
{
// Button is currently active. Just pass current value
performButtonPress(eventbutton1, activeButton1, ignoresets);
}
if (eventbutton2 && !activeButton2)
{
// There is no active button. Call joyEvent and set current
// button as active button
performButtonPress(eventbutton2, activeButton2, ignoresets);
}
else if (eventbutton2 && activeButton2 && eventbutton2 == activeButton2)
{
// Button is currently active. Just pass current value
performButtonPress(eventbutton2, activeButton2, ignoresets);
}
if (eventbutton3 && !activeButton3)
{
// There is no active button. Call joyEvent and set current
// button as active button
performButtonPress(eventbutton3, activeButton3, ignoresets);
}
else if (eventbutton3 && activeButton3 && eventbutton3 == activeButton3)
{
// Button is currently active. Just pass current value
performButtonPress(eventbutton3, activeButton3, ignoresets);
}
}
/**
* @brief Calculate the bearing (in degrees) corresponding to the current
* position of the X and Y axes of a stick.
* @return Bearing (in degrees)
*/
double JoyControlStick::calculateBearing()
{
return calculateBearing(axisX->getCurrentRawValue(), axisY->getCurrentRawValue());
}
/**
* @brief Calculate the bearing (in degrees) corresponding to the
* passed X and Y axes values associated with the stick.
* @param X axis value
* @param Y axis value
* @return Bearing (in degrees)
*/
double JoyControlStick::calculateBearing(int axisXValue, int axisYValue)
{
double finalAngle = 0.0;
int axis1Value = axisXValue;
int axis2Value = axisYValue;
if (axis1Value == 0 && axis2Value == 0)
{
finalAngle = 0.0;
}
else
{
double temp1 = axis1Value;
double temp2 = axis2Value;
double angle = (atan2(temp1, -temp2) * 180) / PI;
if (axis1Value >= 0 && axis2Value <= 0)
{
// NE Quadrant
finalAngle = angle;
}
else if (axis1Value >= 0 && axis2Value >= 0)
{
// SE Quadrant (angle will be positive)
finalAngle = angle;
}
else if (axis1Value <= 0 && axis2Value >= 0)
{
// SW Quadrant (angle will be negative)
finalAngle = 360.0 + angle;
}
else if (axis1Value <= 0 && axis2Value <= 0)
{
// NW Quadrant (angle will be negative)
finalAngle = 360.0 + angle;
}
}
return finalAngle;
}
/**
* @brief Get current radial distance of the stick position past the assigned
* dead zone.
* @return Distance percentage in the range of 0.0 - 1.0.
*/
double JoyControlStick::getDistanceFromDeadZone()
{
return getDistanceFromDeadZone(axisX->getCurrentRawValue(),
axisY->getCurrentRawValue());
}
/**
* @brief Get radial distance of the stick position past the assigned dead zone
* based on the passed X and Y axes values associated with the stick.
* @param X axis value
* @param Y axis value
* @return Distance percentage in the range of 0.0 - 1.0.
*/
double JoyControlStick::getDistanceFromDeadZone(int axisXValue, int axisYValue)
{
double distance = 0.0;
int axis1Value = axisXValue;
int axis2Value = axisYValue;
double angle2 = atan2(axis1Value, -axis2Value);
double ang_sin = sin(angle2);
double ang_cos = cos(angle2);
unsigned int squared_dist = static_cast<unsigned int>(axis1Value*axis1Value)
+ static_cast<unsigned int>(axis2Value*axis2Value);
unsigned int dist = sqrt(squared_dist);
double squareStickFullPhi = qMin(ang_sin ? 1/fabs(ang_sin) : 2, ang_cos ? 1/fabs(ang_cos) : 2);
double circle = this->circle;
double circleStickFull = (squareStickFullPhi - 1) * circle + 1;
double adjustedDist = circleStickFull > 1.0 ? (dist / circleStickFull) : dist;
double adjustedDeadZone = circleStickFull > 1.0 ? (deadZone / circleStickFull) : deadZone;
distance = (adjustedDist - adjustedDeadZone)/(double)(maxZone - adjustedDeadZone);
distance = qBound(0.0, distance, 1.0);
return distance;
}
/**
* @brief Get distance of the Y axis past the assigned dead zone.
* @param Should interpolation be performed along the diagonal regions.
* @return Distance percentage in the range of 0.0 - 1.0.
*/
double JoyControlStick::calculateYDistanceFromDeadZone(bool interpolate)
{
return calculateYDistanceFromDeadZone(axisX->getCurrentRawValue(),
axisY->getCurrentRawValue(),
interpolate);
}
/**
* @brief Get distance of the Y axis past the assigned dead zone based
* on the passed X and Y axis values for the analog stick.
* @param X axis value
* @param Y axis value
* @param Should interpolation be performed along the diagonal regions.
* @return Distance percentage in the range of 0.0 - 1.0.
*/
double JoyControlStick::calculateYDistanceFromDeadZone(int axisXValue,
int axisYValue, bool interpolate)
{
double distance = 0.0;
int axis1Value = axisXValue;
int axis2Value = axisYValue;
//unsigned int square_dist = (unsigned int)(axis1Value*axis1Value) + (unsigned int)(axis2Value*axis2Value);
double angle2 = atan2(axis1Value, -axis2Value);
double ang_sin = sin(angle2);
double ang_cos = cos(angle2);
int deadY = abs(floor(deadZone * ang_cos + 0.5));
//int axis2ValueCircleFull = (int)floor(JoyAxis::AXISMAX * fabs(ang_cos) + 0.5);
double squareStickFullPhi = qMin(ang_sin ? 1/fabs(ang_sin) : 2, ang_cos ? 1/fabs(ang_cos) : 2);
double circle = this->circle;
double circleStickFull = (squareStickFullPhi - 1) * circle + 1;
//double circleToSquareTest = axis2Value * squareStickFullPhi;
double adjustedAxis2Value = circleStickFull > 1.0 ? (axis2Value / circleStickFull) : axis2Value;
double adjustedDeadYZone = circleStickFull > 1.0 ? (deadY / circleStickFull) : deadY;
// Interpolation would return the correct value if diagonalRange is 90 but
// the routine gets skipped to save time.
if (interpolate && diagonalRange < 90)
{
JoyStickDirections direction = calculateStickDirection(axis1Value, axis2Value);
if (direction == StickRightUp || direction == StickUp)
{
QList<double> tempangles = getDiagonalZoneAngles();
double maxangle = tempangles.at(3);
double minangle = tempangles.at(1);
double square_dist = getAbsoluteRawDistance(axis1Value, axis2Value);
double mindeadY = fabs(square_dist * sin(minangle * PI / 180.0));
double currentDeadY = qMax(static_cast<double>(adjustedDeadYZone), mindeadY);
double maxRange = static_cast<double>(maxZone - currentDeadY);
double tempdist4 = 0.0;
if (maxRange != 0.0)
{
tempdist4 = (fabs(adjustedAxis2Value) - currentDeadY) / maxRange;
}
distance = tempdist4;
}
else if (direction == StickRightDown || direction == StickRight)
{
QList<double> tempfuck = getDiagonalZoneAngles();
double maxangle = tempfuck.at(5);
double minangle = tempfuck.at(4);
double square_dist = getAbsoluteRawDistance(axis1Value, axis2Value);
double mindeadY = fabs(square_dist * sin((minangle - 90.0) * PI / 180.0));
double currentDeadY = qMax(static_cast<double>(adjustedDeadYZone), mindeadY);
double maxRange = static_cast<double>(maxZone - currentDeadY);
double tempdist4 = 0.0;
if (maxRange != 0.0)
{
tempdist4 = (fabs(adjustedAxis2Value) - currentDeadY) / maxRange;
}
distance = tempdist4;
}
else if (direction == StickLeftDown || direction == StickDown)
{
QList<double> tempangles = getDiagonalZoneAngles();
double maxangle = tempangles.at(7);
double minangle = tempangles.at(6);
double square_dist = getAbsoluteRawDistance(axis1Value, axis2Value);
double mindeadY = fabs(square_dist * sin((minangle - 180.0) * PI / 180.0));
double currentDeadY = qMax(static_cast<double>(adjustedDeadYZone), mindeadY);
double maxRange = static_cast<double>(maxZone - currentDeadY);
double tempdist4 = 0.0;
if (maxRange != 0.0)
{
tempdist4 = (fabs(adjustedAxis2Value) - currentDeadY) / maxRange;
}
distance = tempdist4;
}
else if (direction == StickLeftUp || direction == StickLeft)
{
QList<double> tempangles = getDiagonalZoneAngles();
double maxangle = tempangles.at(1);
double minangle = tempangles.at(8);
double square_dist = getAbsoluteRawDistance(axis1Value, axis2Value);
double mindeadY = fabs(square_dist * sin((minangle - 270.0) * PI / 180.0));
double currentDeadY = qMax(static_cast<double>(adjustedDeadYZone), mindeadY);
double maxRange = static_cast<double>(maxZone - currentDeadY);
double tempdist4 = 0.0;
if (maxRange != 0.0)
{
tempdist4 = (fabs(adjustedAxis2Value) - currentDeadY) / maxRange;
}
distance = tempdist4;
}
else
{
// Backup plan. Should not arrive here.
double maxRange = static_cast<double>(maxZone - adjustedDeadYZone);
double tempdist4 = 0.0;
if (maxRange != 0.0)
{
tempdist4 = (fabs(adjustedAxis2Value) - adjustedDeadYZone) / maxRange;
}
distance = tempdist4;
}
}
else
{
// No interpolation desired or diagonal range is 90 degrees.
double maxRange = static_cast<double>(maxZone - adjustedDeadYZone);
double tempdist4 = 0.0;
if (maxRange != 0.0)
{
tempdist4 = (fabs(adjustedAxis2Value) - adjustedDeadYZone) / maxRange;
}
distance = tempdist4;
}
distance = qBound(0.0, distance, 1.0);
return distance;
}
/**
* @brief Get distance of the X axis past the assigned dead zone.
* @param Should interpolation be performed along the diagonal regions.
* @return Distance percentage in the range of 0.0 - 1.0.
*/
double JoyControlStick::calculateXDistanceFromDeadZone(bool interpolate)
{
return calculateXDistanceFromDeadZone(axisX->getCurrentRawValue(),
axisY->getCurrentRawValue(),
interpolate);
}
/**
* @brief Get distance of the X axis past the assigned dead zone based
* on the passed X and Y axis values for the analog stick.
* @param X axis value
* @param Y axis value
* @param Should interpolation be performed along the diagonal regions.
* @return Distance percentage in the range of 0.0 - 1.0.
*/
double JoyControlStick::calculateXDistanceFromDeadZone(int axisXValue,
int axisYValue, bool interpolate)
{
double distance = 0.0;
int axis1Value = axisXValue;
int axis2Value = axisYValue;
//unsigned int square_dist = (unsigned int)(axis1Value*axis1Value) + (unsigned int)(axis2Value*axis2Value);
double angle2 = atan2(axis1Value, -axis2Value);
double ang_sin = sin(angle2);
double ang_cos = cos(angle2);
int deadX = abs((int)floor(deadZone * ang_sin + 0.5));
//int axis1ValueCircleFull = (int)floor(JoyAxis::AXISMAX * fabs(ang_sin) + 0.5);
double squareStickFullPhi = qMin(ang_sin ? 1/fabs(ang_sin) : 2, ang_cos ? 1/fabs(ang_cos) : 2);
double circle = this->circle;
double circleStickFull = (squareStickFullPhi - 1) * circle + 1;
//double alternateStickFullValue = circleStickFull * abs(axis1ValueCircleFull);
double adjustedAxis1Value = circleStickFull > 1.0 ? (axis1Value / circleStickFull) : axis1Value;
double adjustedDeadXZone = circleStickFull > 1.0 ? (deadX / circleStickFull) : deadX;
// Interpolation would return the correct value if diagonalRange is 90 but
// the routine gets skipped to save time.
if (interpolate && diagonalRange < 90)
{
JoyStickDirections direction = calculateStickDirection(axis1Value, axis2Value);
if (direction == StickRightUp || direction == StickRight)
{
QList<double> tempangles = getDiagonalZoneAngles();
double maxangle = tempangles.at(3);
double minangle = tempangles.at(1);
double square_dist = getAbsoluteRawDistance(axis1Value, axis2Value);
double mindeadX = fabs(square_dist * cos(maxangle * PI / 180.0));
double currentDeadX = qMax(mindeadX, static_cast<double>(adjustedDeadXZone));
double maxRange = static_cast<double>(maxZone - currentDeadX);
double tempdist4 = 0.0;
if (maxRange != 0.0)
{
tempdist4 = (fabs(adjustedAxis1Value) - currentDeadX) / maxRange;
}
distance = tempdist4;
}
else if (direction == StickRightDown || direction == StickDown)
{
QList<double> tempangles = getDiagonalZoneAngles();
double maxangle = tempangles.at(5);
double minangle = tempangles.at(4);
double square_dist = getAbsoluteRawDistance(axis1Value, axis2Value);
double mindeadX = fabs(square_dist * cos((maxangle - 90.0) * PI / 180.0));
double currentDeadX = qMax(mindeadX, static_cast<double>(adjustedDeadXZone));
double maxRange = static_cast<double>(maxZone - currentDeadX);
double tempdist4 = 0.0;
if (maxRange != 0.0)
{
tempdist4 = (fabs(adjustedAxis1Value) - currentDeadX) / maxRange;
}
distance = tempdist4;
}
else if (direction == StickLeftDown || direction == StickLeft)
{
QList<double> tempangles = getDiagonalZoneAngles();
double maxangle = tempangles.at(7);
double minangle = tempangles.at(6);
double square_dist = getAbsoluteRawDistance(axis1Value, axis2Value);
double mindeadX = fabs(square_dist * cos((maxangle - 180.0) * PI / 180.0));
double currentDeadX = qMax(mindeadX, static_cast<double>(adjustedDeadXZone));
double maxRange = static_cast<double>(maxZone - currentDeadX);
double tempdist4 = 0.0;
if (maxRange != 0.0)
{
tempdist4 = (fabs(adjustedAxis1Value) - currentDeadX) / maxRange;
}
distance = tempdist4;
}
else if (direction == StickLeftUp || direction == StickUp)
{
QList<double> tempangles = getDiagonalZoneAngles();
double maxangle = tempangles.at(1);
double minangle = tempangles.at(8);
double square_dist = getAbsoluteRawDistance(axis1Value, axis2Value);
double mindeadX = fabs(square_dist * cos((maxangle - 270.0) * PI / 180.0));
double currentDeadX = qMax(mindeadX, static_cast<double>(adjustedDeadXZone));
double maxRange = static_cast<double>(maxZone - currentDeadX);
double tempdist4 = 0.0;
if (maxRange != 0.0)
{
tempdist4 = (fabs(adjustedAxis1Value) - currentDeadX) / maxRange;
}
distance = tempdist4;
}
else
{
// Backup plan. Should not arrive here.
double maxRange = static_cast<double>(maxZone - adjustedDeadXZone);
double tempdist4 = 0.0;
if (maxRange != 0.0)
{
tempdist4 = (fabs(adjustedAxis1Value) - adjustedDeadXZone) / maxRange;
}
distance = tempdist4;
}
}
else
{
// No interpolation desired or diagonal range is 90 degrees.
double maxRange = static_cast<double>(maxZone - adjustedDeadXZone);
double tempdist4 = 0.0;
if (maxRange != 0.0)
{
tempdist4 = (fabs(adjustedAxis1Value) - adjustedDeadXZone) / maxRange;
}
distance = tempdist4;
}
distance = qBound(0.0, distance, 1.0);
return distance;
}
/**
* @brief Get the raw radial distance of the stick. Values will be between 0 - 32,767.
* @return Radial distance in the range of 0 - 32,767.
*/
double JoyControlStick::getAbsoluteRawDistance()
{
double temp = getAbsoluteRawDistance(axisX->getCurrentRawValue(),
axisY->getCurrentRawValue());
return temp;
}
double JoyControlStick::getAbsoluteRawDistance(int axisXValue, int axisYValue)
{
double distance = 0.0;
int axis1Value = axisXValue;
int axis2Value = axisYValue;
unsigned int square_dist = static_cast<unsigned int>(axis1Value*axis1Value) +
static_cast<unsigned int>(axis2Value*axis2Value);
distance = sqrt(square_dist);
return distance;
}
double JoyControlStick::getNormalizedAbsoluteDistance()
{
double distance = 0.0;
int axis1Value = axisX->getCurrentRawValue();
int axis2Value = axisY->getCurrentRawValue();
unsigned int square_dist = static_cast<unsigned int>(axis1Value*axis1Value)
+ static_cast<unsigned int>(axis2Value*axis2Value);
distance = sqrt(square_dist)/static_cast<double>(maxZone);
if (distance > 1.0)
{
distance = 1.0;
}
else if (distance < 0.0)
{
distance = 0.0;
}
return distance;
}
double JoyControlStick::getRadialDistance(int axisXValue, int axisYValue)
{
double distance = 0.0;
int axis1Value = axisXValue;
int axis2Value = axisYValue;
unsigned int square_dist = static_cast<unsigned int>(axis1Value*axis1Value)
+ static_cast<unsigned int>(axis2Value*axis2Value);
distance = sqrt(square_dist)/static_cast<double>(maxZone);
if (distance > 1.0)
{
distance = 1.0;
}
else if (distance < 0.0)
{
distance = 0.0;
}
return distance;
}
void JoyControlStick::setIndex(int index)
{
this->index = index;
}
int JoyControlStick::getIndex()
{
return index;
}
int JoyControlStick::getRealJoyIndex()
{
return index + 1;
}
QString JoyControlStick::getName(bool forceFullFormat, bool displayNames)
{
QString label = getPartialName(forceFullFormat, displayNames);
label.append(": ");
QStringList tempList;
if (buttons.contains(StickUp))
{
JoyControlStickButton *button = buttons.value(StickUp);
if (!button->getButtonName().isEmpty())
{
tempList.append(button->getButtonName());
}
else
{
tempList.append(button->getSlotsSummary());
}
}
if (buttons.contains(StickLeft))
{
JoyControlStickButton *button = buttons.value(StickLeft);
if (!button->getButtonName().isEmpty())
{
tempList.append(button->getButtonName());
}
else
{
tempList.append(button->getSlotsSummary());
}
}
if (buttons.contains(StickDown))
{
JoyControlStickButton *button = buttons.value(StickDown);
if (!button->getButtonName().isEmpty())
{
tempList.append(button->getButtonName());
}
else
{
tempList.append(button->getSlotsSummary());
}
}
if (buttons.contains(StickRight))
{
JoyControlStickButton *button = buttons.value(StickRight);
if (!button->getButtonName().isEmpty())
{
tempList.append(button->getButtonName());
}
else
{
tempList.append(button->getSlotsSummary());
}
}
label.append(tempList.join(", "));
return label;
}
QString JoyControlStick::getPartialName(bool forceFullFormat, bool displayNames)
{
QString label;
if (!stickName.isEmpty() && displayNames)
{
if (forceFullFormat)
{
label.append(tr("Stick")).append(" ");
}
label.append(stickName);
}
else if (!defaultStickName.isEmpty())
{
if (forceFullFormat)
{
label.append(tr("Stick")).append(" ");
}
label.append(defaultStickName);
}
else
{
label.append(tr("Stick")).append(" ");
label.append(QString::number(getRealJoyIndex()));
}
return label;
}
void JoyControlStick::setDefaultStickName(QString tempname)
{
defaultStickName = tempname;
emit stickNameChanged();
}
QString JoyControlStick::getDefaultStickName()
{
return defaultStickName;
}
int JoyControlStick::getMaxZone()
{
return maxZone;
}
int JoyControlStick::getCurrentlyAssignedSet()
{
return originset;
}
void JoyControlStick::reset()
{
deadZone = 8000;
maxZone = JoyAxis::AXISMAXZONE;
diagonalRange = 45;
isActive = false;
pendingStickEvent = false;
/*if (activeButton1)
{
activeButton1->reset();
}
activeButton1 = 0;
if (activeButton2)
{
activeButton2->reset();
}
activeButton2 = 0;*/
activeButton1 = 0;
activeButton2 = 0;
activeButton3 = 0;
safezone = false;
currentDirection = StickCentered;
currentMode = StandardMode;
stickName.clear();
circle = DEFAULTCIRCLE;
stickDelay = DEFAULTSTICKDELAY;
resetButtons();
}
void JoyControlStick::setDeadZone(int value)
{
value = abs(value);
if (value > JoyAxis::AXISMAX)
{
value = JoyAxis::AXISMAX;
}
if (value != deadZone && value < maxZone)
{
deadZone = value;
emit deadZoneChanged(value);
emit propertyUpdated();
}
}
void JoyControlStick::setMaxZone(int value)
{
value = abs(value);
if (value >= JoyAxis::AXISMAX)
{
value = JoyAxis::AXISMAX;
}
if (value != maxZone && value > deadZone)
{
maxZone = value;
emit maxZoneChanged(value);
emit propertyUpdated();
}
}
/**
* @brief Set the diagonal range value for a stick.
* @param Value between 1 - 90.
*/
void JoyControlStick::setDiagonalRange(int value)
{
if (value < 1)
{
value = 1;
}
else if (value > 90)
{
value = 90;
}
if (value != diagonalRange)
{
diagonalRange = value;
emit diagonalRangeChanged(value);
emit propertyUpdated();
}
}
/**
* @brief Delete old stick direction buttons and create new stick direction
* buttons.
*/
void JoyControlStick::refreshButtons()
{
deleteButtons();
populateButtons();
}
/**
* @brief Delete stick direction buttons and stick modifier button.
*/
void JoyControlStick::deleteButtons()
{
QHashIterator<JoyStickDirections, JoyControlStickButton*> iter(buttons);
while (iter.hasNext())
{
JoyButton *button = iter.next().value();
if (button)
{
delete button;
button = 0;
}
}
buttons.clear();
if (modifierButton)
{
delete modifierButton;
modifierButton = 0;
}
}
/**
* @brief Take a XML stream and set the stick and direction button properties
* according to the values contained within the stream.
* @param QXmlStreamReader instance that will be used to read property values.
*/
void JoyControlStick::readConfig(QXmlStreamReader *xml)
{
if (xml->isStartElement() && xml->name() == "stick")
{
xml->readNextStartElement();
while (!xml->atEnd() && (!xml->isEndElement() && xml->name() != "stick"))
{
if (xml->name() == "deadZone" && xml->isStartElement())
{
QString temptext = xml->readElementText();
int tempchoice = temptext.toInt();
this->setDeadZone(tempchoice);
}
else if (xml->name() == "maxZone" && xml->isStartElement())
{
QString temptext = xml->readElementText();
int tempchoice = temptext.toInt();
this->setMaxZone(tempchoice);
}
else if (xml->name() == "diagonalRange" && xml->isStartElement())
{
QString temptext = xml->readElementText();
int tempchoice = temptext.toInt();
this->setDiagonalRange(tempchoice);
}
else if (xml->name() == "mode" && xml->isStartElement())
{
QString temptext = xml->readElementText();
if (temptext == "eight-way")
{
this->setJoyMode(EightWayMode);
}
else if (temptext == "four-way")
{
this->setJoyMode(FourWayCardinal);
}
else if (temptext == "diagonal")
{
this->setJoyMode(FourWayDiagonal);
}
}
else if (xml->name() == "squareStick" && xml->isStartElement())
{
QString temptext = xml->readElementText();
int tempchoice = temptext.toInt();
if (tempchoice > 0 && tempchoice <= 100)
{
this->setCircleAdjust(tempchoice / 100.0);
}
}
else if (xml->name() == JoyControlStickButton::xmlName && xml->isStartElement())
{
int index = xml->attributes().value("index").toString().toInt();
JoyControlStickButton *button = buttons.value((JoyStickDirections)index);
if (button)
{
button->readConfig(xml);
}
else
{
xml->skipCurrentElement();
}
}
else if (xml->name() == JoyControlStickModifierButton::xmlName && xml->isStartElement())
{
modifierButton->readConfig(xml);
}
else if (xml->name() == "stickDelay" && xml->isStartElement())
{
QString temptext = xml->readElementText();
int tempchoice = temptext.toInt();
this->setStickDelay(tempchoice);
}
else
{
xml->skipCurrentElement();
}
xml->readNextStartElement();
}
}
}
/**
* @brief Write the status of the properties of a stick and direction buttons
* to an XML stream.
* @param QXmlStreamWriter instance that will be used to write a profile.
*/
void JoyControlStick::writeConfig(QXmlStreamWriter *xml)
{
if (!isDefault())
{
xml->writeStartElement("stick");
xml->writeAttribute("index", QString::number(index+1));
if (deadZone != DEFAULTDEADZONE)
{
xml->writeTextElement("deadZone", QString::number(deadZone));
}
if (maxZone != DEFAULTMAXZONE)
{
xml->writeTextElement("maxZone", QString::number(maxZone));
}
if (currentMode == StandardMode || currentMode == EightWayMode)
{
if (diagonalRange != DEFAULTDIAGONALRANGE)
{
xml->writeTextElement("diagonalRange", QString::number(diagonalRange));
}
}
if (currentMode == EightWayMode)
{
xml->writeTextElement("mode", "eight-way");
}
else if (currentMode == FourWayCardinal)
{
xml->writeTextElement("mode", "four-way");
}
else if (currentMode == FourWayDiagonal)
{
xml->writeTextElement("mode", "diagonal");
}
if (circle > DEFAULTCIRCLE)
{
xml->writeTextElement("squareStick", QString::number(circle * 100));
}
if (stickDelay > DEFAULTSTICKDELAY)
{
xml->writeTextElement("stickDelay", QString::number(stickDelay));
}
QHashIterator<JoyStickDirections, JoyControlStickButton*> iter(buttons);
while (iter.hasNext())
{
JoyControlStickButton *button = iter.next().value();
button->writeConfig(xml);
}
if (!modifierButton->isDefault())
{
modifierButton->writeConfig(xml);
}
xml->writeEndElement();
}
}
/**
* @brief Reset all the properties of the stick direction buttons and the
* stick modifier button.
*/
void JoyControlStick::resetButtons()
{
QHashIterator<JoyStickDirections, JoyControlStickButton*> iter(buttons);
while (iter.hasNext())
{
JoyButton *button = iter.next().value();
if (button)
{
button->reset();
}
}
if (modifierButton)
{
modifierButton->reset();
}
}
/**
* @brief Get a pointer to the stick direction button for the desired
* direction.
* @param Value of the direction of the stick.
* @return Pointer to the stick direction button for the stick
* direction.
*/
JoyControlStickButton* JoyControlStick::getDirectionButton(JoyStickDirections direction)
{
JoyControlStickButton *button = buttons.value(direction);
return button;
}
/**
* @brief Used to calculate the distance value that should be used for mouse
* movement.
* @param button
* @return Distance factor that should be used for mouse movement
*/
double JoyControlStick::calculateMouseDirectionalDistance(JoyControlStickButton *button)
{
double finalDistance = 0.0;
if (currentDirection == StickUp)
{
finalDistance = calculateYDistanceFromDeadZone(true);
}
else if (currentDirection == StickRightUp)
{
if (activeButton1 && activeButton1 == button)
{
finalDistance = calculateXDistanceFromDeadZone(true);
}
else if (activeButton2 && activeButton2 == button)
{
finalDistance = calculateYDistanceFromDeadZone(true);
}
else if (activeButton3 && activeButton3 == button)
{
finalDistance = calculateEightWayDiagonalDistanceFromDeadZone();
}
}
else if (currentDirection == StickRight)
{
finalDistance = calculateXDistanceFromDeadZone(true);
}
else if (currentDirection == StickRightDown)
{
if (activeButton1 && activeButton1 == button)
{
finalDistance = calculateXDistanceFromDeadZone(true);
}
else if (activeButton2 && activeButton2 == button)
{
finalDistance = calculateYDistanceFromDeadZone(true);
}
else if (activeButton3 && activeButton3 == button)
{
finalDistance = calculateEightWayDiagonalDistanceFromDeadZone();
}
}
else if (currentDirection == StickDown)
{
finalDistance = calculateYDistanceFromDeadZone(true);
}
else if (currentDirection == StickLeftDown)
{
if (activeButton1 && activeButton1 == button)
{
finalDistance = calculateXDistanceFromDeadZone(true);
}
else if (activeButton2 && activeButton2 == button)
{
finalDistance = calculateYDistanceFromDeadZone(true);
}
else if (activeButton3 && activeButton3 == button)
{
finalDistance = calculateEightWayDiagonalDistanceFromDeadZone();
}
}
else if (currentDirection == StickLeft)
{
finalDistance = calculateXDistanceFromDeadZone(true);
}
else if (currentDirection == StickLeftUp)
{
if (activeButton1 && activeButton1 == button)
{
finalDistance = calculateXDistanceFromDeadZone(true);
}
else if (activeButton2 && activeButton2 == button)
{
finalDistance = calculateYDistanceFromDeadZone(true);
}
else if (activeButton3 && activeButton3 == button)
{
finalDistance = calculateEightWayDiagonalDistanceFromDeadZone();
}
}
return finalDistance;
}
double JoyControlStick::calculateLastMouseDirectionalDistance(JoyControlStickButton *button)
{
double finalDistance = 0.0;
JoyStickDirections direction = calculateStickDirection(axisX->getLastKnownThrottleValue(),
axisY->getLastKnownThrottleValue());
if (direction == StickUp && button->getJoyNumber() == StickUp)
{
if (axisY->getLastKnownThrottleValue() >= 0)
{
finalDistance = 0.0;
}
else
{
finalDistance = calculateYDistanceFromDeadZone(axisX->getLastKnownThrottleValue(),
axisY->getLastKnownThrottleValue(),
true);
}
}
else if (direction == StickRightUp)
{
if (button->getJoyNumber() == StickRight)
{
if (axisX->getLastKnownThrottleValue() < 0)
{
finalDistance = 0.0;
}
else
{
finalDistance = calculateXDistanceFromDeadZone(axisX->getLastKnownThrottleValue(),
axisY->getLastKnownThrottleValue(),
true);
}
}
else if (button->getJoyNumber() == StickUp)
{
if (axisY->getLastKnownThrottleValue() >= 0)
{
finalDistance = 0.0;
}
else
{
finalDistance = calculateYDistanceFromDeadZone(axisX->getLastKnownThrottleValue(),
axisY->getLastKnownThrottleValue(),
true);
}
}
else if (button->getJoyNumber() == StickRightUp)
{
if (axisX->getLastKnownThrottleValue() <= 0 || axisY->getLastKnownThrottleValue() >= 0)
{
finalDistance = 0.0;
}
else
{
finalDistance = calculateEightWayDiagonalDistanceFromDeadZone(axisX->getLastKnownThrottleValue(),
axisY->getLastKnownThrottleValue());
}
}
}
else if (direction == StickRight && button->getJoyNumber() == StickRight)
{
if (axisX->getLastKnownThrottleValue() < 0)
{
finalDistance = 0.0;
}
else
{
finalDistance = calculateXDistanceFromDeadZone(axisX->getLastKnownThrottleValue(),
axisY->getLastKnownThrottleValue(),
true);
}
}
else if (direction == StickRightDown)
{
if (button->getJoyNumber() == StickRight)
{
if (axisX->getLastKnownThrottleValue() < 0)
{
finalDistance = 0.0;
}
else
{
finalDistance = calculateXDistanceFromDeadZone(axisX->getLastKnownThrottleValue(),
axisY->getLastKnownThrottleValue(),
true);
}
}
else if (button->getJoyNumber() == StickDown)
{
if (axisY->getLastKnownThrottleValue() < 0)
{
finalDistance = 0.0;
}
else
{
finalDistance = calculateYDistanceFromDeadZone(axisX->getLastKnownThrottleValue(),
axisY->getLastKnownThrottleValue(),
true);
}
}
else if (button->getJoyNumber() == StickRightDown)
{
if (axisX->getLastKnownThrottleValue() <= 0 || axisY->getLastKnownThrottleValue() >= 0)
{
finalDistance = 0.0;
}
else
{
finalDistance = calculateEightWayDiagonalDistanceFromDeadZone(axisX->getLastKnownThrottleValue(),
axisY->getLastKnownThrottleValue());
}
}
}
else if (direction == StickDown && button->getJoyNumber() == StickDown)
{
if (axisY->getLastKnownThrottleValue() >= 0)
{
finalDistance = 0.0;
}
else
{
finalDistance = calculateYDistanceFromDeadZone(axisX->getLastKnownThrottleValue(),
axisY->getLastKnownThrottleValue(),
true);
}
}
else if (direction == StickLeftDown)
{
if (button->getJoyNumber() == StickLeft)
{
if (axisX->getLastKnownThrottleValue() >= 0)
{
finalDistance = 0.0;
}
else
{
finalDistance = calculateXDistanceFromDeadZone(axisX->getLastKnownThrottleValue(),
axisY->getLastKnownThrottleValue(),
true);
}
}
else if (button->getJoyNumber() == StickDown)
{
if (axisY->getLastKnownThrottleValue() < 0)
{
finalDistance = 0.0;
}
else
{
finalDistance = calculateYDistanceFromDeadZone(axisX->getLastKnownThrottleValue(),
axisY->getLastKnownThrottleValue(),
true);
}
}
else if (button->getJoyNumber() == StickLeftDown)
{
if (axisX->getLastKnownThrottleValue() >= 0 || axisY->getLastKnownThrottleValue() <= 0)
{
finalDistance = 0.0;
}
else
{
finalDistance = calculateEightWayDiagonalDistanceFromDeadZone(axisX->getLastKnownThrottleValue(),
axisY->getLastKnownThrottleValue());
}
}
}
else if (direction == StickLeft && button->getJoyNumber() == StickLeft)
{
if (axisX->getLastKnownThrottleValue() >= 0)
{
finalDistance = 0.0;
}
else
{
finalDistance = calculateXDistanceFromDeadZone(axisX->getLastKnownThrottleValue(),
axisY->getLastKnownThrottleValue(),
true);
}
}
else if (direction == StickLeftUp)
{
if (button->getJoyNumber() == StickLeft)
{
if (axisX->getLastKnownThrottleValue() >= 0)
{
finalDistance = 0.0;
}
else
{
finalDistance = calculateXDistanceFromDeadZone(axisX->getLastKnownThrottleValue(),
axisY->getLastKnownThrottleValue(),
true);
}
}
else if (button->getJoyNumber() == StickUp)
{
if (axisY->getLastKnownThrottleValue() >= 0)
{
finalDistance = 0.0;
}
else
{
finalDistance = calculateYDistanceFromDeadZone(axisX->getLastKnownThrottleValue(),
axisY->getLastKnownThrottleValue(),
true);
}
}
else if (button->getJoyNumber() == StickLeftUp)
{
if (axisX->getLastKnownThrottleValue() >= 0 || axisY->getLastKnownThrottleValue() >= 0)
{
finalDistance = 0.0;
}
else
{
finalDistance = calculateEightWayDiagonalDistanceFromDeadZone(axisX->getLastKnownThrottleValue(),
axisY->getLastKnownThrottleValue());
}
}
}
return finalDistance;
}
double JoyControlStick::calculateLastDirectionalDistance()
{
double finalDistance = 0.0;
JoyStickDirections direction = calculateStickDirection(axisX->getLastKnownThrottleValue(),
axisY->getLastKnownThrottleValue());
if (direction == StickUp)
{
if (!axisX->getLastKnownThrottleValue() >= 0)
{
finalDistance = calculateYDistanceFromDeadZone(axisX->getLastKnownThrottleValue(),
axisY->getLastKnownThrottleValue());
}
}
else if (direction == StickRightUp)
{
if (!axisY->getLastKnownThrottleValue() <= 0 && !axisY->getLastKnownThrottleValue() >= 0)
{
finalDistance = calculateEightWayDiagonalDistanceFromDeadZone(axisX->getLastKnownThrottleValue(),
axisY->getLastKnownThrottleValue());
}
}
else if (direction == StickRight)
{
if (!axisX->getLastKnownThrottleValue() <= 0)
{
finalDistance = calculateXDistanceFromDeadZone(axisX->getLastKnownThrottleValue(),
axisY->getLastKnownThrottleValue());
}
}
else if (direction == StickRightDown)
{
if (!axisY->getLastKnownThrottleValue() <= 0 && !axisY->getLastKnownThrottleValue() <= 0)
{
finalDistance = calculateEightWayDiagonalDistanceFromDeadZone(axisX->getLastKnownThrottleValue(),
axisY->getLastKnownThrottleValue());
}
}
else if (direction == StickDown)
{
if (!axisY->getLastKnownThrottleValue() <= 0)
{
finalDistance = calculateYDistanceFromDeadZone(axisX->getLastKnownThrottleValue(),
axisY->getLastKnownThrottleValue());
}
}
else if (direction == StickLeftDown)
{
if (!axisY->getLastKnownThrottleValue() >= 0 && !axisY->getLastKnownThrottleValue() <= 0)
{
finalDistance = calculateEightWayDiagonalDistanceFromDeadZone(axisX->getLastKnownThrottleValue(),
axisY->getLastKnownThrottleValue());
}
}
else if (direction == StickLeft)
{
if (!axisX->getLastKnownThrottleValue() >= 0)
{
finalDistance = calculateXDistanceFromDeadZone(axisX->getLastKnownThrottleValue(),
axisY->getLastKnownThrottleValue());
}
}
else if (direction == StickLeftUp)
{
if (!axisY->getLastKnownThrottleValue() >= 0 && !axisY->getLastKnownThrottleValue() >= 0)
{
finalDistance = calculateEightWayDiagonalDistanceFromDeadZone(axisX->getLastKnownThrottleValue(),
axisY->getLastKnownThrottleValue());
}
}
return finalDistance;
}
double JoyControlStick::calculateLastAccelerationDirectionalDistance()
{
double finalDistance = 0.0;
if (currentDirection == StickUp)
{
if (!axisX->getLastKnownRawValue() >= 0)
{
finalDistance = calculateYAxisDistance(axisY->getLastKnownRawValue());
}
}
else if (currentDirection == StickRightUp)
{
if (!axisY->getLastKnownRawValue() <= 0 && !axisY->getLastKnownRawValue() >= 0)
{
finalDistance = calculateEightWayDiagonalDistance(axisX->getLastKnownRawValue(), axisY->getLastKnownRawValue());
}
}
else if (currentDirection == StickRight)
{
if (!axisX->getLastKnownRawValue() <= 0)
{
finalDistance = calculateXAxisDistance(axisX->getLastKnownRawValue());
}
}
else if (currentDirection == StickRightDown)
{
if (!axisY->getLastKnownRawValue() <= 0 && !axisY->getLastKnownRawValue() <= 0)
{
finalDistance = calculateEightWayDiagonalDistance(axisX->getLastKnownRawValue(), axisY->getLastKnownRawValue());
}
}
else if (currentDirection == StickDown)
{
if (!axisY->getLastKnownRawValue() <= 0)
{
finalDistance = calculateYAxisDistance(axisY->getLastKnownRawValue());
}
}
else if (currentDirection == StickLeftDown)
{
if (!axisY->getLastKnownRawValue() >= 0 && !axisY->getLastKnownRawValue() <= 0)
{
finalDistance = calculateEightWayDiagonalDistance(axisX->getLastKnownRawValue(), axisY->getLastKnownRawValue());
}
}
else if (currentDirection == StickLeft)
{
if (!axisX->getLastKnownRawValue() >= 0)
{
finalDistance = calculateXAxisDistance(axisX->getLastKnownRawValue());
}
}
else if (currentDirection == StickLeftUp)
{
if (!axisY->getLastKnownRawValue() >= 0 && !axisY->getLastKnownRawValue() >= 0)
{
finalDistance = calculateEightWayDiagonalDistance(axisX->getLastKnownRawValue(), axisY->getLastKnownRawValue());
}
}
return finalDistance;
}
/**
* @brief Used to calculate the distance value that should be used for keyboard
* events and distance slots
* @return Distance factor that should be used for keyboard events and
* distance slots
*/
double JoyControlStick::calculateDirectionalDistance()
{
double finalDistance = 0.0;
if (currentDirection == StickUp)
{
finalDistance = calculateYDistanceFromDeadZone();
}
else if (currentDirection == StickRightUp)
{
finalDistance = getDistanceFromDeadZone();
}
else if (currentDirection == StickRight)
{
finalDistance = calculateXDistanceFromDeadZone();
}
else if (currentDirection == StickRightDown)
{
finalDistance = getDistanceFromDeadZone();
}
else if (currentDirection == StickDown)
{
finalDistance = calculateYDistanceFromDeadZone();
}
else if (currentDirection == StickLeftDown)
{
finalDistance = getDistanceFromDeadZone();
}
else if (currentDirection == StickLeft)
{
finalDistance = calculateXDistanceFromDeadZone();
}
else if (currentDirection == StickLeftUp)
{
finalDistance = getDistanceFromDeadZone();
}
return finalDistance;
}
/**
* @brief Get the value for the currently active stick direction.
* @return Value of the corresponding active stick direction.
*/
JoyControlStick::JoyStickDirections JoyControlStick::getCurrentDirection()
{
return currentDirection;
}
/**
* @brief Get the value for the corresponding X axis.
* @return X axis value.
*/
int JoyControlStick::getXCoordinate()
{
return axisX->getCurrentRawValue();
}
/**
* @brief Get the value for the corresponding Y axis.
* @return Y axis value.
*/
int JoyControlStick::getYCoordinate()
{
return axisY->getCurrentRawValue();
}
int JoyControlStick::getCircleXCoordinate()
{
int axisXValue = axisX->getCurrentRawValue();
int axisYValue = axisX->getCurrentRawValue();
if (this->circle > 0.0)
{
axisXValue = calculateCircleXValue(axisXValue, axisYValue);
}
return axisXValue;
}
int JoyControlStick::getCircleYCoordinate()
{
int axisXValue = axisX->getCurrentRawValue();
int axisYValue = axisY->getCurrentRawValue();
if (this->circle > 0.0)
{
axisYValue = calculateCircleYValue(axisXValue, axisYValue);
}
return axisYValue;
}
int JoyControlStick::calculateCircleXValue(int axisXValue, int axisYValue)
{
int value = axisXValue;
if (this->circle > 0.0)
{
int axis1Value = axisXValue;
int axis2Value = axisYValue;
double angle2 = atan2(axis1Value, -axis2Value);
double ang_sin = sin(angle2);
double ang_cos = cos(angle2);
//int axisXValueCircleFull = static_cast<int>(floor(JoyAxis::AXISMAX * fabs(ang_sin) + 0.5));
double squareStickFull = qMin(ang_sin ? 1/fabs(ang_sin) : 2, ang_cos ? 1/fabs(ang_cos) : 2);
double circle = this->circle;
double circleStickFull = (squareStickFull - 1) * circle + 1;
//double alternateStickFullValue = circleStickFull * abs(axisXValueCircleFull);
//value = circleStickFull > 1.0 ? static_cast<int>(floor((axisXValue / alternateStickFullValue) * abs(axisXValueCircleFull) + 0.5)) : value;
value = circleStickFull > 1.0 ? static_cast<int>(floor((axisXValue / circleStickFull) + 0.5)) : value;
}
return value;
}
int JoyControlStick::calculateCircleYValue(int axisXValue, int axisYValue)
{
int value = axisYValue;
if (this->circle > 0.0)
{
int axis1Value = axisXValue;
int axis2Value = axisYValue;
double angle2 = atan2(axis1Value, -axis2Value);
double ang_sin = sin(angle2);
double ang_cos = cos(angle2);
//int axisYValueCircleFull = static_cast<int>(floor(JoyAxis::AXISMAX * fabs(ang_cos) + 0.5));
double squareStickFull = qMin(ang_sin ? 1/fabs(ang_sin) : 2, ang_cos ? 1/fabs(ang_cos) : 2);
double circle = this->circle;
double circleStickFull = (squareStickFull - 1) * circle + 1;
//double alternateStickFullValue = circleStickFull * abs(axisYValueCircleFull);
//value = circleStickFull > 1.0 ? static_cast<int>(floor((axisYValue / alternateStickFullValue) * abs(axisYValueCircleFull) + 0.5)) : value;
value = circleStickFull > 1.0 ? static_cast<int>(floor((axisYValue / circleStickFull) + 0.5)) : value;
}
return value;
}
QList<double> JoyControlStick::getDiagonalZoneAngles()
{
QList<double> anglesList;
int diagonalAngle = diagonalRange;
double cardinalAngle = (360 - (diagonalAngle * 4)) / 4.0;
double initialLeft = 360 - ((cardinalAngle) / 2.0);
double initialRight = ((cardinalAngle)/ 2.0);
/*if ((int)(cardinalAngle - 1) % 2 != 0)
{
initialLeft = 360 - (cardinalAngle / 2.0);
initialRight = (cardinalAngle / 2.0) - 1;
}
*/
double upRightInitial = initialRight;
double rightInitial = upRightInitial + diagonalAngle;
double downRightInitial = rightInitial + cardinalAngle;
double downInitial = downRightInitial + diagonalAngle;
double downLeftInitial = downInitial + cardinalAngle;
double leftInitial = downLeftInitial + diagonalAngle;
double upLeftInitial = leftInitial + cardinalAngle;
anglesList.append(initialLeft);
anglesList.append(initialRight);
anglesList.append(upRightInitial);
anglesList.append(rightInitial);
anglesList.append(downRightInitial);
anglesList.append(downInitial);
anglesList.append(downLeftInitial);
anglesList.append(leftInitial);
anglesList.append(upLeftInitial);
return anglesList;
}
QList<int> JoyControlStick::getFourWayCardinalZoneAngles()
{
QList<int> anglesList;
int zoneRange = 90;
int rightInitial = 45;
int downInitial = rightInitial + zoneRange;
int leftInitial = downInitial + zoneRange;
int upInitial = leftInitial + zoneRange;
anglesList.append(rightInitial);
anglesList.append(downInitial);
anglesList.append(leftInitial);
anglesList.append(upInitial);
return anglesList;
}
QList<int> JoyControlStick::getFourWayDiagonalZoneAngles()
{
QList<int> anglesList;
int zoneRange = 90;
int upRightInitial = 0;
int downRightInitial = zoneRange;
int downLeftInitial = downRightInitial + zoneRange;
int upLeftInitial = downLeftInitial + zoneRange;
anglesList.append(upRightInitial);
anglesList.append(downRightInitial);
anglesList.append(downLeftInitial);
anglesList.append(upLeftInitial);
return anglesList;
}
QHash<JoyControlStick::JoyStickDirections, JoyControlStickButton*>* JoyControlStick::getButtons()
{
return &buttons;
}
JoyAxis* JoyControlStick::getAxisX()
{
return axisX;
}
JoyAxis* JoyControlStick::getAxisY()
{
return axisY;
}
void JoyControlStick::replaceXAxis(JoyAxis *axis)
{
if (axis->getParentSet() == axisY->getParentSet())
{
axisX->removeControlStick();
this->axisX = axis;
this->axisX->setControlStick(this);
}
}
void JoyControlStick::replaceYAxis(JoyAxis *axis)
{
if (axis->getParentSet() == axisX->getParentSet())
{
axisY->removeControlStick();
this->axisY = axis;
this->axisY->setControlStick(this);
}
}
void JoyControlStick::replaceAxes(JoyAxis *axisX, JoyAxis *axisY)
{
if (axisX->getParentSet() == axisY->getParentSet())
{
this->axisX->removeControlStick();
this->axisY->removeControlStick();
this->axisX = axisX;
this->axisY = axisY;
this->axisX->setControlStick(this);
this->axisY->setControlStick(this);
}
}
void JoyControlStick::setJoyMode(JoyMode mode)
{
currentMode = mode;
emit joyModeChanged();
emit propertyUpdated();
}
JoyControlStick::JoyMode JoyControlStick::getJoyMode()
{
return currentMode;
}
void JoyControlStick::releaseButtonEvents()
{
QHashIterator<JoyStickDirections, JoyControlStickButton*> iter(buttons);
while (iter.hasNext())
{
JoyControlStickButton *button = iter.next().value();
button->joyEvent(false, true);
}
}
bool JoyControlStick::isDefault()
{
bool value = true;
value = value && (deadZone == DEFAULTDEADZONE);
value = value && (maxZone == DEFAULTMAXZONE);
value = value && (diagonalRange == DEFAULTDIAGONALRANGE);
value = value && (currentMode == DEFAULTMODE);
value = value && (circle == DEFAULTCIRCLE);
value = value && (stickDelay == DEFAULTSTICKDELAY);
QHashIterator<JoyStickDirections, JoyControlStickButton*> iter(buttons);
while (iter.hasNext())
{
JoyControlStickButton *button = iter.next().value();
value = value && (button->isDefault());
}
if (modifierButton)
{
value = value && modifierButton->isDefault();
}
return value;
}
void JoyControlStick::setButtonsMouseMode(JoyButton::JoyMouseMovementMode mode)
{
QHashIterator<JoyStickDirections, JoyControlStickButton*> iter(buttons);
while (iter.hasNext())
{
JoyControlStickButton *button = iter.next().value();
button->setMouseMode(mode);
}
}
bool JoyControlStick::hasSameButtonsMouseMode()
{
bool result = true;
JoyButton::JoyMouseMovementMode initialMode = JoyButton::MouseCursor;
QHash<JoyStickDirections, JoyControlStickButton*> temphash = getApplicableButtons();
QHashIterator<JoyStickDirections, JoyControlStickButton*> iter(temphash);
while (iter.hasNext())
{
if (!iter.hasPrevious())
{
JoyControlStickButton *button = iter.next().value();
initialMode = button->getMouseMode();
}
else
{
JoyControlStickButton *button = iter.next().value();
JoyButton::JoyMouseMovementMode temp = button->getMouseMode();
if (temp != initialMode)
{
result = false;
iter.toBack();
}
}
}
return result;
}
JoyButton::JoyMouseMovementMode JoyControlStick::getButtonsPresetMouseMode()
{
JoyButton::JoyMouseMovementMode resultMode = JoyButton::MouseCursor;
QHash<JoyStickDirections, JoyControlStickButton*> temphash = getApplicableButtons();
QHashIterator<JoyStickDirections, JoyControlStickButton*> iter(temphash);
while (iter.hasNext())
{
if (!iter.hasPrevious())
{
JoyControlStickButton *button = iter.next().value();
resultMode = button->getMouseMode();
}
else
{
JoyControlStickButton *button = iter.next().value();
JoyButton::JoyMouseMovementMode temp = button->getMouseMode();
if (temp != resultMode)
{
resultMode = JoyButton::MouseCursor;
iter.toBack();
}
}
}
return resultMode;
}
void JoyControlStick::setButtonsMouseCurve(JoyButton::JoyMouseCurve mouseCurve)
{
QHashIterator<JoyStickDirections, JoyControlStickButton*> iter(buttons);
while (iter.hasNext())
{
JoyControlStickButton *button = iter.next().value();
button->setMouseCurve(mouseCurve);
}
}
bool JoyControlStick::hasSameButtonsMouseCurve()
{
bool result = true;
JoyButton::JoyMouseCurve initialCurve = JoyButton::LinearCurve;
QHash<JoyStickDirections, JoyControlStickButton*> temphash = getApplicableButtons();
QHashIterator<JoyStickDirections, JoyControlStickButton*> iter(temphash);
while (iter.hasNext())
{
if (!iter.hasPrevious())
{
JoyControlStickButton *button = iter.next().value();
initialCurve = button->getMouseCurve();
}
else
{
JoyControlStickButton *button = iter.next().value();
JoyButton::JoyMouseCurve temp = button->getMouseCurve();
if (temp != initialCurve)
{
result = false;
iter.toBack();
}
}
}
return result;
}
JoyButton::JoyMouseCurve JoyControlStick::getButtonsPresetMouseCurve()
{
JoyButton::JoyMouseCurve resultCurve = JoyButton::LinearCurve;
QHash<JoyStickDirections, JoyControlStickButton*> temphash = getApplicableButtons();
QHashIterator<JoyStickDirections, JoyControlStickButton*> iter(temphash);
while (iter.hasNext())
{
if (!iter.hasPrevious())
{
JoyControlStickButton *button = iter.next().value();
resultCurve = button->getMouseCurve();
}
else
{
JoyControlStickButton *button = iter.next().value();
JoyButton::JoyMouseCurve temp = button->getMouseCurve();
if (temp != resultCurve)
{
resultCurve = JoyButton::LinearCurve;
iter.toBack();
}
}
}
return resultCurve;
}
void JoyControlStick::setButtonsSpringWidth(int value)
{
QHashIterator<JoyStickDirections, JoyControlStickButton*> iter(buttons);
while (iter.hasNext())
{
JoyControlStickButton *button = iter.next().value();
button->setSpringWidth(value);
}
}
void JoyControlStick::setButtonsSpringHeight(int value)
{
QHashIterator<JoyStickDirections, JoyControlStickButton*> iter(buttons);
while (iter.hasNext())
{
JoyControlStickButton *button = iter.next().value();
button->setSpringHeight(value);
}
}
int JoyControlStick::getButtonsPresetSpringWidth()
{
int presetSpringWidth = 0;
QHash<JoyStickDirections, JoyControlStickButton*> temphash = getApplicableButtons();
QHashIterator<JoyStickDirections, JoyControlStickButton*> iter(temphash);
while (iter.hasNext())
{
if (!iter.hasPrevious())
{
JoyControlStickButton *button = iter.next().value();
presetSpringWidth = button->getSpringWidth();
}
else
{
JoyControlStickButton *button = iter.next().value();
int temp = button->getSpringWidth();
if (temp != presetSpringWidth)
{
presetSpringWidth = 0;
iter.toBack();
}
}
}
return presetSpringWidth;
}
int JoyControlStick::getButtonsPresetSpringHeight()
{
int presetSpringHeight = 0;
QHash<JoyStickDirections, JoyControlStickButton*> temphash = getApplicableButtons();
QHashIterator<JoyStickDirections, JoyControlStickButton*> iter(temphash);
while (iter.hasNext())
{
if (!iter.hasPrevious())
{
JoyControlStickButton *button = iter.next().value();
presetSpringHeight = button->getSpringHeight();
}
else
{
JoyControlStickButton *button = iter.next().value();
int temp = button->getSpringHeight();
if (temp != presetSpringHeight)
{
presetSpringHeight = 0;
iter.toBack();
}
}
}
return presetSpringHeight;
}
void JoyControlStick::setButtonsSensitivity(double value)
{
QHashIterator<JoyStickDirections, JoyControlStickButton*> iter(buttons);
while (iter.hasNext())
{
JoyControlStickButton *button = iter.next().value();
button->setSensitivity(value);
}
}
double JoyControlStick::getButtonsPresetSensitivity()
{
double presetSensitivity = 1.0;
QHash<JoyStickDirections, JoyControlStickButton*> temphash = getApplicableButtons();
QHashIterator<JoyStickDirections, JoyControlStickButton*> iter(temphash);
while (iter.hasNext())
{
if (!iter.hasPrevious())
{
JoyControlStickButton *button = iter.next().value();
presetSensitivity = button->getSensitivity();
}
else
{
JoyControlStickButton *button = iter.next().value();
double temp = button->getSensitivity();
if (temp != presetSensitivity)
{
presetSensitivity = 1.0;
iter.toBack();
}
}
}
return presetSensitivity;
}
QHash<JoyControlStick::JoyStickDirections, JoyControlStickButton*> JoyControlStick::getApplicableButtons()
{
QHash<JoyStickDirections, JoyControlStickButton*> temphash;
if (currentMode == StandardMode || currentMode == EightWayMode ||
currentMode == FourWayCardinal)
{
temphash.insert(StickUp, buttons.value(StickUp));
temphash.insert(StickDown, buttons.value(StickDown));
temphash.insert(StickLeft, buttons.value(StickLeft));
temphash.insert(StickRight, buttons.value(StickRight));
}
if (currentMode == EightWayMode || currentMode == FourWayDiagonal)
{
temphash.insert(StickLeftUp, buttons.value(StickLeftUp));
temphash.insert(StickRightUp, buttons.value(StickRightUp));
temphash.insert(StickRightDown, buttons.value(StickRightDown));
temphash.insert(StickLeftDown, buttons.value(StickLeftDown));
}
return temphash;
}
void JoyControlStick::setStickName(QString tempName)
{
if (tempName.length() <= 20 && tempName != stickName)
{
stickName = tempName;
emit stickNameChanged();
emit propertyUpdated();
}
}
QString JoyControlStick::getStickName()
{
return stickName;
}
void JoyControlStick::setButtonsWheelSpeedX(int value)
{
QHashIterator<JoyStickDirections, JoyControlStickButton*> iter(buttons);
while (iter.hasNext())
{
JoyControlStickButton *button = iter.next().value();
button->setWheelSpeedX(value);
}
}
void JoyControlStick::setButtonsWheelSpeedY(int value)
{
QHashIterator<JoyStickDirections, JoyControlStickButton*> iter(buttons);
while (iter.hasNext())
{
JoyControlStickButton *button = iter.next().value();
button->setWheelSpeedY(value);
}
}
/**
* @brief Get pointer to the set that a stick belongs to.
* @return Pointer to the set that a stick belongs to.
*/
SetJoystick* JoyControlStick::getParentSet()
{
SetJoystick *temp = 0;
if (axisX)
{
temp = axisX->getParentSet();
}
else if (axisY)
{
temp = axisY->getParentSet();
}
return temp;
}
/**
* @brief Activate a stick direction button.
* @param Stick direction button that will be activated.
* @param [out] Pointer to the currently active button.
* @param Should set changing routines be ignored.
*/
void JoyControlStick::performButtonPress(JoyControlStickButton *eventbutton, JoyControlStickButton *&activebutton, bool ignoresets)
{
activebutton = eventbutton;
eventbutton->joyEvent(true, ignoresets);
}
/**
* @brief Stick direction button to release.
* @param Stick direction button that will be released.
* @param Should set changing routines be ignored.
*/
void JoyControlStick::performButtonRelease(JoyControlStickButton *&eventbutton, bool ignoresets)
{
eventbutton->joyEvent(false, ignoresets);
eventbutton = 0;
}
/**
* @brief Determine which stick direction buttons should be active for a
* standard mode stick.
* @param [out] Pointer to an X axis stick direction button that should be active.
* @param [out] Pointer to a Y axis stick direction button that should be active.
*/
void JoyControlStick::determineStandardModeEvent(JoyControlStickButton *&eventbutton1, JoyControlStickButton *&eventbutton2)
{
double bearing = calculateBearing();
QList<double> anglesList = getDiagonalZoneAngles();
double initialLeft = anglesList.value(0);
double initialRight = anglesList.value(1);
double upRightInitial = anglesList.value(2);
double rightInitial = anglesList.value(3);
double downRightInitial = anglesList.value(4);
double downInitial = anglesList.value(5);
double downLeftInitial = anglesList.value(6);
double leftInitial = anglesList.value(7);
double upLeftInitial = anglesList.value(8);
//bearing = floor(bearing + 0.5);
if (bearing <= initialRight || bearing >= initialLeft)
{
currentDirection = StickUp;
eventbutton2 = buttons.value(StickUp);
}
else if (bearing >= upRightInitial && bearing < rightInitial)
{
currentDirection = StickRightUp;
eventbutton1 = buttons.value(StickRight);
eventbutton2 = buttons.value(StickUp);
}
else if (bearing >= rightInitial && bearing < downRightInitial)
{
currentDirection = StickRight;
eventbutton1 = buttons.value(StickRight);
}
else if (bearing >= downRightInitial && bearing < downInitial)
{
currentDirection = StickRightDown;
eventbutton1 = buttons.value(StickRight);
eventbutton2 = buttons.value(StickDown);
}
else if (bearing >= downInitial && bearing < downLeftInitial)
{
currentDirection = StickDown;
eventbutton2 = buttons.value(StickDown);
}
else if (bearing >= downLeftInitial && bearing < leftInitial)
{
currentDirection = StickLeftDown;
eventbutton1 = buttons.value(StickLeft);
eventbutton2 = buttons.value(StickDown);
}
else if (bearing >= leftInitial && bearing < upLeftInitial)
{
currentDirection = StickLeft;
eventbutton1 = buttons.value(StickLeft);
}
else if (bearing >= upLeftInitial && bearing < initialLeft)
{
currentDirection = StickLeftUp;
eventbutton1 = buttons.value(StickLeft);
eventbutton2 = buttons.value(StickUp);
}
}
/**
* @brief Determine which stick direction button should be active for a 8 way
* mode stick.
* @param [out] Pointer to an X axis stick direction button that should be active.
* @param [out] Pointer to a Y axis stick direction button that should be active.
* @param [out] Pointer to a diagonal stick direction button that should be active.
*/
void JoyControlStick::determineEightWayModeEvent(JoyControlStickButton *&eventbutton1, JoyControlStickButton *&eventbutton2, JoyControlStickButton *&eventbutton3)
{
double bearing = calculateBearing();
QList<double> anglesList = getDiagonalZoneAngles();
double initialLeft = anglesList.value(0);
double initialRight = anglesList.value(1);
double upRightInitial = anglesList.value(2);
double rightInitial = anglesList.value(3);
double downRightInitial = anglesList.value(4);
double downInitial = anglesList.value(5);
double downLeftInitial = anglesList.value(6);
double leftInitial = anglesList.value(7);
double upLeftInitial = anglesList.value(8);
//bearing = floor(bearing + 0.5);
if (bearing <= initialRight || bearing >= initialLeft)
{
currentDirection = StickUp;
eventbutton2 = buttons.value(StickUp);
}
else if (bearing >= upRightInitial && bearing < rightInitial)
{
currentDirection = StickRightUp;
eventbutton3 = buttons.value(StickRightUp);
}
else if (bearing >= rightInitial && bearing < downRightInitial)
{
currentDirection = StickRight;
eventbutton1 = buttons.value(StickRight);
}
else if (bearing >= downRightInitial && bearing < downInitial)
{
currentDirection = StickRightDown;
eventbutton3 = buttons.value(StickRightDown);
}
else if (bearing >= downInitial && bearing < downLeftInitial)
{
currentDirection = StickDown;
eventbutton2 = buttons.value(StickDown);
}
else if (bearing >= downLeftInitial && bearing < leftInitial)
{
currentDirection = StickLeftDown;
eventbutton3 = buttons.value(StickLeftDown);
}
else if (bearing >= leftInitial && bearing < upLeftInitial)
{
currentDirection = StickLeft;
eventbutton1 = buttons.value(StickLeft);
}
else if (bearing >= upLeftInitial && bearing < initialLeft)
{
currentDirection = StickLeftUp;
eventbutton3 = buttons.value(StickLeftUp);
}
}
/**
* @brief Determine which cardinal stick direction button should be active
* when using a four way cardinal stick.
* @param [out] Pointer to an X axis stick direction button that should be active.
* @param [out] Pointer to a Y axis stick direction button that should be active.
*/
void JoyControlStick::determineFourWayCardinalEvent(JoyControlStickButton *&eventbutton1, JoyControlStickButton *&eventbutton2)
{
double bearing = calculateBearing();
QList<int> anglesList = getFourWayCardinalZoneAngles();
int rightInitial = anglesList.value(0);
int downInitial = anglesList.value(1);
int leftInitial = anglesList.value(2);
int upInitial = anglesList.value(3);
//bearing = floor(bearing + 0.5);
if (bearing < rightInitial || bearing >= upInitial)
{
currentDirection = StickUp;
eventbutton2 = buttons.value(StickUp);
}
else if (bearing >= rightInitial && bearing < downInitial)
{
currentDirection = StickRight;
eventbutton1 = buttons.value(StickRight);
}
else if (bearing >= downInitial && bearing < leftInitial)
{
currentDirection = StickDown;
eventbutton2 = buttons.value(StickDown);
}
else if (bearing >= leftInitial && bearing < upInitial)
{
currentDirection = StickLeft;
eventbutton1 = buttons.value(StickLeft);
}
}
/**
* @brief Determine which stick direction button should be active when using 4 way
* diagonal mode.
* @param [out] pointer to a diagonal stick direction button that should be active.
*/
void JoyControlStick::determineFourWayDiagonalEvent(JoyControlStickButton *&eventbutton3)
{
double bearing = calculateBearing();
QList<int> anglesList = getFourWayDiagonalZoneAngles();
int upRightInitial = anglesList.value(0);
int downRightInitial = anglesList.value(1);
int downLeftInitial = anglesList.value(2);
int upLeftInitial = anglesList.value(3);
//bearing = floor(bearing + 0.5);
if (bearing >= upRightInitial && bearing < downRightInitial)
{
currentDirection = StickRightUp;
eventbutton3 = buttons.value(StickRightUp);
}
else if (bearing >= downRightInitial && bearing < downLeftInitial)
{
currentDirection = StickRightDown;
eventbutton3 = buttons.value(StickRightDown);
}
else if (bearing >= downLeftInitial && bearing < upLeftInitial)
{
currentDirection = StickLeftDown;
eventbutton3 = buttons.value(StickLeftDown);
}
else if (bearing >= upLeftInitial)
{
currentDirection = StickLeftUp;
eventbutton3 = buttons.value(StickLeftUp);
}
}
/**
* @brief Find the current stick direction based on a Standard mode stick.
* @return Current direction the stick is positioned.
*/
JoyControlStick::JoyStickDirections JoyControlStick::determineStandardModeDirection()
{
return determineStandardModeDirection(axisX->getCurrentRawValue(),
axisY->getCurrentRawValue());
}
JoyControlStick::JoyStickDirections
JoyControlStick::determineStandardModeDirection(int axisXValue, int axisYValue)
{
JoyStickDirections result = StickCentered;
double bearing = calculateBearing(axisXValue, axisYValue);
//bearing = floor(bearing + 0.5);
QList<double> anglesList = getDiagonalZoneAngles();
int initialLeft = anglesList.value(0);
int initialRight = anglesList.value(1);
int upRightInitial = anglesList.value(2);
int rightInitial = anglesList.value(3);
int downRightInitial = anglesList.value(4);
int downInitial = anglesList.value(5);
int downLeftInitial = anglesList.value(6);
int leftInitial = anglesList.value(7);
int upLeftInitial = anglesList.value(8);
if (bearing <= initialRight || bearing >= initialLeft)
{
result = StickUp;
}
else if (bearing >= upRightInitial && bearing < rightInitial)
{
result = StickRightUp;
}
else if (bearing >= rightInitial && bearing < downRightInitial)
{
result = StickRight;
}
else if (bearing >= downRightInitial && bearing < downInitial)
{
result = StickRightDown;
}
else if (bearing >= downInitial && bearing < downLeftInitial)
{
result = StickDown;
}
else if (bearing >= downLeftInitial && bearing < leftInitial)
{
result = StickLeftDown;
}
else if (bearing >= leftInitial && bearing < upLeftInitial)
{
result = StickLeft;
}
else if (bearing >= upLeftInitial && bearing < initialLeft)
{
result = StickLeftUp;
}
return result;
}
/**
* @brief Find the current stick direction based on a Eight Way mode stick.
* @return Current direction the stick is positioned.
*/
JoyControlStick::JoyStickDirections
JoyControlStick::determineEightWayModeDirection()
{
return determineStandardModeDirection(axisX->getCurrentRawValue(),
axisY->getCurrentRawValue());
}
JoyControlStick::JoyStickDirections
JoyControlStick::determineEightWayModeDirection(int axisXValue, int axisYValue)
{
return determineStandardModeDirection(axisXValue, axisYValue);
}
/**
* @brief Find the current stick direction based on a Four Way Cardinal mode
* stick.
* @return Current direction the stick is positioned.
*/
JoyControlStick::JoyStickDirections
JoyControlStick::determineFourWayCardinalDirection()
{
return determineFourWayCardinalDirection(axisX->getCurrentRawValue(),
axisY->getCurrentRawValue());
}
JoyControlStick::JoyStickDirections
JoyControlStick::determineFourWayCardinalDirection(int axisXValue, int axisYValue)
{
JoyStickDirections result = StickCentered;
double bearing = calculateBearing(axisXValue, axisYValue);
//bearing = floor(bearing + 0.5);
QList<int> anglesList = getFourWayCardinalZoneAngles();
int rightInitial = anglesList.value(0);
int downInitial = anglesList.value(1);
int leftInitial = anglesList.value(2);
int upInitial = anglesList.value(3);
if (bearing < rightInitial || bearing >= upInitial)
{
result = StickUp;
}
else if (bearing >= rightInitial && bearing < downInitial)
{
result = StickRight;
}
else if (bearing >= downInitial && bearing < leftInitial)
{
result = StickDown;
}
else if (bearing >= leftInitial && bearing < upInitial)
{
result = StickLeft;
}
return result;
}
/**
* @brief Find the current stick direction based on a Four Way Diagonal mode
* stick.
* @return Current direction the stick is positioned.
*/
JoyControlStick::JoyStickDirections
JoyControlStick::determineFourWayDiagonalDirection()
{
return determineFourWayDiagonalDirection(axisX->getCurrentRawValue(),
axisY->getCurrentRawValue());
}
JoyControlStick::JoyStickDirections
JoyControlStick::determineFourWayDiagonalDirection(int axisXValue, int axisYValue)
{
JoyStickDirections result = StickCentered;
double bearing = calculateBearing(axisXValue, axisYValue);
//bearing = floor(bearing + 0.5);
QList<int> anglesList = getFourWayDiagonalZoneAngles();
int upRightInitial = anglesList.value(0);
int downRightInitial = anglesList.value(1);
int downLeftInitial = anglesList.value(2);
int upLeftInitial = anglesList.value(3);
if (bearing >= upRightInitial && bearing < downRightInitial)
{
result = StickRightUp;
}
else if (bearing >= downRightInitial && bearing < downLeftInitial)
{
result = StickRightDown;
}
else if (bearing >= downLeftInitial && bearing < upLeftInitial)
{
result = StickLeftDown;
}
else if (bearing >= upLeftInitial)
{
result = StickLeftUp;
}
return result;
}
/**
* @brief Calculate the current direction of the stick based on the values
* of the X and Y axes and the current mode of the stick.
* @return Current direction the stick is positioned.
*/
JoyControlStick::JoyStickDirections
JoyControlStick::calculateStickDirection()
{
return calculateStickDirection(axisX->getCurrentRawValue(),
axisY->getCurrentRawValue());
}
JoyControlStick::JoyStickDirections
JoyControlStick::calculateStickDirection(int axisXValue, int axisYValue)
{
JoyStickDirections result = StickCentered;
if (currentMode == StandardMode)
{
result = determineStandardModeDirection(axisXValue, axisYValue);
}
else if (currentMode == EightWayMode)
{
result = determineEightWayModeDirection(axisXValue, axisYValue);
}
else if (currentMode == FourWayCardinal)
{
result = determineFourWayCardinalDirection(axisXValue, axisYValue);
}
else if (currentMode == FourWayDiagonal)
{
result = determineFourWayDiagonalDirection(axisXValue, axisYValue);
}
return result;
}
void JoyControlStick::establishPropertyUpdatedConnection()
{
connect(this, SIGNAL(propertyUpdated()), getParentSet()->getInputDevice(), SLOT(profileEdited()));
}
void JoyControlStick::disconnectPropertyUpdatedConnection()
{
disconnect(this, SIGNAL(propertyUpdated()), getParentSet()->getInputDevice(), SLOT(profileEdited()));
}
/**
* @brief Check all stick buttons and see if any have slots assigned.
* @return Status of whether any stick button has a slot assigned.
*/
bool JoyControlStick::hasSlotsAssigned()
{
bool hasSlots = false;
QHashIterator<JoyStickDirections, JoyControlStickButton*> iter(buttons);
while (iter.hasNext())
{
JoyButton *button = iter.next().value();
if (button)
{
if (button->getAssignedSlots()->count() > 0)
{
hasSlots = true;
iter.toBack();
}
}
}
return hasSlots;
}
void JoyControlStick::setButtonsSpringRelativeStatus(bool value)
{
QHashIterator<JoyStickDirections, JoyControlStickButton*> iter(buttons);
while (iter.hasNext())
{
JoyControlStickButton *button = iter.next().value();
button->setSpringRelativeStatus(value);
}
}
bool JoyControlStick::isRelativeSpring()
{
bool relative = false;
QHash<JoyStickDirections, JoyControlStickButton*> temphash = getApplicableButtons();
QHashIterator<JoyStickDirections, JoyControlStickButton*> iter(temphash);
while (iter.hasNext())
{
if (!iter.hasPrevious())
{
JoyControlStickButton *button = iter.next().value();
relative = button->isRelativeSpring();
}
else
{
JoyControlStickButton *button = iter.next().value();
bool temp = button->isRelativeSpring();
if (temp != relative)
{
relative = false;
iter.toBack();
}
}
}
return relative;
}
/**
* @brief Copy slots from all stick buttons and properties from a stick
* onto another.
* @param JoyControlStick object to be modified.
*/
void JoyControlStick::copyAssignments(JoyControlStick *destStick)
{
destStick->reset();
destStick->deadZone = deadZone;
destStick->maxZone = maxZone;
destStick->diagonalRange = diagonalRange;
destStick->currentDirection = currentDirection;
destStick->currentMode = currentMode;
destStick->stickName = stickName;
destStick->circle = circle;
destStick->stickDelay = stickDelay;
QHashIterator<JoyStickDirections, JoyControlStickButton*> iter(destStick->buttons);
while (iter.hasNext())
{
JoyControlStickButton *destButton = iter.next().value();
if (destButton)
{
JoyControlStickButton *sourceButton = buttons.value(destButton->getDirection());
if (sourceButton)
{
sourceButton->copyAssignments(destButton);
}
}
}
JoyControlStickModifierButton *destModifierButton = destStick->getModifierButton();
if (modifierButton && destModifierButton)
{
modifierButton->copyAssignments(destModifierButton);
}
if (!destStick->isDefault())
{
emit propertyUpdated();
}
}
/**
* @brief Set the percentage of the outer square that should be ignored
* when performing the final axis calculations.
* @param Percentage represented by the range of 0.0 - 1.0.
*/
void JoyControlStick::setCircleAdjust(double circle)
{
if (circle >= 0.0 && circle <= 1.0)
{
this->circle = circle;
emit circleAdjustChange(circle);
emit propertyUpdated();
}
}
/**
* @brief Get the current percentage of the outer square that should be ignored
* when performing the final axis calculations.
* @return Percentage represented by the range of 0.0 - 1.0.
*/
double JoyControlStick::getCircleAdjust()
{
return circle;
}
/**
* @brief Slot called when directionDelayTimer has timed out. The method will
* call createDeskEvent.
*/
void JoyControlStick::stickDirectionChangeEvent()
{
createDeskEvent();
}
void JoyControlStick::setStickDelay(int value)
{
if ((value >= 10 && value <= 1000) || (value == 0))
{
this->stickDelay = value;
emit stickDelayChanged(value);
emit propertyUpdated();
}
}
unsigned int JoyControlStick::getStickDelay()
{
return stickDelay;
}
void JoyControlStick::setButtonsEasingDuration(double value)
{
QHashIterator<JoyStickDirections, JoyControlStickButton*> iter(buttons);
while (iter.hasNext())
{
JoyControlStickButton *button = iter.next().value();
button->setEasingDuration(value);
}
}
double JoyControlStick::getButtonsEasingDuration()
{
double result = JoyButton::DEFAULTEASINGDURATION;
QHash<JoyStickDirections, JoyControlStickButton*> temphash = getApplicableButtons();
QHashIterator<JoyStickDirections, JoyControlStickButton*> iter(temphash);
while (iter.hasNext())
{
if (!iter.hasPrevious())
{
JoyControlStickButton *button = iter.next().value();
result = button->getEasingDuration();
}
else
{
JoyControlStickButton *button = iter.next().value();
double temp = button->getEasingDuration();
if (temp != result)
{
result = JoyButton::DEFAULTEASINGDURATION;
iter.toBack();
}
}
}
return result;
}
JoyControlStickModifierButton *JoyControlStick::getModifierButton()
{
return modifierButton;
}
void JoyControlStick::queueJoyEvent(bool ignoresets)
{
Q_UNUSED(ignoresets);
pendingStickEvent = true;
}
bool JoyControlStick::hasPendingEvent()
{
return pendingStickEvent;
}
void JoyControlStick::activatePendingEvent()
{
if (pendingStickEvent)
{
bool ignoresets = false;
joyEvent(ignoresets);
pendingStickEvent = false;
}
}
void JoyControlStick::clearPendingEvent()
{
pendingStickEvent = false;
}
void JoyControlStick::setButtonsExtraAccelerationStatus(bool enabled)
{
QHashIterator<JoyStickDirections, JoyControlStickButton*> iter(getApplicableButtons());
while (iter.hasNext())
{
JoyControlStickButton *button = iter.next().value();
if (button)
{
button->setExtraAccelerationStatus(enabled);
}
}
}
bool JoyControlStick::getButtonsExtraAccelerationStatus()
{
bool result = false;
QHashIterator<JoyStickDirections, JoyControlStickButton*> iter(getApplicableButtons());
while (iter.hasNext())
{
JoyControlStickButton *button = iter.next().value();
if (button)
{
bool temp = button->isExtraAccelerationEnabled();
if (!temp)
{
result = false;
iter.toBack();
}
else
{
result = temp;
}
}
}
return result;
}
void JoyControlStick::setButtonsExtraAccelerationMultiplier(double value)
{
QHashIterator<JoyStickDirections, JoyControlStickButton*> iter(getApplicableButtons());
while (iter.hasNext())
{
JoyControlStickButton *button = iter.next().value();
if (button)
{
button->setExtraAccelerationMultiplier(value);
}
}
}
double JoyControlStick::getButtonsExtraAccelerationMultiplier()
{
double result = JoyButton::DEFAULTEXTRACCELVALUE;
QHashIterator<JoyStickDirections, JoyControlStickButton*> iter(getApplicableButtons());
while (iter.hasNext())
{
if (!iter.hasPrevious())
{
JoyControlStickButton *button = iter.next().value();
if (button)
{
result = button->getExtraAccelerationMultiplier();
}
}
else
{
JoyControlStickButton *button = iter.next().value();
if (button)
{
double temp = button->getExtraAccelerationMultiplier();
if (temp != result)
{
result = JoyButton::DEFAULTEXTRACCELVALUE;
iter.toBack();
}
}
}
}
return result;
}
void JoyControlStick::setButtonsStartAccelerationMultiplier(double value)
{
QHashIterator<JoyStickDirections, JoyControlStickButton*> iter(getApplicableButtons());
while (iter.hasNext())
{
JoyControlStickButton *button = iter.next().value();
if (button)
{
button->setStartAccelMultiplier(value);
}
}
}
double JoyControlStick::getButtonsStartAccelerationMultiplier()
{
double result = JoyButton::DEFAULTSTARTACCELMULTIPLIER;
QHashIterator<JoyStickDirections, JoyControlStickButton*> iter(getApplicableButtons());
while (iter.hasNext())
{
if (!iter.hasPrevious())
{
JoyControlStickButton *button = iter.next().value();
if (button)
{
result = button->getStartAccelMultiplier();
}
}
else
{
JoyControlStickButton *button = iter.next().value();
if (button)
{
double temp = button->getStartAccelMultiplier();
if (temp != result)
{
result = JoyButton::DEFAULTSTARTACCELMULTIPLIER;
iter.toBack();
}
}
}
}
return result;
}
void JoyControlStick::setButtonsMinAccelerationThreshold(double value)
{
QHashIterator<JoyStickDirections, JoyControlStickButton*> iter(getApplicableButtons());
while (iter.hasNext())
{
JoyControlStickButton *button = iter.next().value();
if (button)
{
button->setMinAccelThreshold(value);
}
}
}
double JoyControlStick::getButtonsMinAccelerationThreshold()
{
double result = JoyButton::DEFAULTMINACCELTHRESHOLD;
QHashIterator<JoyStickDirections, JoyControlStickButton*> iter(getApplicableButtons());
while (iter.hasNext())
{
if (!iter.hasPrevious())
{
JoyControlStickButton *button = iter.next().value();
if (button)
{
result = button->getMinAccelThreshold();
}
}
else
{
JoyControlStickButton *button = iter.next().value();
if (button)
{
double temp = button->getMinAccelThreshold();
if (temp != result)
{
result = JoyButton::DEFAULTMINACCELTHRESHOLD;
iter.toBack();
}
}
}
}
return result;
}
void JoyControlStick::setButtonsMaxAccelerationThreshold(double value)
{
QHashIterator<JoyStickDirections, JoyControlStickButton*> iter(getApplicableButtons());
while (iter.hasNext())
{
JoyControlStickButton *button = iter.next().value();
if (button)
{
button->setMaxAccelThreshold(value);
}
}
}
double JoyControlStick::getButtonsMaxAccelerationThreshold()
{
double result = JoyButton::DEFAULTMAXACCELTHRESHOLD;
QHashIterator<JoyStickDirections, JoyControlStickButton*> iter(getApplicableButtons());
while (iter.hasNext())
{
if (!iter.hasPrevious())
{
JoyControlStickButton *button = iter.next().value();
if (button)
{
result = button->getMaxAccelThreshold();
}
}
else
{
JoyControlStickButton *button = iter.next().value();
if (button)
{
double temp = button->getMaxAccelThreshold();
if (temp != result)
{
result = JoyButton::DEFAULTMAXACCELTHRESHOLD;
iter.toBack();
}
}
}
}
return result;
}
void JoyControlStick::setButtonsAccelerationExtraDuration(double value)
{
QHashIterator<JoyStickDirections, JoyControlStickButton*> iter(getApplicableButtons());
while (iter.hasNext())
{
JoyControlStickButton *button = iter.next().value();
if (button)
{
button->setAccelExtraDuration(value);
}
}
}
double JoyControlStick::getButtonsAccelerationEasingDuration()
{
double result = JoyButton::DEFAULTACCELEASINGDURATION;
QHashIterator<JoyStickDirections, JoyControlStickButton*> iter(getApplicableButtons());
while (iter.hasNext())
{
if (!iter.hasPrevious())
{
JoyControlStickButton *button = iter.next().value();
if (button)
{
result = button->getAccelExtraDuration();
}
}
else
{
JoyControlStickButton *button = iter.next().value();
if (button)
{
double temp = button->getAccelExtraDuration();
if (temp != result)
{
result = JoyButton::DEFAULTACCELEASINGDURATION;
iter.toBack();
}
}
}
}
return result;
}
void JoyControlStick::setButtonsSpringDeadCircleMultiplier(int value)
{
QHashIterator<JoyStickDirections, JoyControlStickButton*> iter(getApplicableButtons());
while (iter.hasNext())
{
JoyControlStickButton *button = iter.next().value();
if (button)
{
button->setSpringDeadCircleMultiplier(value);
}
}
}
int JoyControlStick::getButtonsSpringDeadCircleMultiplier()
{
int result = JoyButton::DEFAULTSPRINGRELEASERADIUS;
QHashIterator<JoyStickDirections, JoyControlStickButton*> iter(getApplicableButtons());
while (iter.hasNext())
{
if (!iter.hasPrevious())
{
JoyControlStickButton *button = iter.next().value();
if (button)
{
result = button->getSpringDeadCircleMultiplier();
}
}
else
{
JoyControlStickButton *button = iter.next().value();
if (button)
{
int temp = button->getSpringDeadCircleMultiplier();
if (temp != result)
{
result = JoyButton::DEFAULTSPRINGRELEASERADIUS;
iter.toBack();
}
}
}
}
return result;
}
double JoyControlStick::calculateAccelerationDistance(JoyControlStickButton *button)
{
double finalDistance = 0.0;
if (currentDirection == StickUp)
{
if (axisY->getCurrentRawValue() >= 0)
{
finalDistance = 0.0;
}
else
{
finalDistance = calculateYAxisDistance(axisY->getCurrentRawValue());
}
}
else if (currentDirection == StickRightUp)
{
if (button->getJoyNumber() == StickRight)
{
if (axisX->getCurrentRawValue() < 0)
{
finalDistance = 0.0;
}
else
{
finalDistance = calculateXAxisDistance(axisX->getCurrentRawValue());
}
}
else if (button->getJoyNumber() == StickUp)
{
if (axisY->getCurrentRawValue() >= 0)
{
finalDistance = 0.0;
}
else
{
finalDistance = calculateYAxisDistance(axisY->getCurrentRawValue());
}
}
else if (button->getJoyNumber() == StickRightUp)
{
if (axisX->getCurrentRawValue() <= 0 || axisY->getCurrentRawValue() >= 0)
{
finalDistance = 0.0;
}
else
{
finalDistance = calculateEightWayDiagonalDistance(axisX->getCurrentRawValue(), axisY->getCurrentRawValue());
}
}
}
else if (currentDirection == StickRight)
{
if (axisX->getCurrentRawValue() < 0)
{
finalDistance = 0.0;
}
else
{
finalDistance = calculateXAxisDistance(axisX->getCurrentRawValue());
}
}
else if (currentDirection == StickRightDown)
{
if (button->getJoyNumber() == StickRight)
{
if (axisX->getCurrentRawValue() < 0)
{
finalDistance = 0.0;
}
else
{
finalDistance = calculateXAxisDistance(axisX->getCurrentRawValue());
}
}
else if (button->getJoyNumber() == StickDown)
{
if (axisY->getCurrentRawValue() < 0)
{
finalDistance = 0.0;
}
else
{
finalDistance = calculateYAxisDistance(axisY->getCurrentRawValue());
}
}
else if (button->getJoyNumber() == StickRightDown)
{
if (axisX->getCurrentRawValue() <= 0 || axisY->getCurrentRawValue() <= 0)
{
finalDistance = 0.0;
}
else
{
finalDistance = calculateEightWayDiagonalDistance(axisX->getCurrentRawValue(), axisY->getCurrentRawValue());
}
}
}
else if (currentDirection == StickDown)
{
if (axisY->getCurrentRawValue() <= 0)
{
finalDistance = 0.0;
}
else
{
finalDistance = calculateYAxisDistance(axisY->getCurrentRawValue());
}
}
else if (currentDirection == StickLeftDown)
{
if (button->getJoyNumber() == StickLeft)
{
if (axisX->getCurrentRawValue() >= 0)
{
finalDistance = 0.0;
}
else
{
finalDistance = calculateXAxisDistance(axisX->getCurrentRawValue());
}
}
else if (button->getJoyNumber() == StickDown)
{
if (axisY->getCurrentRawValue() < 0)
{
finalDistance = 0.0;
}
else
{
finalDistance = calculateYAxisDistance(axisY->getCurrentRawValue());
}
}
else if (button->getJoyNumber() == StickLeftDown)
{
if (axisX->getCurrentRawValue() >= 0 || axisY->getCurrentRawValue() <= 0)
{
finalDistance = 0.0;
}
else
{
finalDistance = calculateEightWayDiagonalDistance(axisX->getCurrentRawValue(), axisY->getCurrentRawValue());
}
}
}
else if (currentDirection == StickLeft)
{
if (axisX->getCurrentRawValue() >= 0)
{
finalDistance = 0.0;
}
else
{
finalDistance = calculateXAxisDistance(axisX->getCurrentRawValue());
}
}
else if (currentDirection == StickLeftUp)
{
if (button->getJoyNumber() == StickLeft)
{
if (axisX->getCurrentRawValue() >= 0)
{
finalDistance = 0.0;
}
else
{
finalDistance = calculateXAxisDistance(axisX->getCurrentRawValue());
}
}
else if (button->getJoyNumber() == StickUp)
{
if (axisY->getCurrentRawValue() >= 0)
{
finalDistance = 0.0;
}
else
{
finalDistance = calculateYAxisDistance(axisY->getCurrentRawValue());
}
}
else if (button->getJoyNumber() == StickLeftUp)
{
if (axisX->getCurrentRawValue() >= 0 || axisY->getCurrentRawValue() >= 0)
{
finalDistance = 0.0;
}
else
{
finalDistance = calculateEightWayDiagonalDistance(axisX->getCurrentRawValue(), axisY->getCurrentRawValue());
}
}
}
return finalDistance;
}
// TODO: Maybe change method name.
double JoyControlStick::calculateLastAccelerationButtonDistance(JoyControlStickButton *button)
{
double finalDistance = 0.0;
if (currentDirection == StickUp)
{
if (axisY->getLastKnownRawValue() >= 0)
{
finalDistance = 0.0;
}
else
{
finalDistance = calculateYAxisDistance(axisY->getLastKnownRawValue());
}
}
else if (currentDirection == StickRightUp)
{
if (button->getJoyNumber() == StickRight)
{
if (axisX->getLastKnownRawValue() <= 0)
{
finalDistance = 0.0;
}
else
{
finalDistance = calculateXAxisDistance(axisX->getLastKnownRawValue());
}
}
else if (button->getJoyNumber() == StickUp)
{
if (axisY->getLastKnownRawValue() >= 0)
{
finalDistance = 0.0;
}
else
{
finalDistance = calculateYAxisDistance(axisY->getLastKnownRawValue());
}
}
else if (button->getJoyNumber() == StickRightUp)
{
if (axisX->getLastKnownRawValue() <= 0 || axisY->getLastKnownRawValue() >= 0)
{
finalDistance = 0.0;
}
else
{
finalDistance = calculateEightWayDiagonalDistance(axisX->getLastKnownRawValue(), axisY->getLastKnownRawValue());
}
}
}
else if (currentDirection == StickRight)
{
if (axisX->getLastKnownRawValue() <= 0)
{
finalDistance = 0.0;
}
else
{
finalDistance = calculateXAxisDistance(axisX->getLastKnownRawValue());
}
}
else if (currentDirection == StickRightDown)
{
if (button->getJoyNumber() == StickRight)
{
if (axisX->getLastKnownRawValue() <= 0)
{
finalDistance = 0.0;
}
else
{
finalDistance = calculateXAxisDistance(axisX->getLastKnownRawValue());
}
}
else if (button->getJoyNumber() == StickDown)
{
if (axisY->getLastKnownRawValue() <= 0)
{
finalDistance = 0.0;
}
else
{
finalDistance = calculateYAxisDistance(axisY->getLastKnownRawValue());
}
}
else if (button->getJoyNumber() == StickRightDown)
{
if (axisX->getLastKnownRawValue() <= 0 || axisY->getLastKnownRawValue() <= 0)
{
finalDistance = 0.0;
}
else
{
finalDistance = calculateEightWayDiagonalDistance(axisX->getLastKnownRawValue(), axisY->getLastKnownRawValue());
}
}
}
else if (currentDirection == StickDown)
{
if (axisY->getLastKnownRawValue() <= 0)
{
finalDistance = 0.0;
}
else
{
finalDistance = calculateYAxisDistance(axisY->getLastKnownRawValue());
}
}
else if (currentDirection == StickLeftDown)
{
if (button->getJoyNumber() == StickLeft)
{
if (axisX->getLastKnownRawValue() >= 0)
{
finalDistance = 0.0;
}
else
{
finalDistance = calculateXAxisDistance(axisX->getLastKnownRawValue());
}
}
else if (button->getJoyNumber() == StickDown)
{
if (axisY->getLastKnownRawValue() <= 0)
{
finalDistance = 0.0;
}
else
{
finalDistance = calculateYAxisDistance(axisY->getLastKnownRawValue());
}
}
else if (button->getJoyNumber() == StickLeftDown)
{
if (axisX->getLastKnownRawValue() >= 0 || axisY->getLastKnownRawValue() <= 0)
{
finalDistance = 0.0;
}
else
{
finalDistance = calculateEightWayDiagonalDistance(axisX->getLastKnownRawValue(), axisY->getLastKnownRawValue());
}
}
}
else if (currentDirection == StickLeft)
{
if (axisX->getLastKnownRawValue() >= 0)
{
finalDistance = 0.0;
}
else
{
finalDistance = calculateXAxisDistance(axisX->getLastKnownRawValue());
}
}
else if (currentDirection == StickLeftUp)
{
if (button->getJoyNumber() == StickLeft)
{
if (axisX->getLastKnownRawValue() >= 0)
{
finalDistance = 0.0;
}
else
{
finalDistance = calculateXAxisDistance(axisX->getLastKnownRawValue());
}
}
else if (button->getJoyNumber() == StickUp)
{
if (axisY->getLastKnownRawValue() >= 0)
{
finalDistance = 0.0;
}
else
{
finalDistance = calculateYAxisDistance(axisY->getLastKnownRawValue());
}
}
else if (button->getJoyNumber() == StickLeftUp)
{
if (axisX->getLastKnownRawValue() >= 0 || axisY->getLastKnownRawValue() >= 0)
{
finalDistance = 0.0;
}
else
{
finalDistance = calculateEightWayDiagonalDistance(axisX->getLastKnownRawValue(), axisY->getLastKnownRawValue());
}
}
}
return finalDistance;
}
double JoyControlStick::calculateXAxisDistance(int axisXValue)
{
double distance = 0.0;
int axis1Value = axisXValue;
distance = axis1Value / (double)(maxZone);
if (distance < -1.0)
{
distance = -1.0;
}
else if (distance > 1.0)
{
distance = 1.0;
}
//qDebug() << "DISTANCE: " << distance;
return distance;
}
double JoyControlStick::calculateYAxisDistance(int axisYValue)
{
double distance = 0.0;
int axis2Value = axisYValue;
distance = axis2Value / (double)(maxZone);
if (distance < -1.0)
{
distance = -1.0;
}
else if (distance > 1.0)
{
distance = 1.0;
}
return distance;
}
double JoyControlStick::calculateEightWayDiagonalDistanceFromDeadZone()
{
double temp = calculateEightWayDiagonalDistanceFromDeadZone(axisX->getCurrentRawValue(),
axisY->getCurrentRawValue());
return temp;
}
double JoyControlStick::calculateEightWayDiagonalDistanceFromDeadZone(int axisXValue, int axisYValue)
{
double distance = 0.0;
double radius = getDistanceFromDeadZone(axisXValue, axisYValue);
double bearing = calculateBearing(axisXValue, axisYValue);
int relativeBearing = static_cast<int>(bearing) % 90;
int diagonalAngle = relativeBearing;
if (relativeBearing > 45)
{
diagonalAngle = 90 - relativeBearing;
}
distance = radius * (diagonalAngle / 45.0);
return distance;
}
double JoyControlStick::calculateEightWayDiagonalDistance(int axisXValue, int axisYValue)
{
double distance = 0.0;
double radius = getRadialDistance(axisXValue, axisYValue);
double bearing = calculateBearing(axisXValue, axisYValue);
int relativeBearing = static_cast<int>(bearing) % 90;
int diagonalAngle = relativeBearing;
if (relativeBearing > 45)
{
diagonalAngle = 90 - relativeBearing;
}
distance = radius * (diagonalAngle / 45.0);
return distance;
}
double JoyControlStick::calculateXDiagonalDeadZone(int axisXValue, int axisYValue)
{
double diagonalDeadZone = 0.0;
JoyStickDirections direction = calculateStickDirection(axisXValue, axisYValue);
//double angle2 = atan2(axisXValue, -axisYValue);
//double ang_sin = sin(angle2);
//double ang_cos = cos(angle2);
//int deadX = abs((int)floor(deadZone * ang_sin + 0.5));
if (diagonalRange < 90)
{
if (direction == StickRightUp || direction == StickRight)
{
QList<double> tempangles = getDiagonalZoneAngles();
double maxangle = tempangles.at(3);
//double minangle = tempangles.at(1);
double mindeadX = fabs(deadZone * cos(maxangle * PI / 180.0));
//double currentDeadX = qMax(mindeadX, static_cast<double>(deadX));
diagonalDeadZone = mindeadX;
}
else if (direction == StickRightDown || direction == StickDown)
{
QList<double> tempangles = getDiagonalZoneAngles();
double maxangle = tempangles.at(5);
//double minangle = tempangles.at(4);
double mindeadX = fabs(deadZone * cos((maxangle - 90.0) * PI / 180.0));
//double currentDeadX = qMax(mindeadX, static_cast<double>(deadX));
diagonalDeadZone = mindeadX;
}
else if (direction == StickLeftDown || direction == StickLeft)
{
QList<double> tempangles = getDiagonalZoneAngles();
double maxangle = tempangles.at(7);
//double minangle = tempangles.at(6);
double mindeadX = fabs(deadZone * cos((maxangle - 180.0) * PI / 180.0));
//double currentDeadX = qMax(mindeadX, static_cast<double>(deadX));
diagonalDeadZone = mindeadX;
}
else if (direction == StickLeftUp || direction == StickUp)
{
QList<double> tempangles = getDiagonalZoneAngles();
double maxangle = tempangles.at(1);
//double minangle = tempangles.at(8);
double mindeadX = fabs(deadZone * cos((maxangle - 270.0) * PI / 180.0));
//double currentDeadX = qMax(mindeadX, static_cast<double>(deadX));
diagonalDeadZone = mindeadX;
}
else
{
diagonalDeadZone = 0.0;
}
}
else
{
diagonalDeadZone = 0.0;
}
return diagonalDeadZone;
}
double JoyControlStick::calculateYDiagonalDeadZone(int axisXValue, int axisYValue)
{
double diagonalDeadZone = 0.0;
JoyStickDirections direction = calculateStickDirection(axisXValue, axisYValue);
//double angle2 = atan2(axisXValue, -axisYValue);
//double ang_sin = sin(angle2);
//double ang_cos = cos(angle2);
//int deadY = abs(floor(deadZone * ang_cos + 0.5));
if (diagonalRange < 90)
{
if (direction == StickRightUp || direction == StickUp)
{
QList<double> tempangles = getDiagonalZoneAngles();
//double maxangle = tempangles.at(3);
double minangle = tempangles.at(1);
double mindeadY = fabs(deadZone * sin(minangle * PI / 180.0));
//double currentDeadY = qMax(static_cast<double>(deadY), mindeadY);
diagonalDeadZone = mindeadY;
}
else if (direction == StickRightDown || direction == StickRight)
{
QList<double> tempfuck = getDiagonalZoneAngles();
//double maxangle = tempfuck.at(5);
double minangle = tempfuck.at(4);
double mindeadY = fabs(deadZone * sin((minangle - 90.0) * PI / 180.0));
//double currentDeadY = qMax(static_cast<double>(deadY), mindeadY);
diagonalDeadZone = mindeadY;
}
else if (direction == StickLeftDown || direction == StickDown)
{
QList<double> tempangles = getDiagonalZoneAngles();
//double maxangle = tempangles.at(7);
double minangle = tempangles.at(6);
double mindeadY = fabs(deadZone * sin((minangle - 180.0) * PI / 180.0));
//double currentDeadY = qMax(static_cast<double>(deadY), mindeadY);
diagonalDeadZone = mindeadY;
}
else if (direction == StickLeftUp || direction == StickLeft)
{
QList<double> tempangles = getDiagonalZoneAngles();
//double maxangle = tempangles.at(1);
double minangle = tempangles.at(8);
double mindeadY = fabs(deadZone * sin((minangle - 270.0) * PI / 180.0));
//double currentDeadY = qMax(static_cast<double>(deadY), mindeadY);
diagonalDeadZone = mindeadY;
}
else
{
diagonalDeadZone = 0.0;
}
}
else
{
diagonalDeadZone = 0.0;
}
return diagonalDeadZone;
}
double JoyControlStick::getSpringDeadCircleX()
{
double result = 0.0;
double angle2 = 0.0;
int axis1Value = 0;
int axis2Value = 0;
if (axisX->getCurrentRawValue() == 0 && axisY->getCurrentRawValue() == 0)
{
// Stick moved back to absolute center. Use previously available values
// to find stick angle.
angle2 = atan2(axisX->getLastKnownRawValue(), -axisY->getLastKnownRawValue());
axis1Value = axisX->getLastKnownRawValue();
axis2Value = axisY->getLastKnownRawValue();
}
else
{
// Use current axis values to find stick angle.
angle2 = atan2(axisX->getCurrentRawValue(), -axisY->getCurrentRawValue());
axis1Value = axisX->getCurrentRawValue();
axis2Value = axisY->getCurrentRawValue();
}
double ang_sin = sin(angle2);
double ang_cos = cos(angle2);
int deadX = abs((int)floor(deadZone * ang_sin + 0.5));
double diagonalDeadX = calculateXDiagonalDeadZone(axis1Value, axis2Value);
double squareStickFullPhi = qMin(ang_sin ? 1/fabs(ang_sin) : 2, ang_cos ? 1/fabs(ang_cos) : 2);
double circle = this->circle;
double circleStickFull = (squareStickFullPhi - 1) * circle + 1;
double adjustedDeadXZone = circleStickFull > 1.0 ? (deadX / circleStickFull) : deadX;
//result = adjustedDeadXZone / static_cast<double>(deadZone);
double finalDeadZoneX = adjustedDeadXZone - diagonalDeadX;
double maxRange = static_cast<double>(deadZone - diagonalDeadX);
if (maxRange != 0.0)
{
result = finalDeadZoneX / maxRange;
}
return result;
}
double JoyControlStick::getSpringDeadCircleY()
{
double result = 0.0;
double angle2 = 0.0;
int axis1Value = 0;
int axis2Value = 0;
if (axisX->getCurrentRawValue() == 0 && axisY->getCurrentRawValue() == 0)
{
// Stick moved back to absolute center. Use previously available values
// to find stick angle.
angle2 = atan2(axisX->getLastKnownRawValue(), -axisY->getLastKnownRawValue());
axis1Value = axisX->getLastKnownRawValue();
axis2Value = axisY->getLastKnownRawValue();
}
else
{
// Use current axis values to find stick angle.
angle2 = atan2(axisX->getCurrentRawValue(), -axisY->getCurrentRawValue());
axis1Value = axisX->getCurrentRawValue();
axis2Value = axisY->getCurrentRawValue();
}
double ang_sin = sin(angle2);
double ang_cos = cos(angle2);
int deadY = abs((int)floor(deadZone * ang_cos + 0.5));
double diagonalDeadY = calculateYDiagonalDeadZone(axis1Value, axis2Value);
double squareStickFullPhi = qMin(ang_sin ? 1/fabs(ang_sin) : 2, ang_cos ? 1/fabs(ang_cos) : 2);
double circle = this->circle;
double circleStickFull = (squareStickFullPhi - 1) * circle + 1;
double adjustedDeadYZone = circleStickFull > 1.0 ? (deadY / circleStickFull) : deadY;
//result = adjustedDeadYZone / static_cast<double>(deadZone);
double finalDeadZoneY = adjustedDeadYZone - diagonalDeadY;
double maxRange = static_cast<double>(deadZone - diagonalDeadY);
if (maxRange != 0.0)
{
result = finalDeadZoneY / maxRange;
}
return result;
}
void JoyControlStick::setButtonsExtraAccelCurve(JoyButton::JoyExtraAccelerationCurve curve)
{
QHashIterator<JoyStickDirections, JoyControlStickButton*> iter(getApplicableButtons());
while (iter.hasNext())
{
JoyControlStickButton *button = iter.next().value();
if (button)
{
button->setExtraAccelerationCurve(curve);
}
}
}
JoyButton::JoyExtraAccelerationCurve JoyControlStick::getButtonsExtraAccelerationCurve()
{
JoyButton::JoyExtraAccelerationCurve result = JoyButton::LinearAccelCurve;
QHashIterator<JoyStickDirections, JoyControlStickButton*> iter(getApplicableButtons());
while (iter.hasNext())
{
if (!iter.hasPrevious())
{
JoyControlStickButton *button = iter.next().value();
if (button)
{
result = button->getExtraAccelerationCurve();
}
}
else
{
JoyControlStickButton *button = iter.next().value();
if (button)
{
JoyButton::JoyExtraAccelerationCurve temp = button->getExtraAccelerationCurve();
if (temp != result)
{
result = JoyButton::LinearAccelCurve;
iter.toBack();
}
}
}
}
return result;
}
void
JoyControlStick::setDirButtonsUpdateInitAccel(JoyControlStick::JoyStickDirections direction, bool state)
{
QHash<JoyStickDirections, JoyControlStickButton*> apphash = getButtonsForDirection(direction);
QHashIterator<JoyStickDirections, JoyControlStickButton*> iter(apphash);
while (iter.hasNext())
{
JoyControlStickButton *button = iter.next().value();
button->setUpdateInitAccel(state);
}
}
QHash<JoyControlStick::JoyStickDirections, JoyControlStickButton*>
JoyControlStick::getButtonsForDirection(JoyControlStick::JoyStickDirections direction)
{
QHash<JoyStickDirections, JoyControlStickButton*> temphash;
if (currentMode == StandardMode)
{
if (direction & JoyControlStick::StickUp)
{
JoyControlStickButton *button = this->buttons.value(JoyControlStick::StickUp);
temphash.insert(JoyControlStick::StickUp, button);
}
if (direction & JoyControlStick::StickRight)
{
JoyControlStickButton *button = this->buttons.value(JoyControlStick::StickRight);
temphash.insert(JoyControlStick::StickRight, button);
}
if (direction & JoyControlStick::StickDown)
{
JoyControlStickButton *button = this->buttons.value(JoyControlStick::StickDown);
temphash.insert(JoyControlStick::StickDown, button);
}
if (direction & JoyControlStick::StickLeft)
{
JoyControlStickButton *button = this->buttons.value(JoyControlStick::StickLeft);
temphash.insert(JoyControlStick::StickLeft, button);
}
}
else if (currentMode == EightWayMode)
{
temphash.insert(direction, buttons.value(direction));
}
else if (currentMode == FourWayCardinal)
{
if (direction == JoyControlStick::StickUp ||
direction == JoyControlStick::StickDown ||
direction == JoyControlStick::StickLeft ||
direction == JoyControlStick::StickRight)
{
temphash.insert(direction, buttons.value(direction));
}
}
else if (currentMode == FourWayDiagonal)
{
if (direction == JoyControlStick::StickRightUp ||
direction == JoyControlStick::StickRightDown ||
direction == JoyControlStick::StickLeftDown ||
direction == JoyControlStick::StickLeftUp)
{
temphash.insert(direction, buttons.value(direction));
}
}
return temphash;
}
``` | /content/code_sandbox/src/joycontrolstick.cpp | c++ | 2016-05-24T23:59:31 | 2024-08-11T02:46:48 | antimicro | AntiMicro/antimicro | 1,788 | 29,143 |
```c++
/* antimicro Gamepad to KB+M event mapper
*
* This program is free software: you can redistribute it and/or modify
* (at your option) any later version.
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* along with this program. If not, see <path_to_url
*/
//#include <QDebug>
#include <QFileDialog>
#include <QFileInfo>
#include <QPushButton>
#include <QToolButton>
#include <QHBoxLayout>
#include <QDoubleSpinBox>
#include <QLineEdit>
#include <QComboBox>
#include <QLabel>
#include <cmath>
#include "advancebuttondialog.h"
#include "ui_advancebuttondialog.h"
#include "event.h"
#include "inputdevice.h"
//#include "logger.h"
const int AdvanceButtonDialog::MINIMUMTURBO = 2;
AdvanceButtonDialog::AdvanceButtonDialog(JoyButton *button, QWidget *parent) :
QDialog(parent, Qt::Window),
ui(new Ui::AdvanceButtonDialog),
helper(button)
{
ui->setupUi(this);
setAttribute(Qt::WA_DeleteOnClose);
PadderCommon::inputDaemonMutex.lock();
this->button = button;
oldRow = 0;
helper.moveToThread(button->thread());
if (this->button->getToggleState())
{
ui->toggleCheckbox->setChecked(true);
}
if (this->button->isUsingTurbo())
{
ui->turboCheckbox->setChecked(true);
ui->turboSlider->setEnabled(true);
}
int interval = this->button->getTurboInterval() / 10;
if (interval < MINIMUMTURBO)
{
interval = JoyButton::ENABLEDTURBODEFAULT / 10;
}
ui->turboSlider->setValue(interval);
this->changeTurboText(interval);
QListIterator<JoyButtonSlot*> iter(*(this->button->getAssignedSlots()));
while (iter.hasNext())
{
JoyButtonSlot *buttonslot = iter.next();
SimpleKeyGrabberButton *existingCode = new SimpleKeyGrabberButton(this);
existingCode->setText(buttonslot->getSlotString());
if (buttonslot->getSlotMode() == JoyButtonSlot::JoyLoadProfile)
{
if (!buttonslot->getTextData().isEmpty())
{
existingCode->setValue(buttonslot->getTextData(), JoyButtonSlot::JoyLoadProfile);
existingCode->setToolTip(buttonslot->getTextData());
}
}
else if (buttonslot->getSlotMode() == JoyButtonSlot::JoyTextEntry)
{
if (!buttonslot->getTextData().isEmpty())
{
existingCode->setValue(buttonslot->getTextData(), JoyButtonSlot::JoyTextEntry);
existingCode->setToolTip(buttonslot->getTextData());
}
}
else if (buttonslot->getSlotMode() == JoyButtonSlot::JoyExecute)
{
if (!buttonslot->getTextData().isEmpty())
{
existingCode->setValue(buttonslot->getTextData(), JoyButtonSlot::JoyExecute);
existingCode->setToolTip(buttonslot->getTextData());
if (buttonslot->getExtraData().canConvert<QString>())
{
QString argumentsTemp = buttonslot->getExtraData().toString();
existingCode->getValue()->setExtraData(argumentsTemp);
}
}
}
else
{
existingCode->setValue(buttonslot->getSlotCode(),
buttonslot->getSlotCodeAlias(),
buttonslot->getSlotMode());
}
QListWidgetItem *item = new QListWidgetItem(ui->slotListWidget);
item->setData(Qt::UserRole, QVariant::fromValue<SimpleKeyGrabberButton*>(existingCode));
QHBoxLayout *layout= new QHBoxLayout();
layout->setContentsMargins(10, 0, 10, 0);
layout->addWidget(existingCode);
QWidget *widget = new QWidget();
widget->setLayout(layout);
item->setSizeHint(widget->sizeHint());
ui->slotListWidget->setItemWidget(item, widget);
connectButtonEvents(existingCode);
}
appendBlankKeyGrabber();
populateSetSelectionComboBox();
populateSlotSetSelectionComboBox();
if (this->button->getSetSelection() > -1 &&
this->button->getChangeSetCondition() != JoyButton::SetChangeDisabled)
{
int selectIndex = (int)this->button->getChangeSetCondition();
selectIndex += this->button->getSetSelection() * 3;
if (this->button->getOriginSet() < this->button->getSetSelection())
{
selectIndex -= 3;
}
ui->setSelectionComboBox->setCurrentIndex(selectIndex);
}
fillTimeComboBoxes();
ui->actionTenthsComboBox->setCurrentIndex(1);
updateActionTimeLabel();
changeTurboForSequences();
if (button->isCycleResetActive())
{
ui->autoResetCycleCheckBox->setEnabled(true);
ui->autoResetCycleCheckBox->setChecked(true);
checkCycleResetWidgetStatus(true);
}
if (button->getCycleResetTime() != 0)
{
populateAutoResetInterval();
}
updateWindowTitleButtonName();
if (this->button->isPartRealAxis() && this->button->isUsingTurbo())
{
ui->turboModeComboBox->setEnabled(true);
}
else if (!this->button->isPartRealAxis())
{
ui->turboModeComboBox->setVisible(false);
ui->turboModeLabel->setVisible(false);
}
findTurboModeComboIndex();
// Don't show Set Selector page for modifier buttons
if (this->button->isModifierButton())
{
delete ui->listWidget->item(3);
}
//performStatsWidgetRefresh(ui->slotListWidget->currentItem());
changeSlotHelpText(ui->slotTypeComboBox->currentIndex());
PadderCommon::inputDaemonMutex.unlock();
ui->resetCycleDoubleSpinBox->setMaximum(static_cast<double>(JoyButton::MAXCYCLERESETTIME * 0.001));
connect(ui->turboCheckbox, SIGNAL(clicked(bool)), ui->turboSlider, SLOT(setEnabled(bool)));
connect(ui->turboSlider, SIGNAL(valueChanged(int)), this, SLOT(checkTurboIntervalValue(int)));
connect(ui->insertSlotButton, SIGNAL(clicked()), this, SLOT(insertSlot()));
connect(ui->deleteSlotButton, SIGNAL(clicked()), this, SLOT(deleteSlot()));
connect(ui->clearAllPushButton, SIGNAL(clicked()), this, SLOT(clearAllSlots()));
connect(ui->slotTypeComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(changeSlotTypeDisplay(int)));
connect(ui->slotTypeComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(changeSlotHelpText(int)));
connect(ui->actionHundredthsComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(updateActionTimeLabel()));
connect(ui->actionSecondsComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(updateActionTimeLabel()));
connect(ui->actionMinutesComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(updateActionTimeLabel()));
connect(ui->actionTenthsComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(updateActionTimeLabel()));
connect(ui->toggleCheckbox, SIGNAL(clicked(bool)), button, SLOT(setToggle(bool)));
connect(ui->turboCheckbox, SIGNAL(clicked(bool)), this, SLOT(checkTurboSetting(bool)));
connect(ui->setSelectionComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(updateSetSelection()));
connect(ui->slotListWidget, SIGNAL(itemClicked(QListWidgetItem*)), this, SLOT(performStatsWidgetRefresh(QListWidgetItem*)));
connect(ui->actionHundredthsComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(checkSlotTimeUpdate()));
connect(ui->actionTenthsComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(checkSlotTimeUpdate()));
connect(ui->actionSecondsComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(checkSlotTimeUpdate()));
connect(ui->actionMinutesComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(checkSlotTimeUpdate()));
connect(ui->slotSetChangeComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(checkSlotSetChangeUpdate()));
connect(ui->distanceSpinBox, SIGNAL(valueChanged(int)), this, SLOT(checkSlotDistanceUpdate()));
connect(ui->mouseSpeedModSpinBox, SIGNAL(valueChanged(int)), this, SLOT(checkSlotMouseModUpdate()));
connect(ui->autoResetCycleCheckBox, SIGNAL(clicked(bool)), this, SLOT(checkCycleResetWidgetStatus(bool)));
connect(ui->autoResetCycleCheckBox, SIGNAL(clicked(bool)), this, SLOT(setButtonCycleReset(bool)));
connect(ui->resetCycleDoubleSpinBox, SIGNAL(valueChanged(double)), this, SLOT(setButtonCycleResetInterval(double)));
connect(button, SIGNAL(toggleChanged(bool)), ui->toggleCheckbox, SLOT(setChecked(bool)));
connect(button, SIGNAL(turboChanged(bool)), this, SLOT(checkTurboSetting(bool)));
connect(ui->turboModeComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(setButtonTurboMode(int)));
connect(ui->loadProfilePushButton, SIGNAL(clicked()), this, SLOT(showSelectProfileWindow()));
connect(ui->execToolButton, SIGNAL(clicked(bool)), this, SLOT(showFindExecutableWindow(bool)));
}
AdvanceButtonDialog::~AdvanceButtonDialog()
{
delete ui;
}
void AdvanceButtonDialog::changeTurboText(int value)
{
if (value >= MINIMUMTURBO)
{
double delay = value / 100.0;
double clicks = 100.0 / (double)value;
QString delaytext = QString::number(delay, 'g', 3).append(" ").append(tr("sec."));
QString labeltext = QString::number(clicks, 'g', 2).append(" ").append(tr("/sec."));
ui->delayValueLabel->setText(delaytext);
ui->rateValueLabel->setText(labeltext);
}
}
void AdvanceButtonDialog::updateSlotsScrollArea(int value)
{
int index = ui->slotListWidget->currentRow();
int itemcount = ui->slotListWidget->count();
if (index == (itemcount - 1) && value >= 0)
{
// New slot added on the old blank button. Append
// new blank button to the end of the list.
appendBlankKeyGrabber();
}
// Go through all grabber buttons in list and possibly resize widgets.
for (int i = 0; i < ui->slotListWidget->count(); i++)
{
QListWidgetItem *item = ui->slotListWidget->item(i);
QWidget *widget = ui->slotListWidget->itemWidget(item);
item->setSizeHint(widget->sizeHint());
}
// Alter interface if turbo cannot be used.
changeTurboForSequences();
emit slotsChanged();
}
void AdvanceButtonDialog::connectButtonEvents(SimpleKeyGrabberButton *button)
{
connect(button, SIGNAL(clicked()), this, SLOT(changeSelectedSlot()));
connect(button, SIGNAL(buttonCodeChanged(int)), this, SLOT(updateSelectedSlot(int)));
//connect(button, SIGNAL(buttonCodeChanged(int)), this, SLOT(updateSlotsScrollArea(int)));
}
void AdvanceButtonDialog::updateSelectedSlot(int value)
{
SimpleKeyGrabberButton *grabbutton = static_cast<SimpleKeyGrabberButton*>(sender());
JoyButtonSlot *tempbuttonslot = grabbutton->getValue();
int index = ui->slotListWidget->currentRow();
QMetaObject::invokeMethod(&helper, "setAssignedSlot", Qt::BlockingQueuedConnection,
Q_ARG(int, tempbuttonslot->getSlotCode()),
Q_ARG(unsigned int, tempbuttonslot->getSlotCodeAlias()),
Q_ARG(int, index),
Q_ARG(JoyButtonSlot::JoySlotInputAction, tempbuttonslot->getSlotMode()));
updateSlotsScrollArea(value);
}
void AdvanceButtonDialog::deleteSlot()
{
int index = ui->slotListWidget->currentRow();
int itemcount = ui->slotListWidget->count();
QListWidgetItem *item = ui->slotListWidget->takeItem(index);
delete item;
item = 0;
// Deleted last button. Replace with new blank button
if (index == itemcount - 1)
{
appendBlankKeyGrabber();
}
changeTurboForSequences();
QMetaObject::invokeMethod(&helper, "removeAssignedSlot", Qt::BlockingQueuedConnection,
Q_ARG(int, index));
index = qMax(0, index-1);
performStatsWidgetRefresh(ui->slotListWidget->item(index));
emit slotsChanged();
}
void AdvanceButtonDialog::changeSelectedSlot()
{
SimpleKeyGrabberButton *button = static_cast<SimpleKeyGrabberButton*>(sender());
bool leave = false;
for (int i = 0; i < ui->slotListWidget->count() && !leave; i++)
{
QListWidgetItem *item = ui->slotListWidget->item(i);
SimpleKeyGrabberButton *tempbutton = item->data(Qt::UserRole)
.value<SimpleKeyGrabberButton*>();
if (button == tempbutton)
{
ui->slotListWidget->setCurrentRow(i);
leave = true;
oldRow = i;
}
}
}
void AdvanceButtonDialog::appendBlankKeyGrabber()
{
SimpleKeyGrabberButton *blankButton = new SimpleKeyGrabberButton(this);
QListWidgetItem *item = new QListWidgetItem(ui->slotListWidget);
item->setData(Qt::UserRole,
QVariant::fromValue<SimpleKeyGrabberButton*>(blankButton));
QHBoxLayout *layout= new QHBoxLayout();
layout->setContentsMargins(10, 0, 10, 0);
layout->addWidget(blankButton);
QWidget *widget = new QWidget();
widget->setLayout(layout);
item->setSizeHint(widget->sizeHint());
ui->slotListWidget->setItemWidget(item, widget);
ui->slotListWidget->setCurrentItem(item);
connectButtonEvents(blankButton);
ui->slotTypeComboBox->setCurrentIndex(KBMouseSlot);
}
void AdvanceButtonDialog::insertSlot()
{
int current = ui->slotListWidget->currentRow();
int count = ui->slotListWidget->count();
int slotTypeIndex = ui->slotTypeComboBox->currentIndex();
if (slotTypeIndex == KBMouseSlot)
{
if (current != (count - 1))
{
SimpleKeyGrabberButton *blankButton = new SimpleKeyGrabberButton(this);
QListWidgetItem *item = new QListWidgetItem();
ui->slotListWidget->insertItem(current, item);
item->setData(Qt::UserRole,
QVariant::fromValue<SimpleKeyGrabberButton*>(blankButton));
QHBoxLayout *layout= new QHBoxLayout();
layout->addWidget(blankButton);
QWidget *widget = new QWidget();
widget->setLayout(layout);
item->setSizeHint(widget->sizeHint());
ui->slotListWidget->setItemWidget(item, widget);
ui->slotListWidget->setCurrentItem(item);
connectButtonEvents(blankButton);
blankButton->refreshButtonLabel();
QMetaObject::invokeMethod(&helper, "insertAssignedSlot", Qt::BlockingQueuedConnection,
Q_ARG(int, 0), Q_ARG(uint, 0),
Q_ARG(int, current));
updateSlotsScrollArea(0);
}
}
else if (slotTypeIndex == CycleSlot)
{
insertCycleSlot();
}
else if (slotTypeIndex == DelaySlot)
{
insertDelaySlot();
}
else if (slotTypeIndex == DistanceSlot)
{
insertDistanceSlot();
}
else if (slotTypeIndex == HoldSlot)
{
insertHoldSlot();
}
else if (slotTypeIndex == LoadSlot)
{
showSelectProfileWindow();
}
else if (slotTypeIndex == MouseModSlot)
{
insertMouseSpeedModSlot();
}
else if (slotTypeIndex == PauseSlot)
{
insertPauseSlot();
}
else if (slotTypeIndex == PressTimeSlot)
{
insertKeyPressSlot();
}
else if (slotTypeIndex == ReleaseSlot)
{
insertReleaseSlot();
}
else if (slotTypeIndex == SetChangeSlot)
{
insertSetChangeSlot();
}
else if (slotTypeIndex == TextEntry)
{
insertTextEntrySlot();
}
else if (slotTypeIndex == ExecuteSlot)
{
insertExecuteSlot();
}
}
void AdvanceButtonDialog::insertPauseSlot()
{
int index = ui->slotListWidget->currentRow();
SimpleKeyGrabberButton *tempbutton = ui->slotListWidget->currentItem()
->data(Qt::UserRole).value<SimpleKeyGrabberButton*>();
int actionTime = actionTimeConvert();
if (actionTime >= 0)
{
tempbutton->setValue(actionTime, JoyButtonSlot::JoyPause);
QMetaObject::invokeMethod(&helper, "setAssignedSlot", Qt::BlockingQueuedConnection,
Q_ARG(int, actionTime),
Q_ARG(unsigned int, 0),
Q_ARG(int, index),
Q_ARG(JoyButtonSlot::JoySlotInputAction, JoyButtonSlot::JoyPause));
updateSlotsScrollArea(actionTime);
}
}
void AdvanceButtonDialog::insertReleaseSlot()
{
int index = ui->slotListWidget->currentRow();
SimpleKeyGrabberButton *tempbutton = ui->slotListWidget->currentItem()
->data(Qt::UserRole).value<SimpleKeyGrabberButton*>();
int actionTime = actionTimeConvert();
if (actionTime >= 0)
{
tempbutton->setValue(actionTime, JoyButtonSlot::JoyRelease);
QMetaObject::invokeMethod(&helper, "setAssignedSlot", Qt::BlockingQueuedConnection,
Q_ARG(int, actionTime),
Q_ARG(unsigned int, 0),
Q_ARG(int, index),
Q_ARG(JoyButtonSlot::JoySlotInputAction, JoyButtonSlot::JoyRelease));
updateSlotsScrollArea(actionTime);
}
}
void AdvanceButtonDialog::insertHoldSlot()
{
int index = ui->slotListWidget->currentRow();
SimpleKeyGrabberButton *tempbutton = ui->slotListWidget->currentItem()
->data(Qt::UserRole).value<SimpleKeyGrabberButton*>();
int actionTime = actionTimeConvert();
if (actionTime > 0)
{
tempbutton->setValue(actionTime, JoyButtonSlot::JoyHold);
QMetaObject::invokeMethod(&helper, "setAssignedSlot", Qt::BlockingQueuedConnection,
Q_ARG(int, actionTime),
Q_ARG(unsigned int, 0),
Q_ARG(int, index),
Q_ARG(JoyButtonSlot::JoySlotInputAction, JoyButtonSlot::JoyHold));
updateSlotsScrollArea(actionTime);
}
}
void AdvanceButtonDialog::insertSetChangeSlot()
{
int index = ui->slotListWidget->currentRow();
SimpleKeyGrabberButton *tempbutton = ui->slotListWidget->currentItem()
->data(Qt::UserRole).value<SimpleKeyGrabberButton*>();
int currentIndex = ui->slotSetChangeComboBox->currentIndex();
unsigned int setIndex = ui->slotSetChangeComboBox->itemData(currentIndex).toInt();
if (setIndex >= 0)
{
tempbutton->setValue(setIndex, JoyButtonSlot::JoySetChange);
QMetaObject::invokeMethod(&helper, "setAssignedSlot", Qt::BlockingQueuedConnection,
Q_ARG(int, setIndex),
Q_ARG(unsigned int, 0),
Q_ARG(int, index),
Q_ARG(JoyButtonSlot::JoySlotInputAction, JoyButtonSlot::JoySetChange));
updateSlotsScrollArea(setIndex);
}
}
int AdvanceButtonDialog::actionTimeConvert()
{
int minutesIndex = ui->actionMinutesComboBox->currentIndex();
int secondsIndex = ui->actionSecondsComboBox->currentIndex();
int hundredthsIndex = ui->actionHundredthsComboBox->currentIndex();
int tenthsIndex = ui->actionTenthsComboBox->currentIndex();
int tempMilliSeconds = minutesIndex * 1000 * 60;
tempMilliSeconds += secondsIndex * 1000;
tempMilliSeconds += tenthsIndex * 100;
tempMilliSeconds += hundredthsIndex * 10;
return tempMilliSeconds;
}
void AdvanceButtonDialog::refreshTimeComboBoxes(JoyButtonSlot *slot)
{
disconnectTimeBoxesEvents();
int slottime = slot->getSlotCode();
int tempMinutes = slottime / 1000 / 60;
int tempSeconds = slottime / 1000 % 60;
int tempTenthsSeconds = (slottime % 1000) / 100;
int tempHundredthsSeconds = (slottime % 1000 % 100) / 10;
ui->actionMinutesComboBox->setCurrentIndex(tempMinutes);
ui->actionSecondsComboBox->setCurrentIndex(tempSeconds);
ui->actionTenthsComboBox->setCurrentIndex(tempTenthsSeconds);
ui->actionHundredthsComboBox->setCurrentIndex(tempHundredthsSeconds);
updateActionTimeLabel();
connectTimeBoxesEvents();
}
void AdvanceButtonDialog::updateActionTimeLabel()
{
int actionTime = actionTimeConvert();
int minutes = actionTime / 1000 / 60;
double hundredths = actionTime % 1000 / 1000.0;
double seconds = (actionTime / 1000 % 60) + hundredths;
QString temp;
temp.append(QString::number(minutes)).append("m ");
temp.append(QString::number(seconds, 'f', 2)).append("s");
ui->actionTimeLabel->setText(temp);
}
void AdvanceButtonDialog::clearAllSlots()
{
ui->slotListWidget->clear();
appendBlankKeyGrabber();
changeTurboForSequences();
QMetaObject::invokeMethod(button, "clearSlotsEventReset", Qt::BlockingQueuedConnection);
performStatsWidgetRefresh(ui->slotListWidget->currentItem());
emit slotsChanged();
}
void AdvanceButtonDialog::changeTurboForSequences()
{
bool containsSequences = false;
for (int i = 0; i < ui->slotListWidget->count() && !containsSequences; i++)
{
SimpleKeyGrabberButton *button = ui->slotListWidget->item(i)
->data(Qt::UserRole).value<SimpleKeyGrabberButton*>();
JoyButtonSlot *tempbuttonslot = button->getValue();
if (tempbuttonslot->getSlotCode() > 0 &&
(tempbuttonslot->getSlotMode() == JoyButtonSlot::JoyPause ||
tempbuttonslot->getSlotMode() == JoyButtonSlot::JoyHold ||
tempbuttonslot->getSlotMode() == JoyButtonSlot::JoyDistance
)
)
{
containsSequences = true;
}
}
if (containsSequences)
{
if (ui->turboCheckbox->isChecked())
{
ui->turboCheckbox->setChecked(false);
this->button->setUseTurbo(false);
emit turboChanged(false);
}
if (ui->turboCheckbox->isEnabled())
{
ui->turboCheckbox->setEnabled(false);
emit turboButtonEnabledChange(false);
}
}
else
{
if (!ui->turboCheckbox->isEnabled())
{
ui->turboCheckbox->setEnabled(true);
emit turboButtonEnabledChange(true);
}
}
}
void AdvanceButtonDialog::insertCycleSlot()
{
int index = ui->slotListWidget->currentRow();
SimpleKeyGrabberButton *tempbutton = ui->slotListWidget->currentItem()
->data(Qt::UserRole).value<SimpleKeyGrabberButton*>();
tempbutton->setValue(1, JoyButtonSlot::JoyCycle);
QMetaObject::invokeMethod(&helper, "setAssignedSlot", Qt::BlockingQueuedConnection,
Q_ARG(int, 1),
Q_ARG(unsigned int, 0),
Q_ARG(int, index),
Q_ARG(JoyButtonSlot::JoySlotInputAction, JoyButtonSlot::JoyCycle));
updateSlotsScrollArea(1);
}
void AdvanceButtonDialog::insertDistanceSlot()
{
int index = ui->slotListWidget->currentRow();
SimpleKeyGrabberButton *tempbutton = ui->slotListWidget->currentItem()
->data(Qt::UserRole).value<SimpleKeyGrabberButton*>();
int tempDistance = 0;
for (int i = 0; i < ui->slotListWidget->count(); i++)
{
SimpleKeyGrabberButton *button = ui->slotListWidget->item(i)
->data(Qt::UserRole).value<SimpleKeyGrabberButton*>();
JoyButtonSlot *tempbuttonslot = button->getValue();
if (tempbuttonslot->getSlotMode() == JoyButtonSlot::JoyDistance)
{
tempDistance += tempbuttonslot->getSlotCode();
}
else if (tempbuttonslot->getSlotMode() == JoyButtonSlot::JoyCycle)
{
tempDistance = 0;
}
}
int testDistance = ui->distanceSpinBox->value();
if (testDistance + tempDistance <= 100)
{
tempbutton->setValue(testDistance, JoyButtonSlot::JoyDistance);
QMetaObject::invokeMethod(&helper, "setAssignedSlot", Qt::BlockingQueuedConnection,
Q_ARG(int, testDistance),
Q_ARG(unsigned int, 0),
Q_ARG(int, index),
Q_ARG(JoyButtonSlot::JoySlotInputAction, JoyButtonSlot::JoyDistance));
updateSlotsScrollArea(testDistance);
}
}
void AdvanceButtonDialog::placeNewSlot(JoyButtonSlot *slot)
{
int index = ui->slotListWidget->currentRow();
SimpleKeyGrabberButton *tempbutton = ui->slotListWidget->currentItem()
->data(Qt::UserRole).value<SimpleKeyGrabberButton*>();
tempbutton->setValue(slot->getSlotCode(), slot->getSlotCodeAlias(), slot->getSlotMode());
QMetaObject::invokeMethod(&helper, "setAssignedSlot", Qt::BlockingQueuedConnection,
Q_ARG(int, slot->getSlotCode()),
Q_ARG(unsigned int, slot->getSlotCodeAlias()),
Q_ARG(int, index),
Q_ARG(JoyButtonSlot::JoySlotInputAction, slot->getSlotMode()));
updateSlotsScrollArea(slot->getSlotCode());
slot->deleteLater();
}
void AdvanceButtonDialog::updateTurboIntervalValue(int value)
{
if (value >= MINIMUMTURBO)
{
button->setTurboInterval(value * 10);
}
}
void AdvanceButtonDialog::checkTurboSetting(bool state)
{
ui->turboCheckbox->setChecked(state);
ui->turboSlider->setEnabled(state);
if (this->button->isPartRealAxis())
{
ui->turboModeComboBox->setEnabled(state);
}
changeTurboForSequences();
button->setUseTurbo(state);
if (button->getTurboInterval() / 10 >= MINIMUMTURBO)
{
ui->turboSlider->setValue(button->getTurboInterval() / 10);
}
}
void AdvanceButtonDialog::updateSetSelection()
{
PadderCommon::inputDaemonMutex.lock();
int condition_choice = 0;
int chosen_set = -1;
JoyButton::SetChangeCondition set_selection_condition = JoyButton::SetChangeDisabled;
if (ui->setSelectionComboBox->currentIndex() > 0)
{
condition_choice = (ui->setSelectionComboBox->currentIndex() + 2) % 3;
chosen_set = (ui->setSelectionComboBox->currentIndex() - 1) / 3;
// Above removed rows
if (button->getOriginSet() > chosen_set)
{
chosen_set = (ui->setSelectionComboBox->currentIndex() - 1) / 3;
}
// Below removed rows
else
{
chosen_set = (ui->setSelectionComboBox->currentIndex() + 2) / 3;
}
//qDebug() << "CONDITION: " << QString::number(condition_choice) << endl;
if (condition_choice == 0)
{
set_selection_condition = JoyButton::SetChangeOneWay;
}
else if (condition_choice == 1)
{
set_selection_condition = JoyButton::SetChangeTwoWay;
}
else if (condition_choice == 2)
{
set_selection_condition = JoyButton::SetChangeWhileHeld;
}
//qDebug() << "CHOSEN SET: " << chosen_set << endl;
}
else
{
chosen_set = -1;
set_selection_condition = JoyButton::SetChangeDisabled;
}
if (chosen_set > -1 && set_selection_condition != JoyButton::SetChangeDisabled)
{
// First, remove old condition for the button in both sets.
// After that, make the new assignment.
button->setChangeSetCondition(JoyButton::SetChangeDisabled);
button->setChangeSetSelection(chosen_set);
button->setChangeSetCondition(set_selection_condition);
}
else
{
button->setChangeSetCondition(JoyButton::SetChangeDisabled);
}
PadderCommon::inputDaemonMutex.unlock();
}
void AdvanceButtonDialog::checkTurboIntervalValue(int value)
{
if (value >= MINIMUMTURBO)
{
changeTurboText(value);
updateTurboIntervalValue(value);
}
else
{
ui->turboSlider->setValue(MINIMUMTURBO);
}
}
void AdvanceButtonDialog::fillTimeComboBoxes()
{
ui->actionMinutesComboBox->clear();
ui->actionSecondsComboBox->clear();
ui->actionHundredthsComboBox->clear();
ui->actionTenthsComboBox->clear();
for (double i=0; i <= 10; i++)
{
QString temp = QString::number(i, 'g', 2).append("m");
ui->actionMinutesComboBox->addItem(temp);
}
for (double i=0; i <= 59; i++)
{
QString temp = QString::number(i, 'g', 2);
ui->actionSecondsComboBox->addItem(temp);
}
for (int i=0; i < 10; i++)
{
QString temp = QString(".%1").arg(i, 1, 10, QChar('0'));
ui->actionTenthsComboBox->addItem(temp);
}
for (int i=0; i < 10; i++)
{
QString temp = QString("%1s").arg(i, 1, 10, QChar('0'));
ui->actionHundredthsComboBox->addItem(temp);
}
}
void AdvanceButtonDialog::insertMouseSpeedModSlot()
{
int index = ui->slotListWidget->currentRow();
SimpleKeyGrabberButton *tempbutton = ui->slotListWidget->currentItem()
->data(Qt::UserRole).value<SimpleKeyGrabberButton*>();
int tempMouseMod = ui->mouseSpeedModSpinBox->value();
if (tempMouseMod > 0)
{
tempbutton->setValue(tempMouseMod, JoyButtonSlot::JoyMouseSpeedMod);
QMetaObject::invokeMethod(&helper, "setAssignedSlot", Qt::BlockingQueuedConnection,
Q_ARG(int, tempMouseMod),
Q_ARG(unsigned int, 0),
Q_ARG(int, index),
Q_ARG(JoyButtonSlot::JoySlotInputAction, JoyButtonSlot::JoyMouseSpeedMod));
updateSlotsScrollArea(tempMouseMod);
}
}
void AdvanceButtonDialog::insertKeyPressSlot()
{
int index = ui->slotListWidget->currentRow();
SimpleKeyGrabberButton *tempbutton = ui->slotListWidget->currentItem()
->data(Qt::UserRole).value<SimpleKeyGrabberButton*>();
int actionTime = actionTimeConvert();
if (actionTime > 0)
{
tempbutton->setValue(actionTime, JoyButtonSlot::JoyKeyPress);
QMetaObject::invokeMethod(&helper, "setAssignedSlot", Qt::BlockingQueuedConnection,
Q_ARG(int, actionTime),
Q_ARG(unsigned int, 0),
Q_ARG(int, index),
Q_ARG(JoyButtonSlot::JoySlotInputAction, JoyButtonSlot::JoyKeyPress));
updateSlotsScrollArea(actionTime);
}
}
void AdvanceButtonDialog::insertDelaySlot()
{
//PadderCommon::lockInputDevices();
int index = ui->slotListWidget->currentRow();
SimpleKeyGrabberButton *tempbutton = ui->slotListWidget->currentItem()
->data(Qt::UserRole).value<SimpleKeyGrabberButton*>();
int actionTime = actionTimeConvert();
if (actionTime > 0)
{
tempbutton->setValue(actionTime, JoyButtonSlot::JoyDelay);
QMetaObject::invokeMethod(&helper, "setAssignedSlot", Qt::BlockingQueuedConnection,
Q_ARG(int, actionTime),
Q_ARG(unsigned int, 0),
Q_ARG(int, index),
Q_ARG(JoyButtonSlot::JoySlotInputAction, JoyButtonSlot::JoyDelay));
updateSlotsScrollArea(actionTime);
}
}
void AdvanceButtonDialog::insertTextEntrySlot()
{
int index = ui->slotListWidget->currentRow();
SimpleKeyGrabberButton *tempbutton = ui->slotListWidget->currentItem()
->data(Qt::UserRole).value<SimpleKeyGrabberButton*>();
QString temp = ui->textEntryLineEdit->text();
if (!temp.isEmpty())
{
tempbutton->setValue(temp, JoyButtonSlot::JoyTextEntry);
QMetaObject::invokeMethod(&helper, "setAssignedSlot", Qt::BlockingQueuedConnection,
Q_ARG(JoyButtonSlot*, tempbutton->getValue()),
Q_ARG(int, index));
tempbutton->setToolTip(temp);
updateSlotsScrollArea(0);
}
}
void AdvanceButtonDialog::insertExecuteSlot()
{
int index = ui->slotListWidget->currentRow();
SimpleKeyGrabberButton *tempbutton = ui->slotListWidget->currentItem()
->data(Qt::UserRole).value<SimpleKeyGrabberButton*>();
QString temp = ui->execLineEdit->text();
QString argumentsTemp = ui->execArgumentsLineEdit->text();
if (!temp.isEmpty())
{
QFileInfo tempFileInfo(temp);
if (tempFileInfo.exists() && tempFileInfo.isExecutable())
{
tempbutton->setValue(temp, JoyButtonSlot::JoyExecute);
if (!argumentsTemp.isEmpty())
{
tempbutton->getValue()->setExtraData(QVariant(argumentsTemp));
}
QMetaObject::invokeMethod(&helper, "setAssignedSlot", Qt::BlockingQueuedConnection,
Q_ARG(JoyButtonSlot*, tempbutton->getValue()),
Q_ARG(int, index));
tempbutton->setToolTip(temp);
updateSlotsScrollArea(0);
}
}
}
void AdvanceButtonDialog::performStatsWidgetRefresh(QListWidgetItem *item)
{
SimpleKeyGrabberButton *tempbutton = item->data(Qt::UserRole).value<SimpleKeyGrabberButton*>();
JoyButtonSlot *slot = tempbutton->getValue();
if (slot->getSlotMode() == JoyButtonSlot::JoyKeyboard && slot->getSlotCode() != 0)
{
ui->slotTypeComboBox->setCurrentIndex(KBMouseSlot);
}
else if (slot->getSlotMode() == JoyButtonSlot::JoyMouseButton ||
slot->getSlotMode() == JoyButtonSlot::JoyMouseMovement)
{
ui->slotTypeComboBox->setCurrentIndex(KBMouseSlot);
}
else if (slot->getSlotMode() == JoyButtonSlot::JoyCycle)
{
ui->slotTypeComboBox->setCurrentIndex(CycleSlot);
}
else if (slot->getSlotMode() == JoyButtonSlot::JoyDelay)
{
ui->slotTypeComboBox->setCurrentIndex(DelaySlot);
//changeSlotTypeDisplay(DelaySlot);
refreshTimeComboBoxes(slot);
}
else if (slot->getSlotMode() == JoyButtonSlot::JoyDistance)
{
ui->slotTypeComboBox->setCurrentIndex(DistanceSlot);
disconnect(ui->distanceSpinBox, SIGNAL(valueChanged(int)),
this, SLOT(checkSlotDistanceUpdate()));
ui->distanceSpinBox->setValue(slot->getSlotCode());
connect(ui->distanceSpinBox, SIGNAL(valueChanged(int)),
this, SLOT(checkSlotDistanceUpdate()));
}
else if (slot->getSlotMode() == JoyButtonSlot::JoyHold)
{
ui->slotTypeComboBox->setCurrentIndex(HoldSlot);
refreshTimeComboBoxes(slot);
}
else if (slot->getSlotMode() == JoyButtonSlot::JoyLoadProfile)
{
ui->slotTypeComboBox->setCurrentIndex(LoadSlot);
}
else if (slot->getSlotMode() == JoyButtonSlot::JoyMouseSpeedMod)
{
ui->slotTypeComboBox->setCurrentIndex(MouseModSlot);
disconnect(ui->mouseSpeedModSpinBox, SIGNAL(valueChanged(int)),
this, SLOT(checkSlotMouseModUpdate()));
ui->mouseSpeedModSpinBox->setValue(slot->getSlotCode());
connect(ui->mouseSpeedModSpinBox, SIGNAL(valueChanged(int)),
this, SLOT(checkSlotMouseModUpdate()));
}
else if (slot->getSlotMode() == JoyButtonSlot::JoyPause)
{
ui->slotTypeComboBox->setCurrentIndex(PauseSlot);
refreshTimeComboBoxes(slot);
}
else if (slot->getSlotMode() == JoyButtonSlot::JoyKeyPress)
{
ui->slotTypeComboBox->setCurrentIndex(PressTimeSlot);
refreshTimeComboBoxes(slot);
}
else if (slot->getSlotMode() == JoyButtonSlot::JoyRelease)
{
ui->slotTypeComboBox->setCurrentIndex(ReleaseSlot);
refreshTimeComboBoxes(slot);
}
else if (slot->getSlotMode() == JoyButtonSlot::JoySetChange)
{
disconnect(ui->slotSetChangeComboBox, SIGNAL(currentIndexChanged(int)),
this, SLOT(checkSlotSetChangeUpdate()));
ui->slotTypeComboBox->setCurrentIndex(SetChangeSlot);
unsigned int chooseIndex = slot->getSlotCode();
int foundIndex = ui->slotSetChangeComboBox->findData(QVariant(chooseIndex));
if (foundIndex >= 0)
{
ui->slotSetChangeComboBox->setCurrentIndex(foundIndex);
}
connect(ui->slotSetChangeComboBox, SIGNAL(currentIndexChanged(int)),
this, SLOT(checkSlotSetChangeUpdate()));
}
else if (slot->getSlotMode() == JoyButtonSlot::JoyTextEntry)
{
ui->slotTypeComboBox->setCurrentIndex(TextEntry);
ui->textEntryLineEdit->setText(slot->getTextData());
}
else if (slot->getSlotMode() == JoyButtonSlot::JoyExecute)
{
ui->slotTypeComboBox->setCurrentIndex(ExecuteSlot);
ui->execLineEdit->setText(slot->getTextData());
ui->execArgumentsLineEdit->setText(slot->getExtraData().toString());
}
/*else
{
ui->slotTypeComboBox->setCurrentIndex(KBMouseSlot);
}
*/
}
void AdvanceButtonDialog::checkSlotTimeUpdate()
{
int index = ui->slotListWidget->currentRow();
SimpleKeyGrabberButton *tempbutton = ui->slotListWidget->currentItem()
->data(Qt::UserRole).value<SimpleKeyGrabberButton*>();
JoyButtonSlot *tempbuttonslot = tempbutton->getValue();
if (tempbuttonslot->getSlotMode() == JoyButtonSlot::JoyPause ||
tempbuttonslot->getSlotMode() == JoyButtonSlot::JoyHold ||
tempbuttonslot->getSlotMode() == JoyButtonSlot::JoyRelease ||
tempbuttonslot->getSlotMode() == JoyButtonSlot::JoyKeyPress ||
tempbuttonslot->getSlotMode() == JoyButtonSlot::JoyDelay)
{
int actionTime = actionTimeConvert();
if (actionTime > 0)
{
tempbutton->setValue(actionTime, tempbuttonslot->getSlotMode());
QMetaObject::invokeMethod(&helper, "setAssignedSlot", Qt::BlockingQueuedConnection,
Q_ARG(int, actionTime),
Q_ARG(unsigned int, 0),
Q_ARG(int, index),
Q_ARG(JoyButtonSlot::JoySlotInputAction, tempbuttonslot->getSlotMode()));
updateSlotsScrollArea(actionTime);
}
}
}
void AdvanceButtonDialog::checkSlotMouseModUpdate()
{
int index = ui->slotListWidget->currentRow();
SimpleKeyGrabberButton *tempbutton = ui->slotListWidget->currentItem()
->data(Qt::UserRole).value<SimpleKeyGrabberButton*>();
JoyButtonSlot *tempbuttonslot = tempbutton->getValue();
int tempMouseMod = ui->mouseSpeedModSpinBox->value();
if (tempbuttonslot->getSlotMode() == JoyButtonSlot::JoyMouseSpeedMod &&
tempMouseMod > 0)
{
tempbutton->setValue(tempMouseMod, tempbuttonslot->getSlotMode());
QMetaObject::invokeMethod(&helper, "setAssignedSlot", Qt::BlockingQueuedConnection,
Q_ARG(int, tempMouseMod),
Q_ARG(unsigned int, 0),
Q_ARG(int, index),
Q_ARG(JoyButtonSlot::JoySlotInputAction, tempbuttonslot->getSlotMode()));
updateSlotsScrollArea(tempMouseMod);
}
}
void AdvanceButtonDialog::checkSlotSetChangeUpdate()
{
int index = ui->slotListWidget->currentRow();
SimpleKeyGrabberButton *tempbutton = ui->slotListWidget->currentItem()
->data(Qt::UserRole).value<SimpleKeyGrabberButton*>();
JoyButtonSlot *buttonslot = tempbutton->getValue();
if (buttonslot->getSlotMode() == JoyButtonSlot::JoySetChange)
{
int comboIndex = ui->slotSetChangeComboBox->currentIndex();
int setIndex = ui->slotSetChangeComboBox->itemData(comboIndex).toInt();
if (setIndex >= 0)
{
tempbutton->setValue(setIndex, buttonslot->getSlotMode());
QMetaObject::invokeMethod(&helper, "setAssignedSlot", Qt::BlockingQueuedConnection,
Q_ARG(int, setIndex),
Q_ARG(unsigned int, 0),
Q_ARG(int, index),
Q_ARG(JoyButtonSlot::JoySlotInputAction, buttonslot->getSlotMode()));
updateSlotsScrollArea(setIndex);
}
}
}
void AdvanceButtonDialog::checkSlotDistanceUpdate()
{
int index = ui->slotListWidget->currentRow();
SimpleKeyGrabberButton *tempbutton = ui->slotListWidget->currentItem()
->data(Qt::UserRole).value<SimpleKeyGrabberButton*>();
JoyButtonSlot *buttonslot = tempbutton->getValue();
int tempDistance = 0;
if (buttonslot->getSlotMode() == JoyButtonSlot::JoyDistance)
{
for (int i = 0; i < ui->slotListWidget->count(); i++)
{
SimpleKeyGrabberButton *button = ui->slotListWidget->item(i)
->data(Qt::UserRole).value<SimpleKeyGrabberButton*>();
JoyButtonSlot *tempbuttonslot = button->getValue();
if (tempbuttonslot->getSlotMode() == JoyButtonSlot::JoyDistance)
{
tempDistance += tempbuttonslot->getSlotCode();
}
else if (tempbuttonslot->getSlotMode() == JoyButtonSlot::JoyCycle)
{
tempDistance = 0;
}
}
int testDistance = ui->distanceSpinBox->value();
tempDistance += testDistance - buttonslot->getSlotCode();
if (tempDistance <= 100)
{
tempbutton->setValue(testDistance, buttonslot->getSlotMode());
QMetaObject::invokeMethod(&helper, "setAssignedSlot", Qt::BlockingQueuedConnection,
Q_ARG(int, testDistance),
Q_ARG(unsigned int, 0),
Q_ARG(int, index),
Q_ARG(JoyButtonSlot::JoySlotInputAction, buttonslot->getSlotMode()));
updateSlotsScrollArea(testDistance);
}
}
}
void AdvanceButtonDialog::updateWindowTitleButtonName()
{
QString temp;
temp.append(tr("Advanced").append(": ")).append(button->getPartialName(false, true));
if (button->getParentSet()->getIndex() != 0)
{
unsigned int setIndex = button->getParentSet()->getRealIndex();
temp.append(" [").append(tr("Set %1").arg(setIndex));
QString setName = button->getParentSet()->getName();
if (!setName.isEmpty())
{
temp.append(": ").append(setName);
}
temp.append("]");
}
setWindowTitle(temp);
}
void AdvanceButtonDialog::checkCycleResetWidgetStatus(bool enabled)
{
if (enabled)
{
ui->resetCycleDoubleSpinBox->setEnabled(true);
}
else
{
ui->resetCycleDoubleSpinBox->setEnabled(false);
}
}
void AdvanceButtonDialog::setButtonCycleResetInterval(double value)
{
unsigned int milliseconds = ((int)value * 1000) + (fmod(value, 1.0) * 1000);
button->setCycleResetTime(milliseconds);
}
void AdvanceButtonDialog::populateAutoResetInterval()
{
double seconds = button->getCycleResetTime() / 1000.0;
ui->resetCycleDoubleSpinBox->setValue(seconds);
}
void AdvanceButtonDialog::setButtonCycleReset(bool enabled)
{
if (enabled)
{
button->setCycleResetStatus(true);
if (button->getCycleResetTime() == 0 && ui->resetCycleDoubleSpinBox->value() > 0.0)
{
double current = ui->resetCycleDoubleSpinBox->value();
setButtonCycleResetInterval(current);
}
}
else
{
button->setCycleResetStatus(false);
}
}
void AdvanceButtonDialog::resetTimeBoxes()
{
disconnectTimeBoxesEvents();
ui->actionMinutesComboBox->setCurrentIndex(0);
ui->actionSecondsComboBox->setCurrentIndex(0);
ui->actionTenthsComboBox->setCurrentIndex(1);
ui->actionHundredthsComboBox->setCurrentIndex(0);
updateActionTimeLabel();
connectTimeBoxesEvents();
}
void AdvanceButtonDialog::disconnectTimeBoxesEvents()
{
disconnect(ui->actionSecondsComboBox, SIGNAL(currentIndexChanged(int)),
this, SLOT(updateActionTimeLabel()));
disconnect(ui->actionHundredthsComboBox, SIGNAL(currentIndexChanged(int)),
this, SLOT(updateActionTimeLabel()));
disconnect(ui->actionMinutesComboBox, SIGNAL(currentIndexChanged(int)),
this, SLOT(updateActionTimeLabel()));
disconnect(ui->actionTenthsComboBox, SIGNAL(currentIndexChanged(int)),
this, SLOT(updateActionTimeLabel()));
disconnect(ui->actionHundredthsComboBox, SIGNAL(currentIndexChanged(int)),
this, SLOT(checkSlotTimeUpdate()));
disconnect(ui->actionSecondsComboBox, SIGNAL(currentIndexChanged(int)),
this, SLOT(checkSlotTimeUpdate()));
disconnect(ui->actionMinutesComboBox, SIGNAL(currentIndexChanged(int)),
this, SLOT(checkSlotTimeUpdate()));
disconnect(ui->actionTenthsComboBox, SIGNAL(currentIndexChanged(int)),
this, SLOT(checkSlotTimeUpdate()));
}
void AdvanceButtonDialog::connectTimeBoxesEvents()
{
connect(ui->actionSecondsComboBox, SIGNAL(currentIndexChanged(int)),
this, SLOT(updateActionTimeLabel()));
connect(ui->actionHundredthsComboBox, SIGNAL(currentIndexChanged(int)),
this, SLOT(updateActionTimeLabel()));
connect(ui->actionMinutesComboBox, SIGNAL(currentIndexChanged(int)),
this, SLOT(updateActionTimeLabel()));
connect(ui->actionTenthsComboBox, SIGNAL(currentIndexChanged(int)),
this, SLOT(updateActionTimeLabel()));
connect(ui->actionHundredthsComboBox, SIGNAL(currentIndexChanged(int)),
this, SLOT(checkSlotTimeUpdate()));
connect(ui->actionSecondsComboBox, SIGNAL(currentIndexChanged(int)),
this, SLOT(checkSlotTimeUpdate()));
connect(ui->actionMinutesComboBox, SIGNAL(currentIndexChanged(int)),
this, SLOT(checkSlotTimeUpdate()));
connect(ui->actionTenthsComboBox, SIGNAL(currentIndexChanged(int)),
this, SLOT(checkSlotTimeUpdate()));
}
void AdvanceButtonDialog::populateSetSelectionComboBox()
{
ui->setSelectionComboBox->clear();
ui->setSelectionComboBox->insertItem(0, tr("Disabled"));
int currentIndex = 1;
for (int i=0; i < InputDevice::NUMBER_JOYSETS; i++)
{
if (this->button->getOriginSet() != i)
{
QString temp;
temp.append(tr("Select Set %1").arg(i+1));
InputDevice *tempdevice = button->getParentSet()->getInputDevice();
SetJoystick *tempset = tempdevice->getSetJoystick(i);
if (tempset)
{
QString setName = tempset->getName();
if (!setName.isEmpty())
{
temp.append(" ").append("[");
temp.append(setName).append("]").append(" ");
}
}
QString oneWayText;
oneWayText.append(temp).append(" ").append(tr("One Way"));
QString twoWayText;
twoWayText.append(temp).append(" ").append(tr("Two Way"));
QString whileHeldText;
whileHeldText.append(temp).append(" ").append(tr("While Held"));
QStringList setChoices;
setChoices.append(oneWayText);
setChoices.append(twoWayText);
setChoices.append(whileHeldText);
ui->setSelectionComboBox->insertItems(currentIndex, setChoices);
currentIndex += 3;
}
}
}
void AdvanceButtonDialog::populateSlotSetSelectionComboBox()
{
ui->slotSetChangeComboBox->clear();
unsigned int currentIndex = 0;
for (int i=0; i < InputDevice::NUMBER_JOYSETS; i++)
{
if (this->button->getOriginSet() != i)
{
QString temp;
temp.append(tr("Select Set %1").arg(i+1));
InputDevice *tempdevice = button->getParentSet()->getInputDevice();
SetJoystick *tempset = tempdevice->getSetJoystick(i);
if (tempset)
{
QString setName = tempset->getName();
if (!setName.isEmpty())
{
temp.append(" ").append("[");
temp.append(setName).append("]").append(" ");
}
}
ui->slotSetChangeComboBox->insertItem(currentIndex, temp, QVariant(i));
currentIndex++;
}
}
}
void AdvanceButtonDialog::findTurboModeComboIndex()
{
JoyButton::TurboMode currentTurboMode = this->button->getTurboMode();
if (currentTurboMode == JoyButton::NormalTurbo)
{
ui->turboModeComboBox->setCurrentIndex(0);
}
else if (currentTurboMode == JoyButton::GradientTurbo)
{
ui->turboModeComboBox->setCurrentIndex(1);
}
else if (currentTurboMode == JoyButton::PulseTurbo)
{
ui->turboModeComboBox->setCurrentIndex(2);
}
}
void AdvanceButtonDialog::setButtonTurboMode(int value)
{
if (value == 0)
{
this->button->setTurboMode(JoyButton::NormalTurbo);
}
else if (value == 1)
{
this->button->setTurboMode(JoyButton::GradientTurbo);
}
else if (value == 2)
{
this->button->setTurboMode(JoyButton::PulseTurbo);
}
}
void AdvanceButtonDialog::showSelectProfileWindow()
{
AntiMicroSettings *settings = this->button->getParentSet()->getInputDevice()->getSettings();
QString lookupDir = PadderCommon::preferredProfileDir(settings);
QString filename = QFileDialog::getOpenFileName(this, tr("Choose Profile"),
lookupDir, tr("Config Files (*.amgp *.xml)"));
if (!filename.isEmpty())
{
int index = ui->slotListWidget->currentRow();
SimpleKeyGrabberButton *tempbutton = ui->slotListWidget->currentItem()
->data(Qt::UserRole).value<SimpleKeyGrabberButton*>();
tempbutton->setValue(filename, JoyButtonSlot::JoyLoadProfile);
QMetaObject::invokeMethod(&helper, "setAssignedSlot", Qt::BlockingQueuedConnection,
Q_ARG(JoyButtonSlot*, tempbutton->getValue()),
Q_ARG(int, index));
tempbutton->setToolTip(filename);
updateSlotsScrollArea(0);
}
}
void AdvanceButtonDialog::showFindExecutableWindow(bool)
{
QString temp = ui->execLineEdit->text();
QString lookupDir = QDir::homePath();
if (!temp.isEmpty())
{
QFileInfo tempFileInfo(temp);
if (tempFileInfo.absoluteDir().exists())
{
lookupDir = tempFileInfo.absoluteDir().absolutePath();
}
}
QString filepath = QFileDialog::getOpenFileName(this, tr("Choose Executable"), lookupDir);
if (!filepath.isEmpty())
{
QFileInfo tempFileInfo(filepath);
if (tempFileInfo.exists() && tempFileInfo.isExecutable())
{
ui->execLineEdit->setText(filepath);
}
}
}
void AdvanceButtonDialog::changeSlotTypeDisplay(int index)
{
if (index == KBMouseSlot)
{
ui->slotControlsStackedWidget->setCurrentIndex(0);
}
else if (index == CycleSlot)
{
ui->slotControlsStackedWidget->setCurrentIndex(3);
}
else if (index == DelaySlot)
{
ui->slotControlsStackedWidget->setCurrentIndex(0);
}
else if (index == DistanceSlot)
{
ui->slotControlsStackedWidget->setCurrentIndex(2);
}
else if (index == HoldSlot)
{
ui->slotControlsStackedWidget->setCurrentIndex(0);
}
else if (index == LoadSlot)
{
ui->slotControlsStackedWidget->setCurrentIndex(4);
}
else if (index == MouseModSlot)
{
ui->slotControlsStackedWidget->setCurrentIndex(1);
}
else if (index == PauseSlot)
{
ui->slotControlsStackedWidget->setCurrentIndex(0);
}
else if (index == PressTimeSlot)
{
ui->slotControlsStackedWidget->setCurrentIndex(0);
}
else if (index == ReleaseSlot)
{
ui->slotControlsStackedWidget->setCurrentIndex(0);
}
else if (index == SetChangeSlot)
{
ui->slotControlsStackedWidget->setCurrentIndex(5);
}
else if (index == TextEntry)
{
ui->slotControlsStackedWidget->setCurrentIndex(6);
}
else if (index == ExecuteSlot)
{
ui->slotControlsStackedWidget->setCurrentIndex(7);
}
}
void AdvanceButtonDialog::changeSlotHelpText(int index)
{
if (index == KBMouseSlot)
{
ui->slotTypeHelpLabel->setText(tr("Insert a new blank slot."));
}
else if (index == CycleSlot)
{
ui->slotTypeHelpLabel->setText(tr("Slots past a Cycle action will be executed "
"on the next button press. Multiple cycles can be added "
"in order to create partitions in a sequence."));
}
else if (index == DelaySlot)
{
ui->slotTypeHelpLabel->setText(tr("Delays the time that the next slot is activated "
"by the time specified. Slots activated before the "
"delay will remain active after the delay time "
"has passed."));
}
else if (index == DistanceSlot)
{
ui->slotTypeHelpLabel->setText(tr("Distance action specifies that the slots afterwards "
"will only be executed when an axis is moved "
"a certain range past the designated dead zone."));
}
else if (index == HoldSlot)
{
ui->slotTypeHelpLabel->setText(tr("Insert a hold action. Slots after the action will only be "
"executed if the button is held past the interval specified."));
}
else if (index == LoadSlot)
{
ui->slotTypeHelpLabel->setText(tr("Chose a profile to load when this slot is activated."));
}
else if (index == MouseModSlot)
{
ui->slotTypeHelpLabel->setText(tr("Mouse mod action will modify all mouse speed settings "
"by a specified percentage while the action is being processed. "
"This can be useful for slowing down the mouse while "
"sniping."));
}
else if (index == PauseSlot)
{
ui->slotTypeHelpLabel->setText(tr("Insert a pause that occurs in between key presses."));
}
else if (index == PressTimeSlot)
{
ui->slotTypeHelpLabel->setText(tr("Specify the time that keys past this slot should be "
"held down."));
}
else if (index == ReleaseSlot)
{
ui->slotTypeHelpLabel->setText(tr("Insert a release action. Slots after the action will only be "
"executed after a button release if the button was held "
"past the interval specified."));
}
else if (index == SetChangeSlot)
{
ui->slotTypeHelpLabel->setText(tr("Change to selected set once slot is activated."));
}
else if (index == TextEntry)
{
ui->slotTypeHelpLabel->setText(tr("Full string will be typed when a "
"slot is activated."));
}
else if (index == ExecuteSlot)
{
ui->slotTypeHelpLabel->setText(tr("Execute program when slot is activated."));
}
}
``` | /content/code_sandbox/src/advancebuttondialog.cpp | c++ | 2016-05-24T23:59:31 | 2024-08-11T02:46:48 | antimicro | AntiMicro/antimicro | 1,788 | 12,448 |
```c++
/* antimicro Gamepad to KB+M event mapper
*
* This program is free software: you can redistribute it and/or modify
* (at your option) any later version.
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* along with this program. If not, see <path_to_url
*/
#include <QApplication>
#include <QLibraryInfo>
#ifdef Q_OS_WIN
#include <QStandardPaths>
#endif
#include "common.h"
namespace PadderCommon
{
QString preferredProfileDir(AntiMicroSettings *settings)
{
QString lastProfileDir = settings->value("LastProfileDir", "").toString();
QString defaultProfileDir = settings->value("DefaultProfileDir", "").toString();
QString lookupDir;
if (!defaultProfileDir.isEmpty())
{
QFileInfo dirinfo(defaultProfileDir);
if (dirinfo.isDir() && dirinfo.isReadable())
{
lookupDir = defaultProfileDir;
}
}
if (lookupDir.isEmpty() && !lastProfileDir.isEmpty())
{
QFileInfo dirinfo(lastProfileDir);
if (dirinfo.isDir() && dirinfo.isReadable())
{
lookupDir = lastProfileDir;
}
}
if (lookupDir.isEmpty())
{
#ifdef Q_OS_WIN
#ifdef WIN_PORTABLE_PACKAGE
QString portableProDir = QDir::currentPath().append("/profiles");
QFileInfo portableProDirInfo(portableProDir);
if (portableProDirInfo.isDir() && portableProDirInfo.isReadable())
{
lookupDir = portableProDir;
}
else
{
lookupDir = QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation);
}
#else
lookupDir = QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation);
#endif
#else
lookupDir = QDir::homePath();
#endif
}
return lookupDir;
}
QStringList arguments(int &argc, char **argv)
{
QStringList list;
for (int a = 0; a < argc; ++a) {
list << QString::fromLocal8Bit(argv[a]);
}
return list;
}
QStringList parseArgumentsString(QString tempString)
{
bool inside = (!tempString.isEmpty() && tempString.at(0) == QChar('"'));
QStringList tempList = tempString.split(QRegExp("\""), QString::SkipEmptyParts);
QStringList finalList;
QStringListIterator iter(tempList);
while (iter.hasNext())
{
QString temp = iter.next();
if (inside)
{
finalList.append(temp);
}
else
{
finalList.append(temp.split(QRegExp("\\s+"), QString::SkipEmptyParts));
}
inside = !inside;
}
return finalList;
}
/**
* @brief Reload main application and base Qt translation files.
* @param Based Qt translator
* @param Application translator
* @param Language code
*/
void reloadTranslations(QTranslator *translator,
QTranslator *appTranslator,
QString language)
{
// Remove application specific translation strings
qApp->removeTranslator(translator);
// Remove old Qt translation strings
qApp->removeTranslator(appTranslator);
// Load new Qt translation strings
#if defined(Q_OS_UNIX)
translator->load(QString("qt_").append(language), QLibraryInfo::location(QLibraryInfo::TranslationsPath));
#elif defined(Q_OS_WIN)
#ifdef QT_DEBUG
translator->load(QString("qt_").append(language), QLibraryInfo::location(QLibraryInfo::TranslationsPath));
#else
translator->load(QString("qt_").append(language),
QApplication::applicationDirPath().append("\\share\\qt\\translations"));
#endif
#endif
qApp->installTranslator(appTranslator);
// Load application specific translation strings
#if defined(Q_OS_UNIX)
translator->load("antimicro_" + language, QApplication::applicationDirPath().append("/../share/antimicro/translations"));
#elif defined(Q_OS_WIN)
translator->load("antimicro_" + language, QApplication::applicationDirPath().append("\\share\\antimicro\\translations"));
#endif
qApp->installTranslator(translator);
}
void lockInputDevices()
{
sdlWaitMutex.lock();
/*editingLock.lockForWrite();
editingBindings = true;
editingLock.unlock();
waitMutex.lock();
//editingBindings = true;
waitThisOut.wait(&waitMutex);
*/
}
void unlockInputDevices()
{
sdlWaitMutex.unlock();
/*editingLock.lockForWrite();
editingBindings = false;
editingLock.unlock();
waitMutex.unlock();
*/
}
QWaitCondition waitThisOut;
QMutex sdlWaitMutex;
QMutex inputDaemonMutex;
QReadWriteLock editingLock;
bool editingBindings = false;
MouseHelper mouseHelperObj;
}
``` | /content/code_sandbox/src/common.cpp | c++ | 2016-05-24T23:59:31 | 2024-08-11T02:46:48 | antimicro | AntiMicro/antimicro | 1,788 | 1,086 |
```c++
/* antimicro Gamepad to KB+M event mapper
*
* This program is free software: you can redistribute it and/or modify
* (at your option) any later version.
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* along with this program. If not, see <path_to_url
*/
//#include <QDebug>
#include <QList>
#include "joybutton.h"
#include "joybuttonmousehelper.h"
JoyButtonMouseHelper::JoyButtonMouseHelper(QObject *parent) :
QObject(parent)
{
firstSpringEvent = false;
}
/**
* @brief Perform mouse movement in cursor mode.
*/
void JoyButtonMouseHelper::moveMouseCursor()
{
int finalx = 0;
int finaly = 0;
int elapsedTime = 5;
JoyButton::moveMouseCursor(finalx, finaly, elapsedTime);
if (finalx != 0 || finaly != 0)
{
emit mouseCursorMoved(finalx, finaly, elapsedTime);
}
}
/**
* @brief Perform mouse movement in spring mode.
*/
void JoyButtonMouseHelper::moveSpringMouse()
{
int finalx = 0;
int finaly = 0;
bool hasMoved = false;
JoyButton::moveSpringMouse(finalx, finaly, hasMoved);
if (hasMoved)
{
emit mouseSpringMoved(finalx, finaly);
}
}
/**
* @brief Perform mouse events for all buttons and slots.
*/
void JoyButtonMouseHelper::mouseEvent()
{
if (!JoyButton::hasCursorEvents() && !JoyButton::hasSpringEvents())
{
QList<JoyButton*> *buttonList = JoyButton::getPendingMouseButtons();
QListIterator<JoyButton*> iter(*buttonList);
while (iter.hasNext())
{
JoyButton *temp = iter.next();
temp->mouseEvent();
}
}
moveMouseCursor();
if (JoyButton::hasSpringEvents())
{
moveSpringMouse();
}
JoyButton::restartLastMouseTime();
firstSpringEvent = false;
}
void JoyButtonMouseHelper::resetButtonMouseDistances()
{
QList<JoyButton*> *buttonList = JoyButton::getPendingMouseButtons();
QListIterator<JoyButton*> iter(*buttonList);
while (iter.hasNext())
{
JoyButton *temp = iter.next();
temp->resetAccelerationDistances();
}
}
void JoyButtonMouseHelper::setFirstSpringStatus(bool status)
{
firstSpringEvent = status;
}
bool JoyButtonMouseHelper::getFirstSpringStatus()
{
return firstSpringEvent;
}
void JoyButtonMouseHelper::carryGamePollRateUpdate(unsigned int pollRate)
{
emit gamepadRefreshRateUpdated(pollRate);
}
void JoyButtonMouseHelper::carryMouseRefreshRateUpdate(unsigned int refreshRate)
{
emit mouseRefreshRateUpdated(refreshRate);
}
void JoyButtonMouseHelper::changeThread(QThread *thread)
{
JoyButton::setStaticMouseThread(thread);
}
``` | /content/code_sandbox/src/joybuttonmousehelper.cpp | c++ | 2016-05-24T23:59:31 | 2024-08-11T02:46:48 | antimicro | AntiMicro/antimicro | 1,788 | 662 |
```objective-c
/* antimicro Gamepad to KB+M event mapper
*
* This program is free software: you can redistribute it and/or modify
* (at your option) any later version.
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* along with this program. If not, see <path_to_url
*/
#ifndef JOYAXISWIDGET_H
#define JOYAXISWIDGET_H
#include <QPoint>
#include "flashbuttonwidget.h"
#include "joyaxis.h"
class JoyAxisWidget : public FlashButtonWidget
{
Q_OBJECT
public:
explicit JoyAxisWidget(JoyAxis *axis, bool displayNames, QWidget *parent=0);
JoyAxis* getAxis();
void tryFlash();
protected:
virtual QString generateLabel();
JoyAxis *axis;
signals:
public slots:
void disableFlashes();
void enableFlashes();
private slots:
void showContextMenu(const QPoint &point);
};
#endif // JOYAXISWIDGET_H
``` | /content/code_sandbox/src/joyaxiswidget.h | objective-c | 2016-05-24T23:59:31 | 2024-08-11T02:46:48 | antimicro | AntiMicro/antimicro | 1,788 | 236 |
```c++
/* antimicro Gamepad to KB+M event mapper
*
* This program is free software: you can redistribute it and/or modify
* (at your option) any later version.
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* along with this program. If not, see <path_to_url
*/
//#include <QDebug>
#include <QFileInfo>
#include "inputdevice.h"
#include "joybuttonslot.h"
#include "antkeymapper.h"
#include "event.h"
const int JoyButtonSlot::JOYSPEED = 20;
const QString JoyButtonSlot::xmlName = "slot";
const int JoyButtonSlot::MAXTEXTENTRYDISPLAYLENGTH = 40;
JoyButtonSlot::JoyButtonSlot(QObject *parent) :
QObject(parent),
extraData()
{
deviceCode = 0;
mode = JoyKeyboard;
distance = 0.0;
previousDistance = 0.0;
qkeyaliasCode = 0;
easingActive = false;
}
JoyButtonSlot::JoyButtonSlot(int code, JoySlotInputAction mode, QObject *parent) :
QObject(parent),
extraData()
{
deviceCode = 0;
qkeyaliasCode = 0;
if (code > 0)
{
deviceCode = code;
}
this->mode = mode;
distance = 0.0;
easingActive = false;
}
JoyButtonSlot::JoyButtonSlot(int code, unsigned int alias, JoySlotInputAction mode, QObject *parent) :
QObject(parent),
extraData()
{
deviceCode = 0;
qkeyaliasCode = 0;
if (code > 0)
{
deviceCode = code;
}
if (alias > 0)
{
qkeyaliasCode = alias;
}
this->mode = mode;
distance = 0.0;
easingActive = false;
}
JoyButtonSlot::JoyButtonSlot(JoyButtonSlot *slot, QObject *parent) :
QObject(parent),
extraData()
{
deviceCode = slot->deviceCode;
qkeyaliasCode = slot->qkeyaliasCode;
mode = slot->mode;
distance = slot->distance;
easingActive = false;
textData = slot->getTextData();
extraData = slot->getExtraData();
}
JoyButtonSlot::JoyButtonSlot(QString text, JoySlotInputAction mode, QObject *parent) :
QObject(parent),
extraData()
{
deviceCode = 0;
qkeyaliasCode = 0;
this->mode = mode;
distance = 0.0;
easingActive = false;
if (mode == JoyLoadProfile ||
mode == JoyTextEntry ||
mode == JoyExecute)
{
textData = text;
}
}
void JoyButtonSlot::setSlotCode(int code)
{
if (code >= 0)
{
deviceCode = code;
qkeyaliasCode = 0;
}
}
void JoyButtonSlot::setSlotCode(int code, unsigned int alias)
{
if (mode == JoyButtonSlot::JoyKeyboard && code > 0)
{
deviceCode = code;
qkeyaliasCode = alias;
}
else if (code >= 0)
{
deviceCode = code;
qkeyaliasCode = 0;
}
}
unsigned int JoyButtonSlot::getSlotCodeAlias()
{
return qkeyaliasCode;
}
int JoyButtonSlot::getSlotCode()
{
return deviceCode;
}
void JoyButtonSlot::setSlotMode(JoySlotInputAction selectedMode)
{
mode = selectedMode;
}
JoyButtonSlot::JoySlotInputAction JoyButtonSlot::getSlotMode()
{
return mode;
}
QString JoyButtonSlot::movementString()
{
QString newlabel;
if (mode == JoyMouseMovement)
{
newlabel.append(tr("Mouse")).append(" ");
if (deviceCode == JoyButtonSlot::MouseUp)
{
newlabel.append(tr("Up"));
}
else if (deviceCode == JoyButtonSlot::MouseDown)
{
newlabel.append(tr("Down"));
}
else if (deviceCode == JoyButtonSlot::MouseLeft)
{
newlabel.append(tr("Left"));
}
else if (deviceCode == JoyButtonSlot::MouseRight)
{
newlabel.append(tr("Right"));
}
}
return newlabel;
}
void JoyButtonSlot::setDistance(double distance)
{
this->distance = distance;
}
double JoyButtonSlot::getMouseDistance()
{
return distance;
}
QElapsedTimer* JoyButtonSlot::getMouseInterval()
{
return &mouseInterval;
}
void JoyButtonSlot::restartMouseInterval()
{
mouseInterval.restart();
}
void JoyButtonSlot::readConfig(QXmlStreamReader *xml)
{
if (xml->isStartElement() && xml->name() == "slot")
{
QString profile;
QString tempStringData;
QString extraStringData;
xml->readNextStartElement();
while (!xml->atEnd() && (!xml->isEndElement() && xml->name() != "slot"))
{
if (xml->name() == "code" && xml->isStartElement())
{
QString temptext = xml->readElementText();
bool ok = false;
unsigned int tempchoice = temptext.toInt(&ok, 0);
if (ok)
{
this->setSlotCode(tempchoice);
}
}
else if (xml->name() == "profile" && xml->isStartElement())
{
QString temptext = xml->readElementText();
profile = temptext;
}
else if (xml->name() == "text" && xml->isStartElement())
{
QString temptext = xml->readElementText();
tempStringData = temptext;
}
else if (xml->name() == "path" && xml->isStartElement())
{
QString temptext = xml->readElementText();
tempStringData = temptext;
}
else if (xml->name() == "arguments" && xml->isStartElement())
{
QString temptext = xml->readElementText();
extraStringData = temptext;
}
else if (xml->name() == "mode" && xml->isStartElement())
{
QString temptext = xml->readElementText();
if (temptext == "keyboard")
{
this->setSlotMode(JoyKeyboard);
}
else if (temptext == "mousebutton")
{
this->setSlotMode(JoyMouseButton);
}
else if (temptext == "mousemovement")
{
this->setSlotMode(JoyMouseMovement);
}
else if (temptext == "pause")
{
this->setSlotMode(JoyPause);
}
else if (temptext == "hold")
{
this->setSlotMode(JoyHold);
}
else if (temptext == "cycle")
{
this->setSlotMode(JoyCycle);
}
else if (temptext == "distance")
{
this->setSlotMode(JoyDistance);
}
else if (temptext == "release")
{
this->setSlotMode(JoyRelease);
}
else if (temptext == "mousespeedmod")
{
this->setSlotMode(JoyMouseSpeedMod);
}
else if (temptext == "keypress")
{
this->setSlotMode(JoyKeyPress);
}
else if (temptext == "delay")
{
this->setSlotMode(JoyDelay);
}
else if (temptext == "loadprofile")
{
this->setSlotMode(JoyLoadProfile);
}
else if (temptext == "setchange")
{
this->setSlotMode(JoySetChange);
}
else if (temptext == "textentry")
{
this->setSlotMode(JoyTextEntry);
}
else if (temptext == "execute")
{
this->setSlotMode(JoyExecute);
}
}
else
{
xml->skipCurrentElement();
}
xml->readNextStartElement();
}
if (this->getSlotMode() == JoyButtonSlot::JoyKeyboard)
{
unsigned int virtualkey = AntKeyMapper::getInstance()->returnVirtualKey(this->getSlotCode());
unsigned int tempkey = this->getSlotCode();
if (virtualkey)
{
// Mapping found a valid native keysym.
this->setSlotCode(virtualkey, tempkey);
}
else if ((unsigned int)this->getSlotCode() > QtKeyMapperBase::nativeKeyPrefix)
{
// Value is in the native key range. Remove prefix and use
// new value as a native keysym.
unsigned int temp = this->getSlotCode() - QtKeyMapperBase::nativeKeyPrefix;
this->setSlotCode(temp);
}
}
else if (this->getSlotMode() == JoyButtonSlot::JoyLoadProfile && !profile.isEmpty())
{
QFileInfo profileInfo(profile);
if (!profileInfo.exists() || !(profileInfo.suffix() == "amgp" || profileInfo.suffix() == "xml"))
{
this->setTextData("");
}
else
{
this->setTextData(profile);
}
}
else if (this->getSlotMode() == JoySetChange)
{
if (!this->getSlotCode() >= 0 && !this->getSlotCode() < InputDevice::NUMBER_JOYSETS)
{
this->setSlotCode(-1);
}
}
else if (this->getSlotMode() == JoyTextEntry && !tempStringData.isEmpty())
{
this->setTextData(tempStringData);
}
else if (this->getSlotMode() == JoyExecute && !tempStringData.isEmpty())
{
QFileInfo tempFile(tempStringData);
if (tempFile.exists() && tempFile.isExecutable())
{
this->setTextData(tempStringData);
if (!extraStringData.isEmpty())
{
this->setExtraData(QVariant(extraStringData));
}
}
}
}
}
void JoyButtonSlot::writeConfig(QXmlStreamWriter *xml)
{
xml->writeStartElement(getXmlName());
if (mode == JoyKeyboard)
{
unsigned int basekey = AntKeyMapper::getInstance()->returnQtKey(deviceCode);
unsigned int qtkey = this->getSlotCodeAlias();
if (qtkey > 0 || basekey > 0)
{
// Did not add an alias to slot. If a possible Qt key value
// was found, use it.
if (qtkey == 0 && basekey > 0)
{
qtkey = basekey;
}
// Found a valid abstract keysym.
//qDebug() << "ANT KEY: " << QString::number(qtkey, 16);
xml->writeTextElement("code", QString("0x%1").arg(qtkey, 0, 16));
}
else if (deviceCode > 0)
{
// No abstraction provided for key. Add prefix to native keysym.
unsigned int tempkey = deviceCode | QtKeyMapperBase::nativeKeyPrefix;
//qDebug() << "ANT KEY: " << QString::number(tempkey, 16);
xml->writeTextElement("code", QString("0x%1").arg(tempkey, 0, 16));
}
}
else if (mode == JoyLoadProfile && !textData.isEmpty())
{
xml->writeTextElement("profile", textData);
}
else if (mode == JoyTextEntry && !textData.isEmpty())
{
xml->writeTextElement("text", textData);
}
else if (mode == JoyExecute && !textData.isEmpty())
{
xml->writeTextElement("path", textData);
if (!extraData.isNull() && extraData.canConvert<QString>())
{
xml->writeTextElement("arguments", extraData.toString());
}
}
else
{
xml->writeTextElement("code", QString::number(deviceCode));
}
xml->writeStartElement("mode");
if (mode == JoyKeyboard)
{
xml->writeCharacters("keyboard");
}
else if (mode == JoyMouseButton)
{
xml->writeCharacters("mousebutton");
}
else if (mode == JoyMouseMovement)
{
xml->writeCharacters("mousemovement");
}
else if (mode == JoyPause)
{
xml->writeCharacters("pause");
}
else if (mode == JoyHold)
{
xml->writeCharacters("hold");
}
else if (mode == JoyCycle)
{
xml->writeCharacters("cycle");
}
else if (mode == JoyDistance)
{
xml->writeCharacters("distance");
}
else if (mode == JoyRelease)
{
xml->writeCharacters("release");
}
else if (mode == JoyMouseSpeedMod)
{
xml->writeCharacters("mousespeedmod");
}
else if (mode == JoyKeyPress)
{
xml->writeCharacters("keypress");
}
else if (mode == JoyDelay)
{
xml->writeCharacters("delay");
}
else if (mode == JoyLoadProfile)
{
xml->writeCharacters("loadprofile");
}
else if (mode == JoySetChange)
{
xml->writeCharacters("setchange");
}
else if (mode == JoyTextEntry)
{
xml->writeCharacters("textentry");
}
else if (mode == JoyExecute)
{
xml->writeCharacters("execute");
}
xml->writeEndElement();
xml->writeEndElement();
}
QString JoyButtonSlot::getXmlName()
{
return this->xmlName;
}
QString JoyButtonSlot::getSlotString()
{
QString newlabel;
if (deviceCode >= 0)
{
if (mode == JoyButtonSlot::JoyKeyboard)
{
unsigned int tempDeviceCode = deviceCode;
#ifdef Q_OS_WIN
QtKeyMapperBase *nativeWinKeyMapper = AntKeyMapper::getInstance()->getNativeKeyMapper();
if (nativeWinKeyMapper)
{
tempDeviceCode = nativeWinKeyMapper->returnVirtualKey(qkeyaliasCode);
}
#endif
newlabel = newlabel.append(keysymToKeyString(tempDeviceCode, qkeyaliasCode).toUpper());
}
else if (mode == JoyButtonSlot::JoyMouseButton)
{
newlabel.append(tr("Mouse")).append(" ");
switch (deviceCode)
{
case 1:
newlabel.append(tr("LB"));
break;
case 2:
newlabel.append(tr("MB"));
break;
case 3:
newlabel.append(tr("RB"));
break;
#ifdef Q_OS_WIN
case 8:
newlabel.append(tr("B4"));
break;
case 9:
newlabel.append(tr("B5"));
break;
#endif
default:
newlabel.append(QString::number(deviceCode));
break;
}
}
else if (mode == JoyMouseMovement)
{
newlabel.append(movementString());
}
else if (mode == JoyPause)
{
int minutes = deviceCode / 1000 / 60;
int seconds = (deviceCode / 1000 % 60);
int hundredths = deviceCode % 1000 / 10;
newlabel.append(tr("Pause")).append(" ");
if (minutes > 0)
{
newlabel.append(QString("%1:").arg(minutes, 2, 10, QChar('0')));
}
newlabel.append(QString("%1.%2")
.arg(seconds, 2, 10, QChar('0'))
.arg(hundredths, 2, 10, QChar('0')));
}
else if (mode == JoyHold)
{
int minutes = deviceCode / 1000 / 60;
int seconds = (deviceCode / 1000 % 60);
int hundredths = deviceCode % 1000 / 10;
newlabel.append(tr("Hold")).append(" ");
if (minutes > 0)
{
newlabel.append(QString("%1:").arg(minutes, 2, 10, QChar('0')));
}
newlabel.append(QString("%1.%2")
.arg(seconds, 2, 10, QChar('0'))
.arg(hundredths, 2, 10, QChar('0')));
}
else if (mode == JoyButtonSlot::JoyCycle)
{
newlabel.append(tr("Cycle"));
}
else if (mode == JoyDistance)
{
QString temp(tr("Distance"));
temp.append(" ").append(QString::number(deviceCode).append("%"));
newlabel.append(temp);
}
else if (mode == JoyRelease)
{
int minutes = deviceCode / 1000 / 60;
int seconds = (deviceCode / 1000 % 60);
int hundredths = deviceCode % 1000 / 10;
newlabel.append(tr("Release")).append(" ");
if (minutes > 0)
{
newlabel.append(QString("%1:").arg(minutes, 2, 10, QChar('0')));
}
newlabel.append(QString("%1.%2")
.arg(seconds, 2, 10, QChar('0'))
.arg(hundredths, 2, 10, QChar('0')));
}
else if (mode == JoyMouseSpeedMod)
{
QString temp;
temp.append(tr("Mouse Mod")).append(" ");
temp.append(QString::number(deviceCode).append("%"));
newlabel.append(temp);
}
else if (mode == JoyKeyPress)
{
int minutes = deviceCode / 1000 / 60;
int seconds = (deviceCode / 1000 % 60);
int hundredths = deviceCode % 1000 / 10;
QString temp;
temp.append(tr("Press Time")).append(" ");
if (minutes > 0)
{
temp.append(QString("%1:").arg(minutes, 2, 10, QChar('0')));
}
temp.append(QString("%1.%2")
.arg(seconds, 2, 10, QChar('0'))
.arg(hundredths, 2, 10, QChar('0')));
newlabel.append(temp);
}
else if (mode == JoyDelay)
{
int minutes = deviceCode / 1000 / 60;
int seconds = (deviceCode / 1000 % 60);
int hundredths = deviceCode % 1000 / 10;
QString temp;
temp.append(tr("Delay")).append(" ");
if (minutes > 0)
{
temp.append(QString("%1:").arg(minutes, 2, 10, QChar('0')));
}
temp.append(QString("%1.%2")
.arg(seconds, 2, 10, QChar('0'))
.arg(hundredths, 2, 10, QChar('0')));
newlabel.append(temp);
}
else if (mode == JoyLoadProfile)
{
if (!textData.isEmpty())
{
QFileInfo profileInfo(textData);
QString temp;
temp.append(tr("Load %1").arg(PadderCommon::getProfileName(profileInfo)));
newlabel.append(temp);
}
}
else if (mode == JoySetChange)
{
newlabel.append(tr("Set Change %1").arg(deviceCode+1));
}
else if (mode == JoyTextEntry)
{
QString temp = textData;
if (temp.length() > MAXTEXTENTRYDISPLAYLENGTH)
{
temp.truncate(MAXTEXTENTRYDISPLAYLENGTH - 3);
temp.append("...");
}
newlabel.append(tr("[Text] %1").arg(temp));
}
else if (mode == JoyExecute)
{
QString temp;
if (!textData.isEmpty())
{
QFileInfo tempFileInfo(textData);
temp.append(tempFileInfo.fileName());
}
newlabel.append(tr("[Exec] %1").arg(temp));
}
}
else
{
newlabel = newlabel.append(tr("[NO KEY]"));
}
return newlabel;
}
void JoyButtonSlot::setPreviousDistance(double distance)
{
previousDistance = distance;
}
double JoyButtonSlot::getPreviousDistance()
{
return previousDistance;
}
bool JoyButtonSlot::isModifierKey()
{
bool modifier = false;
if (mode == JoyKeyboard && AntKeyMapper::getInstance()->isModifierKey(qkeyaliasCode))
{
modifier = true;
}
return modifier;
}
bool JoyButtonSlot::isEasingActive()
{
return easingActive;
}
void JoyButtonSlot::setEasingStatus(bool isActive)
{
easingActive = isActive;
}
QTime* JoyButtonSlot::getEasingTime()
{
return &easingTime;
}
void JoyButtonSlot::setTextData(QString textData)
{
this->textData = textData;
}
QString JoyButtonSlot::getTextData()
{
return textData;
}
void JoyButtonSlot::setExtraData(QVariant data)
{
this->extraData = data;
}
QVariant JoyButtonSlot::getExtraData()
{
return extraData;
}
bool JoyButtonSlot::isValidSlot()
{
bool result = true;
switch (mode)
{
case JoyLoadProfile:
case JoyTextEntry:
case JoyExecute:
{
if (textData.isEmpty())
{
result = false;
}
break;
}
case JoySetChange:
{
if (deviceCode < 0)
{
result = false;
}
break;
}
}
return result;
}
``` | /content/code_sandbox/src/joybuttonslot.cpp | c++ | 2016-05-24T23:59:31 | 2024-08-11T02:46:48 | antimicro | AntiMicro/antimicro | 1,788 | 4,755 |
```c++
/* antimicro Gamepad to KB+M event mapper
*
* This program is free software: you can redistribute it and/or modify
* (at your option) any later version.
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* along with this program. If not, see <path_to_url
*/
//#include <QDebug>
#include "event.h"
#include "antkeymapper.h"
#include "eventhandlerfactory.h"
#ifdef Q_OS_WIN
#include "winextras.h"
#endif
#ifdef Q_OS_UNIX
#if (QT_VERSION >= QT_VERSION_CHECK(5, 0, 0))
#include <QApplication>
#endif
#endif
#include "simplekeygrabberbutton.h"
SimpleKeyGrabberButton::SimpleKeyGrabberButton(QWidget *parent) :
QPushButton(parent)
{
grabNextAction = false;
grabbingWheel = false;
edited = false;
this->installEventFilter(this);
}
void SimpleKeyGrabberButton::keyPressEvent(QKeyEvent *event)
{
// Do not allow closing of dialog using Escape key
if (event->key() == Qt::Key_Escape)
{
return;
}
QPushButton::keyPressEvent(event);
}
bool SimpleKeyGrabberButton::eventFilter(QObject *obj, QEvent *event)
{
Q_UNUSED(obj);
int controlcode = 0;
if (grabNextAction && event->type() == QEvent::MouseButtonRelease)
{
QMouseEvent *mouseEve = static_cast<QMouseEvent*>(event);
if (mouseEve->button() == Qt::RightButton)
{
controlcode = 3;
}
else if (mouseEve->button() == Qt::MiddleButton)
{
controlcode = 2;
}
else {
controlcode = mouseEve->button();
}
//setText(QString(tr("Mouse")).append(" ").append(QString::number(controlcode)));
buttonslot.setSlotCode(controlcode);
buttonslot.setSlotMode(JoyButtonSlot::JoyMouseButton);
refreshButtonLabel();
edited = true;
releaseMouse();
releaseKeyboard();
grabNextAction = grabbingWheel = false;
emit buttonCodeChanged(controlcode);
}
else if (grabNextAction && event->type() == QEvent::KeyRelease)
{
QKeyEvent *keyEve = static_cast<QKeyEvent*>(event);
int tempcode = keyEve->nativeScanCode();
int virtualactual = keyEve->nativeVirtualKey();
BaseEventHandler *handler = EventHandlerFactory::getInstance()->handler();
#ifdef Q_OS_WIN
int finalvirtual = 0;
int checkalias = 0;
#ifdef WITH_VMULTI
if (handler->getIdentifier() == "vmulti")
{
finalvirtual = WinExtras::correctVirtualKey(tempcode, virtualactual);
checkalias = AntKeyMapper::getInstance()->returnQtKey(finalvirtual);
QtKeyMapperBase *nativeWinKeyMapper = AntKeyMapper::getInstance()->getNativeKeyMapper();
unsigned int tempQtKey = 0;
if (nativeWinKeyMapper)
{
tempQtKey = nativeWinKeyMapper->returnQtKey(finalvirtual);
}
//unsigned int tempQtKey = nativeWinKeyMapper.returnQtKey(finalvirtual);
if (tempQtKey > 0)
{
finalvirtual = AntKeyMapper::getInstance()->returnVirtualKey(tempQtKey);
checkalias = AntKeyMapper::getInstance()->returnQtKey(finalvirtual);
}
else
{
finalvirtual = AntKeyMapper::getInstance()->returnVirtualKey(keyEve->key());
}
}
#endif
BACKEND_ELSE_IF (handler->getIdentifier() == "sendinput")
{
// Find more specific virtual key (VK_SHIFT -> VK_LSHIFT)
// by checking for extended bit in scan code.
finalvirtual = WinExtras::correctVirtualKey(tempcode, virtualactual);
checkalias = AntKeyMapper::getInstance()->returnQtKey(finalvirtual, tempcode);
}
#else
#if defined(WITH_X11)
int finalvirtual = 0;
int checkalias = 0;
#if (QT_VERSION >= QT_VERSION_CHECK(5, 0, 0))
if (QApplication::platformName() == QStringLiteral("xcb"))
{
#endif
// Obtain group 1 X11 keysym. Removes effects from modifiers.
finalvirtual = X11KeyCodeToX11KeySym(tempcode);
#ifdef WITH_UINPUT
if (handler->getIdentifier() == "uinput")
{
// Find Qt Key corresponding to X11 KeySym.
//checkalias = x11KeyMapper.returnQtKey(finalvirtual);
QtKeyMapperBase *x11KeyMapper = AntKeyMapper::getInstance()->getNativeKeyMapper();
checkalias = x11KeyMapper->returnQtKey(finalvirtual);
// Find corresponding Linux input key for the Qt key.
finalvirtual = AntKeyMapper::getInstance()->returnVirtualKey(checkalias);
}
#endif
#ifdef WITH_XTEST
if (handler->getIdentifier() == "xtest")
{
// Check for alias against group 1 keysym.
checkalias = AntKeyMapper::getInstance()->returnQtKey(finalvirtual);
}
#endif
#if (QT_VERSION >= QT_VERSION_CHECK(5, 0, 0))
}
else
{
// Not running on xcb platform.
finalvirtual = tempcode;
checkalias = AntKeyMapper::getInstance()->returnQtKey(finalvirtual);
}
#endif
#else
int finalvirtual = 0;
int checkalias = 0;
#if (QT_VERSION >= QT_VERSION_CHECK(5, 0, 0))
if (QApplication::platformName() == QStringLiteral("xcb"))
{
#endif
finalvirtual = AntKeyMapper::getInstance()->returnVirtualKey(keyEve->key());
checkalias = AntKeyMapper::getInstance()->returnQtKey(finalvirtual);
#if (QT_VERSION >= QT_VERSION_CHECK(5, 0, 0))
}
else
{
// Not running on xcb platform.
finalvirtual = tempcode;
checkalias = AntKeyMapper::getInstance()->returnQtKey(finalvirtual);
}
#endif
#endif
#endif
controlcode = tempcode;
bool valueUpdated = false;
if ((keyEve->modifiers() & Qt::ControlModifier) && keyEve->key() == Qt::Key_X)
{
controlcode = 0;
refreshButtonLabel();
}
else if (controlcode <= 0)
{
controlcode = 0;
setText("");
valueUpdated = true;
edited = true;
}
else
{
if (checkalias > 0 && finalvirtual > 0)
{
buttonslot.setSlotCode(finalvirtual, checkalias);
buttonslot.setSlotMode(JoyButtonSlot::JoyKeyboard);
setText(keysymToKeyString(finalvirtual, checkalias).toUpper());
edited = true;
valueUpdated = true;
}
else if (virtualactual > 0)
{
buttonslot.setSlotCode(virtualactual);
buttonslot.setSlotMode(JoyButtonSlot::JoyKeyboard);
setText(keysymToKeyString(virtualactual).toUpper());
edited = true;
valueUpdated = true;
}
}
grabNextAction = false;
grabbingWheel = false;
releaseMouse();
releaseKeyboard();
if (valueUpdated)
{
emit buttonCodeChanged(controlcode);
}
}
else if (grabNextAction && event->type() == QEvent::Wheel && !grabbingWheel)
{
grabbingWheel = true;
}
else if (grabNextAction && event->type() == QEvent::Wheel)
{
QWheelEvent *wheelEve = static_cast<QWheelEvent*>(event);
QString text = QString(tr("Mouse")).append(" ");
if (wheelEve->orientation() == Qt::Vertical && wheelEve->delta() >= 120)
{
controlcode = 4;
}
else if (wheelEve->orientation() == Qt::Vertical && wheelEve->delta() <= -120)
{
controlcode = 5;
}
else if (wheelEve->orientation() == Qt::Horizontal && wheelEve->delta() >= 120)
{
controlcode = 6;
}
else if (wheelEve->orientation() == Qt::Horizontal && wheelEve->delta() <= -120)
{
controlcode = 7;
}
if (controlcode > 0)
{
text = text.append(QString::number(controlcode));
setText(text);
grabNextAction = false;
grabbingWheel = false;
edited = true;
releaseMouse();
releaseKeyboard();
buttonslot.setSlotCode(controlcode);
buttonslot.setSlotMode(JoyButtonSlot::JoyMouseButton);
emit buttonCodeChanged(controlcode);
}
}
else if (event->type() == QEvent::MouseButtonRelease)
{
QMouseEvent *mouseEve = static_cast<QMouseEvent*>(event);
if (mouseEve->button() == Qt::LeftButton)
{
grabNextAction = true;
setText("...");
setFocus();
grabKeyboard();
grabMouse();
}
}
return false;
}
void SimpleKeyGrabberButton::setValue(int value, unsigned int alias, JoyButtonSlot::JoySlotInputAction mode)
{
buttonslot.setSlotCode(value, alias);
buttonslot.setSlotMode(mode);
edited = true;
setText(buttonslot.getSlotString());
}
void SimpleKeyGrabberButton::setValue(int value, JoyButtonSlot::JoySlotInputAction mode)
{
buttonslot.setSlotCode(value);
buttonslot.setSlotMode(mode);
edited = true;
setText(buttonslot.getSlotString());
}
void SimpleKeyGrabberButton::setValue(QString value, JoyButtonSlot::JoySlotInputAction mode)
{
switch (mode)
{
case JoyButtonSlot::JoyLoadProfile:
case JoyButtonSlot::JoyTextEntry:
case JoyButtonSlot::JoyExecute:
{
buttonslot.setTextData(value);
buttonslot.setSlotMode(mode);
edited = true;
break;
}
}
setText(buttonslot.getSlotString());
}
JoyButtonSlot* SimpleKeyGrabberButton::getValue()
{
return &buttonslot;
}
void SimpleKeyGrabberButton::refreshButtonLabel()
{
setText(buttonslot.getSlotString());
}
bool SimpleKeyGrabberButton::isEdited()
{
return edited;
}
bool SimpleKeyGrabberButton::isGrabbing()
{
return grabNextAction;
}
``` | /content/code_sandbox/src/simplekeygrabberbutton.cpp | c++ | 2016-05-24T23:59:31 | 2024-08-11T02:46:48 | antimicro | AntiMicro/antimicro | 1,788 | 2,339 |
```c++
/* antimicro Gamepad to KB+M event mapper
*
* This program is free software: you can redistribute it and/or modify
* (at your option) any later version.
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* along with this program. If not, see <path_to_url
*/
//#include <QDebug>
#include <QProgressBar>
#include <QVBoxLayout>
#include <QHBoxLayout>
#include <QGridLayout>
#include <QLabel>
#include <QSpacerItem>
#include "joystickstatuswindow.h"
#include "ui_joystickstatuswindow.h"
#include "joybuttonstatusbox.h"
JoystickStatusWindow::JoystickStatusWindow(InputDevice *joystick, QWidget *parent) :
QDialog(parent),
ui(new Ui::JoystickStatusWindow)
{
ui->setupUi(this);
setAttribute(Qt::WA_DeleteOnClose);
this->joystick = joystick;
PadderCommon::inputDaemonMutex.lock();
setWindowTitle(tr("%1 (#%2) Properties").arg(joystick->getSDLName())
.arg(joystick->getRealJoyNumber()));
ui->joystickNameLabel->setText(joystick->getSDLName());
ui->joystickNumberLabel->setText(QString::number(joystick->getRealJoyNumber()));
ui->joystickAxesLabel->setText(QString::number(joystick->getNumberRawAxes()));
ui->joystickButtonsLabel->setText(QString::number(joystick->getNumberRawButtons()));
ui->joystickHatsLabel->setText(QString::number(joystick->getNumberRawHats()));
joystick->getActiveSetJoystick()->setIgnoreEventState(true);
joystick->getActiveSetJoystick()->release();
joystick->resetButtonDownCount();
QVBoxLayout *axesBox = new QVBoxLayout();
axesBox->setSpacing(4);
for (int i=0; i < joystick->getNumberAxes(); i++)
{
JoyAxis *axis = joystick->getActiveSetJoystick()->getJoyAxis(i);
if (axis)
{
QHBoxLayout *hbox = new QHBoxLayout();
QLabel *axisLabel = new QLabel();
axisLabel->setText(tr("Axis %1").arg(axis->getRealJoyIndex()));
QProgressBar *axisBar = new QProgressBar();
axisBar->setMinimum(JoyAxis::AXISMIN);
axisBar->setMaximum(JoyAxis::AXISMAX);
axisBar->setFormat("%v");
axisBar->setValue(axis->getCurrentRawValue());
hbox->addWidget(axisLabel);
hbox->addWidget(axisBar);
hbox->addSpacing(10);
axesBox->addLayout(hbox);
connect(axis, SIGNAL(moved(int)), axisBar, SLOT(setValue(int)));
}
}
ui->axesScrollArea->setLayout(axesBox);
QGridLayout *buttonsGrid = new QGridLayout();
buttonsGrid->setHorizontalSpacing(10);
buttonsGrid->setVerticalSpacing(10);
int currentRow = 0;
int currentColumn = 0;
for (int i=0; i < joystick->getNumberButtons(); i++)
{
JoyButton *button = joystick->getActiveSetJoystick()->getJoyButton(i);
if (button)
{
JoyButtonStatusBox *statusbox = new JoyButtonStatusBox(button);
statusbox->setSizePolicy(QSizePolicy::Expanding,
QSizePolicy::Expanding);
buttonsGrid->addWidget(statusbox, currentRow, currentColumn);
currentColumn++;
if (currentColumn >= 6)
{
currentRow++;
currentColumn = 0;
}
}
}
ui->buttonsScrollArea->setLayout(buttonsGrid);
QVBoxLayout *hatsBox = new QVBoxLayout();
hatsBox->setSpacing(4);
for (int i=0; i < joystick->getNumberHats(); i++)
{
JoyDPad *dpad = joystick->getActiveSetJoystick()->getJoyDPad(i);
if (dpad)
{
QHBoxLayout *hbox = new QHBoxLayout();
QLabel *dpadLabel = new QLabel();
dpadLabel->setText(tr("Hat %1").arg(dpad->getRealJoyNumber()));
QProgressBar *dpadBar = new QProgressBar();
dpadBar->setMinimum(JoyDPadButton::DpadCentered);
dpadBar->setMaximum(JoyDPadButton::DpadLeftDown);
dpadBar->setFormat("%v");
dpadBar->setValue(dpad->getCurrentDirection());
hbox->addWidget(dpadLabel);
hbox->addWidget(dpadBar);
hbox->addSpacing(10);
hatsBox->addLayout(hbox);
connect(dpad, SIGNAL(active(int)), dpadBar, SLOT(setValue(int)));
connect(dpad, SIGNAL(released(int)), dpadBar, SLOT(setValue(int)));
}
}
hatsBox->addSpacerItem(new QSpacerItem(20, 20, QSizePolicy::Preferred, QSizePolicy::Fixed));
if (ui->hatsGroupBox->layout())
{
delete ui->hatsGroupBox->layout();
}
ui->hatsGroupBox->setLayout(hatsBox);
QString guidString = joystick->getGUIDString();
if (!guidString.isEmpty())
{
ui->guidHeaderLabel->show();
ui->guidLabel->setText(guidString);
ui->guidLabel->show();
}
else
{
ui->guidHeaderLabel->hide();
ui->guidLabel->hide();
}
#ifdef USE_SDL_2
QString usingGameController = tr("No");
if (joystick->isGameController())
{
usingGameController = tr("Yes");
}
ui->sdlGameControllerLabel->setText(usingGameController);
#else
ui->sdlcontrollerHeaderLabel->setVisible(false);
ui->sdlGameControllerLabel->setVisible(false);
#endif
PadderCommon::inputDaemonMutex.unlock();
connect(joystick, SIGNAL(destroyed()), this, SLOT(obliterate()));
connect(this, SIGNAL(finished(int)), this, SLOT(restoreButtonStates(int)));
}
JoystickStatusWindow::~JoystickStatusWindow()
{
delete ui;
}
void JoystickStatusWindow::restoreButtonStates(int code)
{
if (code == QDialogButtonBox::AcceptRole)
{
PadderCommon::inputDaemonMutex.lock();
joystick->getActiveSetJoystick()->setIgnoreEventState(false);
joystick->getActiveSetJoystick()->release();
PadderCommon::inputDaemonMutex.unlock();
}
}
void JoystickStatusWindow::obliterate()
{
this->done(QDialogButtonBox::DestructiveRole);
}
``` | /content/code_sandbox/src/joystickstatuswindow.cpp | c++ | 2016-05-24T23:59:31 | 2024-08-11T02:46:48 | antimicro | AntiMicro/antimicro | 1,788 | 1,435 |
```objective-c
/* antimicro Gamepad to KB+M event mapper
*
* This program is free software: you can redistribute it and/or modify
* (at your option) any later version.
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* along with this program. If not, see <path_to_url
*/
#ifndef JOYCONTROLSTICKCONTEXTMENU_H
#define JOYCONTROLSTICKCONTEXTMENU_H
#include <QMenu>
#include "joycontrolstick.h"
#include "uihelpers/joycontrolstickcontextmenuhelper.h"
class JoyControlStickContextMenu : public QMenu
{
Q_OBJECT
public:
explicit JoyControlStickContextMenu(JoyControlStick *stick, QWidget *parent = 0);
void buildMenu();
protected:
int getPresetIndex();
JoyControlStick *stick;
JoyControlStickContextMenuHelper helper;
signals:
public slots:
private slots:
void setStickPreset();
void setStickMode();
void openMouseSettingsDialog();
};
#endif // JOYCONTROLSTICKCONTEXTMENU_H
``` | /content/code_sandbox/src/joycontrolstickcontextmenu.h | objective-c | 2016-05-24T23:59:31 | 2024-08-11T02:46:48 | antimicro | AntiMicro/antimicro | 1,788 | 246 |
```c++
/* antimicro Gamepad to KB+M event mapper
*
* This program is free software: you can redistribute it and/or modify
* (at your option) any later version.
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* along with this program. If not, see <path_to_url
*/
#define XK_MISCELLANY
#define XK_LATIN1
#define XK_KOREAN
#define XK_XKB_KEYS
//#include <QDebug>
#include <QApplication>
#include <QHashIterator>
#include <X11/keysymdef.h>
#include <X11/XF86keysym.h>
#include <X11/XKBlib.h>
#include <X11/Xutil.h>
#include "qtx11keymapper.h"
#include "x11extras.h"
QtX11KeyMapper::QtX11KeyMapper(QObject *parent) :
QtKeyMapperBase(parent)
{
identifier = "xtest";
populateMappingHashes();
populateCharKeyInformation();
}
/*
* The following mappings are mainly taken from qkeymapper_x11.cpp.
* There are portions of the mapping that are customized to work around
* some of the ambiguity introduced with some Qt keys
* (XK_Alt_L and XK_Alt_R become Qt::Key_Alt in Qt).
*/
void QtX11KeyMapper::populateMappingHashes()
{
if (qtKeyToVirtualKey.isEmpty())
{
// misc keys
qtKeyToVirtualKey[Qt::Key_Escape] = XK_Escape;
qtKeyToVirtualKey[Qt::Key_Tab] = XK_Tab;
qtKeyToVirtualKey[Qt::Key_Backtab] = XK_ISO_Left_Tab;
qtKeyToVirtualKey[Qt::Key_Backspace] = XK_BackSpace;
qtKeyToVirtualKey[Qt::Key_Return] = XK_Return;
qtKeyToVirtualKey[Qt::Key_Insert] = XK_Insert;
qtKeyToVirtualKey[Qt::Key_Delete] = XK_Delete;
qtKeyToVirtualKey[Qt::Key_Delete] = XK_Delete;
//qtKeyToX11KeySym[Qt::Key_Delete] = XK_Clear;
qtKeyToVirtualKey[Qt::Key_Pause] = XK_Pause;
qtKeyToVirtualKey[Qt::Key_Print] = XK_Print;
// cursor movement
qtKeyToVirtualKey[Qt::Key_Home] = XK_Home;
qtKeyToVirtualKey[Qt::Key_End] = XK_End;
qtKeyToVirtualKey[Qt::Key_Left] = XK_Left;
qtKeyToVirtualKey[Qt::Key_Up] = XK_Up;
qtKeyToVirtualKey[Qt::Key_Right] = XK_Right;
qtKeyToVirtualKey[Qt::Key_Down] = XK_Down;
qtKeyToVirtualKey[Qt::Key_PageUp] = XK_Prior;
qtKeyToVirtualKey[Qt::Key_PageDown] = XK_Next;
// modifiers
qtKeyToVirtualKey[Qt::Key_Shift] = XK_Shift_L;
//qtKeyToX11KeySym[Qt::Key_Shift] = XK_Shift_R;
//qtKeyToX11KeySym[Qt::Key_Shift] = XK_Shift_Lock;
qtKeyToVirtualKey[Qt::Key_Control] = XK_Control_L;
//qtKeyToX11KeySym[Qt::Key_Control] = XK_Control_R;
//qtKeyToVirtualKey[Qt::Key_Meta] = XK_Meta_L;
//qtKeyToX11KeySym[Qt::Key_Meta] = XK_Meta_R;
qtKeyToVirtualKey[Qt::Key_Alt] = XK_Alt_L;
//qtKeyToX11KeySym[Qt::Key_Alt] = XK_Alt_R;
qtKeyToVirtualKey[Qt::Key_CapsLock] = XK_Caps_Lock;
qtKeyToVirtualKey[Qt::Key_NumLock] = XK_Num_Lock;
qtKeyToVirtualKey[Qt::Key_ScrollLock] = XK_Scroll_Lock;
qtKeyToVirtualKey[Qt::Key_Meta] = XK_Super_L;
qtKeyToVirtualKey[AntKey_Meta_R] = XK_Super_R;
//qtKeyToVirtualKey[Qt::Key_Super_L] = XK_Super_L;
//qtKeyToVirtualKey[Qt::Key_Super_R] = XK_Super_R;
qtKeyToVirtualKey[Qt::Key_Menu] = XK_Menu;
qtKeyToVirtualKey[Qt::Key_Hyper_L] = XK_Hyper_L;
qtKeyToVirtualKey[Qt::Key_Hyper_R] = XK_Hyper_R;
qtKeyToVirtualKey[Qt::Key_Help] = XK_Help;
// numeric and function keypad keys
//qtKeyToVirtualKey[Qt::Key_Space] = XK_KP_Space;
//qtKeyToX11KeySym[Qt::Key_Tab] = XK_KP_Tab;
qtKeyToVirtualKey[Qt::Key_Enter] = XK_KP_Enter;
qtKeyToVirtualKey[AntKey_KP_Home] = XK_KP_Home;
//qtKeyToX11KeySym[Qt::Key_Home] = XK_KP_Home;
qtKeyToVirtualKey[AntKey_KP_Left] = XK_KP_Left;
qtKeyToVirtualKey[AntKey_KP_Up] = XK_KP_Up;
qtKeyToVirtualKey[AntKey_KP_Right] = XK_KP_Right;
qtKeyToVirtualKey[AntKey_KP_Down] = XK_KP_Down;
qtKeyToVirtualKey[AntKey_KP_Prior] = XK_KP_Prior;
qtKeyToVirtualKey[AntKey_KP_Next] = XK_KP_Next;
qtKeyToVirtualKey[AntKey_KP_End] = XK_KP_End;
qtKeyToVirtualKey[AntKey_KP_Begin] = XK_KP_Begin;
qtKeyToVirtualKey[AntKey_KP_Insert] = XK_KP_Insert;
qtKeyToVirtualKey[AntKey_KP_Delete] = XK_KP_Delete;
//qtKeyToX11KeySym[AntKey_KP_Equal] = XK_KP_Equal;
qtKeyToVirtualKey[AntKey_KP_Add] = XK_KP_Add;
//qtKeyToX11KeySym[AntKey_KP_Separator] = XK_KP_Separator;
qtKeyToVirtualKey[AntKey_KP_Subtract] = XK_KP_Subtract;
qtKeyToVirtualKey[AntKey_KP_Decimal] = XK_KP_Decimal;
qtKeyToVirtualKey[AntKey_KP_Divide] = XK_KP_Divide;
// International input method support keys
// International & multi-key character composition
qtKeyToVirtualKey[Qt::Key_AltGr] = XK_ISO_Level3_Shift;
qtKeyToVirtualKey[Qt::Key_Multi_key] = XK_Multi_key;
qtKeyToVirtualKey[Qt::Key_Codeinput] = XK_Codeinput;
qtKeyToVirtualKey[Qt::Key_SingleCandidate] = XK_SingleCandidate;
qtKeyToVirtualKey[Qt::Key_MultipleCandidate] = XK_MultipleCandidate;
qtKeyToVirtualKey[Qt::Key_PreviousCandidate] = XK_PreviousCandidate;
// Misc Functions
qtKeyToVirtualKey[Qt::Key_Mode_switch] = XK_Mode_switch;
//qtKeyToX11KeySym[Qt::Key_Mode_switch] = XK_script_switch;
// Japanese keyboard support
qtKeyToVirtualKey[Qt::Key_Kanji] = XK_Kanji;
qtKeyToVirtualKey[Qt::Key_Muhenkan] = XK_Muhenkan;
qtKeyToVirtualKey[Qt::Key_Henkan] = XK_Henkan_Mode;
//qtKeyToX11KeySym[Qt::Key_Henkan] = XK_Henkan;
qtKeyToVirtualKey[Qt::Key_Romaji] = XK_Romaji;
qtKeyToVirtualKey[Qt::Key_Hiragana] = XK_Hiragana;
qtKeyToVirtualKey[Qt::Key_Katakana] = XK_Katakana;
qtKeyToVirtualKey[Qt::Key_Hiragana_Katakana] = XK_Hiragana_Katakana;
qtKeyToVirtualKey[Qt::Key_Zenkaku] = XK_Zenkaku;
qtKeyToVirtualKey[Qt::Key_Hankaku] = XK_Hankaku;
qtKeyToVirtualKey[Qt::Key_Zenkaku_Hankaku] = XK_Zenkaku_Hankaku;
qtKeyToVirtualKey[Qt::Key_Touroku] = XK_Touroku;
qtKeyToVirtualKey[Qt::Key_Massyo] = XK_Massyo;
qtKeyToVirtualKey[Qt::Key_Kana_Lock] = XK_Kana_Lock;
qtKeyToVirtualKey[Qt::Key_Kana_Shift] = XK_Kana_Shift;
qtKeyToVirtualKey[Qt::Key_Eisu_Shift] = XK_Eisu_Shift;
qtKeyToVirtualKey[Qt::Key_Eisu_toggle] = XK_Eisu_toggle;
qtKeyToVirtualKey[Qt::Key_Codeinput] = XK_Kanji_Bangou;
//qtKeyToX11KeySym[Qt::Key_MultipleCandidate] = XK_Zen_Koho;
//qtKeyToX11KeySym[Qt::Key_PreviousCandidate] = XK_Mae_Koho;
#ifdef XK_KOREAN
qtKeyToVirtualKey[Qt::Key_Hangul] = XK_Hangul;
qtKeyToVirtualKey[Qt::Key_Hangul_Start] = XK_Hangul_Start;
qtKeyToVirtualKey[Qt::Key_Hangul_End] = XK_Hangul_End;
qtKeyToVirtualKey[Qt::Key_Hangul_Hanja] = XK_Hangul_Hanja;
qtKeyToVirtualKey[Qt::Key_Hangul_Jamo] = XK_Hangul_Jamo;
qtKeyToVirtualKey[Qt::Key_Hangul_Romaja] = XK_Hangul_Romaja;
//qtKeyToX11KeySym[Qt::Key_Codeinput] = XK_Hangul_Codeinput;
qtKeyToVirtualKey[Qt::Key_Hangul_Jeonja] = XK_Hangul_Jeonja;
qtKeyToVirtualKey[Qt::Key_Hangul_Banja] = XK_Hangul_Banja;
qtKeyToVirtualKey[Qt::Key_Hangul_PreHanja] = XK_Hangul_PreHanja;
qtKeyToVirtualKey[Qt::Key_Hangul_PostHanja] = XK_Hangul_PostHanja;
//qtKeyToX11KeySym[Qt::Key_SingleCandidate] = XK_Hangul_SingleCandidate;
//qtKeyToX11KeySym[Qt::Key_MultipleCandidate] = XK_Hangul_MultipleCandidate;
//qtKeyToX11KeySym[Qt::Key_PreviousCandidate] = XK_Hangul_PreviousCandidate;
qtKeyToVirtualKey[Qt::Key_Hangul_Special] = XK_Hangul_Special;
//qtKeyToX11KeySym[Qt::Key_Mode_switch] = XK_Hangul_switch;
#endif // XK_KOREAN
// dead keys
qtKeyToVirtualKey[Qt::Key_Dead_Grave] = XK_dead_grave;
qtKeyToVirtualKey[Qt::Key_Dead_Acute] = XK_dead_acute;
qtKeyToVirtualKey[Qt::Key_Dead_Circumflex] = XK_dead_circumflex;
qtKeyToVirtualKey[Qt::Key_Dead_Tilde] = XK_dead_tilde;
qtKeyToVirtualKey[Qt::Key_Dead_Macron] = XK_dead_macron;
qtKeyToVirtualKey[Qt::Key_Dead_Breve] = XK_dead_breve;
qtKeyToVirtualKey[Qt::Key_Dead_Abovedot] = XK_dead_abovedot;
qtKeyToVirtualKey[Qt::Key_Dead_Diaeresis] = XK_dead_diaeresis;
qtKeyToVirtualKey[Qt::Key_Dead_Abovering] = XK_dead_abovering;
qtKeyToVirtualKey[Qt::Key_Dead_Doubleacute] = XK_dead_doubleacute;
qtKeyToVirtualKey[Qt::Key_Dead_Caron] = XK_dead_caron;
qtKeyToVirtualKey[Qt::Key_Dead_Cedilla] = XK_dead_cedilla;
qtKeyToVirtualKey[Qt::Key_Dead_Ogonek] = XK_dead_ogonek;
qtKeyToVirtualKey[Qt::Key_Dead_Iota] = XK_dead_iota;
qtKeyToVirtualKey[Qt::Key_Dead_Voiced_Sound] = XK_dead_voiced_sound;
qtKeyToVirtualKey[Qt::Key_Dead_Semivoiced_Sound] = XK_dead_semivoiced_sound;
qtKeyToVirtualKey[Qt::Key_Dead_Belowdot] = XK_dead_belowdot;
qtKeyToVirtualKey[Qt::Key_Dead_Hook] = XK_dead_hook;
qtKeyToVirtualKey[Qt::Key_Dead_Horn] = XK_dead_horn;
// Special multimedia keys
// currently only tested with MS internet keyboard
// browsing keys
qtKeyToVirtualKey[Qt::Key_Back] = XF86XK_Back;
qtKeyToVirtualKey[Qt::Key_Forward] = XF86XK_Forward;
qtKeyToVirtualKey[Qt::Key_Stop] = XF86XK_Stop;
qtKeyToVirtualKey[Qt::Key_Refresh] = XF86XK_Refresh;
qtKeyToVirtualKey[Qt::Key_Favorites] = XF86XK_Favorites;
qtKeyToVirtualKey[Qt::Key_LaunchMedia] = XF86XK_AudioMedia;
qtKeyToVirtualKey[Qt::Key_OpenUrl] = XF86XK_OpenURL;
qtKeyToVirtualKey[Qt::Key_HomePage] = XF86XK_HomePage;
qtKeyToVirtualKey[Qt::Key_Search] = XF86XK_Search;
// media keys
qtKeyToVirtualKey[Qt::Key_VolumeDown] = XF86XK_AudioLowerVolume;
qtKeyToVirtualKey[Qt::Key_VolumeMute] = XF86XK_AudioMute;
qtKeyToVirtualKey[Qt::Key_VolumeUp] = XF86XK_AudioRaiseVolume;
qtKeyToVirtualKey[Qt::Key_MediaPlay] = XF86XK_AudioPlay;
qtKeyToVirtualKey[Qt::Key_MediaStop] = XF86XK_AudioStop;
qtKeyToVirtualKey[Qt::Key_MediaPrevious] = XF86XK_AudioPrev;
qtKeyToVirtualKey[Qt::Key_MediaNext] = XF86XK_AudioNext;
qtKeyToVirtualKey[Qt::Key_MediaRecord] = XF86XK_AudioRecord;
// launch keys
qtKeyToVirtualKey[Qt::Key_LaunchMail] = XF86XK_Mail;
qtKeyToVirtualKey[Qt::Key_Launch0] = XF86XK_MyComputer;
qtKeyToVirtualKey[Qt::Key_Launch1] = XF86XK_Calculator;
qtKeyToVirtualKey[Qt::Key_Standby] = XF86XK_Standby;
qtKeyToVirtualKey[Qt::Key_Launch2] = XF86XK_Launch0;
qtKeyToVirtualKey[Qt::Key_Launch3] = XF86XK_Launch1;
qtKeyToVirtualKey[Qt::Key_Launch4] = XF86XK_Launch2;
qtKeyToVirtualKey[Qt::Key_Launch5] = XF86XK_Launch3;
qtKeyToVirtualKey[Qt::Key_Launch6] = XF86XK_Launch4;
qtKeyToVirtualKey[Qt::Key_Launch7] = XF86XK_Launch5;
qtKeyToVirtualKey[Qt::Key_Launch8] = XF86XK_Launch6;
qtKeyToVirtualKey[Qt::Key_Launch9] = XF86XK_Launch7;
qtKeyToVirtualKey[Qt::Key_LaunchA] = XF86XK_Launch8;
qtKeyToVirtualKey[Qt::Key_LaunchB] = XF86XK_Launch9;
qtKeyToVirtualKey[Qt::Key_LaunchC] = XF86XK_LaunchA;
qtKeyToVirtualKey[Qt::Key_LaunchD] = XF86XK_LaunchB;
qtKeyToVirtualKey[Qt::Key_LaunchE] = XF86XK_LaunchC;
qtKeyToVirtualKey[Qt::Key_LaunchF] = XF86XK_LaunchD;
// Map initial ASCII keys
for (int i=0; i <= (XK_at - XK_space); i++)
{
qtKeyToVirtualKey[Qt::Key_Space + i] = XK_space + i;
}
// Map lowercase alpha keys
for (int i=0; i <= (XK_z - XK_a); i++)
{
qtKeyToVirtualKey[Qt::Key_A + i] = XK_a + i;
}
// Map [ to ` ASCII keys
for (int i=0; i <= (XK_grave - XK_bracketleft); i++)
{
qtKeyToVirtualKey[Qt::Key_BracketLeft + i] = XK_bracketleft + i;
}
// Map { to ~ ASCII keys
for (int i=0; i <= (XK_asciitilde - XK_braceleft); i++)
{
qtKeyToVirtualKey[Qt::Key_BraceLeft + i] = XK_braceleft + i;
}
// Map function keys
for (int i=0; i <= (XK_F35 - XK_F1); i++)
{
qtKeyToVirtualKey[Qt::Key_F1 + i] = XK_F1 + i;
}
// Misc
//qtKeyToVirtualKey[Qt::KeyBri]
// Map custom defined keys
qtKeyToVirtualKey[AntKey_Shift_R] = XK_Shift_R;
qtKeyToVirtualKey[AntKey_Control_R] = XK_Control_R;
//qtKeyToX11KeySym[AntKey_Shift_Lock] = XK_Shift_Lock;
//qtKeyToVirtualKey[AntKey_Meta_R] = XK_Meta_R;
qtKeyToVirtualKey[AntKey_Alt_R] = XK_Alt_R;
qtKeyToVirtualKey[AntKey_KP_Multiply] = XK_KP_Multiply;
// Map 0 to 9
for (int i=0; i <= (XK_KP_9 - XK_KP_0); i++)
{
qtKeyToVirtualKey[AntKey_KP_0 + i] = XK_KP_0 + i;
}
// Map lower-case latin characters to their capital equivalents
for( int i=0; i <= (XK_odiaeresis - XK_agrave); i++) {
qtKeyToVirtualKey[ Qt::Key_Agrave + i ] = XK_agrave + i;
}
for( int i=0; i <= (XK_thorn - XK_oslash); i++) {
qtKeyToVirtualKey[ Qt::Key_Ooblique + i ] = XK_oslash + i;
}
QHashIterator<unsigned int, unsigned int> iter(qtKeyToVirtualKey);
while (iter.hasNext())
{
iter.next();
virtualKeyToQtKey[iter.value()] = iter.key();
}
}
}
void QtX11KeyMapper::populateCharKeyInformation()
{
virtualkeyToCharKeyInformation.clear();
Display* display = X11Extras::getInstance()->display();
unsigned int total = 0;
for (int i=8; i <= 255; i++)
{
for (int j=0; j <= 3; j++)
{
Qt::KeyboardModifiers dicis;
if (j >= 2)
{
dicis |= Qt::MetaModifier;
}
if (j == 1 || j == 3)
{
dicis |= Qt::ShiftModifier;
}
unsigned int testsym = XkbKeycodeToKeysym(display, i,
dicis & Qt::MetaModifier ? 1 : 0,
dicis & Qt::ShiftModifier ? 1 : 0);
if (testsym != NoSymbol)
{
XKeyPressedEvent tempevent;
tempevent.keycode = i;
tempevent.type = KeyPress;
tempevent.display = display;
tempevent.state = 0;
if (dicis & Qt::ShiftModifier)
{
tempevent.state |= ShiftMask;
}
if (dicis & Qt::MetaModifier)
{
tempevent.state |= Mod1Mask;
}
char returnstring[256];
memset(returnstring, 0, sizeof(returnstring));
int bitestoreturn = sizeof(returnstring) - 1;
int numchars = XLookupString(&tempevent, returnstring, bitestoreturn, NULL, NULL);
if (numchars > 0)
{
returnstring[numchars] = '\0';
QString tempstring = QString::fromUtf8(returnstring);
if (tempstring.length() == 1)
{
QChar tempchar(tempstring.at(0));
charKeyInformation testKeyInformation;
testKeyInformation.modifiers = dicis;
testKeyInformation.virtualkey = testsym;
if (!virtualkeyToCharKeyInformation.contains(tempchar.unicode()))
{
virtualkeyToCharKeyInformation.insert(tempchar.unicode(), testKeyInformation);
//qDebug() << "I FOUND SOMETHING: " << tempchar;
total++;
}
}
else
{
//qDebug() << "YOU FAIL: " << tempchar;
}
}
}
}
}
//qDebug() << "TOTAL: " << total;
//qDebug() << "";
QChar tempa('*');
if (virtualkeyToCharKeyInformation.contains(tempa.unicode()))
{
charKeyInformation projects = virtualkeyToCharKeyInformation.value(tempa.unicode());
}
}
``` | /content/code_sandbox/src/qtx11keymapper.cpp | c++ | 2016-05-24T23:59:31 | 2024-08-11T02:46:48 | antimicro | AntiMicro/antimicro | 1,788 | 4,957 |
```c++
/* antimicro Gamepad to KB+M event mapper
*
* This program is free software: you can redistribute it and/or modify
* (at your option) any later version.
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* along with this program. If not, see <path_to_url
*/
#include <unistd.h>
//#include <QDebug>
#include <QFileInfo>
#include <QThreadStorage>
#include "common.h"
#include <X11/Xatom.h>
#include <X11/XKBlib.h>
#include <X11/extensions/XInput.h>
#include <X11/extensions/XInput2.h>
#include "x11extras.h"
const QString X11Extras::mouseDeviceName = PadderCommon::mouseDeviceName;
const QString X11Extras::keyboardDeviceName = PadderCommon::keyboardDeviceName;
const QString X11Extras::xtestMouseDeviceName = QString("Virtual core XTEST pointer");
QString X11Extras::_customDisplayString = QString("");
static QThreadStorage<X11Extras*> displays;
X11Extras* X11Extras::_instance = 0;
X11Extras::X11Extras(QObject *parent) :
QObject(parent),
knownAliases()
{
//knownAliases = QHash<QString, QString> ();
_display = XOpenDisplay(NULL);
populateKnownAliases();
}
/**
* @brief Close display connection if one exists
*/
X11Extras::~X11Extras()
{
if (_display)
{
XCloseDisplay(display());
_display = 0;
//_customDisplayString = "";
}
}
X11Extras *X11Extras::getInstance()
{
/*if (!_instance)
{
_instance = new X11Extras();
}
return _instance;
*/
X11Extras *temp = 0;
if (!displays.hasLocalData())
{
temp = new X11Extras();
displays.setLocalData(temp);
}
else
{
temp = displays.localData();
}
return temp;
}
void X11Extras::deleteInstance()
{
/*if (_instance)
{
delete _instance;
_instance = 0;
}
*/
if (displays.hasLocalData())
{
X11Extras *temp = displays.localData();
delete temp;
displays.setLocalData(0);
}
}
/**
* @brief Get display instance
* @return Display struct
*/
Display* X11Extras::display()
{
return _display;
}
bool X11Extras::hasValidDisplay()
{
bool result = _display != NULL;
return result;
}
/**
* @brief CURRENTLY NOT USED
*/
void X11Extras::closeDisplay()
{
if (_display)
{
XCloseDisplay(display());
_display = 0;
//_customDisplayString = "";
}
}
/**
* @brief Grab instance of active display.
*/
void X11Extras::syncDisplay()
{
_display = XOpenDisplay(NULL);
//_customDisplayString = "";
}
/**
* @brief Grab instance of specified display. Useful for having the GUI
* on one display while generating events on another during ssh tunneling.
* @param Valid display string that X can use
*/
void X11Extras::syncDisplay(QString displayString)
{
QByteArray tempByteArray = displayString.toLocal8Bit();
_display = XOpenDisplay(tempByteArray.constData());
/*if (_display)
{
_customDisplayString = displayString;
}
else
{
_customDisplayString = "";
}
*/
}
void X11Extras::setCustomDisplay(QString displayString)
{
_customDisplayString = displayString;
}
/**
* @brief Return root window for a given X display
* @param Screen number. If no value is passed, uses screen 1.
* @return XID of the window
*/
unsigned long X11Extras::appRootWindow(int screen)
{
return screen == -1 ? XDefaultRootWindow(display()) : XRootWindowOfScreen(XScreenOfDisplay(display(), screen));
}
/**
* @brief Get appropriate alias for a known KeySym string that might be blank
* or contain invalid characters when returned from X.
* @param QString representation of a KeySym string
* @return Alias string or a blank QString if no alias was found
*/
QString X11Extras::getDisplayString(QString xcodestring)
{
QString temp;
if (knownAliases.contains(xcodestring))
{
temp = knownAliases.value(xcodestring);
}
return temp;
}
void X11Extras::populateKnownAliases()
{
// These aliases are needed for xstrings that would
// return empty space characters from XLookupString
if (knownAliases.isEmpty())
{
knownAliases.insert("Escape", tr("ESC"));
knownAliases.insert("Tab", tr("Tab"));
knownAliases.insert("space", tr("Space"));
knownAliases.insert("Delete", tr("DEL"));
knownAliases.insert("Return", tr("Return"));
knownAliases.insert("KP_Enter", tr("KP_Enter"));
knownAliases.insert("BackSpace", tr("Backspace"));
}
}
Window X11Extras::findParentClient(Window window)
{
Window parent = 0;
Window root = 0;
Window *children = 0;
unsigned int num_children = 0;
Window finalwindow = 0;
Display *display = this->display();
if (windowIsViewable(display, window) &&
isWindowRelevant(display, window))
{
finalwindow = window;
}
else
{
bool quitTraversal = false;
while (!quitTraversal)
{
children = 0;
if (XQueryTree(display, window, &root, &parent, &children, &num_children))
{
if (children)
{
// must test for NULL
XFree(children);
}
if (parent)
{
if (windowIsViewable(display, parent) &&
isWindowRelevant(display, parent))
{
quitTraversal = true;
finalwindow = parent;
}
else if (parent == 0)
{
quitTraversal = true;
}
else if (parent == root)
{
quitTraversal = true;
}
else
{
window = parent;
}
}
else
{
quitTraversal = true;
}
}
else
{
quitTraversal = true;
}
}
}
return finalwindow;
}
/**
* @brief Check window and any parents for the window property "_NET_WM_PID"
* @param Window XID for window of interest
* @return PID of the application instance corresponding to the window
*/
int X11Extras::getApplicationPid(Window window)
{
Atom atom, actual_type;
int actual_format = 0;
unsigned long nitems = 0;
unsigned long bytes_after = 0;
unsigned char *prop = 0;
int status = 0;
int pid = 0;
Window finalwindow = 0;
Display *display = this->display();
atom = XInternAtom(display, "_NET_WM_PID", True);
if (windowHasProperty(display, window, atom))
{
finalwindow = window;
}
else
{
Window parent = 0;
Window root = 0;
Window *children;
unsigned int num_children;
bool quitTraversal = false;
while (!quitTraversal)
{
children = 0;
if (XQueryTree(display, window, &root, &parent, &children, &num_children))
{
if (children)
{
// must test for NULL
XFree(children);
}
if (parent)
{
if (windowHasProperty(display, parent, atom))
{
quitTraversal = true;
finalwindow = parent;
}
else if (parent == 0)
{
quitTraversal = true;
}
else if (parent == root)
{
quitTraversal = true;
}
else
{
window = parent;
}
}
else
{
quitTraversal = true;
}
}
else
{
quitTraversal = true;
}
}
}
if (finalwindow)
{
status = XGetWindowProperty(display, finalwindow, atom, 0, 1024, false, AnyPropertyType, &actual_type, &actual_format, &nitems, &bytes_after, &prop);
if (status == 0 && prop)
{
pid = prop[1] << 8;
pid += prop[0];
XFree(prop);
}
}
return pid;
}
/**
* @brief Find the application file location for a given PID
* @param PID of window
* @return File location of application
*/
QString X11Extras::getApplicationLocation(int pid)
{
QString exepath;
if (pid > 0)
{
QString procString = QString("/proc/%1/exe").arg(pid);
QFileInfo procFileInfo(procString);
if (procFileInfo.exists())
{
char buf[1024];
QByteArray tempByteArray = procString.toLocal8Bit();
ssize_t len = readlink(tempByteArray.constData(), buf, sizeof(buf)-1);
if (len != -1)
{
buf[len] = '\0';
}
if (len > 0)
{
QString temp = QString::fromUtf8(buf);
if (!temp.isEmpty())
{
exepath = temp;
}
}
}
}
return exepath;
}
/**
* @brief Find the proper client window within a hierarchy. This check is needed
* in some environments where the window that has been selected is actually
* a child to a transparent parent window which was the one that was
* actually grabbed
* @param Top window to check
* @return Client window XID or 0 if no appropriate window was found
*/
Window X11Extras::findClientWindow(Window window)
{
Window parent = 1;
Window root = 0;
Window *children = 0;
unsigned int num_children = 0;
Window finalwindow = 0;
Display *display = this->display();
if (windowIsViewable(display, window) &&
isWindowRelevant(display, window))
{
finalwindow = window;
}
else
{
XQueryTree(display, window, &root, &parent, &children, &num_children);
if (children)
{
for (unsigned int i = 0; i < num_children && !finalwindow; i++)
{
if (windowIsViewable(display, children[i]) &&
isWindowRelevant(display, window))
{
finalwindow = children[i];
}
}
}
if (!finalwindow && children)
{
for (unsigned int i = 0; i < num_children && !finalwindow; i++)
{
finalwindow = findClientWindow(children[i]);
}
}
if (children)
{
XFree(children);
children = 0;
}
}
return finalwindow;
}
bool X11Extras::windowHasProperty(Display *display, Window window, Atom atom)
{
bool result = false;
Atom actual_type;
int actual_format = 0;
unsigned long nitems = 0;
unsigned long bytes_after = 0;
unsigned char *prop = 0;
int status = 0;
status = XGetWindowProperty(display, window, atom, 0, 1024, false, AnyPropertyType,
&actual_type, &actual_format, &nitems, &bytes_after,
&prop);
if (status == Success && prop)
{
result = true;
}
if (prop)
{
XFree(prop);
prop = 0;
}
return result;
}
bool X11Extras::windowIsViewable(Display *display, Window window)
{
bool result = false;
XWindowAttributes xwa;
XGetWindowAttributes(display, window, &xwa);
if (xwa.c_class == InputOutput && xwa.map_state == IsViewable)
{
result = true;
}
return result;
}
/**
* @brief Go through a window's properties and search for an Atom
* from a defined list. If an Atom is found in a window's properties,
* that window should be considered relevant and one that should be grabbed.
* @param Display*
* @param Window
* @return If a window has a relevant Atom in its properties.
*/
bool X11Extras::isWindowRelevant(Display *display, Window window)
{
bool result = false;
QList<Atom> temp;
temp.append(XInternAtom(display, "WM_STATE", True));
temp.append(XInternAtom(display, "_NW_WM_STATE", True));
temp.append(XInternAtom(display, "_NW_WM_NAME", True));
QListIterator<Atom> iter(temp);
while (iter.hasNext())
{
Atom current_atom = iter.next();
if (windowHasProperty(display, window, current_atom))
{
iter.toBack();
result = true;
}
}
return result;
}
QString X11Extras::getWindowTitle(Window window)
{
QString temp;
Atom atom, actual_type;
int actual_format = 0;
unsigned long nitems = 0;
unsigned long bytes_after = 0;
unsigned char *prop = 0;
int status = 0;
//qDebug() << "WIN: 0x" << QString::number(window, 16);
Display *display = this->display();
Atom wm_name = XInternAtom(display, "WM_NAME", True);
Atom net_wm_name = XInternAtom(display, "_NET_WM_NAME", True);
atom = wm_name;
QList<Atom> tempList;
tempList.append(wm_name);
tempList.append(net_wm_name);
QListIterator<Atom> iter(tempList);
while (iter.hasNext())
{
Atom temp_atom = iter.next();
if (windowHasProperty(display, window, temp_atom))
{
iter.toBack();
atom = temp_atom;
}
}
status = XGetWindowProperty(display, window, atom, 0, 1024, false, AnyPropertyType,
&actual_type, &actual_format, &nitems, &bytes_after,
&prop);
if (status == Success && prop)
{
char *tempprop = (char*)prop;
temp.append(QString::fromUtf8(tempprop));
//qDebug() << temp;
}
if (prop)
{
XFree(prop);
prop = 0;
}
return temp;
}
QString X11Extras::getWindowClass(Window window)
{
QString temp;
Atom atom, actual_type;
int actual_format = 0;
unsigned long nitems = 0;
unsigned long bytes_after = 0;
unsigned char *prop = 0;
int status = 0;
Display *display = this->display();
atom = XInternAtom(display, "WM_CLASS", True);
status = XGetWindowProperty(display, window, atom, 0, 1024, false, AnyPropertyType,
&actual_type, &actual_format, &nitems, &bytes_after,
&prop);
if (status == Success && prop)
{
//qDebug() << nitems;
char *null_char = strchr((char*)prop, '\0');
if ((char*)prop + nitems - 1 > null_char)
{
*(null_char) = ' ';
}
char *tempprop = (char*)prop;
temp.append(QString::fromUtf8(tempprop));
//qDebug() << temp;
//qDebug() << (char*)prop;
}
if (prop)
{
XFree(prop);
prop = 0;
}
return temp;
}
unsigned long X11Extras::getWindowInFocus()
{
unsigned long result = 0;
Window currentWindow = 0;
int focusState = 0;
Display *display = this->display();
XGetInputFocus(display, ¤tWindow, &focusState);
if (currentWindow > 0)
{
result = static_cast<unsigned long>(currentWindow);
}
return result;
}
/**
* @brief Get QString representation of currently utilized X display.
* @return
*/
QString X11Extras::getXDisplayString()
{
return _customDisplayString;
}
unsigned int X11Extras::getGroup1KeySym(unsigned int virtualkey)
{
unsigned int result = 0;
Display *display = this->display();
unsigned int temp = XKeysymToKeycode(display, virtualkey);
result = XkbKeycodeToKeysym(display, temp, 0, 0);
return result;
}
void X11Extras::x11ResetMouseAccelerationChange(QString pointerName)
{
int xi_opcode, event, error;
xi_opcode = event = error = 0;
Display *display = this->display();
bool result = XQueryExtension(display, "XInputExtension", &xi_opcode, &event, &error);
if (!result)
{
Logger::LogInfo(tr("xinput extension was not found. No mouse acceleration changes will occur."));
}
else
{
int ximajor = 2, ximinor = 0;
if (XIQueryVersion(display, &ximajor, &ximinor) != Success)
{
Logger::LogInfo(tr("xinput version must be at least 2.0. No mouse acceleration changes will occur."));
result = false;
}
}
if (result)
{
XIDeviceInfo *all_devices = 0;
XIDeviceInfo *current_devices = 0;
XIDeviceInfo *mouse_device = 0;
int num_devices = 0;
all_devices = XIQueryDevice(display, XIAllDevices, &num_devices);
for (int i=0; i < num_devices; i++)
{
current_devices = &all_devices[i];
if (current_devices->use == XISlavePointer &&
QString::fromUtf8(current_devices->name) == pointerName)
{
Logger::LogInfo(tr("Virtual pointer found with id=%1.").arg(current_devices->deviceid));
mouse_device = current_devices;
}
}
if (mouse_device)
{
XDevice *device = XOpenDevice(display, mouse_device->deviceid);
int num_feedbacks = 0;
int feedback_id = -1;
XFeedbackState *feedbacks = XGetFeedbackControl(display, device, &num_feedbacks);
XFeedbackState *temp = feedbacks;
for (int i=0; (i < num_feedbacks) && (feedback_id == -1); i++)
{
if (temp->c_class == PtrFeedbackClass)
{
feedback_id = temp->id;
}
if (i+1 < num_feedbacks)
{
temp = (XFeedbackState*) ((char*) temp + temp->length);
}
}
XFree(feedbacks);
feedbacks = temp = 0;
if (feedback_id <= -1)
{
Logger::LogInfo(tr("PtrFeedbackClass was not found for virtual pointer."
"No change to mouse acceleration will occur for device with id=%1").arg(device->device_id));
result = false;
}
else
{
Logger::LogInfo(tr("Changing mouse acceleration for device with id=%1").arg(device->device_id));
XPtrFeedbackControl feedback;
feedback.c_class = PtrFeedbackClass;
feedback.length = sizeof(XPtrFeedbackControl);
feedback.id = feedback_id;
feedback.threshold = 0;
feedback.accelNum = 1;
feedback.accelDenom = 1;
XChangeFeedbackControl(display, device, DvAccelNum|DvAccelDenom|DvThreshold,
(XFeedbackControl*) &feedback);
XSync(display, false);
}
XCloseDevice(display, device);
}
if (all_devices)
{
XIFreeDeviceInfo(all_devices);
}
}
}
void X11Extras::x11ResetMouseAccelerationChange()
{
x11ResetMouseAccelerationChange(mouseDeviceName);
}
struct X11Extras::ptrInformation X11Extras::getPointInformation(QString pointerName)
{
struct ptrInformation tempInfo;
int xi_opcode, event, error;
xi_opcode = event = error = 0;
Display *display = this->display();
bool result = XQueryExtension(display, "XInputExtension", &xi_opcode, &event, &error);
if (result)
{
int ximajor = 2, ximinor = 0;
if (XIQueryVersion(display, &ximajor, &ximinor) != Success)
{
Logger::LogInfo(tr("xinput version must be at least 2.0. No mouse acceleration changes will occur."));
result = false;
}
}
if (result)
{
XIDeviceInfo *all_devices = 0;
XIDeviceInfo *current_devices = 0;
XIDeviceInfo *mouse_device = 0;
int num_devices = 0;
all_devices = XIQueryDevice(display, XIAllDevices, &num_devices);
for (int i=0; i < num_devices; i++)
{
current_devices = &all_devices[i];
if (current_devices->use == XISlavePointer &&
QString::fromUtf8(current_devices->name) == pointerName)
{
mouse_device = current_devices;
}
}
if (mouse_device)
{
XDevice *device = XOpenDevice(display, mouse_device->deviceid);
int num_feedbacks = 0;
int feedback_id = -1;
XFeedbackState *feedbacks = XGetFeedbackControl(display, device, &num_feedbacks);
XFeedbackState *temp = feedbacks;
for (int i=0; (i < num_feedbacks) && (feedback_id == -1); i++)
{
if (temp->c_class == PtrFeedbackClass)
{
feedback_id = temp->id;
}
if (feedback_id == -1 && (i+1 < num_feedbacks))
{
temp = (XFeedbackState*) ((char*) temp + temp->length);
}
}
if (feedback_id <= -1)
{
result = false;
}
else
{
XPtrFeedbackState *tempPtrFeedback = reinterpret_cast<XPtrFeedbackState*>(temp);
tempInfo.id = feedback_id;
tempInfo.accelNum = tempPtrFeedback->accelNum;
tempInfo.accelDenom = tempPtrFeedback->accelDenom;
tempInfo.threshold = tempPtrFeedback->threshold;
}
XFree(feedbacks);
feedbacks = temp = 0;
XCloseDevice(display, device);
}
if (all_devices)
{
XIFreeDeviceInfo(all_devices);
}
}
return tempInfo;
}
struct X11Extras::ptrInformation X11Extras::getPointInformation()
{
return getPointInformation(mouseDeviceName);
}
QPoint X11Extras::getPos()
{
XEvent mouseEvent;
Window wid = DefaultRootWindow(display());
XWindowAttributes xwAttr;
XQueryPointer(display(), wid,
&mouseEvent.xbutton.root, &mouseEvent.xbutton.window,
&mouseEvent.xbutton.x_root, &mouseEvent.xbutton.y_root,
&mouseEvent.xbutton.x, &mouseEvent.xbutton.y,
&mouseEvent.xbutton.state);
XGetWindowAttributes(display(), wid, &xwAttr);
QPoint currentPoint(mouseEvent.xbutton.x_root, mouseEvent.xbutton.y_root);
return currentPoint;
}
``` | /content/code_sandbox/src/x11extras.cpp | c++ | 2016-05-24T23:59:31 | 2024-08-11T02:46:48 | antimicro | AntiMicro/antimicro | 1,788 | 5,177 |
```objective-c
/* antimicro Gamepad to KB+M event mapper
*
* This program is free software: you can redistribute it and/or modify
* (at your option) any later version.
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* along with this program. If not, see <path_to_url
*/
#ifndef XMLCONFIGMIGRATION_H
#define XMLCONFIGMIGRATION_H
#include <QObject>
#include <QXmlStreamReader>
#include <QXmlStreamWriter>
#include "common.h"
class XMLConfigMigration : public QObject
{
Q_OBJECT
public:
explicit XMLConfigMigration(QXmlStreamReader *reader, QObject *parent = 0);
bool requiresMigration();
QString migrate();
protected:
QXmlStreamReader *reader;
int fileVersion;
private:
QString readConfigToString();
QString version0006Migration();
signals:
public slots:
};
#endif // XMLCONFIGMIGRATION_H
``` | /content/code_sandbox/src/xmlconfigmigration.h | objective-c | 2016-05-24T23:59:31 | 2024-08-11T02:46:48 | antimicro | AntiMicro/antimicro | 1,788 | 219 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.