jquery-dirtyforms-rails 2.0.0

data/vendor/assets/javascripts/jquery.dirtyforms.dialogs.pnotify.js

@@ -0,0 +1,159 @@
+/*!
+PNotify dialog module (for jQuery Dirty Forms) | v | github.com/snikch/jquery.dirtyforms
+(c) 2015-2016 Shad Storhaug
+License MIT
+*/
+
+(function($, window, document, undefined) {
+    // Can't use ECMAScript 5's strict mode because several apps 
+    // including ASP.NET trace the stack via arguments.caller.callee 
+    // and Firefox dies if you try to trace through "use strict" call chains. 
+    // See jQuery issue (#13335)
+    // Support: Firefox 18+
+    //"use strict";
+
+    var modal_overlay,
+        notice,
+        isPN1 = typeof PNotify !== 'function';
+
+    $.DirtyForms.dialog = {
+
+        // Custom properties and methods to allow overriding (may differ per dialog)
+        title: 'Are you sure you want to do that?',
+        class: 'dirty-dialog',
+        proceedButtonText: 'Leave This Page',
+        stayButtonText: 'Stay Here',
+        styling: 'bootstrap3',
+        width: '330',
+
+        // Typical Dirty Forms Properties and Methods
+        open: function (choice, message, ignoreClass) {
+            var content = $.extend(true, {}, {
+                title: this.title,
+                hide: false,
+                styling: this.styling,
+                width: this.width,
+
+                // 3.x and 2.x confirm buttons
+                confirm: {
+                    confirm: true,
+                    align: 'center',
+                    buttons: [
+                        {
+                            text: this.proceedButtonText,
+                            addClass: 'dirty-proceed ' + ignoreClass
+                        },
+                        {
+                            text: this.stayButtonText,
+                            addClass: 'dirty-stay ' + ignoreClass
+                        }
+                    ]
+                },
+                // 3.x don't use history
+                history: {
+                    history: false
+                },
+                // 3.x modal dialog
+                addclass: 'stack-modal ' + this.class,
+                stack: { 'dir1': 'down', 'dir2': 'right', 'modal': true },
+
+                // 3.x and 2.x hide closer and sticker
+                buttons: {
+                    closer: false,
+                    sticker: false
+                },
+                // 1.x hide closer and sticker
+                closer: false,
+                sticker: false,
+
+                // NOTE: Animate does not seem to work in 3.x in conjunction with confirm,
+                // but this is being added so the settings can be supplied externally should
+                // this issue be fixed. https://github.com/sciactive/pnotify/issues/224
+                animate: this.animate === undefined ? undefined : this.animate,
+
+                text: !isPN1 ? message :
+                    '<span class="' + this.class + '">' +
+                        '<p>' + message + '</p>' +
+                        '<span style="display:block;text-align:center;">' +
+                            '<button type="button" class="btn btn-default dirty-proceed ' + ignoreClass + '">' + this.proceedButtonText + '</button> ' +
+                            '<button type="button" class="btn btn-default dirty-stay ' + ignoreClass + '">' + this.stayButtonText + '</button>' +
+                        '</span>' +
+                    '</span>',
+
+                // Not supported in 3.x
+                before_open: function (PNotify) {
+                    if (!isPN1) {
+                        // Position this notice in the center of the screen.
+                        PNotify.get().css({
+                            "top": ($(window).height() / 2) - (PNotify.get().height() / 2),
+                            "left": ($(window).width() / 2) - (PNotify.get().width() / 2)
+                        });
+                    }
+
+                    // Make a modal screen overlay.
+                    if (modal_overlay) modal_overlay.fadeIn("fast");
+                    else modal_overlay = $("<div />", {
+                        "class": "ui-widget-overlay",
+                        "css": {
+                            "display": "none",
+                            "position": "fixed",
+                            "top": "0",
+                            "bottom": "0",
+                            "right": "0",
+                            "left": "0"
+                        }
+                    }).appendTo("body").fadeIn("fast");
+                }
+            });
+
+            // Patch for PNotify 1.x
+            notice = !isPN1 ? new PNotify(content) : $.pnotify(content);
+
+            // Bind Events
+            choice.bindEnterKey = true;
+            choice.proceedSelector = '.' + this.class + ' .dirty-proceed';
+            choice.staySelector = '.' + this.class + ' .dirty-stay,.ui-widget-overlay';
+
+            // Support for Dirty Forms < 2.0
+            if (choice.isDF1) {
+                var close = function (decision) {
+                    return function (e) {
+                        if (e.type !== 'keydown' || (e.type === 'keydown' && (e.which == 27 || e.which == 13))) {
+                            notice.remove();
+                            if (modal_overlay) modal_overlay.fadeOut("fast");
+                            decision(e);
+                            return false;
+                        }
+                    };
+                };
+                // Trap the escape key and force a close. Cancel it so PNotify doesn't intercept it.
+                var decidingCancel = $.DirtyForms.decidingCancel;
+                $(document).keydown(close(decidingCancel));
+                $(choice.staySelector).click(close(decidingCancel));
+                $(choice.proceedSelector).click(close($.DirtyForms.decidingContinue));
+            }
+        },
+        close: function () {
+            notice.remove();
+            if (modal_overlay) modal_overlay.fadeOut("fast");
+        },
+
+        // Support for Dirty Forms < 2.0
+        fire: function (message, title) {
+            this.title = title;
+            this.open({ isDF1: true }, message, $.DirtyForms.ignoreClass);
+        },
+
+        // Support for Dirty Forms < 1.2
+        bind: function () {
+        },
+        stash: function () {
+            return false;
+        },
+        refire: function () {
+            return false;
+        },
+        selector: 'no-op'
+    };
+
+})(jQuery, window, document);

