PDF rausgenommen

msd2/tracking/piwik/libs/bower_components/mousetrap/plugins/README.md

@@ -0,0 +1,24 @@
+# Plugins
+
+Plugins extend the functionality of Mousetrap.  To use a plugin just include the plugin after mousetrap.
+
+```html
+<script src="mousetrap.js"></script>
+<script src="mousetrap-record.js"></script>
+```
+
+## Bind dictionary
+
+Allows you to make multiple bindings in a single ``Mousetrap.bind`` call.
+
+## Global bind
+
+Allows you to set global bindings that work even inside of input fields.
+
+## Pause/unpause
+
+Allows you to temporarily prevent Mousetrap events from firing.
+
+## Record
+
+Allows you to capture a keyboard shortcut or sequence defined by a user.

msd2/tracking/piwik/libs/bower_components/mousetrap/plugins/bind-dictionary/README.md

@@ -0,0 +1,16 @@
+# Bind Dictionary
+
+This extension overwrites the default bind behavior and allows you to bind multiple combinations in a single bind call.
+
+Usage looks like:
+
+```javascript
+Mousetrap.bind({
+    'a': function() { console.log('a'); },
+    'b': function() { console.log('b'); }
+});
+```
+
+You can optionally pass in ``keypress``, ``keydown`` or ``keyup`` as a second argument.
+
+Other bind calls work the same way as they do by default.

msd2/tracking/piwik/libs/bower_components/mousetrap/plugins/bind-dictionary/mousetrap-bind-dictionary.js

@@ -0,0 +1,39 @@
+/**
+ * Overwrites default Mousetrap.bind method to optionally accept
+ * an object to bind multiple key events in a single call
+ *
+ * You can pass it in like:
+ *
+ * Mousetrap.bind({
+ *     'a': function() { console.log('a'); },
+ *     'b': function() { console.log('b'); }
+ * });
+ *
+ * And can optionally pass in 'keypress', 'keydown', or 'keyup'
+ * as a second argument
+ *
+ */
+/* global Mousetrap:true */
+Mousetrap = (function(Mousetrap) {
+    var self = Mousetrap,
+        _oldBind = self.bind,
+        args;
+
+    self.bind = function() {
+        args = arguments;
+
+        // normal call
+        if (typeof args[0] == 'string' || args[0] instanceof Array) {
+            return _oldBind(args[0], args[1], args[2]);
+        }
+
+        // object passed in
+        for (var key in args[0]) {
+            if (args[0].hasOwnProperty(key)) {
+                _oldBind(key, args[0][key], args[1]);
+            }
+        }
+    };
+
+    return self;
+}) (Mousetrap);

msd2/tracking/piwik/libs/bower_components/mousetrap/plugins/bind-dictionary/mousetrap-bind-dictionary.min.js

@@ -0,0 +1 @@
+Mousetrap=function(b){var c=b.bind,a;b.bind=function(){a=arguments;if("string"==typeof a[0]||a[0]instanceof Array)return c(a[0],a[1],a[2]);for(var b in a[0])a[0].hasOwnProperty(b)&&c(b,a[0][b],a[1])};return b}(Mousetrap);

msd2/tracking/piwik/libs/bower_components/mousetrap/plugins/global-bind/README.md

@@ -0,0 +1,15 @@
+# Global Bind
+
+This extension allows you to specify keyboard events that will work anywhere including inside textarea/input fields.
+
+Usage looks like:
+
+```javascript
+Mousetrap.bindGlobal('ctrl+s', function() {
+    _save();
+});
+```
+
+This means that a keyboard event bound using ``Mousetrap.bind`` will only work outside of form input fields, but using ``Moustrap.bindGlobal`` will work in both places.
+
+If you wanted to create keyboard shortcuts that only work when you are inside a specific textarea you can do that too by creating your own extension.

msd2/tracking/piwik/libs/bower_components/mousetrap/plugins/global-bind/mousetrap-global-bind.js

@@ -0,0 +1,36 @@
+/**
+ * adds a bindGlobal method to Mousetrap that allows you to
+ * bind specific keyboard shortcuts that will still work
+ * inside a text input field
+ *
+ * usage:
+ * Mousetrap.bindGlobal('ctrl+s', _saveChanges);
+ */
+/* global Mousetrap:true */
+Mousetrap = (function(Mousetrap) {
+    var _globalCallbacks = {},
+        _originalStopCallback = Mousetrap.stopCallback;
+
+    Mousetrap.stopCallback = function(e, element, combo, sequence) {
+        if (_globalCallbacks[combo] || _globalCallbacks[sequence]) {
+            return false;
+        }
+
+        return _originalStopCallback(e, element, combo);
+    };
+
+    Mousetrap.bindGlobal = function(keys, callback, action) {
+        Mousetrap.bind(keys, callback, action);
+
+        if (keys instanceof Array) {
+            for (var i = 0; i < keys.length; i++) {
+                _globalCallbacks[keys[i]] = true;
+            }
+            return;
+        }
+
+        _globalCallbacks[keys] = true;
+    };
+
+    return Mousetrap;
+}) (Mousetrap);

