right-rails 1.2.1 → 1.2.2

data/vendor/assets/javascripts/right/sortable.js

@@ -0,0 +1,7 @@
+/**
+ * RightJS-UI Sortable v2.2.0
+ * http://rightjs.org/ui/sortable
+ *
+ * Copyright (C) 2009-2011 Nikolay Nemshilov
+ */
+var Sortable=RightJS.Sortable=function(a,b){function c(a,c){c||(c=a,a="DIV");var d=new b.Class(b.Element.Wrappers[a]||b.Element,{initialize:function(c,d){this.key=c;var e=[{"class":"rui-"+c}];this instanceof b.Input||this instanceof b.Form||e.unshift(a),this.$super.apply(this,e),b.isString(d)&&(d=b.$(d)),d instanceof b.Element&&(this._=d._,"$listeners"in d&&(d.$listeners=d.$listeners),d={}),this.setOptions(d,this);return b.Wrapper.Cache[b.$uid(this._)]=this},setOptions:function(a,c){c&&(a=b.Object.merge(a,(new Function("return "+(c.get("data-"+this.key)||"{}")))())),a&&b.Options.setOptions.call(this,b.Object.merge(this.options,a));return this}}),e=new b.Class(d,c);b.Observer.createShortcuts(e.prototype,e.EVENTS||b([]));return e}var d=b,e=b.$,f=b.$w,g=b.isString,h=b.isArray,i=b.Object,j=new c("UL",{extend:{version:"2.2.0",EVENTS:f("start change finish"),Options:{url:null,method:"put",Xhr:{},idParam:"id",posParam:"position",parseId:!0,dragClass:"dragging",accept:null,minLength:1,itemCss:"li",handleCss:"li",cssRule:"*[data-sortable]"},current:!1,cast:function(a){a=e(a._),a instanceof j||(a=new j(a));return a}},initialize:function(a,b){this.$super("sortable",a).setOptions(b).addClass("rui-sortable").on("finish",this._tryXhr).on("selectstart","stopEvent")},setOptions:function(a,b){this.$super(a,b),a=this.options;var c=a.accept||[];h(c)||(c=[c]),a.accept=d([this].concat(c)).map(e).uniq();return this},items:function(){return this.children(this.options.itemCss)},startDrag:function(a){if(this.items().length>this.options.minLength){var b=a.find(this.options.itemCss),c=a.find(this.options.handleCss);b&&c&&(this._initDrag(b,a.position()),j.current=this,this.fire("start",this._evOpts(a)))}},moveItem:function(a){var b=a.position(),c=this.itemClone._.style,d=b.y-this.yRDiff,e=b.x-this.xRDiff,f=e+this.cloneWidth,g=d+this.cloneHeight;c.top=b.y-this.yDiff+"px",c.left=b.x-this.xDiff+"px";var h=this.suspects.first(function(a){return(d>a.top&&d<a.topHalf||g<a.bottom&&g>a.topHalf)&&(e>a.left&&e<a.leftHalf||f<a.right&&f>a.leftHalf)});h&&(c=h.item,c.insert(this.item,c.prevSiblings().include(this.item)?"after":"before"),this._findSuspects(),this.fire("change",this._evOpts(a,c)))},finishDrag:function(a){this.itemClone&&(this.itemClone.remove(),this.item.setStyle("visibility:visible")),j.current=!1,this.fire("finish",this._evOpts(a))},_evOpts:function(a,b){b=b||this.item;var c=j.cast(b.parent());return{list:c,item:b,event:a,index:c.items().indexOf(b)}},_initDrag:function(a,b){var c=this.dimensions(),d=a.dimensions(),e=a.clone().setStyle({margin:0,zIndex:9999,position:"absolute",top:"0px",left:"0px"}).addClass(this.options.dragClass).insertTo(this).setHeight(this.cloneHeight=d.height).setWidth(this.cloneWidth=d.width),f=e.position(),g=d.left-f.x,h=d.top-f.y;e.moveTo(g,h),this.item=a.setStyle("visibility:hidden"),this.itemClone=e,this.xDiff=b.x-g,this.yDiff=b.y-h,this.xRDiff=b.x-e.position().x,this.yRDiff=b.y-e.position().y,this._findSuspects()},_findSuspects:function(){var a=this.suspects=d([]),b=this.item,c=this.itemClone;this.options.accept.each(function(d){j.cast(d).items().each(function(d){if(d!==b&&d!==c){var e=d.dimensions();a.push({item:d,top:e.top,left:e.left,right:e.left+e.width,bottom:e.top+e.height,topHalf:e.top+e.height/2,leftHalf:e.left+e.width/2})}})})},_tryXhr:function(a){if(this.options.url){var c=d(this.options.url),e={},f=a.item,h=a.index+1,j=i.merge({method:this.options.method,params:{}},this.options.Xhr),k=f.get("id")||"";this.options.parseId&&k&&(k=(k.match(/\d+/)||[""])[0]),c.include("%{id}")?c=c.replace("%{id}",k):e[this.options.idParam]=k,e[this.options.posParam]=h,g(j.params)?j.params+="&"+i.toQueryString(e):j.params=i.merge(j.params,e),b.Xhr.load(c,j)}}});e(a).on({mousedown:function(a){var b=a.find(j.Options.cssRule+",*.rui-sortable");b&&j.cast(b).startDrag(a)},mousemove:function(a){j.current&&j.current.moveItem(a)},mouseup:function(a){j.current&&j.current.finishDrag(a)}}),e(window).onBlur(function(){j.current&&j.current.finishDrag()});var k=a.createElement("style"),l=a.createTextNode(".rui-sortable{user-select:none;-moz-user-select:none;-webkit-user-select:none}");k.type="text/css",a.getElementsByTagName("head")[0].appendChild(k),k.styleSheet?k.styleSheet.cssText=l.nodeValue:k.appendChild(l);return j}(document,RightJS)

data/vendor/assets/javascripts/right/table-src.js