data/vendor/assets/javascripts/jquery.dirtyforms.helpers.alwaysdirty.js

@@ -0,0 +1,27 @@
+/*!
+Always dirty helper module (for jQuery Dirty Forms) | v | github.com/snikch/jquery.dirtyforms
+(c) 2012-2016 Mal Curtis
+License MIT
+*/
+
+// Example helper, the form is always considered dirty
+
+(function($, window, document, undefined) {
+    // Can't use ECMAScript 5's strict mode because several apps 
+    // including ASP.NET trace the stack via arguments.caller.callee 
+    // and Firefox dies if you try to trace through "use strict" call chains. 
+    // See jQuery issue (#13335)
+    // Support: Firefox 18+
+    //"use strict";
+
+    // Create a new object, with an isDirty method
+    var alwaysDirty = {
+        isDirty: function (node) {
+            // Perform dirty check on a given node (usually a form element)	
+            return true;
+        }
+    };
+    // Push the new object onto the helpers array
+    $.DirtyForms.helpers.push(alwaysDirty);
+
+})(jQuery, window, document);

data/vendor/assets/javascripts/jquery.dirtyforms.helpers.ckeditor.js

@@ -0,0 +1,67 @@
+/*!
+CkEditor helper module (for jQuery Dirty Forms) | v | github.com/snikch/jquery.dirtyforms
+(c) 2012-2016 Mal Curtis
+License MIT
+*/
+
+(function($, window, document, undefined) {
+    // Can't use ECMAScript 5's strict mode because several apps 
+    // including ASP.NET trace the stack via arguments.caller.callee 
+    // and Firefox dies if you try to trace through "use strict" call chains. 
+    // See jQuery issue (#13335)
+    // Support: Firefox 18+
+    //"use strict";
+
+    var ignoreSelector = '.cke_dialog_ui_button,.cke_tpl_list a';
+
+    var ckeditor = {
+        ignoreSelector: ignoreSelector,
+        isDirty: function ($form) {
+            var $editors = ckeditors($form),
+                isDirty = false;
+            if ($editors.length > 0) {
+                $.DirtyForms.dirtylog('Checking ' + $editors.length + ' ckeditors for dirtyness.');
+                $editors.each(function (editorIndex) {
+                    if (this.checkDirty()) {
+                        isDirty = true;
+
+                        $.DirtyForms.dirtylog('CKEditor with index ' + editorIndex + ' was dirty, exiting...');
+                        // Return false to break out of the .each() function
+                        return false;
+                    }
+                });
+            }
+            return isDirty;
+        },
+        setClean: function ($form) {
+            ckeditors($form).each(function () { this.resetDirty(); });
+        },
+
+        // Support for Dirty Forms < 2.0
+        ignoreAnchorSelector: ignoreSelector
+    };
+    var ckeditors = function (form) {
+        var $form = form.jquery ? form : $(form);
+        var editors = [];
+        if (!window.CKEDITOR || !window.CKEDITOR.instances) {
+            return $(editors);
+        }
+        try {
+            for (var key in window.CKEDITOR.instances) {
+                if (window.CKEDITOR.instances.hasOwnProperty(key)) {
+                    var editor = window.CKEDITOR.instances[key];
+                    if ($(editor.element.$).parents().index($form) != -1) {
+                        $.DirtyForms.dirtylog('Adding CKEditor with key ' + key);
+                        editors.push(editor);
+                    }
+                }
+            }
+        }
+        catch (e) {
+            // Ignore, means there was no CKEDITOR variable
+        }
+        return $(editors);
+    };
+    $.DirtyForms.helpers.push(ckeditor);
+
+})(jQuery, window, document);