msd2/tracking/piwik/libs/bower_components/mousetrap/plugins/global-bind/mousetrap-global-bind.min.js

@@ -0,0 +1 @@
+Mousetrap=function(a){var d={},e=a.stopCallback;a.stopCallback=function(b,c,a){return d[a]?!1:e(b,c,a)};a.bindGlobal=function(b,c,e){a.bind(b,c,e);if(b instanceof Array)for(c=0;c<b.length;c++)d[b[c]]=!0;else d[b]=!0};return a}(Mousetrap);

msd2/tracking/piwik/libs/bower_components/mousetrap/plugins/pause/README.md

@@ -0,0 +1,13 @@
+# Pause/unpause
+
+This extension allows Mousetrap to be paused and unpaused without having to reset keyboard shortcuts and rebind them.
+
+Usage looks like:
+
+```javascript
+// stop Mousetrap events from firing
+Mousetrap.pause();
+
+// allow Mousetrap events to fire again
+Mousetrap.unpause();
+```

msd2/tracking/piwik/libs/bower_components/mousetrap/plugins/pause/mousetrap-pause.js

@@ -0,0 +1,29 @@
+/**
+ * adds a pause and unpause method to Mousetrap
+ * this allows you to enable or disable keyboard shortcuts
+ * without having to reset Mousetrap and rebind everything
+ */
+/* global Mousetrap:true */
+Mousetrap = (function(Mousetrap) {
+    var self = Mousetrap,
+        _originalStopCallback = self.stopCallback,
+        enabled = true;
+
+    self.stopCallback = function(e, element, combo) {
+        if (!enabled) {
+            return true;
+        }
+
+        return _originalStopCallback(e, element, combo);
+    };
+
+    self.pause = function() {
+        enabled = false;
+    };
+
+    self.unpause = function() {
+        enabled = true;
+    };
+
+    return self;
+}) (Mousetrap);

msd2/tracking/piwik/libs/bower_components/mousetrap/plugins/pause/mousetrap-pause.min.js

@@ -0,0 +1 @@
+Mousetrap=function(a){var c=a.stopCallback,b=!0;a.stopCallback=function(a,d,e){return b?c(a,d,e):!0};a.pause=function(){b=!1};a.unpause=function(){b=!0};return a}(Mousetrap);

msd2/tracking/piwik/libs/bower_components/mousetrap/plugins/record/README.md

@@ -0,0 +1,16 @@
+# Record
+
+This extension lets you use Mousetrap to record keyboard sequences and play them back:
+
+```html
+<button onclick="recordSequence()">Record</button>
+
+<script>
+    function recordSequence() {
+        Mousetrap.record(function(sequence) {
+            // sequence is an array like ['ctrl+k', 'c']
+            alert('You pressed: ' + sequence.join(' '));
+        });
+    }
+</script>
+```

msd2/tracking/piwik/libs/bower_components/mousetrap/plugins/record/mousetrap-record.js

