first

plugins/bootstrap-maxlength/1.5.5/bootstrap-maxlength.js

@@ -0,0 +1,404 @@
+(function ($) {
+
+  'use strict';
+
+  /**
+
+   * We need an event when the elements are destroyed
+
+   * because if an input is remvoed, we have to remove the
+
+   * maxlength object associated (if any).
+
+   * From:
+
+   * http://stackoverflow.com/questions/2200494/jquery-trigger-event-when-an-element-is-removed-from-the-dom
+
+   */
+
+  if (!$.event.special.destroyed) {
+
+    $.event.special.destroyed = {
+
+      remove: function (o) {
+
+        if (o.handler) {
+
+          o.handler();
+
+        }
+
+      }
+
+    };
+
+  }
+
+
+
+
+
+  $.fn.extend({
+
+    maxlength: function (options, callback) {
+
+
+
+      var documentBody = $('body'),
+
+          defaults = {
+
+            showOnReady: false, // true to always show when indicator is ready
+
+            alwaysShow: false, // if true the indicator it's always shown.
+
+            threshold: 10, // Represents how many chars left are needed to show up the counter
+
+            warningClass: 'label label-success',
+
+            limitReachedClass: 'label label-important label-danger',
+
+            separator: ' / ',
+
+            preText: '',
+
+            postText: '',
+
+            showMaxLength : true,
+
+            placement: 'bottom',
+
+            showCharsTyped: true, // show the number of characters typed and not the number of characters remaining
+
+            validate: false, // if the browser doesn't support the maxlength attribute, attempt to type more than
+
+                                                                // the indicated chars, will be prevented.
+
+            utf8: false, // counts using bytesize rather than length.  eg: '£' is counted as 2 characters.
+
+
+
+            appendToParent: false // append the indicator to the input field's parent instead of body
+
+          };
+
+
+
+      if ($.isFunction(options) && !callback) {
+
+        callback = options;
+
+        options = {};
+
+      }
+
+      options = $.extend(defaults, options);
+
+
+
+      /**
+
+      * Return the length of the specified input.
+
+      *
+
+      * @param input
+
+      * @return {number}
+
+      */
+
+      function inputLength(input) {
+
+        var text = input.val();
+
+
+
+        // Remove all double-character (\r\n) linebreaks, so they're counted only once.
+
+        text = text.replace(new RegExp('\r?\n','g'), '\n');
+
+        // var matches = text.match(/\n/g);
+
+
+
+        var currentLength = 0;
+
+
+
+        if (options.utf8) {
+
+          currentLength = utf8Length(input.val());
+
+        } else {
+
+          currentLength = input.val().length;
+
+        }
+
+        return currentLength;
+
+      }
+
+
+
+      /**
+
+      * Truncate the text of the specified input.
+
+      *
+
+      * @param input
+
+      * @param limit
+
+      */
+
+      function truncateChars(input, maxlength) {
+
+        var text = input.val();
+
+        input.val(text.substr(0, maxlength));
+
+      }
+
+
+
+      /**
+
+      * Return the length of the specified input in UTF8 encoding.
+
+      *
+
+      * @param input
+
+      * @return {number}
+
+      */
+
+      function utf8Length(string) {
+
+        var utf8length = 0;
+
+        for (var n = 0; n < string.length; n++) {
+
+          var c = string.charCodeAt(n);
+
+          if (c < 128) {
+
+            utf8length++;
+
+          }
+
+          else if ((c > 127) && (c < 2048)) {
+
+            utf8length = utf8length + 2;
+
+          }
+
+          else {
+
+            utf8length = utf8length + 3;
+
+          }
+
+        }
+
+        return utf8length;
+
+      }
+
+
+
+      /**
+
+       * Return true if the indicator should be showing up.
+
+       *
+
+       * @param input
+
+       * @param thereshold
+
+       * @param maxlength
+
+       * @return {number}
+
+       */
+
+      function charsLeftThreshold(input, thereshold, maxlength) {
+
+        var output = true;
+
+        if (!options.alwaysShow && (maxlength - inputLength(input) > thereshold)) {
+
+          output = false;
+
+        }
+
+        return output;
+
+      }
+
+
+
+      /**
+
+       * Returns how many chars are left to complete the fill up of the form.
+
+       *
+
+       * @param input
+
+       * @param maxlength
+
+       * @return {number}
+
+       */
+
+      function remainingChars(input, maxlength) {
+
+        var length = maxlength - inputLength(input);
+
+        return length;
+
+      }
+
+
+
+      /**
+
+       * When called displays the indicator.
+
+       *
+
+       * @param indicator
+
+       */
+
+      function showRemaining(indicator) {
+
+        indicator.css({
+
+          display: 'block'
+
+        });
+
+      }
+
+
+
+      /**
+
+       * When called shows the indicator.
+
+       *
+
+       * @param indicator
+
+       */
+
+      function hideRemaining(indicator) {
+
+        indicator.css({
+
+          display: 'none'
+
+        });
+
+      }
+
+
+
+       /**
+
+       * This function updates the value in the indicator
+
+       *
+
+       * @param maxLengthThisInput
+
+       * @param typedChars
+
+       * @return String
+
+       */
+
+      function updateMaxLengthHTML(maxLengthThisInput, typedChars) {
+
+        var output = '';
+
+        if (options.message){
+
+          output = options.message.replace('%charsTyped%', typedChars)
+
+                  .replace('%charsRemaining%', maxLengthThisInput - typedChars)
+
+                  .replace('%charsTotal%', maxLengthThisInput);
+
+        } else {
+
+          if (options.preText) {
+
+            output += options.preText;
+
+          }
+
+          if (!options.showCharsTyped) {
+
+            output += maxLengthThisInput - typedChars;
+
+          }
+
+          else {
+
+            output += typedChars;
+
+          }
+
+          if (options.showMaxLength) {
+
+            output += options.separator + maxLengthThisInput;
+
+          }
+
+          if (options.postText) {
+
+            output += options.postText;
+
+          }
+
+        }
+
+        return output;
+
+      }
+
+
+
+      /**
+
+       * This function updates the value of the counter in the indicator.
+
+       * Wants as parameters: the number of remaining chars, the element currently managed,
+
+       * the maxLength for the current input and the indicator generated for it.
+
+       *
+
+       * @param remaining
+
+       * @param currentInput
+
+       * @param maxLengthCurrentInput
+
+       * @param maxLengthIndicator
+
+       */
+
+      function manageRemainingVisibility(remaining, currentInput, maxLengthCurrentInput, maxLengthIndicator) {
+
+        maxLengthIndicator.html(updateMaxLengthHTML(maxLengthCurrentInput, (maxLengthCurrentInput - remaining)));
+
+
+

plugins/bootstrap-maxlength/1.5.5/bootstrap-maxlength.min.js

@@ -0,0 +1,10 @@
+/* ========================================================== 
+
+ * 
+
+ * bootstrap-maxlength.js v 1.5.5 
+
+ * Copyright 2014 Maurizio Napoleoni @mimonap
+
+ * Licensed under MIT License
+