data/vendor/assets/javascripts/jquery.dirtyforms.helpers.tinymce.js

@@ -0,0 +1,158 @@
+/*!
+TinyMCE helper module (for jQuery Dirty Forms) | v | github.com/snikch/jquery.dirtyforms
+(c) 2013-2016 Mal Curtis
+License MIT
+*/
+
+(function($, window, document, undefined) {
+    // Can't use ECMAScript 5's strict mode because several apps 
+    // including ASP.NET trace the stack via arguments.caller.callee 
+    // and Firefox dies if you try to trace through "use strict" call chains. 
+    // See jQuery issue (#13335)
+    // Support: Firefox 18+
+    //"use strict";
+
+    var tinymceSelector = ':tinymce:not(.dirty-forms-temp)',
+        ignoreSelector = '.mceEditor a,.mceMenu a,[name^="mce_"]';
+
+    // Create a new object, with an isDirty method
+    var tinymce = {
+        // Dirty Forms properties and methods
+        ignoreSelector: ignoreSelector,
+        isDirty: function ($node) {
+            var isDirty = false;
+            if (hasTinyMCE($node)) {
+                // Search the current node and all descendant nodes that match the selector
+                $node.filter(tinymceSelector).add($node.find(tinymceSelector)).each(function () {
+                    var $field = $(this);
+
+                    $.DirtyForms.dirtylog('Checking node ' + $field.attr('id'));
+                    if (typeof $field.data('df-tinymce-orig') === 'undefined') {
+                        // For Dirty Forms < 2.0 and TinyMCE elements that were added via AJAX,
+                        // we default to using TinyMCE's isDirty behavior (which is stateless).
+                        if ($field.tinymce().isDirty()) {
+                            isDirty = true;
+                            $.DirtyForms.dirtylog('Node was totally dirty.');
+                            // Return false to stop iterating.
+                            return false;
+                        }
+                    } else {
+                        // For Dirty Forms >= 2.0, we compare hash codes with the original content
+                        var content = getTinyMceContent($field);
+                        $.DirtyForms.dirtylog('TinyMCE content: ' + content);
+                        var hash = getHashCode(content);
+                        $.DirtyForms.dirtylog('TinyMCE hash: ' + hash);
+                        var originalHash = $field.data('df-tinymce-orig');
+                        $.DirtyForms.dirtylog('Original TinyMCE hash: ' + originalHash);
+
+                        if (hash !== originalHash) {
+                            isDirty = true;
+                            $.DirtyForms.dirtylog('Node was totally dirty.');
+                            // Return false to stop iterating.
+                            return false;
+                        }
+                    }
+                });
+            }
+            return isDirty;
+        },
+        setClean: function ($node) {
+            if (hasTinyMCE($node)) {
+
+                // Search the current node and all descendant nodes that match the selector
+                $node.filter(tinymceSelector).add($node.find(tinymceSelector)).each(function () {
+                    var $field = $(this);
+
+                    // Set TinyMCE clean
+                    if ($field.tinymce().isDirty()) {
+                        $.DirtyForms.dirtylog('Resetting isDirty on node ' + $field.attr('id'));
+                        $field.tinymce().isNotDirty = 1; //Force not dirty state
+                    }
+
+                    // Forget the original value and reset to the current state
+                    storeOriginalValue($field);
+                });
+            }
+        },
+        rescan: function ($node) {
+            if (hasTinyMCE($node)) {
+                $node.filter(tinymceSelector).add($node.find(tinymceSelector)).each(function () {
+                    var $field = $(this);
+
+                    if (typeof $field.data('df-tinymce-orig') !== 'undefined') {
+                        storeOriginalValue($field);
+                    }
+                });
+            }
+        },
+
+        // Patch for Dirty Forms < 2.0
+        ignoreAnchorSelector: ignoreSelector
+    };
+
+    // Push the new object onto the helpers array
+    $.DirtyForms.helpers.push(tinymce);
+
+    // Fix: tinymce throws an error if the selector doesn't match anything
+    // (such as when there are no textareas on the current page)
+    var hasTinyMCE = function ($node) {
+        try {
+            return $node.filter(tinymceSelector).length > 0 || $node.find(tinymceSelector).length > 0;
+        }
+        catch (e) {
+            return false;
+        }
+    };
+
+    var getTinyMceContent = function ($field) {
+        // Hack: TinyMCE puts an extra <br> tag at the end of a paragraph when it is edited, so ignore that case.
+        return $field.tinymce().getContent({ format: 'raw' }).replace(/<br><\/p>/mg, '</p>');
+    };
+
+    var storeOriginalValue = function ($field) {
+        var content = getTinyMceContent($field);
+        $.DirtyForms.dirtylog('Original TinyMCE content: ' + content);
+
+        var hash = getHashCode(content);
+        $.DirtyForms.dirtylog('Original TinyMCE hash: ' + hash);
+
+        $field.data('df-tinymce-orig', hash);
+    };
+
+    // When TinyMCE is found, store the original value as a hash so we can see if there are changes later.
+    var init = function ($node) {
+        if (hasTinyMCE($node)) {
+            $node.filter(tinymceSelector).add($node.find(tinymceSelector)).each(function () {
+                storeOriginalValue($(this));
+            });
+        }
+    };
+
+    $(document).bind('scan.dirtyforms', function (ev) {
+        // Hack: TinyMCE doesn't have a global init event. So, we create a new 
+        // TinyMCE editor within an invisible div and respond to its init event. 
+        // There doesn't seem to be a reasonable way
+        // to remove the control again, so we simply ignore it.
+        var $form = $(ev.target);
+        var $editor = $('<div style="display:none;" class="dirty-forms-temp"></div>');
+        $form.append($editor);
+        $editor.tinymce({
+            oninit: function () {
+                init($form);
+            }
+        });
+    });
+
+    // Simple way to hash a string: http://stackoverflow.com/questions/7616461/generate-a-hash-from-string-in-javascript-jquery
+    var getHashCode = function (str) {
+        var hash = 0, i, chr, len;
+        if (str.length === 0) return hash;
+        for (i = 0, len = str.length; i < len; i++) {
+            chr = str.charCodeAt(i);
+            hash = ((hash << 5) - hash) + chr;
+            hash |= 0; // Convert to 32bit integer
+        }
+        return hash;
+    };
+
+})(jQuery, window, document);

