tribeca_cms 0.1.1

data/vendor/assets/javascripts/locomotive/liquid_mode.js

@@ -0,0 +1,42 @@
+/*
+  This overlay provides a 'liquid' mode to the excellent CodeMirror editor (http://codemirror.net/).
+  Add something like this to your CSS:
+
+    .cm-liquid-tag {
+      color: #32273f;
+      background: #ead9ff;
+    }
+
+    .cm-liquid-variable {
+      color: #29739b
+      background: #c2e0f0;
+    }
+
+  https://gist.github.com/1356686
+*/
+
+CodeMirror.defineMode("liquid", function(config, parserConfig) {
+  var liquidOverlay = {
+    token: function(stream, state) {
+
+      // Variables.
+      if (stream.match("{{")) {
+        while ((ch = stream.next()) != null)
+          if (ch == "}" && stream.next() == "}") break;
+        return "liquid-variable";
+      }
+
+      // Tags.
+      if(stream.match("{%")) {
+        while ((ch = stream.next()) != null)
+          if (ch == "%" && stream.next() == "}") break;
+        return "liquid-tag";
+      }
+
+      while (stream.next() != null && !stream.match("{{", false) && !stream.match("{%", false)) {}
+      return null;
+    }
+  };
+
+  return CodeMirror.overlayParser(CodeMirror.getMode(config, parserConfig.backdrop || "text/html"), liquidOverlay);
+});

data/vendor/assets/javascripts/locomotive/menu_toggler.js

@@ -0,0 +1,37 @@
+/**
+ * Version 1.0.1
+ * Init and deploy childs on menu (admin)
+ * Benjamin Athlan - Bewcultures
+ * Andrew Bennett - Delorum
+ * Didier Lafforgue - NoCoffee
+ */
+$.fn.toggleMe = function(settings) {
+
+  settings = $.extend({}, settings);
+
+  var toggle = function(event) {
+    var toggler     = $(this);
+    var children    = toggler.parent().find('> ul.folder');
+    var openClass   = toggler.data('open')
+    var closedClass = toggler.data('closed')
+
+    children.each(function() {
+      var child = $(this);
+
+      if (child.is(':visible')) {
+        child.slideUp('fast', function() {
+          toggler.removeClass(openClass).addClass(closedClass)
+          $.cookie(child.attr('id'), 'none');
+        });
+      } else {
+        child.slideDown('fast', function() {
+          toggler.removeClass(closedClass).addClass(openClass)
+          $.cookie(child.attr('id'), 'block');
+        });
+      }
+    });
+  };
+
+  return $(this).bind('click', toggle);
+
+};

data/vendor/assets/javascripts/locomotive/resize.js

@@ -0,0 +1,9 @@
+/*
+ * jQuery resize event - v1.1 - 3/14/2010
+ * http://benalman.com/projects/jquery-resize-plugin/
+ *
+ * Copyright (c) 2010 "Cowboy" Ben Alman
+ * Dual licensed under the MIT and GPL licenses.
+ * http://benalman.com/about/license/
+ */
+(function($,h,c){var a=$([]),e=$.resize=$.extend($.resize,{}),i,k="setTimeout",j="resize",d=j+"-special-event",b="delay",f="throttleWindow";e[b]=250;e[f]=true;$.event.special[j]={setup:function(){if(!e[f]&&this[k]){return false}var l=$(this);a=a.add(l);$.data(this,d,{w:l.width(),h:l.height()});if(a.length===1){g()}},teardown:function(){if(!e[f]&&this[k]){return false}var l=$(this);a=a.not(l);l.removeData(d);if(!a.length){clearTimeout(i)}},add:function(l){if(!e[f]&&this[k]){return false}var n;function m(s,o,p){var q=$(this),r=$.data(this,d);r.w=o!==c?o:q.width();r.h=p!==c?p:q.height();n.apply(this,arguments)}if($.isFunction(l)){n=l;return m}else{n=l.handler;l.handler=m}}};function g(){i=h[k](function(){a.each(function(){var n=$(this),m=n.width(),l=n.height(),o=$.data(this,d);if(m!==o.w||l!==o.h){n.trigger(j,[o.w=m,o.h=l])}});g()},e[b])}})(jQuery,this);

data/vendor/assets/javascripts/locomotive/slugify.js

