(function($) {

    $.fn.extend({
      slimscroll: function(options) {
  
        var defaults = {
  
          // width in pixels of the visible scroll area
          width : 'auto',
  
          // height in pixels of the visible scroll area
          height : '250px',
  
          // width in pixels of the scrollbar and rail
          size : '7px',
  
          // scrollbar color, accepts any hex/color value
          color: '#000',
  
          // scrollbar position - left/right
          position : 'right',
  
          // distance in pixels between the side edge and the scrollbar
          distance : '1px',
  
          // default scroll position on load - top / bottom / $('selector')
          start : 'top',
  
          // sets scrollbar opacity
          opacity : .4,
  
          // enables always-on mode for the scrollbar
          alwaysvisible : false,
  
          // check if we should hide the scrollbar when user is hovering over
          disablefadeout : false,
  
          // sets visibility of the rail
          railvisible : false,
  
          // sets rail color
          railcolor : '#333',
  
          // sets rail opacity
          railopacity : .2,
  
          // whether  we should use jquery ui draggable to enable bar dragging
          raildraggable : true,
  
          // defautlt css class of the slimscroll rail
          railclass : 'slimscrollrail',
  
          // defautlt css class of the slimscroll bar
          barclass : 'slimscrollbar',
  
          // defautlt css class of the slimscroll wrapper
          wrapperclass : 'slimscrolldiv',
  
          // check if mousewheel should scroll the window if we reach top/bottom
          allowpagescroll : false,
  
          // scroll amount applied to each mouse wheel step
          wheelstep : 20,
  
          // scroll amount applied when user is using gestures
          touchscrollstep : 200,
  
          // sets border radius
          borderradius: '7px',
  
          // sets border radius of the rail
          railborderradius : '7px'
        };
  
        var o = $.extend(defaults, options);
  
        // do it for every element that matches selector
        this.each(function(){
  
        var isoverpanel, isoverbar, isdragg, queuehide, touchdif,
          barheight, percentscroll, lastscroll,
          divs = '<div></div>',
          minbarheight = 30,
          releasescroll = false;
  
          // used in event handlers and for better minification
          var me = $(this);
  
          // ensure we are not binding it again
          if (me.parent().hasclass(o.wrapperclass))
          {
              // start from last bar position
              var offset = me.scrolltop();
  
              // find bar and rail
              bar = me.siblings('.' + o.barclass);
              rail = me.siblings('.' + o.railclass);
  
              getbarheight();
  
              // check if we should scroll existing instance
              if ($.isplainobject(options))
              {
                // pass height: auto to an existing slimscroll object to force a resize after contents have changed
                if ( 'height' in options && options.height == 'auto' ) {
                  me.parent().css('height', 'auto');
                  me.css('height', 'auto');
                  var height = me.parent().parent().height();
                  me.parent().css('height', height);
                  me.css('height', height);
                } else if ('height' in options) {
                  var h = options.height;
                  me.parent().css('height', h);
                  me.css('height', h);
                }
  
                if ('scrollto' in options)
                {
                  // jump to a static point
                  offset = parseint(o.scrollto);
                }
                else if ('scrollby' in options)
                {
                  // jump by value pixels
                  offset += parseint(o.scrollby);
                }
                else if ('destroy' in options)
                {
                  // remove slimscroll elements
                  bar.remove();
                  rail.remove();
                  me.unwrap();
                  return;
                }
  
                // scroll content by the given offset
                scrollcontent(offset, false, true);
              }
  
              return;
          }
          else if ($.isplainobject(options))
          {
              if ('destroy' in options)
              {
                  return;
              }
          }
  
          // optionally set height to the parent's height
          o.height = (o.height == 'auto') ? me.parent().height() : o.height;
  
          // wrap content
          var wrapper = $(divs)
            .addclass(o.wrapperclass)
            .css({
              position: 'relative',
              overflow: 'hidden',
              width: o.width,
              height: o.height
            });
  
          // update style for the div
          me.css({
            overflow: 'hidden',
            width: o.width,
            height: o.height
          });
  
          // create scrollbar rail
          var rail = $(divs)
            .addclass(o.railclass)
            .css({
              width: o.size,
              height: '100%',
              position: 'absolute',
              top: 0,
              display: (o.alwaysvisible && o.railvisible) ? 'block' : 'none',
              'border-radius': o.railborderradius,
              background: o.railcolor,
              opacity: o.railopacity,
              zindex: 90
            });
  
          // create scrollbar
          var bar = $(divs)
            .addclass(o.barclass)
            .css({
              background: o.color,
              width: o.size,
              position: 'absolute',
              top: 0,
              opacity: o.opacity,
              display: o.alwaysvisible ? 'block' : 'none',
              'border-radius' : o.borderradius,
              borderradius: o.borderradius,
              mozborderradius: o.borderradius,
              webkitborderradius: o.borderradius,
              zindex: 99
            });
  
          // set position
          var poscss = (o.position == 'right') ? { right: o.distance } : { left: o.distance };
          rail.css(poscss);
          bar.css(poscss);
  
          // wrap it
          me.wrap(wrapper);
  
          // append to parent div
          me.parent().append(bar);
          me.parent().append(rail);
  
          // make it draggable and no longer dependent on the jqueryui
          if (o.raildraggable){
            bar.bind("mousedown", function(e) {
              var $doc = $(document);
              isdragg = true;
              t = parsefloat(bar.css('top'));
              pagey = e.pagey;
  
              $doc.bind("mousemove.slimscroll", function(e){
                currtop = t + e.pagey - pagey;
                bar.css('top', currtop);
                scrollcontent(0, bar.position().top, false);// scroll content
              });
  
              $doc.bind("mouseup.slimscroll", function(e) {
                isdragg = false;hidebar();
                $doc.unbind('.slimscroll');
              });
              return false;
            }).bind("selectstart.slimscroll", function(e){
              e.stoppropagation();
              e.preventdefault();
              return false;
            });
          }
  
          // on rail over
          rail.hover(function(){
            showbar();
          }, function(){
            hidebar();
          });
  
          // on bar over
          bar.hover(function(){
            isoverbar = true;
          }, function(){
            isoverbar = false;
          });
  
          // show on parent mouseover
          me.hover(function(){
            isoverpanel = true;
            showbar();
            hidebar();
          }, function(){
            isoverpanel = false;
            hidebar();
          });
  
          // support for mobile
          me.bind('touchstart', function(e,b){
            if (e.originalevent.touches.length)
            {
              // record where touch started
              touchdif = e.originalevent.touches[0].pagey;
            }
          });
  
          me.bind('touchmove', function(e){
            // prevent scrolling the page if necessary
            if(!releasescroll)
            {
                  e.originalevent.preventdefault();
                }
            if (e.originalevent.touches.length)
            {
              // see how far user swiped
              var diff = (touchdif - e.originalevent.touches[0].pagey) / o.touchscrollstep;
              // scroll content
              scrollcontent(diff, true);
              touchdif = e.originalevent.touches[0].pagey;
            }
          });
  
          // set up initial height
          getbarheight();
  
          // check start position
          if (o.start === 'bottom')
          {
            // scroll content to bottom
            bar.css({ top: me.outerheight() - bar.outerheight() });
            scrollcontent(0, true);
          }
          else if (o.start !== 'top')
          {
            // assume jquery selector
            scrollcontent($(o.start).position().top, null, true);
  
            // make sure bar stays hidden
            if (!o.alwaysvisible) { bar.hide(); }
          }
  
          // attach scroll events
          attachwheel(this);
  
          function _onwheel(e)
          {
            // use mouse wheel only when mouse is over
            if (!isoverpanel) { return; }
  
            var e = e || window.event;
  
            var delta = 0;
            if (e.wheeldelta) { delta = -e.wheeldelta/120; }
            if (e.detail) { delta = e.detail / 3; }
  
            var target = e.target || e.srctarget || e.srcelement;
            if ($(target).closest('.' + o.wrapperclass).is(me.parent())) {
              // scroll content
              scrollcontent(delta, true);
            }
  
            // stop window scroll
            if (e.preventdefault && !releasescroll) { e.preventdefault(); }
            if (!releasescroll) { e.returnvalue = false; }
          }
  
          function scrollcontent(y, iswheel, isjump)
          {
            releasescroll = false;
            var delta = y;
            var maxtop = me.outerheight() - bar.outerheight();
  
            if (iswheel)
            {
              // move bar with mouse wheel
              delta = parseint(bar.css('top')) + y * parseint(o.wheelstep) / 100 * bar.outerheight();
  
              // move bar, make sure it doesn't go out
              delta = math.min(math.max(delta, 0), maxtop);
  
              // if scrolling down, make sure a fractional change to the
              // scroll position isn't rounded away when the scrollbar's css is set
              // this flooring of delta would happened automatically when
              // bar.css is set below, but we floor here for clarity
              delta = (y > 0) ? math.ceil(delta) : math.floor(delta);
  
              // scroll the scrollbar
              bar.css({ top: delta + 'px' });
            }
  
            // calculate actual scroll amount
            percentscroll = parseint(bar.css('top')) / (me.outerheight() - bar.outerheight());
            delta = percentscroll * (me[0].scrollheight - me.outerheight());
  
            if (isjump)
            {
              delta = y;
              var offsettop = delta / me[0].scrollheight * me.outerheight();
              offsettop = math.min(math.max(offsettop, 0), maxtop);
              bar.css({ top: offsettop + 'px' });
            }
  
            // scroll content
            me.stop().animate({scrolltop:delta});
  
            // fire scrolling event
            me.trigger('slimscrolling', ~~delta);
  
            // ensure bar is visible
            showbar();
  
            // trigger hide when scroll is stopped
            hidebar();
          }
  
          function attachwheel(target)
          {
            if (window.addeventlistener)
            {
              target.addeventlistener('dommousescroll', _onwheel, false );
              target.addeventlistener('mousewheel', _onwheel, false );
            }
            else
            {
              document.attachevent("onmousewheel", _onwheel)
            }
          }
  
          function getbarheight()
          {
            // calculate scrollbar height and make sure it is not too small
            barheight = math.max((me.outerheight() / me[0].scrollheight) * me.outerheight(), minbarheight);
            bar.css({ height: barheight + 'px' });
  
            // hide scrollbar if content is not long enough
            var display = barheight == me.outerheight() ? 'none' : 'block';
            bar.css({ display: display });
          }
  
          function showbar()
          {
            // recalculate bar height
            getbarheight();
            cleartimeout(queuehide);
  
            // when bar reached top or bottom
            if (percentscroll == ~~percentscroll)
            {
              //release wheel
              releasescroll = o.allowpagescroll;
  
              // publish approporiate event
              if (lastscroll != percentscroll)
              {
                  var msg = (~~percentscroll == 0) ? 'top' : 'bottom';
                  me.trigger('slimscroll', msg);
              }
            }
            else
            {
              releasescroll = false;
            }
            lastscroll = percentscroll;
  
            // show only when required
            if(barheight >= me.outerheight()) {
              //allow window scroll
              releasescroll = true;
              return;
            }
            bar.stop(true,true).fadein('fast');
            if (o.railvisible) { rail.stop(true,true).fadein('fast'); }
          }
  
          function hidebar()
          {
            // only hide when options allow it
            if (!o.alwaysvisible)
            {
              queuehide = settimeout(function(){
                if (!(o.disablefadeout && isoverpanel) && !isoverbar && !isdragg)
                {
                  bar.fadeout('slow');
                  rail.fadeout('slow');
                }
              }, 1000);
            }
          }
  
        });
  
        // maintain chainability
        return this;
      }
    });
  
    $.fn.extend({
      slimscroll: $.fn.slimscroll
    });
  
  })(jquery);