data/vendor/assets/javascripts/jquery.dirtyforms.js

@@ -0,0 +1,596 @@
+/*!
+Dirty Forms jQuery Plugin | v | github.com/snikch/jquery.dirtyforms
+(c) 2010-2016 Mal Curtis
+License MIT
+*/
+
+(function($, window, document, undefined) {
+    // Can't use ECMAScript 5's strict mode because several apps 
+    // including ASP.NET trace the stack via arguments.caller.callee 
+    // and Firefox dies if you try to trace through "use strict" call chains. 
+    // See jQuery issue (#13335)
+    // Support: Firefox 18+
+    //"use strict";
+
+    if (!$.fn.on) {
+        // Patch jQuery 1.4.2 - 1.7 with an on function (that uses delegate).
+        $.fn.on = function (events, selector, data, handler) {
+            return this.delegate(selector, events, data, handler);
+        };
+    }
+
+    $.fn.dirtyForms = function (method) {
+        // Method calling logic
+        if (methods[method]) {
+            return methods[method].apply(this, Array.prototype.slice.call(arguments, 1));
+        } else if (typeof method === 'object' || !method) {
+            return methods.init.apply(this, arguments);
+        } else {
+            $.error('Method ' + method + ' does not exist on jQuery.dirtyForms');
+        }
+    };
+
+    // Public Element methods ( $('form').dirtyForms('methodName', args) )
+    var methods = {
+        init: function (options) {
+            var data = {};
+
+            if (!state.initialized) {
+                // Override any default options
+                $.extend(true, $.DirtyForms, options);
+
+                $(document).trigger('bind.dirtyforms', [events]);
+                events.bind(window, document, data);
+
+                state.initialized = true;
+            }
+
+            this.filter('form').not(':dirtylistening').each(function () {
+                var $form = $(this);
+                dirtylog('Adding form ' + $form.attr('id') + ' to forms to watch');
+
+                // Store original values of the fields
+                $form.find($.DirtyForms.fieldSelector).each(function () {
+                    storeOriginalValue($(this));
+                });
+
+                $form.trigger('scan.dirtyforms');
+                events.bindForm($form, data);
+            });
+            return this;
+        },
+        // Returns true if any of the selected elements or their children are dirty
+        isDirty: function (excludeHelpers) {
+            var ignoreSelector = getIgnoreSelector(),
+                dirtyClass = $.DirtyForms.dirtyClass,
+                isDirty = false;
+
+            this.each(function (index) {
+                var $node = $(this),
+                    ignored = isFieldIgnored($node, ignoreSelector);
+
+                if ($node.hasClass(dirtyClass) && !ignored) {
+                    isDirty = true;
+                    // Exit out of the .each() function
+                    return false;
+                }
+
+                // Check any descendant nodes (if this is a container element)
+                $node.find('.' + dirtyClass).each(function () {
+                    if (!isFieldIgnored($(this), ignoreSelector)) {
+                        isDirty = true;
+                        // Exit out of the .each() function
+                        return false;
+                    }
+                });
+                // Exit out of the .each() function
+                if (isDirty) return false;
+
+                if (!ignored && !excludeHelpers) {
+                    // Test helpers for this node.
+                    $.each($.DirtyForms.helpers, function (i, helper) {
+                        if (helper.isDirty && helper.isDirty($node, index)) {
+                            isDirty = true;
+                            // Exit out of the .each() function
+                            return false;
+                        }
+                    });
+
+                    // Exit out of the .each() function
+                    if (isDirty) return false;
+                }
+            });
+
+            return isDirty;
+        },
+        // Marks the element(s) and any helpers within the element not dirty.
+        // If all of the fields in a form are marked not dirty, the form itself will be marked not dirty even
+        // if it is not included in the selector. Also resets original values to the current state - 
+        // essentially "forgetting" the node or its descendants are dirty.
+        setClean: function (excludeIgnored, excludeHelpers) {
+            dirtylog('setClean called');
+
+            var doSetClean = function () {
+                var $field = $(this);
+
+                // Reset by storing the original value again
+                storeOriginalValue($field);
+
+                // Remove the dirty class
+                setDirtyStatus($field, false);
+            };
+
+            elementsInRange(this, $.DirtyForms.fieldSelector, excludeIgnored)
+                .each(doSetClean)
+                .parents('form').trigger('setclean.dirtyforms', [excludeIgnored]);
+
+            if (excludeHelpers) return this;
+            return fireHelperMethod(this, 'setClean', excludeIgnored, getIgnoreSelector());
+        },
+        // Scans the selected elements and descendants for any new fields and stores their original values.
+        // Ignores any original values that had been set previously. Also resets the dirty status of all fields
+        // whose ignore status has changed since the last scan.
+        rescan: function (excludeIgnored, excludeHelpers) {
+            dirtylog('rescan called');
+
+            var doRescan = function () {
+                var $field = $(this);
+
+                // Skip previously added fields
+                if (!hasOriginalValue($field)) {
+                    // Store the original value
+                    storeOriginalValue($field);
+                }
+
+                // Set the dirty status
+                setDirtyStatus($field, isFieldDirty($field));
+            };
+
+            elementsInRange(this, $.DirtyForms.fieldSelector, excludeIgnored)
+                .each(doRescan)
+                .parents('form').trigger('rescan.dirtyforms', [excludeIgnored]);
+
+            if (excludeHelpers) return this;
+            return fireHelperMethod(this, 'rescan', excludeIgnored, getIgnoreSelector());
+        }
+    };
+
+    // Custom selectors $('form:dirty')
+    $.extend($.expr[":"], {
+        dirty: function (element) {
+            var $element = $(element);
+            return $element.hasClass($.DirtyForms.dirtyClass) && !$element.is(':dirtyignored');
+        },
+        dirtylistening: function (element) {
+            return $(element).hasClass($.DirtyForms.listeningClass);
+        },
+        dirtyignored: function (element) {
+            return isFieldIgnored($(element), false);
+        }
+    });
+
+    // Public General Plugin properties and methods $.DirtyForms
+    $.DirtyForms = {
+        message: "You've made changes on this page which aren't saved. If you leave you will lose these changes.",
+        dirtyClass: 'dirty',
+        listeningClass: 'dirtylisten',
+        ignoreClass: 'dirtyignore',
+        ignoreSelector: '',
+        // exclude all HTML 4 except checkbox, option, text and password, but include HTML 5 except search
+        fieldSelector: "input:not([type='button'],[type='image'],[type='submit']," +
+            "[type='reset'],[type='file'],[type='search']),select,textarea",
+        /*<log>*/
+        debug: false,
+        dirtylog: function (msg) {
+            dirtylog(msg);
+        },
+        /*</log>*/
+        helpers: [],
+        dialog: false
+    };
+
+    // Private State Management
+    var state = {
+        initialized: false,
+        formStash: false,
+        dialogStash: false,
+        deciding: false,
+        decidingEvent: false
+    };
+
+    // Dialog Decision Management
+    var choice;
+
+    var bindKeys = function (ev) {
+        if (ev.data.bindEscKey && ev.which == 27 || ev.data.bindEnterKey && ev.which == 13) {
+            return doCommit(ev, false);
+        }
+    };
+
+    var bindDialog = function (choice) {
+        var staySelector = choice.staySelector,
+            proceedSelector = choice.proceedSelector;
+
+        if (staySelector !== '') {
+            $(staySelector).unbind('click', doCommit)
+                             .click(doCommit);
+        }
+        if (proceedSelector !== '') {
+            $(proceedSelector).unbind('click', doProceed)
+                               .click(doProceed);
+        }
+        if (choice.bindEscKey || choice.bindEnterKey) {
+            $(document).unbind('keydown', bindKeys)
+                       .keydown(choice, bindKeys);
+        }
+    };
+
+    var callDialogClose = function (proceeding, unstashing) {
+        if ($.isFunction($.DirtyForms.dialog.close)) {
+            dirtylog('Calling dialog close');
+            $.DirtyForms.dialog.close(proceeding, unstashing);
+        }
+    };
+
+    var doProceed = function (ev) {
+        return doCommit(ev, true);
+    };
+
+    var doCommit = function (ev, proceeding) {
+        if (!state.deciding) return;
+        ev.preventDefault();
+
+        if (proceeding === true) {
+            var refireEvent = state.decidingEvent;
+            $(document).trigger('proceed.dirtyforms', [refireEvent]);
+            events.clearUnload(); // fix for chrome/safari
+            callDialogClose(proceeding, false);
+            refire(refireEvent);
+        } else {
+            $(document).trigger('stay.dirtyforms');
+            var isUnstashing = $.DirtyForms.dialog !== false && state.dialogStash !== false && $.isFunction($.DirtyForms.dialog.unstash);
+            callDialogClose(proceeding, isUnstashing);
+            if (isUnstashing) {
+                dirtylog('Refiring the dialog with stashed content');
+                $.DirtyForms.dialog.unstash(state.dialogStash, ev);
+            }
+            $(document).trigger('afterstay.dirtyforms');
+        }
+
+        state.deciding = state.decidingEvent = state.dialogStash = state.formStash = false;
+        return false;
+    };
+
+    // Event management
+    var events = {
+        bind: function (window, document, data) {
+            $(window).bind('beforeunload', data, events.onBeforeUnload);
+            $(document).on('click', 'a:not([target="_blank"])', data, events.onAnchorClick)
+                       .on('submit', 'form', data, events.onSubmit);
+        },
+        bindForm: function ($form, data) {
+            var dirtyForms = $.DirtyForms;
+
+            // Test whether we are dealing with IE < 10
+            var isIE8_9 = ('onpropertychange' in document.createElement('input'));
+            var inputEvents = 'change input' + (isIE8_9 ? ' keyup selectionchange cut paste' : '');
+            $form.addClass(dirtyForms.listeningClass)
+                 .on('focus keydown', dirtyForms.fieldSelector, data, events.onFocus)
+                 .on(inputEvents, dirtyForms.fieldSelector, data, events.onFieldChange)
+                 .bind('reset', data, events.onReset);
+        },
+        // For any fields added after the form was initialized, store the value when focused.
+        onFocus: function (ev) {
+            var $field = $(ev.target);
+            if (!hasOriginalValue($field)) {
+                storeOriginalValue($field);
+            }
+        },
+        onFieldChange: function (ev) {
+            var $field = $(ev.target);
+            if (ev.type !== 'change') {
+                delay(function () { setFieldStatus($field); }, 100);
+            } else {
+                setFieldStatus($field);
+            }
+        },
+        onReset: function (ev) {
+            var $form = $(ev.target).closest('form');
+            // Need a delay here because reset is called before the state of the form is reset.
+            setTimeout(function () { $form.dirtyForms('setClean'); }, 100);
+        },
+        onAnchorClick: function (ev) {
+            bindFn(ev);
+        },
+        onSubmit: function (ev) {
+            bindFn(ev);
+        },
+        onBeforeUnload: function (ev) {
+            var result = bindFn(ev);
+
+            if (result && state.doubleunloadfix !== true) {
+                dirtylog('Before unload will be called, resetting');
+                state.deciding = false;
+            }
+
+            state.doubleunloadfix = true;
+            setTimeout(function () { state.doubleunloadfix = false; }, 200);
+
+            // Only return the result if it is a string, otherwise don't return anything.
+            if (typeof result === 'string') {
+                // For IE and Firefox prior to version 4, set the returnValue.
+                ev.returnValue = result;
+                return result;
+            }
+        },
+        onRefireClick: function (ev) {
+            var event = new $.Event('click');
+            $(ev.target).trigger(event);
+            if (!event.isDefaultPrevented()) {
+                events.onRefireAnchorClick(ev);
+            }
+        },
+        onRefireAnchorClick: function (ev) {
+            var href = $(ev.target).closest('a[href]').attr('href');
+            if (href !== undefined) {
+                dirtylog('Sending location to ' + href);
+                window.location.href = href;
+            }
+        },
+        clearUnload: function () {
+            // I'd like to just be able to unbind this but there seems
+            // to be a bug in jQuery which doesn't unbind onbeforeunload
+            dirtylog('Clearing the beforeunload event');
+            $(window).unbind('beforeunload', events.onBeforeUnload);
+            window.onbeforeunload = null;
+            $(document).trigger('beforeunload.dirtyforms');
+        }
+    };
+
+    var elementsInRange = function ($this, selector, excludeIgnored) {
+        var $elements = $this.filter(selector).add($this.find(selector));
+        if (excludeIgnored) {
+            $elements = $elements.not(':dirtyignored');
+        }
+        return $elements;
+    };
+
+    var fireHelperMethod = function ($this, method, excludeIgnored, ignoreSelector) {
+        return $this.each(function (index) {
+            var $node = $(this);
+
+            if (!excludeIgnored || !isFieldIgnored($node, ignoreSelector)) {
+                $.each($.DirtyForms.helpers, function (i, helper) {
+                    if (helper[method]) { helper[method]($node, index, excludeIgnored); }
+                });
+            }
+        });
+    };
+
+    var getFieldValue = function ($field) {
+        var value;
+        if ($field.is('select')) {
+            value = '';
+            $field.find('option').each(function () {
+                var $option = $(this);
+                if ($option.is(':selected')) {
+                    if (value.length > 0) { value += ','; }
+                    value += $option.val();
+                }
+            });
+        } else if ($field.is(":checkbox,:radio")) {
+            value = $field.is(':checked');
+        } else {
+            value = $field.val();
+        }
+
+        return value;
+    };
+
+    var storeOriginalValue = function ($field) {
+        dirtylog('Storing original value for ' + $field.attr('name'));
+        $field.data('df-orig', getFieldValue($field));
+        var isEmpty = ($field.data('df-orig') === undefined);
+        $field.data('df-empty', isEmpty);
+    };
+
+    var hasOriginalValue = function ($field) {
+        return ($field.data('df-orig') !== undefined || $field.data('df-empty') === true);
+    };
+
+    var getIgnoreSelector = function () {
+        var dirtyForms = $.DirtyForms,
+            result = dirtyForms.ignoreSelector;
+        $.each(dirtyForms.helpers, function (key, obj) {
+            if ('ignoreSelector' in obj) {
+                if (result.length > 0) { result += ','; }
+                result += obj.ignoreSelector;
+            }
+        });
+        return result;
+    };
+
+    var isFieldIgnored = function ($field, ignoreSelector) {
+        if (!ignoreSelector) {
+            ignoreSelector = getIgnoreSelector();
+        }
+        return $field.is(ignoreSelector) || $field.closest('.' + $.DirtyForms.ignoreClass).length > 0;
+    };
+
+    var isFieldDirty = function ($field, ignoreSelector) {
+        if (!hasOriginalValue($field) || isFieldIgnored($field, ignoreSelector)) return false;
+        return (getFieldValue($field) != $field.data('df-orig'));
+    };
+
+    var setFieldStatus = function ($field, ignoreSelector) {
+        if (isFieldIgnored($field, ignoreSelector)) return;
+
+        // Option groups are a special case because they change more than the current element.
+        if ($field.is(':radio[name]')) {
+            var name = $field.attr('name'),
+                $form = $field.parents('form');
+
+            $form.find(":radio[name='" + name + "']").each(function () {
+                var $radio = $(this);
+                setDirtyStatus($radio, isFieldDirty($radio, ignoreSelector));
+            });
+        } else {
+            setDirtyStatus($field, isFieldDirty($field, ignoreSelector));
+        }
+    };
+
+    var setDirtyStatus = function ($field, isDirty) {
+        dirtylog('Setting dirty status to ' + isDirty + ' on field ' + $field.attr('id'));
+        var dirtyClass = $.DirtyForms.dirtyClass,
+            $form = $field.parents('form');
+
+        // Mark the field dirty/clean
+        $field.toggleClass(dirtyClass, isDirty);
+        var changed = (isDirty !== ($form.hasClass(dirtyClass) && $form.find(':dirty').length === 0));
+
+        if (changed) {
+            dirtylog('Setting dirty status to ' + isDirty + ' on form ' + $form.attr('id'));
+            $form.toggleClass(dirtyClass, isDirty);
+
+            if (isDirty) $form.trigger('dirty.dirtyforms');
+            if (!isDirty) $form.trigger('clean.dirtyforms');
+        }
+    };
+
+    // A delay to keep the key events from slowing down when changing the dirty status on the fly.
+    var delay = (function () {
+        var timer = 0;
+        return function (callback, ms) {
+            clearTimeout(timer);
+            timer = setTimeout(callback, ms);
+        };
+    })();
+
+    var bindFn = function (ev) {
+        var $element = $(ev.target),
+            eventType = ev.type,
+            dirtyForms = $.DirtyForms;
+        dirtylog('Entering: Leaving Event fired, type: ' + eventType + ', element: ' + ev.target + ', class: ' + $element.attr('class') + ' and id: ' + ev.target.id);
+
+        // Important: Do this check before calling events.clearUnload()
+        if (ev.isDefaultPrevented()) {
+            dirtylog('Leaving: Event has been stopped elsewhere');
+            return false;
+        }
+
+        if (eventType == 'beforeunload' && state.doubleunloadfix) {
+            dirtylog('Skip this unload, Firefox bug triggers the unload event multiple times');
+            state.doubleunloadfix = false;
+            return false;
+        }
+
+        if ($element.is(':dirtyignored')) {
+            dirtylog('Leaving: Element has ignore class or a descendant of an ignored element');
+            events.clearUnload();
+            return false;
+        }
+
+        if (state.deciding) {
+            dirtylog('Leaving: Already in the deciding process');
+            return false;
+        }
+
+        if (!$('form:dirtylistening').dirtyForms('isDirty')) {
+            dirtylog('Leaving: Not dirty');
+            events.clearUnload();
+            return false;
+        }
+
+        if (eventType == 'submit' && $element.dirtyForms('isDirty')) {
+            dirtylog('Leaving: Form submitted is a dirty form');
+            events.clearUnload();
+            return true;
+        }
+
+        // Callback for page access in current state
+        $(document).trigger('defer.dirtyforms');
+
+        if (eventType == 'beforeunload') {
+            dirtylog('Returning to beforeunload browser handler with: ' + dirtyForms.message);
+            return dirtyForms.message;
+        }
+        if (!dirtyForms.dialog) return;
+
+        // Using the GUI dialog...
+        ev.preventDefault();
+        ev.stopImmediatePropagation();
+
+        dirtylog('Setting deciding active');
+        state.deciding = true;
+        state.decidingEvent = ev;
+
+        // Stash the dialog (with a form). This is done so it can be shown again via unstash().
+        if ($.isFunction(dirtyForms.dialog.stash)) {
+            dirtylog('Stashing dialog content');
+            state.dialogStash = dirtyForms.dialog.stash();
+            dirtylog('Dialog Stash: ' + state.dialogStash);
+        }
+
+        // Stash the form from the dialog. This is done so we can fire events on it if the user makes a proceed choice.
+        var stashSelector = dirtyForms.dialog.stashSelector;
+        if (typeof stashSelector === 'string' && $element.is('form') && $element.parents(stashSelector).length > 0) {
+            dirtylog('Stashing form');
+            state.formStash = $element.clone(true).hide();
+        } else {
+            state.formStash = false;
+        }
+
+        dirtylog('Deferring to the dialog');
+
+        // Create a new choice object
+        choice = {
+            proceed: false,
+            commit: function (ev) {
+                return doCommit(ev, choice.proceed);
+            },
+            bindEscKey: true,
+            bindEnterKey: false,
+            proceedSelector: '',
+            staySelector: ''
+        };
+
+        dirtyForms.dialog.open(choice, dirtyForms.message, dirtyForms.ignoreClass);
+        bindDialog(choice);
+    };
+
+    var refire = function (ev) {
+        if (ev.type === 'click') {
+            dirtylog("Refiring click event");
+            events.onRefireClick(ev);
+        } else {
+            dirtylog("Refiring " + ev.type + " event on " + ev.target);
+            var target;
+            if (state.formStash) {
+                dirtylog('Appending stashed form to body');
+                target = state.formStash;
+                $('body').append(target);
+            }
+            else {
+                target = $(ev.target).closest('form');
+            }
+            target.trigger(ev.type);
+        }
+    };
+
+    /*<log>*/
+    var dirtylog = function (msg) {
+        if (!$.DirtyForms.debug) return;
+        var hasFirebug = 'console' in window && 'firebug' in window.console,
+            hasConsoleLog = 'console' in window && 'log' in window.console;
+        msg = '[DirtyForms] ' + msg;
+        if (hasFirebug) {
+            console.log(msg);
+        } else if (hasConsoleLog) {
+            window.console.log(msg);
+        } else {
+            alert(msg);
+        }
+    };
+    /*</log>*/
+
+})(jQuery, window, document);