@@ -0,0 +1,176 @@
+/**
+ * Tables Specific Wrappers v2.2.0
+ * http://rightjs.org/plugins/table
+ *
+ * Copyright (C) 2009-2011 Nikolay Nemshilov
+ */
+var Table = RightJS.Table = (function(RightJS) {
+/**
+ * Table plugin initialization script
+ *
+ * Copyright (C) 2010 Nikolay Nemshilov
+ */
+var R = RightJS,
+    $ = RightJS.$,
+    $E = RightJS.$E,
+    isHash  = RightJS.isHash,
+    isElement = RightJS.isElement,
+    Class   = RightJS.Class,
+    Object  = RightJS.Object,
+    Element = RightJS.Element;
+
+
+
+
+/**
+ * Tables specific dom-wrapper
+ *
+ * Copyright (C) 2010-2011 Nikolay Nemshilov
+ */
+var Table = Element.Wrappers.TABLE = new Class(Element, {
+
+  extend: {
+    version: '2.2.0',
+
+    Options: {
+      ascMarker:  '▼',  // asc marker content
+      descMarker: '▲',  // desc marker content
+      algorithm:  'text',      // default sorting algorithm 'text' or 'numeric'
+      order:      'asc',        // default order
+      sortedClass: 'sorted'
+    }
+  },
+
+  /**
+   * Basic constructor
+   *
+   * @param mixed raw dom-element or an options list
+   * @return void
+   */
+  initialize: function(arg) {
+    var options = arg || {}, element = options;
+
+    if (isHash(options) && !isElement(options)) {
+      element = 'table';
+    }
+
+    this.$super(element, options);
+
+    this.options = Object.merge(
+      Table.Options, new Function('return '+ this.get('data-table'))
+    );
+  },
+
+  /**
+   * Sorts the table by the given index
+   *
+   * @param mixed Number column index or TH element
+   * @param String order direction 'asc' or 'desc'
+   * @param String optional algorythm 'string', 'numeric'
+   * @return Table this
+   */
+  sort: function(index, direction, algorithm) {
+    var th = index instanceof Element ? index : this.header().last().children('th')[index];
+    if (!th) { return this; } // in case something goes wrong
+
+    // reading data from the TH cell
+    index     = th.parent().children('th').indexOf(th);
+    direction = direction || (this.marker && this.marker.parent() === th ? this.marker.asc ? 'desc' : 'asc' : null);
+    algorithm = algorithm || (th.hasClass('numeric') ? 'numeric' : null);
+
+    // handling the fallback from the options
+    direction = direction || this.options.order;
+    algorithm = algorithm || this.options.algorithm;
+    sortedClass =  this.options.sortedClass;
+
+    // collecting the list of sortable rows
+    var rows  = this.rows().map(function(row) {
+      var cell = row.children('td')[index], text = cell ? cell.text() : '';
+
+      if (algorithm === 'numeric') {
+        text = R(text).toFloat();
+      }
+
+      return { row: row, text: text };
+    });
+
+    // creating an anchor where to insert the rows
+    var anchor = rows[0] ?
+      $E('tr').insertTo(rows[0].row, 'before') :
+      $E('tr').insertTo(this.first('tbody') || this);
+
+    // finding the exact sorting algorithm
+    if (typeof(algorithm) !== 'function') {
+      algorithm = direction === 'asc' ? function(a, b) {
+        return a.text > b.text ? 1 : a.text < b.text ? -1 : 0;
+      } : function(a, b) {
+        return a.text > b.text ? -1 : a.text < b.text ? 1 : 0;
+      };
+    }
+
+    // sorting the rows and reinsert them in the correct order
+    rows.sort(algorithm).reverse().each(function(hash) {
+      anchor.insert(hash.row, 'after');
+    });
+
+    anchor.remove();
+
+    // putting the sorting marker
+    this.marker = (
+      this.marker || th.first('span.sort-marker') || $E('span', {'class': 'sort-marker'})
+    ).update(
+      this.options[direction === 'asc' ? 'ascMarker' : 'descMarker']
+    ).insertTo(th, 'bottom');
+    this.marker.asc = direction === 'asc';
+    this.find('th').each(function(th) {
+      th.removeClass(sortedClass);
+    });
+    this.marker.parent().toggleClass(sortedClass);
+
+    return this;
+  },
+
+  /**
+   * Returns the table data-rows
+   *
+   * @return Array table data rows
+   */
+  rows: function() {
+    return this.find('tr').reject(function(row) {
+      return row.first('th') || row.parent('tfoot');
+    });
+  },
+
+  /**
+   * Returns the table header rows
+   *
+   * @return Array table header rows
+   */
+  header: function() {
+    return this.find('tr').filter('first', 'th');
+  },
+
+  /**
+   * Returns the table footer rows
+   *
+   * @return Array table footer rows
+   */
+  footer: function() {
+    return this.find('tfoot > tr');
+  }
+});
+
+/**
+ * Document level hooks for the table plugin
+ *
+ * Copyright (C) 2010 Nikolay Nemshilov
+ */
+$(document).onClick(function(event) {
+  var th = event.find('th.sortable');
+
+  if (th) {
+    th.parent('table').sort(th);
+  }
+});
+return Table;
+})(RightJS);

data/vendor/assets/javascripts/right/table.js

@@ -0,0 +1,7 @@
+/**
+ * Tables Specific Wrappers v2.2.0
+ * http://rightjs.org/plugins/table
+ *
+ * Copyright (C) 2009-2011 Nikolay Nemshilov
+ */
+var Table=RightJS.Table=function(a){var b=a,c=a.$,d=a.$E,e=a.isHash,f=a.isElement,g=a.Class,h=a.Object,i=a.Element,j=i.Wrappers.TABLE=new g(i,{extend:{version:"2.2.0",Options:{ascMarker:"&#x25BC;",descMarker:"&#x25B2;",algorithm:"text",order:"asc",sortedClass:"sorted"}},initialize:function(a){var b=a||{},c=b;e(b)&&!f(b)&&(c="table"),this.$super(c,b),this.options=h.merge(j.Options,new Function("return "+this.get("data-table")))},sort:function(a,c,e){var f=a instanceof i?a:this.header().last().children("th")[a];if(!f)return this;a=f.parent().children("th").indexOf(f),c=c||(this.marker&&this.marker.parent()===f?this.marker.asc?"desc":"asc":null),e=e||(f.hasClass("numeric")?"numeric":null),c=c||this.options.order,e=e||this.options.algorithm,sortedClass=this.options.sortedClass;var g=this.rows().map(function(c){var d=c.children("td")[a],f=d?d.text():"";e==="numeric"&&(f=b(f).toFloat());return{row:c,text:f}}),h=g[0]?d("tr").insertTo(g[0].row,"before"):d("tr").insertTo(this.first("tbody")||this);typeof e!=="function"&&(e=c==="asc"?function(a,b){return a.text>b.text?1:a.text<b.text?-1:0}:function(a,b){return a.text>b.text?-1:a.text<b.text?1:0}),g.sort(e).reverse().each(function(a){h.insert(a.row,"after")}),h.remove(),this.marker=(this.marker||f.first("span.sort-marker")||d("span",{"class":"sort-marker"})).update(this.options[c==="asc"?"ascMarker":"descMarker"]).insertTo(f,"bottom"),this.marker.asc=c==="asc",this.find("th").each(function(a){a.removeClass(sortedClass)}),this.marker.parent().toggleClass(sortedClass);return this},rows:function(){return this.find("tr").reject(function(a){return a.first("th")||a.parent("tfoot")})},header:function(){return this.find("tr").filter("first","th")},footer:function(){return this.find("tfoot > tr")}});c(document).onClick(function(a){var b=a.find("th.sortable");b&&b.parent("table").sort(b)});return j}(RightJS)