@@ -0,0 +1,31 @@
+/**
+ * Version 0.0.1
+ * Fill in an input field from another one (source)
+ * and apply a filter on the string (slugify)
+ * Didier Lafforgue
+ */
+$.fn.slugify = function(settings) {
+
+  settings = $.extend({
+    sep: '-'
+  }, settings);
+
+  var target = $(settings.target);
+  target.data('touched', (target.val() != ''));
+
+  var makeSlug = function(event) {
+    var source = $(this);
+    var newVal = source.val().slugify(settings.sep);
+
+    if (!target.data('touched')) {
+      target.val(newVal);
+      target.trigger('change');
+    }
+  }
+
+  target.bind('keyup', function(event) {
+    $(this).data('touched', ($(this).val() != ''));
+  });
+
+  return $(this).bind('keyup', makeSlug);
+};

data/vendor/assets/javascripts/locomotive/smartupdater.js

@@ -0,0 +1,296 @@
+/**
+* smartupdater - jQuery Plugin
+*
+* Version - 4.0.beta
+* Copyright (c) 2010 - 2011 Vadim Kiryukhin
+* vkiryukhin @ gmail.com
+*
+* http://www.eslinstructor.net/smartupdater/
+*
+* Dual licensed under the MIT and GPL licenses:
+*   http://www.opensource.org/licenses/mit-license.php
+*   http://www.gnu.org/licenses/gpl.html
+*
+* USAGE:
+*
+* $("#myObject").smartupdater({
+*     url : "foo.php"
+*     }, function (data) {
+*       //process data here;
+*     }
+*   );
+*
+* Public functions:
+*   $("#myObject").smartupdater("stop")
+*   $("#myObject").smartupdater("restart");
+*   $("#myObject").smartupdater("setTimeout",timeout);
+*   $("#myObject").smartupdater("alterUrl"[,"foo.php"[,data]]);
+*   $("#myObject").smartupdater("alterCallback"[, foo]);
+*
+* Public Attributes:
+*   var status  = $("#myObject").smartupdater("getState");
+*   var timeout = $("#myObject").smartupdater("getTimeout");
+*
+**/
+
+(function($) {
+
+
+    var methods = {
+
+      init : function( options, callback) {
+        return this.each(function () {
+          var elem = this,
+          es = {};
+
+          elem.settings = jQuery.extend(true,{
+            url         : '',   // see jQuery.ajax for details
+            type        : 'get',  // see jQuery.ajax for details
+            data        : '',     // see jQuery.ajax for details
+            dataType      : 'text',   // see jQuery.ajax for details
+
+            minTimeout      : 60000,  // 1 minute
+            maxFailedRequests   : 10,     // max. number of consecutive ajax failures
+            maxFailedRequestsCb : false,  // falure callback function
+            httpCache       : false,  // http cache
+            rCallback     : false,  // remote callback functions
+            selfStart     : true,   // start automatically after initializing
+            smartStop     : { active:     false,  //disabled by default
+                        monitorTimeout: 2500,   // 2.5 seconds
+                        minHeight:    1,      // 1px
+                        minWidth:   1     // 1px
+                        }
+
+          }, options);
+
+          elem.smartupdaterStatus = {state:'',timeout:0};
+
+          es = elem.settings;
+
+          es.prevContent    = '';
+          es.failedRequests = 0;
+          es.etag       = '0';
+          es.lastModified   = '0';
+          es.callback     = callback;
+          es.origReq = {url:es.url,data:es.data,callback:callback};
+          es.stopFlag = false;
+
+
+          function start() {
+
+          /* check if element has been deleted and clean it up  */
+            if(!$(elem).parents('body').length) {
+                clearInterval(elem.smartupdaterStatus.smartStop);
+                clearTimeout(elem.settings.h);
+                elem = {};
+                return;
+            }
+
+            $.ajax({
+              url   : es.url,
+              type  : es.type,
+              data  : es.data,
+              dataType: es.dataType,
+              cache : false, // MUST be set to false to prevent IE caching issue.
+
+              success: function (data, statusText, xhr) {
+
+                var dataNotModified = false,
+                  rCallback = false,
+                  xSmart = jQuery.parseJSON(xhr.getResponseHeader("X-Smartupdater")),
+                  xhrEtag, xhrLM;
+
+                if(xSmart) { // remote control
+
+                  /* remote timeout */
+                  es.minTimeout = xSmart.timeout ? xSmart.timeout : es.minTimeout;
+
+                  /* remote callback */
+                  rCallback = xSmart.callback ? xSmart.callback : false;
+                }
+
+                if(es.httpCache) { // http cache process here
+
+                  xhrEtag = xhr.getResponseHeader("ETag");
+                  xhrLM = xhr.getResponseHeader("Last-Modified");
+
+                  dataNotModified = (es.etag ==  xhrEtag || es.lastModified == xhrLM) ? true : false;
+                  es.etag     =  xhrEtag ? xhrEtag : es.etag;
+                  es.lastModified =  xhrLM   ? xhrLM   : es.lastModified;
+                }
+
+                if (  dataNotModified ||
+                    es.prevContent == xhr.responseText ||
+                    xhr.status == 304 ) { // data is not changed
+
+                    if(!es.stopFlag) {
+                      clearTimeout(es.h);
+                      es.h = setTimeout(start, es.minTimeout);
+                    }
+
+                } else { // data is changed
+
+                /* cache response data */
+                  es.prevContent = xhr.responseText;
+
+                /* reset timeout */
+                  if(!es.stopFlag) {
+                    clearTimeout(es.h);
+                    es.h = setTimeout(start, es.minTimeout);
+                  }
+
+                /* run callback function */
+                  if(es.rCallback && rCallback && es.rCallback.search(rCallback) != -1) {
+                    window[rCallback](data);
+                  } else  {
+                    es.callback(data);
+                  }
+                }
+
+                elem.smartupdaterStatus.timeout = es.minTimeout;
+                es.failedRequests = 0;
+              },
+
+              error: function(xhr, textStatus, errorThrown) {
+                if ( ++es.failedRequests < es.maxFailedRequests ) {
+
+                /* increment falure counter and reset timeout */
+                  if(!es.stopFlag) {
+                    clearTimeout(es.h);
+                    es.h = setTimeout(start, es.minTimeout);
+                    elem.smartupdaterStatus.timeout = es.minTimeout;
+                  }
+
+                } else {
+
+                /* stop smartupdater */
+                  clearTimeout(es.h);
+                  elem.smartupdaterStatus.state = 'OFF';
+                  if( typeof(es.maxFailedRequestsCb)==='function') {
+                    es.maxFailedRequestsCb(xhr, textStatus, errorThrown);
+                  }
+                }
+              },
+
+              beforeSend: function(xhr, settings) {
+
+                if(es.httpCache) {
+
+                /* set http cache-related headers */
+                  xhr.setRequestHeader("If-None-Match", es.etag );
+                  xhr.setRequestHeader("If-Modified-Since", es.lastModified );
+                }
+
+              /* Feedback: Smartupdater sends it's current timeout to server */
+                xhr.setRequestHeader("X-Smartupdater", '{"timeout":"'+elem.smartupdaterStatus.timeout+'"}');
+              }
+            });
+
+            elem.smartupdaterStatus.state = 'ON';
+          }
+
+          es.fnStart = start;
+
+          if(es.selfStart) {
+            start();
+          }
+
+          if(es.smartStop.active) {
+
+            elem.smartupdaterStatus.smartStop = setInterval(function(){
+
+              // check if object has been deleted
+              if(!$(elem).parents('body').length) {
+                clearInterval(elem.smartupdaterStatus.smartStop);
+                clearTimeout(elem.settings.h);
+                elem = {};
+                return;
+              }
+
+              var $elem = $(elem);
+              var width =  $elem.width(),
+                height = $elem.height(),
+                hidden = $elem.is(":hidden");
+
+              //element has been expanded, so smartupdater should be re-started.
+              if(!hidden && height > es.smartStop.minHeight && width > es.smartStop.minWidth
+                 && elem.smartupdaterStatus.state=="OFF") {
+                $elem.smartupdater("restart");
+              } else
+              //element has been minimized, so smartupdater should be stopped.
+              if( (hidden || height <= es.smartStop.minHeight || width <= es.smartStop.minWidth)
+                  && elem.smartupdaterStatus.state=="ON") {
+                $elem.smartupdater("stop");
+
+              }
+
+            },es.smartStop.monitorTimeout);
+          }
+
+        });
+
+      },// init()
+
+      stop : function () {
+        return this.each(function () {
+          this.settings.stopFlag = true;
+          clearTimeout(this.settings.h);
+          this.smartupdaterStatus.state = 'OFF';
+        });
+      },
+
+      restart : function () {
+        return this.each(function () {
+          this.settings.stopFlag = false;
+          clearTimeout(this.settings.h);
+          this.settings.failedRequests = 0;
+          this.settings.etag = "0";
+          this.settings.lastModified = "0";
+          this.settings.fnStart();
+        })
+      },
+
+      setTimeout : function (period) {
+        return this.each(function () {
+          clearTimeout(this.settings.h);
+          this.settings.minTimeout = period;
+          this.settings.fnStart();
+        });
+      },
+
+      alterCallback : function (callback) {
+        return this.each(function () {
+          this.settings.callback  = callback  ? callback  : this.settings.origReq.callback;
+        });
+      },
+
+      alterUrl : function (url,data) {
+        return this.each(function () {
+          this.settings.url   = url   ? url : this.settings.origReq.url;
+          this.settings.data  = data  ? data : this.settings.origReq.data;
+        });
+      },
+
+      getTimeout : function () {
+        return this[0].smartupdaterStatus.timeout;
+      },
+
+      getState : function () {
+        return this[0].smartupdaterStatus.state;
+      }
+
+    }; //methods
+
+  jQuery.fn.smartupdater = function (options, callback) {
+
+    if ( methods[options] ) {
+      return methods[ options ].apply( this, Array.prototype.slice.call( arguments, 1 ));
+    } else if ( typeof options === 'object' || ! method ) {
+      return methods.init.apply( this, arguments );
+    } else {
+      $.error( 'Method ' +  options + ' does not exist on jQuery.tooltip' );
+    }
+  };
+
+
+})(jQuery);