@@ -0,0 +1,189 @@
+/**
+ * This extension allows you to record a sequence using Mousetrap.
+ *
+ * @author Dan Tao <daniel.tao@gmail.com>
+ */
+(function(Mousetrap) {
+    /**
+     * the sequence currently being recorded
+     *
+     * @type {Array}
+     */
+    var _recordedSequence = [],
+
+        /**
+         * a callback to invoke after recording a sequence
+         *
+         * @type {Function|null}
+         */
+        _recordedSequenceCallback = null,
+
+        /**
+         * a list of all of the keys currently held down
+         *
+         * @type {Array}
+         */
+        _currentRecordedKeys = [],
+
+        /**
+         * temporary state where we remember if we've already captured a
+         * character key in the current combo
+         *
+         * @type {boolean}
+         */
+        _recordedCharacterKey = false,
+
+        /**
+         * a handle for the timer of the current recording
+         *
+         * @type {null|number}
+         */
+        _recordTimer = null,
+
+        /**
+         * the original handleKey method to override when Mousetrap.record() is
+         * called
+         *
+         * @type {Function}
+         */
+        _origHandleKey = Mousetrap.handleKey;
+
+    /**
+     * handles a character key event
+     *
+     * @param {string} character
+     * @param {Array} modifiers
+     * @param {Event} e
+     * @returns void
+     */
+    function _handleKey(character, modifiers, e) {
+        // remember this character if we're currently recording a sequence
+        if (e.type == 'keydown') {
+            if (character.length === 1 && _recordedCharacterKey) {
+                _recordCurrentCombo();
+            }
+
+            for (i = 0; i < modifiers.length; ++i) {
+                _recordKey(modifiers[i]);
+            }
+            _recordKey(character);
+
+        // once a key is released, all keys that were held down at the time
+        // count as a keypress
+        } else if (e.type == 'keyup' && _currentRecordedKeys.length > 0) {
+            _recordCurrentCombo();
+        }
+    }
+
+    /**
+     * marks a character key as held down while recording a sequence
+     *
+     * @param {string} key
+     * @returns void
+     */
+    function _recordKey(key) {
+        var i;
+
+        // one-off implementation of Array.indexOf, since IE6-9 don't support it
+        for (i = 0; i < _currentRecordedKeys.length; ++i) {
+            if (_currentRecordedKeys[i] === key) {
+                return;
+            }
+        }
+
+        _currentRecordedKeys.push(key);
+
+        if (key.length === 1) {
+            _recordedCharacterKey = true;
+        }
+    }
+
+    /**
+     * marks whatever key combination that's been recorded so far as finished
+     * and gets ready for the next combo
+     *
+     * @returns void
+     */
+    function _recordCurrentCombo() {
+        _recordedSequence.push(_currentRecordedKeys);
+        _currentRecordedKeys = [];
+        _recordedCharacterKey = false;
+        _restartRecordTimer();
+    }
+
+    /**
+     * ensures each combo in a sequence is in a predictable order and formats
+     * key combos to be '+'-delimited
+     *
+     * modifies the sequence in-place
+     *
+     * @param {Array} sequence
+     * @returns void
+     */
+    function _normalizeSequence(sequence) {
+        var i;
+
+        for (i = 0; i < sequence.length; ++i) {
+            sequence[i].sort(function(x, y) {
+                // modifier keys always come first, in alphabetical order
+                if (x.length > 1 && y.length === 1) {
+                    return -1;
+                } else if (x.length === 1 && y.length > 1) {
+                    return 1;
+                }
+
+                // character keys come next (list should contain no duplicates,
+                // so no need for equality check)
+                return x > y ? 1 : -1;
+            });
+
+            sequence[i] = sequence[i].join('+');
+        }
+    }
+
+    /**
+     * finishes the current recording, passes the recorded sequence to the stored
+     * callback, and sets Mousetrap.handleKey back to its original function
+     *
+     * @returns void
+     */
+    function _finishRecording() {
+        if (_recordedSequenceCallback) {
+            _normalizeSequence(_recordedSequence);
+            _recordedSequenceCallback(_recordedSequence);
+        }
+
+        // reset all recorded state
+        _recordedSequence = [];
+        _recordedSequenceCallback = null;
+        _currentRecordedKeys = [];
+
+        Mousetrap.handleKey = _origHandleKey;
+    }
+
+    /**
+     * called to set a 1 second timeout on the current recording
+     *
+     * this is so after each key press in the sequence the recording will wait for
+     * 1 more second before executing the callback
+     *
+     * @returns void
+     */
+    function _restartRecordTimer() {
+        clearTimeout(_recordTimer);
+        _recordTimer = setTimeout(_finishRecording, 1000);
+    }
+
+    /**
+     * records the next sequence and passes it to a callback once it's
+     * completed
+     *
+     * @param {Function} callback
+     * @returns void
+     */
+    Mousetrap.record = function(callback) {
+        Mousetrap.handleKey = _handleKey;
+        _recordedSequenceCallback = callback;
+    };
+
+})(Mousetrap);

msd2/tracking/piwik/libs/bower_components/mousetrap/plugins/record/mousetrap-record.min.js

@@ -0,0 +1,2 @@
+(function(d){function n(b,a,h){if("keydown"==h.type){1===b.length&&g&&k();for(i=0;i<a.length;++i)l(a[i]);l(b)}else"keyup"==h.type&&0<c.length&&k()}function l(b){var a;for(a=0;a<c.length;++a)if(c[a]===b)return;c.push(b);1===b.length&&(g=!0)}function k(){e.push(c);c=[];g=!1;clearTimeout(m);m=setTimeout(p,1E3)}function q(b){var a;for(a=0;a<b.length;++a)b[a].sort(function(a,b){return 1<a.length&&1===b.length?-1:1===a.length&&1<b.length?1:a>b?1:-1}),b[a]=b[a].join("+")}function p(){f&&(q(e),f(e));e=[];
+f=null;c=[];d.handleKey=r}var e=[],f=null,c=[],g=!1,m=null,r=d.handleKey;d.record=function(b){d.handleKey=n;f=b}})(Mousetrap);