data/vendor/assets/javascripts/right/tabs-src.js

@@ -0,0 +1,1157 @@
+/**
+ * RightJS-UI Tabs v2.2.3
+ * http://rightjs.org/ui/tabs
+ *
+ * Copyright (C) 2009-2011 Nikolay Nemshilov
+ */
+var Tabs = RightJS.Tabs = (function(document, parseInt, RightJS) {
+/**
+ * This module defines the basic widgets constructor
+ * it creates an abstract proxy with the common functionality
+ * which then we reuse and override in the actual widgets
+ *
+ * Copyright (C) 2010-2011 Nikolay Nemshilov
+ */
+
+/**
+ * The widget units constructor
+ *
+ * @param String tag-name or Object methods
+ * @param Object methods
+ * @return Widget wrapper
+ */
+function Widget(tag_name, methods) {
+  if (!methods) {
+    methods = tag_name;
+    tag_name = 'DIV';
+  }
+
+  /**
+   * An Abstract Widget Unit
+   *
+   * Copyright (C) 2010 Nikolay Nemshilov
+   */
+  var AbstractWidget = new RightJS.Class(RightJS.Element.Wrappers[tag_name] || RightJS.Element, {
+    /**
+     * The common constructor
+     *
+     * @param Object options
+     * @param String optional tag name
+     * @return void
+     */
+    initialize: function(key, options) {
+      this.key = key;
+      var args = [{'class': 'rui-' + key}];
+
+      // those two have different constructors
+      if (!(this instanceof RightJS.Input || this instanceof RightJS.Form)) {
+        args.unshift(tag_name);
+      }
+      this.$super.apply(this, args);
+
+      if (RightJS.isString(options)) {
+        options = RightJS.$(options);
+      }
+
+      // if the options is another element then
+      // try to dynamically rewrap it with our widget
+      if (options instanceof RightJS.Element) {
+        this._ = options._;
+        if ('$listeners' in options) {
+          options.$listeners = options.$listeners;
+        }
+        options = {};
+      }
+      this.setOptions(options, this);
+
+      return (RightJS.Wrapper.Cache[RightJS.$uid(this._)] = this);
+    },
+
+  // protected
+
+    /**
+     * Catches the options
+     *
+     * @param Object user-options
+     * @param Element element with contextual options
+     * @return void
+     */
+    setOptions: function(options, element) {
+      if (element) {
+        options = RightJS.Object.merge(options, new Function("return "+(
+          element.get('data-'+ this.key) || '{}'
+        ))());
+      }
+
+      if (options) {
+        RightJS.Options.setOptions.call(this, RightJS.Object.merge(this.options, options));
+      }
+
+      return this;
+    }
+  });
+
+  /**
+   * Creating the actual widget class
+   *
+   */
+  var Klass = new RightJS.Class(AbstractWidget, methods);
+
+  // creating the widget related shortcuts
+  RightJS.Observer.createShortcuts(Klass.prototype, Klass.EVENTS || RightJS([]));
+
+  return Klass;
+}
+
+
+/**
+ * A shared module to create textual spinners
+ *
+ * Copyright (C) 2010-2011 Nikolay Nemshilov
+ */
+var Spinner = new RightJS.Class(RightJS.Element, {
+  /**
+   * Constructor
+   *
+   * @param Number optional spinner size (4 by default)
+   * @return void
+   */
+  initialize: function(size) {
+    this.$super('div', {'class': 'rui-spinner'});
+    this.dots = [];
+
+    for (var i=0; i < (size || 4); i++) {
+      this.dots.push(new RightJS.Element('div'));
+    }
+
+    this.dots[0].addClass('glowing');
+    this.insert(this.dots);
+    RightJS(this.shift).bind(this).periodical(300);
+  },
+
+  /**
+   * Shifts the spinner elements
+   *
+   * @return void
+   */
+  shift: function() {
+    if (this.visible()) {
+      var dot = this.dots.pop();
+      this.dots.unshift(dot);
+      this.insert(dot, 'top');
+    }
+  }
+});
+
+
+/**
+ * The tabs init-script
+ *
+ * Copyright (C) 2010-2011 Nikolay Nemshilov
+ */
+var R  = RightJS,
+    $  = RightJS.$,
+    $$ = RightJS.$$,
+    $w = RightJS.$w,
+    $E = RightJS.$E,
+    Fx       = RightJS.Fx,
+    Object   = RightJS.Object,
+    Browser  = RightJS.Browser,
+    isArray  = RightJS.isArray,
+    isNumber = RightJS.isNumber,
+    Class    = RightJS.Class,
+    Element  = RightJS.Element,
+    Cookie   = RightJS.Cookie;
+
+
+
+
+
+
+
+/**
+ * The basic tabs handling engine
+ *
+ * Copyright (C) 2009-2011 Nikolay Nemshilov
+ */
+var Tabs = new Widget('UL', {
+  extend: {
+    version: '2.2.3',
+
+    EVENTS: $w('select hide load disable enable add remove move'),
+
+    Options: {
+      idPrefix:       '',      // the tab-body elements id prefix
+      tabsElement:    null,    // the tabs list element reference, in case it's situated somewhere else
+
+      resizeFx:       'both',  // 'slide', 'fade', 'both' or null for no fx
+      resizeDuration: 400,     // the tab panels resize fx duration
+
+      scrollTabs:     false,   // use the tabs list scrolling
+      scrollDuration: 400,     // the tabs scrolling fx duration
+
+      selected:       null,    // the index of the currently opened tab, by default will check url, cookies or set 0
+      disabled:       null,    // list of disabled tab indexes
+
+      closable:       false,   // set true if you want a close icon on your tabs
+
+      loop:           false,   // put a delay in ms to make it autostart the slideshow loop
+      loopPause:      true,    // make the loop get paused when user hovers the tabs with mouse
+
+      url:            false,   // a common remote tabs url template, should have the %{id} placeholder
+      cache:          false,   // marker if the remote tabs should be cached
+
+      Xhr:            null,    // the xhr addtional options
+      Cookie:         null     // set the cookie options if you'd like to keep the last selected tab index in cookies
+    },
+
+    // scans and automatically intializes the tabs
+    rescan: function(scope) {
+      $(scope || document).find('.rui-tabs,*[data-tabs]').each(function(element) {
+        element = element instanceof Tabs ? element : new Tabs(element);
+      });
+    }
+  },
+
+  /**
+   * The basic constructor
+   *
+   * @param element or id
+   * @param Object options
+   */
+  initialize: function(element, options) {
+    this
+      .$super('tabs', element)
+      .setOptions(options)
+      .addClass('rui-tabs');
+
+    this.isHarmonica = this._.tagName === 'DL';
+    this.isCarousel  = this.hasClass('rui-tabs-carousel');
+    this.isSimple    = !this.isHarmonica && !this.isCarousel;
+
+    this
+      .findTabs()
+      .initScrolls()
+      .findCurrent()
+      .setStyle('visibility:visible');
+
+    if (this.options.disabled) {
+      this.disable(this.options.disabled);
+    }
+
+    if (this.options.loop) {
+      this.startLoop();
+    }
+  },
+
+  /**
+   * Shows the given tab
+   *
+   * @param integer tab index or a Tabs.Tab instance
+   * @return Tabs this
+   */
+  select: function(tab) {
+    return this.callTab(tab, 'select');
+  },
+
+  /**
+   * Disables the given tab
+   *
+   * @param integer tab index or a Tabs.Tab instance or a list of them
+   * @return Tabs this
+   */
+  disable: function(tab) {
+    return this.callTab(tab, 'disable');
+  },
+
+  /**
+   * Enables the given tab
+   *
+   * @param integer tab index or a Tabs.Tab instance or a list of them
+   * @return Tabs this
+   */
+  enable: function(tab) {
+    return this.callTab(tab, 'enable');
+  },
+
+  /**
+   * Returns the reference to the currently opened tab
+   *
+   * @return Tab tab or undefined
+   */
+  current: function() {
+    return this.tabs.first('current');
+  },
+
+  /**
+   * Returns the list of enabled tabs
+   *
+   * @return Array of enabled tabs
+   */
+  enabled: function() {
+    return this.tabs.filter('enabled');
+  },
+
+// protected
+
+  // calls the tab (or tabs) method
+  callTab: function(tabs, method) {
+    R(isArray(tabs) ? tabs : [tabs]).each(function(tab) {
+      if (isNumber(tab)) { tab = this.tabs[tab]; }
+      if (tab && tab instanceof Tab) {
+        tab[method]();
+      }
+    }, this);
+
+    return this;
+  },
+
+  // finds and interconnects the tabs
+  findTabs: function() {
+    this.tabsList = this.isHarmonica ? this :
+      $(this.options.tabsElement) || this.first('.rui-tabs-list') ||
+        (this.first('UL') || $E('UL').insertTo(this)).addClass('rui-tabs-list');
+
+    this.tabs = R([]);
+
+    this.tabsList.children(this.isHarmonica ? 'dt' : null).map(function(node) {
+      this.tabs.push(new Tab(node, this));
+    }, this);
+
+    // removing the whitespaces so the didn't screw with the margins
+    for (var i=0, list = this.tabsList.get('childNodes'); i < list.length; i++) {
+      if (list[i].nodeType == 3) { this.tabsList._.removeChild(list[i]); }
+    }
+
+    return this;
+  }
+});
+
+
+/**
+ * A single tab handling object
+ *
+ * Copyright (C) 2009-2011 Nikolay Nemshilov
+ */
+var Tab = Tabs.Tab = new Class(Element, {
+  extend: {
+    autoId: 0
+  },
+
+  /**
+   * Constructor
+   *
+   * @param Element the tab's element
+   * @param Tabs the main element
+   * @return void
+   */
+  initialize: function(element, main) {
+    this.$super(element._);
+    this.addClass('rui-tabs-tab');
+
+    this.main  = main;
+    this.link  = this.first('a');
+    this.id    = this.link.get('href').split('#')[1] || Tab.autoId++;
+    this.panel = new Panel(this.findPanel(), this);
+
+    if (this.current()) {
+      this.select();
+    }
+
+    // adding the 'close' icon onto the tab if needed
+    if (main.options.closable) {
+      this.link.insert($E('div', {
+        'class': 'rui-tabs-tab-close-icon', 'html': '&times;'
+      }).onClick(R(this.remove).bind(this)));
+    }
+
+    this.onClick(this._clicked);
+  },
+
+  select: function() {
+    if (this.enabled()) {
+      var prev_tab = this.main.current();
+      if (prev_tab) {
+        prev_tab.removeClass('rui-tabs-current').fire('hide');
+      }
+
+      this.addClass('rui-tabs-current');
+      this.main.scrollToTab(this);
+      this.panel.show();
+    }
+
+    return this.fire('select');
+  },
+
+  disable: function() {
+    return this.addClass('rui-tabs-disabled').fire('disable');
+  },
+
+  enable: function() {
+    return this.removeClass('rui-tabs-disabled').fire('enable');
+  },
+
+  disabled: function() {
+    return !this.enabled();
+  },
+
+  enabled: function() {
+    return !this.hasClass('rui-tabs-disabled');
+  },
+
+  current: function() {
+    return this.hasClass('rui-tabs-current');
+  },
+
+  remove: function(event) {
+    if (event) { event.stop(); }
+
+    // switching to the next available sibling
+    if (this.current()) {
+      var enabled = this.main.enabled();
+      var sibling = enabled[enabled.indexOf(this) + 1] || enabled[enabled.indexOf(this)-1];
+
+      if (sibling) {
+        sibling.select();
+      }
+    }
+
+    // removing the tab out of the list
+    this.main.tabs.splice(this.main.tabs.indexOf(this), 1);
+    this.panel.remove();
+
+    var parent = this.parent();
+    this.fire('beforeremove');
+    this.$super();
+    parent.fire('remove', {target: this});
+
+    return this;
+  },
+
+// protected
+
+  // handles the clicks on the tabs
+  _clicked: function(event) {
+    event.stop();
+    return this.select();
+  },
+
+  // searches for a panel for the tab
+  findPanel: function() {
+    var main = this.main, panel_id = main.options.idPrefix + this.id, panel;
+
+    if (main.isHarmonica) {
+      var next = this.next();
+      panel = (next && next._.tagName === 'DD') ? next : $E('DD').insertTo(this, 'after');
+    } else {
+      panel = $(panel_id) || $E(main._.tagName === 'UL' ? 'LI' : 'DIV').insertTo(main);
+    }
+
+    return panel.set('id', panel_id);
+  },
+
+  // returns the tab width, used for the scrolling calculations
+  width: function() {
+    var next = this.next();
+
+    if (next) {
+      return next.position().x - this.position().x;
+    } else {
+      return this.size().x + 1;
+    }
+  }
+
+});
+
+
+/**
+ * The tab panels behavior logic
+ *
+ * Copyright (C) 2009-2011 Nikolay Nemshilov
+ */
+var Panel = Tabs.Panel = new Class(Element, {
+
+  /**
+   * Basic constructor
+   *
+   * @param Element panel-element
+   * @param Tab the tab object
+   * @return void
+   */
+  initialize: function(element, tab) {
+    this.$super(element._);
+    this.addClass('rui-tabs-panel');
+
+    this.tab = tab;
+    this.id  = this.get('id');
+  },
+
+  // shows the panel
+  show: function() {
+    return this.resizing(function() {
+      this.tab.main.tabs.each(function(tab) {
+        tab.panel[
+          tab.panel === this ? 'addClass' : 'removeClass'
+        ]('rui-tabs-current');
+      }, this);
+    });
+  },
+
+  // updates the panel content
+  update: function(content) {
+    // don't use resize if it's some other hidden tab was loaded asynch
+    if (this.tab.current()) {
+      this.resizing(function() {
+        Element.prototype.update.call(this, content||'');
+      });
+    } else {
+      this.$super(content||'');
+    }
+
+    return this;
+  },
+
+  // locks the panel with a spinner locker
+  lock: function() {
+    this.insert(this.locker(), 'top');
+  },
+
+// protected
+
+  resizing: function(callback) {
+    var controller = this.tab.main;
+
+    if (controller.__working) { return this.resizing.bind(this, callback).delay(100); }
+
+    var options    = controller.options;
+    var prev_panel = controller.tabs.map('panel').first('hasClass', 'rui-tabs-current');
+    var this_panel = this;
+    var swapping   = prev_panel !== this_panel;
+    var loading    = this.first('div.rui-tabs-panel-locker');
+
+    // sometimes it looses the parent on remote tabs
+    if (this_panel.parent().hasClass('rui-tabs-resizer')) {
+      this_panel.insertTo(prev_panel.parent());
+    }
+
+    if (options.resizeFx && RightJS.Fx && prev_panel && (swapping || loading)) {
+      controller.__working = true;
+      var unlock = function() { controller.__working = false; };
+
+      // calculating the visual effects durations
+      var fx_name  = (options.resizeFx === 'both' && loading) ? 'slide' : options.resizeFx;
+      var duration = options.resizeDuration; duration = Fx.Durations[duration] || duration;
+      var resize_duration = fx_name === 'fade' ? 0 : fx_name === 'slide' ? duration : duration / 2;
+      var fade_duration   = duration - resize_duration;
+
+      if (fx_name !== 'slide') {
+        this_panel.setStyle({opacity: 0});
+      }
+
+      // saving the previous sizes
+      var prev_panel_height = (controller.isHarmonica && swapping) ? 0 : prev_panel.size().y;
+
+      // applying the changes
+      callback.call(this);
+
+      // getting the new size
+      var new_panel_height  = this_panel.size().y;
+      var fx_wrapper = null;
+      var hide_wrapper = null;
+      var prev_back = null;
+
+      if (fx_name !== 'fade' && prev_panel_height !== new_panel_height) {
+        // preserving the whole element size so it didn't jump when we are tossing the tabs around
+        controller._.style.height = controller.size().y + 'px';
+
+        // wrapping the element with an overflowed element to visualize the resize
+        fx_wrapper = $E('div', {
+          'class': 'rui-tabs-resizer',
+          'style': 'height: '+ prev_panel_height + 'px'
+        });
+
+        // in case of harmonica nicely hidding the previous panel
+        if (controller.isHarmonica && swapping) {
+          prev_panel.addClass('rui-tabs-current');
+          hide_wrapper = $E('div', {'class': 'rui-tabs-resizer'});
+          hide_wrapper._.style.height = prev_panel.size().y + 'px';
+          prev_back = function() {
+            hide_wrapper.replace(prev_panel.removeClass('rui-tabs-current'));
+          };
+          prev_panel.wrap(hide_wrapper);
+
+          fx_wrapper._.style.height = '0px';
+        }
+
+        this_panel.wrap(fx_wrapper);
+
+        // getting back the auto-size so we could resize it
+        controller._.style.height = 'auto';
+
+      } else {
+        // removing the resize duration out of the equasion
+        rezise_duration = 0;
+        duration = fade_duration;
+      }
+
+      var counter = 0;
+      var set_back = function() {
+        if (fx_wrapper) {
+          if (fx_name == 'both' && !counter) {
+            return counter ++;
+          }
+
+          fx_wrapper.replace(this_panel);
+        }
+
+        unlock();
+      };
+
+      if (hide_wrapper) {
+        hide_wrapper.morph({height: '0px'},
+          {duration: resize_duration, onFinish: prev_back});
+      }
+
+      if (fx_wrapper) {
+        fx_wrapper.morph({height: new_panel_height + 'px'},
+          {duration: resize_duration, onFinish: set_back});
+      }
+
+      if (fx_name !== 'slide') {
+        this_panel.morph.bind(this_panel, {opacity: 1},
+          {duration: fade_duration, onFinish: set_back}
+            ).delay(resize_duration);
+      }
+
+      if (!fx_wrapper && fx_name === 'slide') {
+        set_back();
+      }
+
+    } else {
+      callback.call(this);
+    }
+
+    return this;
+  },
+
+  // builds the locker element
+  locker: function() {
+    return this._locker || (this._locker =
+      $E('div', {'class': 'rui-tabs-panel-locker'}).insert(new Spinner(5))
+    );
+  }
+});
+
+
+/**
+ * Contains the tabs scrolling functionality
+ *
+ * NOTE: different types of tabs have different scrolling behavior
+ *       simple tabs just scroll the tabs line without actually picking
+ *       any tab. But the carousel tabs scrolls to the next/previous
+ *       tabs on the list.
+ *
+ * Copyright (C) 2009-2010 Nikolay Nemshilov
+ */
+Tabs.include({
+  /**
+   * Shows the next tab
+   *
+   * @return Tabs this
+   */
+  next: function() {
+    return this.pickTab(+1);
+  },
+
+  /**
+   * Shows the preveious tab
+   *
+   * @return Tabs this
+   */
+  prev: function() {
+    return this.pickTab(-1);
+  },
+
+  /**
+   * Scrolls the tabs to the left
+   *
+   * @return Tabs this
+   */
+  scrollLeft: function() {
+    if (!this.prevButton.hasClass('rui-tabs-scroller-disabled')) {
+      this[this.isCarousel ? 'prev' : 'justScroll'](+0.6);
+    }
+    return this;
+  },
+
+  /**
+   * Scrolls the tabs to the right
+   *
+   * @return Tabs this
+   */
+  scrollRight: function() {
+    if (!this.nextButton.hasClass('rui-tabs-scroller-disabled')) {
+      this[this.isCarousel ? 'next' : 'justScroll'](-0.6);
+    }
+    return this;
+  },
+
+// protected
+
+  // overloading the init script to add the scrollbar support
+  initScrolls: function() {
+    if ((this.scrollable = (this.options.scrollTabs || this.isCarousel))) {
+      this.buildScroller();
+    }
+
+    return this;
+  },
+
+  // builds the tabs scroller block
+  buildScroller: function() {
+    if (!(
+      (this.prevButton = this.first('.rui-tabs-scroller-prev')) &&
+      (this.nextButton = this.first('.rui-tabs-scroller-next'))
+    )) {
+      this.prevButton = $E('div', {'class': 'rui-tabs-scroller-prev', 'html': '&laquo;'});
+      this.nextButton = $E('div', {'class': 'rui-tabs-scroller-next', 'html': '&raquo;'});
+
+      // using a dummy element to insert the scroller in place of the tabs list
+      $E('div').insertTo(this.tabsList, 'before')
+        .replace(
+          $E('div', {'class': 'rui-tabs-scroller'}).insert([
+            this.prevButton, this.nextButton, this.scroller = $E('div', {
+              'class': 'rui-tabs-scroller-body'
+            }).insert(this.tabsList)
+          ])
+        ).remove();
+    }
+
+    this.prevButton.onClick(R(this.scrollLeft).bind(this));
+    this.nextButton.onClick(R(this.scrollRight).bind(this));
+  },
+
+  // picks the next/prev non-disabled available tab
+  pickTab: function(pos) {
+    var current = this.current();
+    if (current && current.enabled()) {
+      var enabled_tabs = this.enabled();
+      var tab = enabled_tabs[enabled_tabs.indexOf(current) + pos];
+      if (tab) { tab.select(); }
+    }
+  },
+
+  // scrolls the tabs line to make the tab visible
+  scrollToTab: function(tab) {
+    if (this.scroller) {
+      // calculating the previous tabs widths
+      var tabs_width      = 0;
+      for (var i=0; i < this.tabs.length; i++) {
+        tabs_width += this.tabs[i].width();
+        if (this.tabs[i] === tab) { break; }
+      }
+
+      // calculating the scroll (the carousel tabs should be centralized)
+      var available_width = this.scroller.size().x;
+      var scroll = (this.isCarousel ? (available_width/2 + tab.width()/2) : available_width) - tabs_width;
+
+      // check if the tab doesn't need to be scrolled
+      if (!this.isCarousel) {
+        var current_scroll  = parseInt(this.tabsList.getStyle('left') || 0, 10);
+
+        if (scroll >= current_scroll && scroll < (current_scroll + available_width - tab.width())) {
+          scroll = current_scroll;
+        } else if (current_scroll > -tabs_width && current_scroll <= (tab.width() - tabs_width)) {
+          scroll = tab.width() - tabs_width;
+        }
+      }
+
+      this.scrollTo(scroll);
+    }
+  },
+
+  // just scrolls the scrollable area onto the given number of scrollable area widths
+  justScroll: function(size) {
+    if (!this.scroller) { return this; }
+    var current_scroll  = parseInt(this.tabsList.getStyle('left') || 0, 10);
+    var available_width = this.scroller.size().x;
+
+    this.scrollTo(current_scroll + available_width * size);
+  },
+
+  // scrolls the tabs list to the position
+  scrollTo: function(scroll) {
+    // checking the constraints
+    var available_width = this.scroller.size().x;
+    var overall_width   = this.tabs.map('width').sum();
+
+    if (scroll < (available_width - overall_width)) {
+      scroll = available_width - overall_width;
+    }
+    if (scroll > 0) { scroll = 0; }
+
+    // applying the scroll
+    this.tabsList.morph({left: scroll+'px'}, {duration: this.options.scrollDuration});
+
+    this.checkScrollButtons(overall_width, available_width, scroll);
+  },
+
+  // checks the scroll buttons
+  checkScrollButtons: function(overall_width, available_width, scroll) {
+    var has_prev = false, has_next = false;
+
+    if (this.isCarousel) {
+      var enabled = this.enabled();
+      var current = enabled.first('current');
+
+      if (current) {
+        var index = enabled.indexOf(current);
+
+        has_prev = index > 0;
+        has_next = index < enabled.length - 1;
+      }
+    } else {
+      has_prev = scroll !== 0;
+      has_next = scroll > (available_width - overall_width);
+    }
+
+    this.prevButton[has_prev ? 'removeClass' : 'addClass']('rui-tabs-scroller-disabled');
+    this.nextButton[has_next ? 'removeClass' : 'addClass']('rui-tabs-scroller-disabled');
+  }
+
+});
+
+
+/**
+ * This module handles the current tab state saving/restoring processes
+ *
+ * Copyright (C) 2009-2010 Nikolay Nemshilov
+ */
+function get_cookie_indexes() {
+  return R(RightJS.Cookie ? (Cookie.get('right-tabs-indexes') || '').split(',') : []);
+}
+
+function save_tab_in_cookies(options, tabs, event) {
+  if (RightJS.Cookie) {
+    var indexes = get_cookie_indexes();
+    indexes = indexes.without.apply(indexes, tabs.map('id'));
+    indexes.push(event.target.id);
+    Cookie.set('right-tabs-indexes', indexes.uniq().join(','), options);
+  }
+}
+
+Tabs.include({
+
+// protected
+
+  // searches and activates the current tab
+  findCurrent: function() {
+    var enabled = this.enabled(), current = (
+      this.tabs[this.options.selected] ||
+      this.tabs[this.urlIndex()]       ||
+      this.tabs[this.cookieIndex()]    ||
+      enabled.first('current')         ||
+      enabled[0]
+    );
+
+    if (current) {
+      current.select();
+    }
+
+    // initializing the cookies storage if set
+    if (this.options.Cookie) {
+      this.onSelect(R(save_tab_in_cookies).curry(this.options.Cookie, this.tabs));
+    }
+
+    return this;
+  },
+
+  // tries to find the current tab index in the url hash
+  urlIndex: function() {
+    var index = -1, id = document.location.href.split('#')[1];
+
+    if (id) {
+      for (var i=0; i < this.tabs.length; i++) {
+        if (this.tabs[i].id == id) {
+          index = i;
+          break;
+        }
+      }
+    }
+
+    return index;
+  },
+
+  // tries to find the current tab index in the cookies storage
+  cookieIndex: function() {
+    var index = -1;
+
+    if (this.options.Cookie) {
+      var indexes = get_cookie_indexes();
+      for (var i=0; i < this.tabs.length; i++) {
+        if (indexes.include(this.tabs[i].id)) {
+          index = i;
+          break;
+        }
+      }
+    }
+
+    return index;
+  }
+
+});
+
+
+/**
+ * This module handles the tabs cration and removing processes
+ *
+ * Copyright (C) 2009-2010 Nikolay Nemshilov
+ */
+Tabs.include({
+  /**
+   * Creates a new tab
+   *
+   * USAGE:
+   *   With the #add method you have to specify the tab title
+   *   optional content (possibly empty or null) and some options
+   *   The options might have the following keys
+   *
+   *     * id - the tab/panel id (will use the idPrefix option for the panels)
+   *     * url - a remote tab content address
+   *     * position - an integer position of the tab in the stack
+   *
+   * @param String title
+   * @param mixed content
+   * @param Object options
+   * @return Tabs this
+   */
+  add: function(title, content, options) {
+    options = options || {};
+
+    // creating the new tab element
+    var element = $E(this.isHarmonica ? 'dt' : 'li').insert(
+      $E('a', {html: title, href: options.url || '#'+(options.id||'')}
+    )).insertTo(this.tabsList);
+
+    // creating the actual tab instance
+    var tab = new Tab(element, this);
+    tab.panel.update(content||'');
+    this.tabs.push(tab);
+    tab.fire('add');
+
+    // moving the tab in place if asked
+    if ('position' in options) {
+      this.move(tab, options.position);
+    }
+
+    return this;
+  },
+
+  /**
+   * Moves the given tab to the given position
+   *
+   * NOTE if the position is not within the tabs range then it will do nothing
+   *
+   * @param mixed tab index or a tab instance
+   * @param Integer position
+   * @return Tabs this
+   */
+  move: function(tab, position) {
+    tab = this.tabs[tab] || tab;
+
+    if (this.tabs[position] && this.tabs[position] !== tab) {
+      // moving the tab element
+      this.tabs[position].insert(tab, (position === this.tabs.length-1) ? 'after' : 'before');
+
+      // inserting the panel after the tab if it's a harmonica
+      if (this.isHarmonica) {
+        tab.insert(tab.panel, 'after');
+      }
+
+      // moving the tab in the registry
+      this.tabs.splice(this.tabs.indexOf(tab), 1);
+      this.tabs.splice(position, 0, tab);
+
+      tab.fire('move', {index: position});
+    }
+
+    return this;
+  },
+
+  /**
+   * Removes the given tab
+   *
+   * @param integer tab index or a Tabs.Tab instance or a list of them
+   * @return Tabs this
+   */
+  remove: function(tab) {
+    return arguments.length === 0 ? this.$super() : this.callTab(tab, 'remove');
+  }
+
+});
+
+
+/**
+ * This module contains the remote tabs loading logic
+ *
+ * Copyright (C) 2009-2010 Nikolay Nemshilov
+ */
+var old_select = Tab.prototype.select;
+
+Tab.include({
+
+  // wrapping the original mehtod, to catch the remote requests
+  select: function() {
+    if (this.dogPiling(arguments)) { return this; }
+
+    var result  = old_select.apply(this, arguments);
+    var url     = R(this.link.get('href'));
+    var options = this.main.options;
+
+    // building the url
+    if (url.includes('#')) {
+      url = options.url ? options.url.replace('%{id}', url.split('#')[1]) : null;
+    }
+
+    // if there is an actual url and no ongoing request or a cache, starting the request
+    if (url && !this.request && !(options.cache || this.cache)) {
+      this.panel.lock();
+
+      try { // basically that's for the development tests, so the IE browsers didn't get screwed on the test page
+
+        this.request = new RightJS.Xhr(url, Object.merge({method: 'get'}, options.Xhr))
+          .onComplete(R(function(response) {
+            if (this.main.__working) {
+              return arguments.callee.bind(this, response).delay(100);
+            }
+
+            this.panel.update(response.text);
+
+            this.request = null; // removing the request marker so it could be rerun
+            if (options.cache) {
+              this.cache = true;
+            }
+
+            this.fire('load');
+          }).bind(this)
+        ).send();
+
+      } catch(e) { if (!Browser.OLD) { throw(e); } }
+    }
+
+    return result;
+  },
+
+// protected
+
+  dogPiling: function(args) {
+    if (this.main.__working) {
+      if (this.main.__timeout) {
+        this.main.__timeout.cancel();
+      }
+
+      this.main.__timeout = R(function(args) {
+        this.select.apply(this, args);
+      }).bind(this, args).delay(100);
+
+      return true;
+    }
+
+    return (this.main.__timeout = null);
+  }
+
+});
+
+
+/**
+ * This module handles the slide-show loop feature for the Tabs
+ *
+ * Copyright (C) 2009-2010 Nikolay Nemshilov
+ */
+Tabs.include({
+
+  /**
+   * Starts the slideshow loop
+   *
+   * @param Number optional delay in ms
+   * @return Tabs this
+   */
+  startLoop: function(delay) {
+    if (!delay && !this.options.loop) { return this; }
+
+    // attaching the loop pause feature
+    if (this.options.loopPause) {
+      this._stopLoop  = this._stopLoop  || R(this.stopLoop).bind(this, true);
+      this._startLoop = this._startLoop || R(this.startLoop).bind(this, delay);
+
+      this.forgetHovers().on({
+        mouseover: this._stopLoop,
+        mouseout:  this._startLoop
+      });
+    }
+
+    if (this.timer) { this.timer.stop(); }
+
+    this.timer = R(function() {
+      var enabled = this.enabled();
+      var current = this.current();
+      var next    = enabled[enabled.indexOf(current)+1];
+
+      this.select(next || enabled.first());
+
+    }).bind(this).periodical(this.options.loop || delay);
+
+    return this;
+  },
+
+  /**
+   * Stops the slideshow loop
+   *
+   * @return Tabs this
+   */
+  stopLoop: function(event, pause) {
+    if (this.timer) {
+      this.timer.stop();
+      this.timer = null;
+    }
+    if (!pause && this._startLoop) {
+      this.forgetHovers();
+    }
+  },
+
+// private
+  forgetHovers: function() {
+    return this
+      .stopObserving('mouseover', this._stopLoop)
+      .stopObserving('mouseout', this._startLoop);
+  }
+
+
+});
+
+
+/**
+ * The document level hooks for the tabs-egnine
+ *
+ * Copyright (C) 2009-2010 Nikolay Nemshilov
+ */
+$(document).onReady(function() {
+  Tabs.rescan();
+});
+
+
+var embed_style = document.createElement('style'),                 
+    embed_rules = document.createTextNode("div.rui-spinner,div.rui-spinner div{margin:0;padding:0;border:none;background:none;list-style:none;font-weight:normal;float:none;display:inline-block; *display:inline; *zoom:1;border-radius:.12em;-moz-border-radius:.12em;-webkit-border-radius:.12em}div.rui-spinner{text-align:center;white-space:nowrap;background:#EEE;border:1px solid #DDD;height:1.2em;padding:0 .2em}div.rui-spinner div{width:.4em;height:70%;background:#BBB;margin-left:1px}div.rui-spinner div:first-child{margin-left:0}div.rui-spinner div.glowing{background:#777}.rui-tabs,.rui-tabs-list,.rui-tabs-tab,.rui-tabs-panel,.rui-tabs-scroll-left,.rui-tabs-scroll-right,.rui-tabs-scroll-body,.rui-tabs-panel-locker,.rui-tabs-resizer{margin:0;padding:0;background:none;border:none;list-style:none;display:block;width:auto;height:auto}.rui-tabs{display:block;visibility:hidden;border-bottom:1px solid #CCC}.rui-tabs-resizer{overflow:hidden}.rui-tabs-list{display:block;position:relative;padding:0 .5em;border-bottom:1px solid #CCC;white-space:nowrap}.rui-tabs-list .rui-tabs-tab,.rui-tabs-tab *,.rui-tabs-tab *:hover{display:inline-block; *display:inline; *zoom:1;cursor:pointer;text-decoration:none;vertical-align:center}.rui-tabs-list .rui-tabs-tab{vertical-align:bottom;margin-right:.1em}.rui-tabs-tab a{outline:none;position:relative;border:1px solid #CCC;background:#DDD;color:#444;padding:.3em 1em;border-radius:.3em;-moz-border-radius:.3em;-webkit-border-radius:.3em;border-bottom:none;border-bottom-left-radius:0;border-bottom-right-radius:0;-moz-border-radius-bottomleft:0;-moz-border-radius-bottomright:0;-webkit-border-bottom-left-radius:0;-webkit-border-bottom-right-radius:0}.rui-tabs-tab a:hover{border-color:#CCC;background:#EEE}.rui-tabs-list .rui-tabs-current a,.rui-tabs-list .rui-tabs-current a:hover{font-weight:bold;color:#000;background:#FFF;border-bottom:1px solid #FFF;border-top-width:2px;padding-top:.34em;padding-bottom:.34em;top:1px}.rui-tabs-tab a img{border:none;opacity:.6;filter:alpha(opacity=60)}.rui-tabs-tab a:hover img,.rui-tabs-list .rui-tabs-current a img{opacity:1;filter:alpha(opacity=100)}.rui-tabs-disabled a,.rui-tabs-disabled a:hover{background:#EEE;border-color:#DDD;color:#AAA;cursor:default}.rui-tabs-disabled a img,.rui-tabs-disabled a:hover img{opacity:.5;filter:alpha(opacity=50)}.rui-tabs-tab-close-icon{display:inline-block; *display:inline; *zoom:1;margin-right:-0.5em;margin-left:0.5em;cursor:pointer;opacity:0.5;filter:alpha(opacity=50)}.rui-tabs-tab-close-icon:hover{opacity:1;filter:alpha(opacity=100);color:#B00;text-shadow:#888 .15em .15em .2em}.rui-tabs-panel{display:none;position:relative;min-height:4em;padding:.5em 0}.rui-tabs-current{display:block}.rui-tabs-scroller{position:relative;padding:0 1.4em}.rui-tabs-scroller-prev,.rui-tabs-scroller-next{width:1.1em;text-align:center;background:#EEE;color:#666;cursor:pointer;border:1px solid #CCC;border-radius:.2em;-moz-border-radius:.2em;-webkit-border-radius:.2em;position:absolute;bottom:0px;left:0px;padding:0.3em 0;user-select:none;-moz-user-select:none;-webkit-user-select:none}.rui-tabs-scroller-prev:hover,.rui-tabs-scroller-next:hover{color:#000;background:#DDD;border-color:#AAA}.rui-tabs-scroller-prev:active,.rui-tabs-scroller-next:active{background:#eee;border-color:#ccc}.rui-tabs-scroller-next{left:auto;right:0px}.rui-tabs-scroller-disabled,.rui-tabs-scroller-disabled:hover{cursor:default;background:#DDD;border-color:#DDD;color:#AAA}.rui-tabs-scroller-body{overflow:hidden;width:100%;position:relative}.rui-tabs-scroller .rui-tabs-list{padding-left:0;padding-right:0;width:9999em;z-index:10}.rui-tabs-panel-locker{position:absolute;top:0px;left:0px;opacity:0.5;filter:alpha(opacity=50);background:#CCC;width:100%;height:100%;text-align:center}.rui-tabs-panel-locker .rui-spinner{position:absolute;left:44%;top:44%;background:none;border:none;height:2em}.rui-tabs-panel-locker .rui-spinner div{background:#666;width:.65em;margin-left:.15em}.rui-tabs-panel-locker .rui-spinner div.glowing{background:#000}.rui-tabs-carousel .rui-tabs-list{border:none}.rui-tabs-carousel .rui-tabs-tab a,.rui-tabs-carousel .rui-tabs-scroller .rui-tabs-scroller-prev,.rui-tabs-carousel .rui-tabs-scroller .rui-tabs-scroller-next{height:6em;line-height:6em;padding:0;border-bottom:1px solid #ccc;border-radius:.25em;-moz-border-radius:.25em;-webkit-border-radius:.25em}.rui-tabs-carousel .rui-tabs-tab{margin-right:3px}.rui-tabs-carousel .rui-tabs-tab a img{border:1px solid #CCC;vertical-align:middle;margin:.4em;padding:0;border-radius:0;-moz-border-radius:0;-webkit-border-radius:0}.rui-tabs-carousel .rui-tabs-list .rui-tabs-current a{border-width:1px;border-color:#AAA;padding:0;top:auto}.rui-tabs-carousel .rui-tabs-list .rui-tabs-current a img{border-color:#bbb}.rui-tabs-carousel .rui-tabs-panel{text-align:center}dl.rui-tabs{border:none}dt.rui-tabs-tab,dt.rui-tabs-tab a,dt.rui-tabs-tab a:hover{display:block;float:none}dt.rui-tabs-tab a,dt.rui-tabs-tab a:hover{padding:.2em 1em;border:1px solid #ccc;border-radius:.25em;-moz-border-radius:.3em;-webkit-border-radius:.3em}dl.rui-tabs dt.rui-tabs-current a{background:#EEE;border-bottom-left-radius:0;border-bottom-right-radius:0;-moz-border-radius-bottomleft:0;-moz-border-radius-bottomright:0;-webkit-border-bottom-left-radius:0;-webkit-border-bottom-right-radius:0}dl.rui-tabs dd.rui-tabs-current+dt.rui-tabs-tab a{border-top-left-radius:0;border-top-right-radius:0;-moz-border-radius-topleft:0;-moz-border-radius-topright:0;-webkit-border-top-left-radius:0;-webkit-border-top-right-radius:0}");      
+                                                                   
+embed_style.type = 'text/css';                                     
+document.getElementsByTagName('head')[0].appendChild(embed_style); 
+                                                                   
+if(embed_style.styleSheet) {                                       
+  embed_style.styleSheet.cssText = embed_rules.nodeValue;          
+} else {                                                           
+  embed_style.appendChild(embed_rules);                            
+}                                                                  
+
+
+return Tabs;
+})(document, parseInt, RightJS);