data/vendor/assets/javascripts/locomotive/subscribe.js

@@ -0,0 +1,367 @@
+/*
+ * jquery.subscribe.1.1
+ *
+ * Implementation of publish/subcription framework for jQuery
+ * Requires use of jQuery. Tested with jQuery 1.3 and above
+ *
+ *
+ * Copyright (c) 2008 Eric Chijioke (obinna a-t g mail dot c o m)
+ *
+ *
+ * Dual licensed under the MIT and GPL licenses:
+ *   http://www.opensource.org/licenses/mit-license.php
+ *   http://www.gnu.org/licenses/gpl.html
+ *
+ *  Release Notes:
+ *
+ *  version 1.1:
+ *
+ *  Fixed unexpected behavior which can occur when a script in a embedded page (page loaded in div,tab etc.) subscribes a handler for a topic using
+ *  the jQuery subscribe ($.subscribe) or a no-id element but this subscribe plugin is not reloaded within that embedded page (for example, when
+ *  script is included in containing page) . In this case, if the embedded page is reloaded without reloading the entire page (and plugin), the
+ *  subscription could be made multiple times for the topic, which will call the handler multiple times each time the topic is published.
+ *  Code has been added to prevent this when the subscription is made using the non-element subscribe ($.subscribe()), which assures that only one
+ *  subscription is made for a topic for a given window/frame. To prevent this from happening for an element subscription ($elem.subscribe()), make
+ *  sure that the element has an id attribute.
+ */
+
+
+(function($){
+
+  _subscribe_topics = {};
+  _subscribe_handlers = {};
+
+  _subscribe_getDocumentWindow = function(document){
+
+    return document.parentWindow || document.defaultView;
+  };
+
+  $.fn.extend({
+
+    /**
+     * Creates a new topic without any subscribers.
+     * Not usually used explicitly
+     */
+    createTopic :  function(topic) {
+      if(topic && !_subscribe_topics[topic]) {
+
+        _subscribe_topics[topic] = {};
+        _subscribe_topics[topic].objects = {};
+        _subscribe_topics[topic].objects['__noId__'] = [];
+      }
+
+      return this;
+    },
+
+    /**
+     * Destroy an existing topic and unsubscribe all subscribers
+     */
+    destroyTopic  :  function(topic) {
+
+      if(topic && _subscribe_topics[topic]) {
+
+        for(i in _subscribe_topics[topic].objects) {
+
+          var object = _subscribe_topics[topic].objects[i];
+
+          if($.isArray(object)) {   // handle '__noId__' elements
+
+            if(object.length > 0) {
+
+              for(j in object) {
+
+                object[j].unbind(topic);
+              }
+            }
+
+          } else {
+
+            object.unbind(topic,data);
+          }
+        }
+      }
+
+      delete _subscribe_topics[topic];
+
+      return this;
+    },
+
+    /**
+     * Subscribes an object to particular topic with a handler.
+     * When the topic is published, this handler will be executed.
+     *
+     * Parameters:
+     *  -topic- is the string name of the topic
+     *  -handler- is a handler function and is of the form function(event, data), in which the 'this' refers to the element itself.
+     *        handler can be a function or can be a string referring to a function previously registered using the $.subscribeHandler() function
+     *            Note: returning 'false' from the handler will prevent subsequent handlers from being executed on this element during
+     *            this call.
+     *  -data- (optional) is additional data that is passed to the event handler as event.data when the topic is published
+     *
+     * Note: Unexpected behavior can occur when a script in a embedded page (page loaded in div,tab etc.) subscribes a handler for a topic using
+     *  the jQuery subscribe ($.subscribe) or a no-id element but this subscribe plugin is not reloaded within that embedded page (for example, when
+     *  script is included in containing page) . In this case, if the embedded page is reloaded without reloading the entire page (and plugin), the
+     *  subscription could be made multiple times for the topic, which will call the handler multiple times each time the topic is published.
+     *  Code has been added to prevent this when the subscription is made using the non-element subscribe ($.subscribe()), which assures that only one
+     *  subscription is made for a topic for a given window/frame. To prevent this from happening for an element subscription ($elem.subscribe()), make
+     *  sure that the element has an id attribute.
+     */
+    subscribe :  function(topic, handler, data) {
+
+      if(this[0] && topic && handler) {
+
+        this.createTopic(topic);
+
+        if(this.attr('id')) {
+
+          _subscribe_topics[topic].objects[this.attr('id')] = this;
+
+        } else {
+
+          //do not subscribe the same window/frame document multiple times, this causes unexpected behavior of executing embedded scripts multiple times
+          var noIdObjects = _subscribe_topics[topic].objects['__noId__'];
+
+          if(this[0].nodeType == 9) { //if document is being bound (the case for non-element jQuery subscribing ($.subscribe)
+
+            for ( var index in noIdObjects) {
+
+              var noIdObject = noIdObjects[index];
+
+              if(noIdObject[0].nodeType == 9 && _subscribe_getDocumentWindow(this[0]).frameElement == _subscribe_getDocumentWindow(noIdObject[0]).frameElement ) {
+
+                return this;
+              }
+            }
+          }
+
+          var exists = false;
+          for(var i = 0; i < noIdObjects.length; i++){
+            if(noIdObjects[i] == this){
+              exists = true;
+              break;
+            }
+          }
+
+          if(!exists) {
+
+            _subscribe_topics[topic].objects['__noId__'].push(this);
+          }
+        }
+
+        if(typeof(handler) == 'function') {
+
+          this.bind(topic, data, handler);
+
+        } else if(typeof(handler) == 'string' && typeof(_subscribe_handlers[handler]) == 'function') {
+
+          this.bind(topic, data, _subscribe_handlers[handler]);
+        }
+      }
+
+      return this;
+    },
+
+    /**
+     * Remove a subscription of an element to a topic.
+     * This will unbind stop all handlers from executing on this element when the topic
+     * is published
+     */
+    unsubscribe :  function(topic) {
+
+      if(topic) {
+
+        if(_subscribe_topics[topic]) {
+
+          if(this.attr('id')) {
+
+            var object = _subscribe_topics[topic].objects[this.attr('id')];
+
+            if(object) {
+
+              delete _subscribe_topics[topic].objects[this.attr('id')];
+            }
+
+          } else {
+
+            var noIdObjects = _subscribe_topics[topic].objects['__noId__'];
+
+            for(var i = 0; i < noIdObjects.length; i++){
+
+              if(noIdObjects[i] == this){
+
+                subscribe_topics[topic].objects['__noId__'].splice(index,1);
+                break;
+              }
+            }
+          }
+        }
+
+        this.unbind(topic);
+      }
+
+      return this;
+    },
+
+    /**
+     * Publishes a topic (triggers handlers on all topic subscribers)
+     * This ends up calling any subscribed handlers which are functions of the form function (event, data)
+     * where: event - is a standard jQuery event object
+     *      data - is the data parameter that was passed to this publish() method
+     *      event.data - is the data parameter passed to the subscribe() function when this published topic was subscribed to
+     *      event.target  - is the dom element that subscribed to the event (or the document element if $.subscribe() was used)
+     *
+     * Parameters:
+     *  -topic- is the string name of the topic
+     *  -data- (optional) is additional data that is passed to the event handler 'data' parameter when the topic is published
+     *        handler can be a function or can be a string referring to a function previously registered using the $.subscribeHandler() function
+     *  -originalEvent- (optional) may be passed in a reference to an event which triggered this publishing. This will be passed as the
+     *        'originalEvent' field of the triggered event which will allow for controlling the propagation of higher level events
+     *        from within the topic handler. In other words, this allows one to cancel execution of all subsequent handlers on the originalEvent
+     *            for this element by return 'false' from a handler that is subscribed to the topic published here. This can be especially useful
+     *            in conjunction with publishOnEvent(), where a topic is published when an event executes (such as a click) and we want our
+     *            handler logic prevent additional topics from being published (For example if our topic displays a 'delete confirm' dialog on click and
+     *            the user cancels, we may want to prevent subsequent topics bound to the original click event from being published).
+     */
+    publish : function(topic, data, originalEvent) {
+
+      if(topic) {
+
+        this.createTopic(topic);
+
+        //if an orginal event exists, need to modify the event object to prevent execution of all
+        //other handlers if the result of the handler is false (which calls stopPropagation())
+
+        var subscriberStopPropagation = function(){
+
+          this.isImmediatePropagationStopped = function(){
+            return true;
+          };
+
+          (new $.Event).stopPropagation();
+
+          if(this.originalEvent) {
+
+            this.originalEvent.isImmediatePropagationStopped = function(){
+              return true;
+            };
+
+            this.originalEvent.stopPropagation = subscriberStopPropagation;
+          }
+        }
+
+        var event = jQuery.Event(topic);
+        $.extend(event,{originalEvent: originalEvent, stopPropagation: subscriberStopPropagation});
+
+        for(i in _subscribe_topics[topic].objects) {
+
+          var object = _subscribe_topics[topic].objects[i];
+
+          if($.isArray(object)) {   // handle '__noId__' elements (if any)
+
+            if(object.length > 0) {
+
+              for(j in object) {
+
+                object[j].trigger( event,data);
+              }
+            }
+
+          } else {
+
+            object.trigger( event,data);
+          }
+        }
+
+      }
+
+      return this;
+    },
+
+    /**
+     * Binds an objects event handler to a publish call
+     *
+     * Upon the event triggering, this ends up calling any subscribed handlers which are functions of the form function (event, data)
+     * where: event- is a standard jQuery event object
+     *      event.data- is the data parameter passed to the subscribe() function when this published topic was subscribed to
+     *      data- is the data parameter that was passed to this publishOnEvent() method
+     * Parameters:
+     *  -event- is the string name of the event upon which to publish the topic
+     *  -topic- is the string name of the topic to publish when the event occurs
+     *  -data- (optional) is additional data which will be passed in to the publish() method ant hen available as the second ('data')
+     *          parameter to the topic handler
+     */
+    publishOnEvent : function(event, topic, data) {
+
+      if(event && topic) {
+
+        this.createTopic(topic);
+
+        this.bind(event, data, function (e) {
+
+          $(this).publish(topic, e.data, e);
+        });
+      }
+
+      return this;
+    }
+  });
+
+  /**
+   * Make publish(), createTopic() and destroyTopic() callable without an element context
+   * Often don't need a context to subscribe, publish, create or destroy a topic.
+   * We will call from the document context
+   */
+  $.extend({
+
+    /**
+     * Subscribe an event handler to a topic without an element context
+     *
+     * Note: Caution about subscribing using same document to topic multiple time (maybe by loading subscribe script multiple times)
+     *
+     */
+    subscribe :  function(topic, handler, data) {
+      return $(window).subscribe(topic, handler, data);
+
+    },
+
+    /**
+     * Unsubscribe an event handler for a topic without an element context
+     *
+     */
+    unsubscribe :  function(topic, handler, data) {
+
+      return $(window).unsubscribe(topic, handler, data);
+
+    },
+
+    /**
+     * Register a handler function which can then be referenced by name when calling subscribe()
+     */
+    subscribeHandler: function(name, handler) {
+
+      if(name && handler && typeof(handler) == "function") {
+
+        _subscribe_handlers[name] = handler;
+      }
+
+      return $(window);
+    },
+
+    publish: function(topic, data) {
+
+      return $(window).publish(topic,data);
+    },
+
+    createTopic: function(topic) {
+
+      return $(window).createTopic(topic);
+    },
+
+    destroyTopic: function(topic) {
+
+      return $(window).destroyTopic(topic);
+    }
+
+  });
+
+})(jQuery);