You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@mesos.apache.org by ss...@apache.org on 2013/12/16 19:57:28 UTC
[02/10] Upgraded UI Bootstrap to 0.7.0, Angular to 1.2.3.
http://git-wip-us.apache.org/repos/asf/mesos/blob/9cbb81ba/src/webui/master/static/js/ui-bootstrap-tpls-0.7.0.js
----------------------------------------------------------------------
diff --git a/src/webui/master/static/js/ui-bootstrap-tpls-0.7.0.js b/src/webui/master/static/js/ui-bootstrap-tpls-0.7.0.js
new file mode 100644
index 0000000..08c2b78
--- /dev/null
+++ b/src/webui/master/static/js/ui-bootstrap-tpls-0.7.0.js
@@ -0,0 +1,3583 @@
+angular.module("ui.bootstrap", ["ui.bootstrap.tpls", "ui.bootstrap.transition","ui.bootstrap.collapse","ui.bootstrap.accordion","ui.bootstrap.alert","ui.bootstrap.bindHtml","ui.bootstrap.buttons","ui.bootstrap.carousel","ui.bootstrap.position","ui.bootstrap.datepicker","ui.bootstrap.dropdownToggle","ui.bootstrap.modal","ui.bootstrap.pagination","ui.bootstrap.tooltip","ui.bootstrap.popover","ui.bootstrap.progressbar","ui.bootstrap.rating","ui.bootstrap.tabs","ui.bootstrap.timepicker","ui.bootstrap.typeahead"]);
+angular.module("ui.bootstrap.tpls", ["template/accordion/accordion-group.html","template/accordion/accordion.html","template/alert/alert.html","template/carousel/carousel.html","template/carousel/slide.html","template/datepicker/datepicker.html","template/datepicker/popup.html","template/modal/backdrop.html","template/modal/window.html","template/pagination/pager.html","template/pagination/pagination.html","template/tooltip/tooltip-html-unsafe-popup.html","template/tooltip/tooltip-popup.html","template/popover/popover.html","template/progressbar/bar.html","template/progressbar/progress.html","template/rating/rating.html","template/tabs/tab.html","template/tabs/tabset-titles.html","template/tabs/tabset.html","template/timepicker/timepicker.html","template/typeahead/typeahead-match.html","template/typeahead/typeahead-popup.html"]);
+angular.module('ui.bootstrap.transition', [])
+
+/**
+ * $transition service provides a consistent interface to trigger CSS 3 transitions and to be informed when they complete.
+ * @param {DOMElement} element The DOMElement that will be animated.
+ * @param {string|object|function} trigger The thing that will cause the transition to start:
+ * - As a string, it represents the css class to be added to the element.
+ * - As an object, it represents a hash of style attributes to be applied to the element.
+ * - As a function, it represents a function to be called that will cause the transition to occur.
+ * @return {Promise} A promise that is resolved when the transition finishes.
+ */
+.factory('$transition', ['$q', '$timeout', '$rootScope', function($q, $timeout, $rootScope) {
+
+ var $transition = function(element, trigger, options) {
+ options = options || {};
+ var deferred = $q.defer();
+ var endEventName = $transition[options.animation ? "animationEndEventName" : "transitionEndEventName"];
+
+ var transitionEndHandler = function(event) {
+ $rootScope.$apply(function() {
+ element.unbind(endEventName, transitionEndHandler);
+ deferred.resolve(element);
+ });
+ };
+
+ if (endEventName) {
+ element.bind(endEventName, transitionEndHandler);
+ }
+
+ // Wrap in a timeout to allow the browser time to update the DOM before the transition is to occur
+ $timeout(function() {
+ if ( angular.isString(trigger) ) {
+ element.addClass(trigger);
+ } else if ( angular.isFunction(trigger) ) {
+ trigger(element);
+ } else if ( angular.isObject(trigger) ) {
+ element.css(trigger);
+ }
+ //If browser does not support transitions, instantly resolve
+ if ( !endEventName ) {
+ deferred.resolve(element);
+ }
+ });
+
+ // Add our custom cancel function to the promise that is returned
+ // We can call this if we are about to run a new transition, which we know will prevent this transition from ending,
+ // i.e. it will therefore never raise a transitionEnd event for that transition
+ deferred.promise.cancel = function() {
+ if ( endEventName ) {
+ element.unbind(endEventName, transitionEndHandler);
+ }
+ deferred.reject('Transition cancelled');
+ };
+
+ return deferred.promise;
+ };
+
+ // Work out the name of the transitionEnd event
+ var transElement = document.createElement('trans');
+ var transitionEndEventNames = {
+ 'WebkitTransition': 'webkitTransitionEnd',
+ 'MozTransition': 'transitionend',
+ 'OTransition': 'oTransitionEnd',
+ 'transition': 'transitionend'
+ };
+ var animationEndEventNames = {
+ 'WebkitTransition': 'webkitAnimationEnd',
+ 'MozTransition': 'animationend',
+ 'OTransition': 'oAnimationEnd',
+ 'transition': 'animationend'
+ };
+ function findEndEventName(endEventNames) {
+ for (var name in endEventNames){
+ if (transElement.style[name] !== undefined) {
+ return endEventNames[name];
+ }
+ }
+ }
+ $transition.transitionEndEventName = findEndEventName(transitionEndEventNames);
+ $transition.animationEndEventName = findEndEventName(animationEndEventNames);
+ return $transition;
+}]);
+
+angular.module('ui.bootstrap.collapse',['ui.bootstrap.transition'])
+
+// The collapsible directive indicates a block of html that will expand and collapse
+.directive('collapse', ['$transition', function($transition) {
+ // CSS transitions don't work with height: auto, so we have to manually change the height to a
+ // specific value and then once the animation completes, we can reset the height to auto.
+ // Unfortunately if you do this while the CSS transitions are specified (i.e. in the CSS class
+ // "collapse") then you trigger a change to height 0 in between.
+ // The fix is to remove the "collapse" CSS class while changing the height back to auto - phew!
+ var fixUpHeight = function(scope, element, height) {
+ // We remove the collapse CSS class to prevent a transition when we change to height: auto
+ element.removeClass('collapse');
+ element.css({ height: height });
+ // It appears that reading offsetWidth makes the browser realise that we have changed the
+ // height already :-/
+ var x = element[0].offsetWidth;
+ element.addClass('collapse');
+ };
+
+ return {
+ link: function(scope, element, attrs) {
+
+ var isCollapsed;
+ var initialAnimSkip = true;
+
+ scope.$watch(attrs.collapse, function(value) {
+ if (value) {
+ collapse();
+ } else {
+ expand();
+ }
+ });
+
+
+ var currentTransition;
+ var doTransition = function(change) {
+ if ( currentTransition ) {
+ currentTransition.cancel();
+ }
+ currentTransition = $transition(element,change);
+ currentTransition.then(
+ function() { currentTransition = undefined; },
+ function() { currentTransition = undefined; }
+ );
+ return currentTransition;
+ };
+
+ var expand = function() {
+ if (initialAnimSkip) {
+ initialAnimSkip = false;
+ if ( !isCollapsed ) {
+ fixUpHeight(scope, element, 'auto');
+ element.addClass('in');
+ }
+ } else {
+ doTransition({ height : element[0].scrollHeight + 'px' })
+ .then(function() {
+ // This check ensures that we don't accidentally update the height if the user has closed
+ // the group while the animation was still running
+ if ( !isCollapsed ) {
+ fixUpHeight(scope, element, 'auto');
+ element.addClass('in');
+ }
+ });
+ }
+ isCollapsed = false;
+ };
+
+ var collapse = function() {
+ isCollapsed = true;
+ element.removeClass('in');
+ if (initialAnimSkip) {
+ initialAnimSkip = false;
+ fixUpHeight(scope, element, 0);
+ } else {
+ fixUpHeight(scope, element, element[0].scrollHeight + 'px');
+ doTransition({'height':'0'});
+ }
+ };
+ }
+ };
+}]);
+
+angular.module('ui.bootstrap.accordion', ['ui.bootstrap.collapse'])
+
+.constant('accordionConfig', {
+ closeOthers: true
+})
+
+.controller('AccordionController', ['$scope', '$attrs', 'accordionConfig', function ($scope, $attrs, accordionConfig) {
+
+ // This array keeps track of the accordion groups
+ this.groups = [];
+
+ // Keep reference to user's scope to properly assign `is-open`
+ this.scope = $scope;
+
+ // Ensure that all the groups in this accordion are closed, unless close-others explicitly says not to
+ this.closeOthers = function(openGroup) {
+ var closeOthers = angular.isDefined($attrs.closeOthers) ? $scope.$eval($attrs.closeOthers) : accordionConfig.closeOthers;
+ if ( closeOthers ) {
+ angular.forEach(this.groups, function (group) {
+ if ( group !== openGroup ) {
+ group.isOpen = false;
+ }
+ });
+ }
+ };
+
+ // This is called from the accordion-group directive to add itself to the accordion
+ this.addGroup = function(groupScope) {
+ var that = this;
+ this.groups.push(groupScope);
+
+ groupScope.$on('$destroy', function (event) {
+ that.removeGroup(groupScope);
+ });
+ };
+
+ // This is called from the accordion-group directive when to remove itself
+ this.removeGroup = function(group) {
+ var index = this.groups.indexOf(group);
+ if ( index !== -1 ) {
+ this.groups.splice(this.groups.indexOf(group), 1);
+ }
+ };
+
+}])
+
+// The accordion directive simply sets up the directive controller
+// and adds an accordion CSS class to itself element.
+.directive('accordion', function () {
+ return {
+ restrict:'EA',
+ controller:'AccordionController',
+ transclude: true,
+ replace: false,
+ templateUrl: 'template/accordion/accordion.html'
+ };
+})
+
+// The accordion-group directive indicates a block of html that will expand and collapse in an accordion
+.directive('accordionGroup', ['$parse', '$transition', '$timeout', function($parse, $transition, $timeout) {
+ return {
+ require:'^accordion', // We need this directive to be inside an accordion
+ restrict:'EA',
+ transclude:true, // It transcludes the contents of the directive into the template
+ replace: true, // The element containing the directive will be replaced with the template
+ templateUrl:'template/accordion/accordion-group.html',
+ scope:{ heading:'@' }, // Create an isolated scope and interpolate the heading attribute onto this scope
+ controller: ['$scope', function($scope) {
+ this.setHeading = function(element) {
+ this.heading = element;
+ };
+ }],
+ link: function(scope, element, attrs, accordionCtrl) {
+ var getIsOpen, setIsOpen;
+
+ accordionCtrl.addGroup(scope);
+
+ scope.isOpen = false;
+
+ if ( attrs.isOpen ) {
+ getIsOpen = $parse(attrs.isOpen);
+ setIsOpen = getIsOpen.assign;
+
+ accordionCtrl.scope.$watch(getIsOpen, function(value) {
+ scope.isOpen = !!value;
+ });
+ }
+
+ scope.$watch('isOpen', function(value) {
+ if ( value ) {
+ accordionCtrl.closeOthers(scope);
+ }
+ if ( setIsOpen ) {
+ setIsOpen(accordionCtrl.scope, value);
+ }
+ });
+ }
+ };
+}])
+
+// Use accordion-heading below an accordion-group to provide a heading containing HTML
+// <accordion-group>
+// <accordion-heading>Heading containing HTML - <img src="..."></accordion-heading>
+// </accordion-group>
+.directive('accordionHeading', function() {
+ return {
+ restrict: 'EA',
+ transclude: true, // Grab the contents to be used as the heading
+ template: '', // In effect remove this element!
+ replace: true,
+ require: '^accordionGroup',
+ compile: function(element, attr, transclude) {
+ return function link(scope, element, attr, accordionGroupCtrl) {
+ // Pass the heading to the accordion-group controller
+ // so that it can be transcluded into the right place in the template
+ // [The second parameter to transclude causes the elements to be cloned so that they work in ng-repeat]
+ accordionGroupCtrl.setHeading(transclude(scope, function() {}));
+ };
+ }
+ };
+})
+
+// Use in the accordion-group template to indicate where you want the heading to be transcluded
+// You must provide the property on the accordion-group controller that will hold the transcluded element
+// <div class="accordion-group">
+// <div class="accordion-heading" ><a ... accordion-transclude="heading">...</a></div>
+// ...
+// </div>
+.directive('accordionTransclude', function() {
+ return {
+ require: '^accordionGroup',
+ link: function(scope, element, attr, controller) {
+ scope.$watch(function() { return controller[attr.accordionTransclude]; }, function(heading) {
+ if ( heading ) {
+ element.html('');
+ element.append(heading);
+ }
+ });
+ }
+ };
+});
+
+angular.module("ui.bootstrap.alert", []).directive('alert', function () {
+ return {
+ restrict:'EA',
+ templateUrl:'template/alert/alert.html',
+ transclude:true,
+ replace:true,
+ scope: {
+ type: '=',
+ close: '&'
+ },
+ link: function(scope, iElement, iAttrs) {
+ scope.closeable = "close" in iAttrs;
+ }
+ };
+});
+
+angular.module('ui.bootstrap.bindHtml', [])
+
+ .directive('bindHtmlUnsafe', function () {
+ return function (scope, element, attr) {
+ element.addClass('ng-binding').data('$binding', attr.bindHtmlUnsafe);
+ scope.$watch(attr.bindHtmlUnsafe, function bindHtmlUnsafeWatchAction(value) {
+ element.html(value || '');
+ });
+ };
+ });
+angular.module('ui.bootstrap.buttons', [])
+
+.constant('buttonConfig', {
+ activeClass: 'active',
+ toggleEvent: 'click'
+})
+
+.directive('btnRadio', ['buttonConfig', function (buttonConfig) {
+ var activeClass = buttonConfig.activeClass || 'active';
+ var toggleEvent = buttonConfig.toggleEvent || 'click';
+
+ return {
+ require: 'ngModel',
+ link: function (scope, element, attrs, ngModelCtrl) {
+
+ //model -> UI
+ ngModelCtrl.$render = function () {
+ element.toggleClass(activeClass, angular.equals(ngModelCtrl.$modelValue, scope.$eval(attrs.btnRadio)));
+ };
+
+ //ui->model
+ element.bind(toggleEvent, function () {
+ if (!element.hasClass(activeClass)) {
+ scope.$apply(function () {
+ ngModelCtrl.$setViewValue(scope.$eval(attrs.btnRadio));
+ ngModelCtrl.$render();
+ });
+ }
+ });
+ }
+ };
+}])
+
+.directive('btnCheckbox', ['buttonConfig', function (buttonConfig) {
+ var activeClass = buttonConfig.activeClass || 'active';
+ var toggleEvent = buttonConfig.toggleEvent || 'click';
+
+ return {
+ require: 'ngModel',
+ link: function (scope, element, attrs, ngModelCtrl) {
+
+ function getTrueValue() {
+ var trueValue = scope.$eval(attrs.btnCheckboxTrue);
+ return angular.isDefined(trueValue) ? trueValue : true;
+ }
+
+ function getFalseValue() {
+ var falseValue = scope.$eval(attrs.btnCheckboxFalse);
+ return angular.isDefined(falseValue) ? falseValue : false;
+ }
+
+ //model -> UI
+ ngModelCtrl.$render = function () {
+ element.toggleClass(activeClass, angular.equals(ngModelCtrl.$modelValue, getTrueValue()));
+ };
+
+ //ui->model
+ element.bind(toggleEvent, function () {
+ scope.$apply(function () {
+ ngModelCtrl.$setViewValue(element.hasClass(activeClass) ? getFalseValue() : getTrueValue());
+ ngModelCtrl.$render();
+ });
+ });
+ }
+ };
+}]);
+
+/**
+* @ngdoc overview
+* @name ui.bootstrap.carousel
+*
+* @description
+* AngularJS version of an image carousel.
+*
+*/
+angular.module('ui.bootstrap.carousel', ['ui.bootstrap.transition'])
+.controller('CarouselController', ['$scope', '$timeout', '$transition', '$q', function ($scope, $timeout, $transition, $q) {
+ var self = this,
+ slides = self.slides = [],
+ currentIndex = -1,
+ currentTimeout, isPlaying;
+ self.currentSlide = null;
+
+ /* direction: "prev" or "next" */
+ self.select = function(nextSlide, direction) {
+ var nextIndex = slides.indexOf(nextSlide);
+ //Decide direction if it's not given
+ if (direction === undefined) {
+ direction = nextIndex > currentIndex ? "next" : "prev";
+ }
+ if (nextSlide && nextSlide !== self.currentSlide) {
+ if ($scope.$currentTransition) {
+ $scope.$currentTransition.cancel();
+ //Timeout so ng-class in template has time to fix classes for finished slide
+ $timeout(goNext);
+ } else {
+ goNext();
+ }
+ }
+ function goNext() {
+ //If we have a slide to transition from and we have a transition type and we're allowed, go
+ if (self.currentSlide && angular.isString(direction) && !$scope.noTransition && nextSlide.$element) {
+ //We shouldn't do class manip in here, but it's the same weird thing bootstrap does. need to fix sometime
+ nextSlide.$element.addClass(direction);
+ var reflow = nextSlide.$element[0].offsetWidth; //force reflow
+
+ //Set all other slides to stop doing their stuff for the new transition
+ angular.forEach(slides, function(slide) {
+ angular.extend(slide, {direction: '', entering: false, leaving: false, active: false});
+ });
+ angular.extend(nextSlide, {direction: direction, active: true, entering: true});
+ angular.extend(self.currentSlide||{}, {direction: direction, leaving: true});
+
+ $scope.$currentTransition = $transition(nextSlide.$element, {});
+ //We have to create new pointers inside a closure since next & current will change
+ (function(next,current) {
+ $scope.$currentTransition.then(
+ function(){ transitionDone(next, current); },
+ function(){ transitionDone(next, current); }
+ );
+ }(nextSlide, self.currentSlide));
+ } else {
+ transitionDone(nextSlide, self.currentSlide);
+ }
+ self.currentSlide = nextSlide;
+ currentIndex = nextIndex;
+ //every time you change slides, reset the timer
+ restartTimer();
+ }
+ function transitionDone(next, current) {
+ angular.extend(next, {direction: '', active: true, leaving: false, entering: false});
+ angular.extend(current||{}, {direction: '', active: false, leaving: false, entering: false});
+ $scope.$currentTransition = null;
+ }
+ };
+
+ /* Allow outside people to call indexOf on slides array */
+ self.indexOfSlide = function(slide) {
+ return slides.indexOf(slide);
+ };
+
+ $scope.next = function() {
+ var newIndex = (currentIndex + 1) % slides.length;
+
+ //Prevent this user-triggered transition from occurring if there is already one in progress
+ if (!$scope.$currentTransition) {
+ return self.select(slides[newIndex], 'next');
+ }
+ };
+
+ $scope.prev = function() {
+ var newIndex = currentIndex - 1 < 0 ? slides.length - 1 : currentIndex - 1;
+
+ //Prevent this user-triggered transition from occurring if there is already one in progress
+ if (!$scope.$currentTransition) {
+ return self.select(slides[newIndex], 'prev');
+ }
+ };
+
+ $scope.select = function(slide) {
+ self.select(slide);
+ };
+
+ $scope.isActive = function(slide) {
+ return self.currentSlide === slide;
+ };
+
+ $scope.slides = function() {
+ return slides;
+ };
+
+ $scope.$watch('interval', restartTimer);
+ function restartTimer() {
+ if (currentTimeout) {
+ $timeout.cancel(currentTimeout);
+ }
+ function go() {
+ if (isPlaying) {
+ $scope.next();
+ restartTimer();
+ } else {
+ $scope.pause();
+ }
+ }
+ var interval = +$scope.interval;
+ if (!isNaN(interval) && interval>=0) {
+ currentTimeout = $timeout(go, interval);
+ }
+ }
+ $scope.play = function() {
+ if (!isPlaying) {
+ isPlaying = true;
+ restartTimer();
+ }
+ };
+ $scope.pause = function() {
+ if (!$scope.noPause) {
+ isPlaying = false;
+ if (currentTimeout) {
+ $timeout.cancel(currentTimeout);
+ }
+ }
+ };
+
+ self.addSlide = function(slide, element) {
+ slide.$element = element;
+ slides.push(slide);
+ //if this is the first slide or the slide is set to active, select it
+ if(slides.length === 1 || slide.active) {
+ self.select(slides[slides.length-1]);
+ if (slides.length == 1) {
+ $scope.play();
+ }
+ } else {
+ slide.active = false;
+ }
+ };
+
+ self.removeSlide = function(slide) {
+ //get the index of the slide inside the carousel
+ var index = slides.indexOf(slide);
+ slides.splice(index, 1);
+ if (slides.length > 0 && slide.active) {
+ if (index >= slides.length) {
+ self.select(slides[index-1]);
+ } else {
+ self.select(slides[index]);
+ }
+ } else if (currentIndex > index) {
+ currentIndex--;
+ }
+ };
+}])
+
+/**
+ * @ngdoc directive
+ * @name ui.bootstrap.carousel.directive:carousel
+ * @restrict EA
+ *
+ * @description
+ * Carousel is the outer container for a set of image 'slides' to showcase.
+ *
+ * @param {number=} interval The time, in milliseconds, that it will take the carousel to go to the next slide.
+ * @param {boolean=} noTransition Whether to disable transitions on the carousel.
+ * @param {boolean=} noPause Whether to disable pausing on the carousel (by default, the carousel interval pauses on hover).
+ *
+ * @example
+<example module="ui.bootstrap">
+ <file name="index.html">
+ <carousel>
+ <slide>
+ <img src="http://placekitten.com/150/150" style="margin:auto;">
+ <div class="carousel-caption">
+ <p>Beautiful!</p>
+ </div>
+ </slide>
+ <slide>
+ <img src="http://placekitten.com/100/150" style="margin:auto;">
+ <div class="carousel-caption">
+ <p>D'aww!</p>
+ </div>
+ </slide>
+ </carousel>
+ </file>
+ <file name="demo.css">
+ .carousel-indicators {
+ top: auto;
+ bottom: 15px;
+ }
+ </file>
+</example>
+ */
+.directive('carousel', [function() {
+ return {
+ restrict: 'EA',
+ transclude: true,
+ replace: true,
+ controller: 'CarouselController',
+ require: 'carousel',
+ templateUrl: 'template/carousel/carousel.html',
+ scope: {
+ interval: '=',
+ noTransition: '=',
+ noPause: '='
+ }
+ };
+}])
+
+/**
+ * @ngdoc directive
+ * @name ui.bootstrap.carousel.directive:slide
+ * @restrict EA
+ *
+ * @description
+ * Creates a slide inside a {@link ui.bootstrap.carousel.directive:carousel carousel}. Must be placed as a child of a carousel element.
+ *
+ * @param {boolean=} active Model binding, whether or not this slide is currently active.
+ *
+ * @example
+<example module="ui.bootstrap">
+ <file name="index.html">
+<div ng-controller="CarouselDemoCtrl">
+ <carousel>
+ <slide ng-repeat="slide in slides" active="slide.active">
+ <img ng-src="{{slide.image}}" style="margin:auto;">
+ <div class="carousel-caption">
+ <h4>Slide {{$index}}</h4>
+ <p>{{slide.text}}</p>
+ </div>
+ </slide>
+ </carousel>
+ <div class="row-fluid">
+ <div class="span6">
+ <ul>
+ <li ng-repeat="slide in slides">
+ <button class="btn btn-mini" ng-class="{'btn-info': !slide.active, 'btn-success': slide.active}" ng-disabled="slide.active" ng-click="slide.active = true">select</button>
+ {{$index}}: {{slide.text}}
+ </li>
+ </ul>
+ <a class="btn" ng-click="addSlide()">Add Slide</a>
+ </div>
+ <div class="span6">
+ Interval, in milliseconds: <input type="number" ng-model="myInterval">
+ <br />Enter a negative number to stop the interval.
+ </div>
+ </div>
+</div>
+ </file>
+ <file name="script.js">
+function CarouselDemoCtrl($scope) {
+ $scope.myInterval = 5000;
+ var slides = $scope.slides = [];
+ $scope.addSlide = function() {
+ var newWidth = 200 + ((slides.length + (25 * slides.length)) % 150);
+ slides.push({
+ image: 'http://placekitten.com/' + newWidth + '/200',
+ text: ['More','Extra','Lots of','Surplus'][slides.length % 4] + ' '
+ ['Cats', 'Kittys', 'Felines', 'Cutes'][slides.length % 4]
+ });
+ };
+ for (var i=0; i<4; i++) $scope.addSlide();
+}
+ </file>
+ <file name="demo.css">
+ .carousel-indicators {
+ top: auto;
+ bottom: 15px;
+ }
+ </file>
+</example>
+*/
+
+.directive('slide', ['$parse', function($parse) {
+ return {
+ require: '^carousel',
+ restrict: 'EA',
+ transclude: true,
+ replace: true,
+ templateUrl: 'template/carousel/slide.html',
+ scope: {
+ },
+ link: function (scope, element, attrs, carouselCtrl) {
+ //Set up optional 'active' = binding
+ if (attrs.active) {
+ var getActive = $parse(attrs.active);
+ var setActive = getActive.assign;
+ var lastValue = scope.active = getActive(scope.$parent);
+ scope.$watch(function parentActiveWatch() {
+ var parentActive = getActive(scope.$parent);
+
+ if (parentActive !== scope.active) {
+ // we are out of sync and need to copy
+ if (parentActive !== lastValue) {
+ // parent changed and it has precedence
+ lastValue = scope.active = parentActive;
+ } else {
+ // if the parent can be assigned then do so
+ setActive(scope.$parent, parentActive = lastValue = scope.active);
+ }
+ }
+ return parentActive;
+ });
+ }
+
+ carouselCtrl.addSlide(scope, element);
+ //when the scope is destroyed then remove the slide from the current slides array
+ scope.$on('$destroy', function() {
+ carouselCtrl.removeSlide(scope);
+ });
+
+ scope.$watch('active', function(active) {
+ if (active) {
+ carouselCtrl.select(scope);
+ }
+ });
+ }
+ };
+}]);
+
+angular.module('ui.bootstrap.position', [])
+
+/**
+ * A set of utility methods that can be use to retrieve position of DOM elements.
+ * It is meant to be used where we need to absolute-position DOM elements in
+ * relation to other, existing elements (this is the case for tooltips, popovers,
+ * typeahead suggestions etc.).
+ */
+ .factory('$position', ['$document', '$window', function ($document, $window) {
+
+ function getStyle(el, cssprop) {
+ if (el.currentStyle) { //IE
+ return el.currentStyle[cssprop];
+ } else if ($window.getComputedStyle) {
+ return $window.getComputedStyle(el)[cssprop];
+ }
+ // finally try and get inline style
+ return el.style[cssprop];
+ }
+
+ /**
+ * Checks if a given element is statically positioned
+ * @param element - raw DOM element
+ */
+ function isStaticPositioned(element) {
+ return (getStyle(element, "position") || 'static' ) === 'static';
+ }
+
+ /**
+ * returns the closest, non-statically positioned parentOffset of a given element
+ * @param element
+ */
+ var parentOffsetEl = function (element) {
+ var docDomEl = $document[0];
+ var offsetParent = element.offsetParent || docDomEl;
+ while (offsetParent && offsetParent !== docDomEl && isStaticPositioned(offsetParent) ) {
+ offsetParent = offsetParent.offsetParent;
+ }
+ return offsetParent || docDomEl;
+ };
+
+ return {
+ /**
+ * Provides read-only equivalent of jQuery's position function:
+ * http://api.jquery.com/position/
+ */
+ position: function (element) {
+ var elBCR = this.offset(element);
+ var offsetParentBCR = { top: 0, left: 0 };
+ var offsetParentEl = parentOffsetEl(element[0]);
+ if (offsetParentEl != $document[0]) {
+ offsetParentBCR = this.offset(angular.element(offsetParentEl));
+ offsetParentBCR.top += offsetParentEl.clientTop - offsetParentEl.scrollTop;
+ offsetParentBCR.left += offsetParentEl.clientLeft - offsetParentEl.scrollLeft;
+ }
+
+ var boundingClientRect = element[0].getBoundingClientRect();
+ return {
+ width: boundingClientRect.width || element.prop('offsetWidth'),
+ height: boundingClientRect.height || element.prop('offsetHeight'),
+ top: elBCR.top - offsetParentBCR.top,
+ left: elBCR.left - offsetParentBCR.left
+ };
+ },
+
+ /**
+ * Provides read-only equivalent of jQuery's offset function:
+ * http://api.jquery.com/offset/
+ */
+ offset: function (element) {
+ var boundingClientRect = element[0].getBoundingClientRect();
+ return {
+ width: boundingClientRect.width || element.prop('offsetWidth'),
+ height: boundingClientRect.height || element.prop('offsetHeight'),
+ top: boundingClientRect.top + ($window.pageYOffset || $document[0].body.scrollTop || $document[0].documentElement.scrollTop),
+ left: boundingClientRect.left + ($window.pageXOffset || $document[0].body.scrollLeft || $document[0].documentElement.scrollLeft)
+ };
+ }
+ };
+ }]);
+
+angular.module('ui.bootstrap.datepicker', ['ui.bootstrap.position'])
+
+.constant('datepickerConfig', {
+ dayFormat: 'dd',
+ monthFormat: 'MMMM',
+ yearFormat: 'yyyy',
+ dayHeaderFormat: 'EEE',
+ dayTitleFormat: 'MMMM yyyy',
+ monthTitleFormat: 'yyyy',
+ showWeeks: true,
+ startingDay: 0,
+ yearRange: 20,
+ minDate: null,
+ maxDate: null
+})
+
+.controller('DatepickerController', ['$scope', '$attrs', 'dateFilter', 'datepickerConfig', function($scope, $attrs, dateFilter, dtConfig) {
+ var format = {
+ day: getValue($attrs.dayFormat, dtConfig.dayFormat),
+ month: getValue($attrs.monthFormat, dtConfig.monthFormat),
+ year: getValue($attrs.yearFormat, dtConfig.yearFormat),
+ dayHeader: getValue($attrs.dayHeaderFormat, dtConfig.dayHeaderFormat),
+ dayTitle: getValue($attrs.dayTitleFormat, dtConfig.dayTitleFormat),
+ monthTitle: getValue($attrs.monthTitleFormat, dtConfig.monthTitleFormat)
+ },
+ startingDay = getValue($attrs.startingDay, dtConfig.startingDay),
+ yearRange = getValue($attrs.yearRange, dtConfig.yearRange);
+
+ this.minDate = dtConfig.minDate ? new Date(dtConfig.minDate) : null;
+ this.maxDate = dtConfig.maxDate ? new Date(dtConfig.maxDate) : null;
+
+ function getValue(value, defaultValue) {
+ return angular.isDefined(value) ? $scope.$parent.$eval(value) : defaultValue;
+ }
+
+ function getDaysInMonth( year, month ) {
+ return new Date(year, month, 0).getDate();
+ }
+
+ function getDates(startDate, n) {
+ var dates = new Array(n);
+ var current = startDate, i = 0;
+ while (i < n) {
+ dates[i++] = new Date(current);
+ current.setDate( current.getDate() + 1 );
+ }
+ return dates;
+ }
+
+ function makeDate(date, format, isSelected, isSecondary) {
+ return { date: date, label: dateFilter(date, format), selected: !!isSelected, secondary: !!isSecondary };
+ }
+
+ this.modes = [
+ {
+ name: 'day',
+ getVisibleDates: function(date, selected) {
+ var year = date.getFullYear(), month = date.getMonth(), firstDayOfMonth = new Date(year, month, 1);
+ var difference = startingDay - firstDayOfMonth.getDay(),
+ numDisplayedFromPreviousMonth = (difference > 0) ? 7 - difference : - difference,
+ firstDate = new Date(firstDayOfMonth), numDates = 0;
+
+ if ( numDisplayedFromPreviousMonth > 0 ) {
+ firstDate.setDate( - numDisplayedFromPreviousMonth + 1 );
+ numDates += numDisplayedFromPreviousMonth; // Previous
+ }
+ numDates += getDaysInMonth(year, month + 1); // Current
+ numDates += (7 - numDates % 7) % 7; // Next
+
+ var days = getDates(firstDate, numDates), labels = new Array(7);
+ for (var i = 0; i < numDates; i ++) {
+ var dt = new Date(days[i]);
+ days[i] = makeDate(dt, format.day, (selected && selected.getDate() === dt.getDate() && selected.getMonth() === dt.getMonth() && selected.getFullYear() === dt.getFullYear()), dt.getMonth() !== month);
+ }
+ for (var j = 0; j < 7; j++) {
+ labels[j] = dateFilter(days[j].date, format.dayHeader);
+ }
+ return { objects: days, title: dateFilter(date, format.dayTitle), labels: labels };
+ },
+ compare: function(date1, date2) {
+ return (new Date( date1.getFullYear(), date1.getMonth(), date1.getDate() ) - new Date( date2.getFullYear(), date2.getMonth(), date2.getDate() ) );
+ },
+ split: 7,
+ step: { months: 1 }
+ },
+ {
+ name: 'month',
+ getVisibleDates: function(date, selected) {
+ var months = new Array(12), year = date.getFullYear();
+ for ( var i = 0; i < 12; i++ ) {
+ var dt = new Date(year, i, 1);
+ months[i] = makeDate(dt, format.month, (selected && selected.getMonth() === i && selected.getFullYear() === year));
+ }
+ return { objects: months, title: dateFilter(date, format.monthTitle) };
+ },
+ compare: function(date1, date2) {
+ return new Date( date1.getFullYear(), date1.getMonth() ) - new Date( date2.getFullYear(), date2.getMonth() );
+ },
+ split: 3,
+ step: { years: 1 }
+ },
+ {
+ name: 'year',
+ getVisibleDates: function(date, selected) {
+ var years = new Array(yearRange), year = date.getFullYear(), startYear = parseInt((year - 1) / yearRange, 10) * yearRange + 1;
+ for ( var i = 0; i < yearRange; i++ ) {
+ var dt = new Date(startYear + i, 0, 1);
+ years[i] = makeDate(dt, format.year, (selected && selected.getFullYear() === dt.getFullYear()));
+ }
+ return { objects: years, title: [years[0].label, years[yearRange - 1].label].join(' - ') };
+ },
+ compare: function(date1, date2) {
+ return date1.getFullYear() - date2.getFullYear();
+ },
+ split: 5,
+ step: { years: yearRange }
+ }
+ ];
+
+ this.isDisabled = function(date, mode) {
+ var currentMode = this.modes[mode || 0];
+ return ((this.minDate && currentMode.compare(date, this.minDate) < 0) || (this.maxDate && currentMode.compare(date, this.maxDate) > 0) || ($scope.dateDisabled && $scope.dateDisabled({date: date, mode: currentMode.name})));
+ };
+}])
+
+.directive( 'datepicker', ['dateFilter', '$parse', 'datepickerConfig', '$log', function (dateFilter, $parse, datepickerConfig, $log) {
+ return {
+ restrict: 'EA',
+ replace: true,
+ templateUrl: 'template/datepicker/datepicker.html',
+ scope: {
+ dateDisabled: '&'
+ },
+ require: ['datepicker', '?^ngModel'],
+ controller: 'DatepickerController',
+ link: function(scope, element, attrs, ctrls) {
+ var datepickerCtrl = ctrls[0], ngModel = ctrls[1];
+
+ if (!ngModel) {
+ return; // do nothing if no ng-model
+ }
+
+ // Configuration parameters
+ var mode = 0, selected = new Date(), showWeeks = datepickerConfig.showWeeks;
+
+ if (attrs.showWeeks) {
+ scope.$parent.$watch($parse(attrs.showWeeks), function(value) {
+ showWeeks = !! value;
+ updateShowWeekNumbers();
+ });
+ } else {
+ updateShowWeekNumbers();
+ }
+
+ if (attrs.min) {
+ scope.$parent.$watch($parse(attrs.min), function(value) {
+ datepickerCtrl.minDate = value ? new Date(value) : null;
+ refill();
+ });
+ }
+ if (attrs.max) {
+ scope.$parent.$watch($parse(attrs.max), function(value) {
+ datepickerCtrl.maxDate = value ? new Date(value) : null;
+ refill();
+ });
+ }
+
+ function updateShowWeekNumbers() {
+ scope.showWeekNumbers = mode === 0 && showWeeks;
+ }
+
+ // Split array into smaller arrays
+ function split(arr, size) {
+ var arrays = [];
+ while (arr.length > 0) {
+ arrays.push(arr.splice(0, size));
+ }
+ return arrays;
+ }
+
+ function refill( updateSelected ) {
+ var date = null, valid = true;
+
+ if ( ngModel.$modelValue ) {
+ date = new Date( ngModel.$modelValue );
+
+ if ( isNaN(date) ) {
+ valid = false;
+ $log.error('Datepicker directive: "ng-model" value must be a Date object, a number of milliseconds since 01.01.1970 or a string representing an RFC2822 or ISO 8601 date.');
+ } else if ( updateSelected ) {
+ selected = date;
+ }
+ }
+ ngModel.$setValidity('date', valid);
+
+ var currentMode = datepickerCtrl.modes[mode], data = currentMode.getVisibleDates(selected, date);
+ angular.forEach(data.objects, function(obj) {
+ obj.disabled = datepickerCtrl.isDisabled(obj.date, mode);
+ });
+
+ ngModel.$setValidity('date-disabled', (!date || !datepickerCtrl.isDisabled(date)));
+
+ scope.rows = split(data.objects, currentMode.split);
+ scope.labels = data.labels || [];
+ scope.title = data.title;
+ }
+
+ function setMode(value) {
+ mode = value;
+ updateShowWeekNumbers();
+ refill();
+ }
+
+ ngModel.$render = function() {
+ refill( true );
+ };
+
+ scope.select = function( date ) {
+ if ( mode === 0 ) {
+ var dt = new Date( ngModel.$modelValue );
+ dt.setFullYear( date.getFullYear(), date.getMonth(), date.getDate() );
+ ngModel.$setViewValue( dt );
+ refill( true );
+ } else {
+ selected = date;
+ setMode( mode - 1 );
+ }
+ };
+ scope.move = function(direction) {
+ var step = datepickerCtrl.modes[mode].step;
+ selected.setMonth( selected.getMonth() + direction * (step.months || 0) );
+ selected.setFullYear( selected.getFullYear() + direction * (step.years || 0) );
+ refill();
+ };
+ scope.toggleMode = function() {
+ setMode( (mode + 1) % datepickerCtrl.modes.length );
+ };
+ scope.getWeekNumber = function(row) {
+ return ( mode === 0 && scope.showWeekNumbers && row.length === 7 ) ? getISO8601WeekNumber(row[0].date) : null;
+ };
+
+ function getISO8601WeekNumber(date) {
+ var checkDate = new Date(date);
+ checkDate.setDate(checkDate.getDate() + 4 - (checkDate.getDay() || 7)); // Thursday
+ var time = checkDate.getTime();
+ checkDate.setMonth(0); // Compare with Jan 1
+ checkDate.setDate(1);
+ return Math.floor(Math.round((time - checkDate) / 86400000) / 7) + 1;
+ }
+ }
+ };
+}])
+
+.constant('datepickerPopupConfig', {
+ dateFormat: 'yyyy-MM-dd',
+ currentText: 'Today',
+ toggleWeeksText: 'Weeks',
+ clearText: 'Clear',
+ closeText: 'Done',
+ closeOnDateSelection: true,
+ appendToBody: false
+})
+
+.directive('datepickerPopup', ['$compile', '$parse', '$document', '$position', 'dateFilter', 'datepickerPopupConfig', 'datepickerConfig',
+function ($compile, $parse, $document, $position, dateFilter, datepickerPopupConfig, datepickerConfig) {
+ return {
+ restrict: 'EA',
+ require: 'ngModel',
+ link: function(originalScope, element, attrs, ngModel) {
+ var dateFormat;
+ attrs.$observe('datepickerPopup', function(value) {
+ dateFormat = value || datepickerPopupConfig.dateFormat;
+ ngModel.$render();
+ });
+
+ var closeOnDateSelection = angular.isDefined(attrs.closeOnDateSelection) ? originalScope.$eval(attrs.closeOnDateSelection) : datepickerPopupConfig.closeOnDateSelection;
+ var appendToBody = angular.isDefined(attrs.datepickerAppendToBody) ? originalScope.$eval(attrs.datepickerAppendToBody) : datepickerPopupConfig.appendToBody;
+
+ // create a child scope for the datepicker directive so we are not polluting original scope
+ var scope = originalScope.$new();
+
+ originalScope.$on('$destroy', function() {
+ scope.$destroy();
+ });
+
+ attrs.$observe('currentText', function(text) {
+ scope.currentText = angular.isDefined(text) ? text : datepickerPopupConfig.currentText;
+ });
+ attrs.$observe('toggleWeeksText', function(text) {
+ scope.toggleWeeksText = angular.isDefined(text) ? text : datepickerPopupConfig.toggleWeeksText;
+ });
+ attrs.$observe('clearText', function(text) {
+ scope.clearText = angular.isDefined(text) ? text : datepickerPopupConfig.clearText;
+ });
+ attrs.$observe('closeText', function(text) {
+ scope.closeText = angular.isDefined(text) ? text : datepickerPopupConfig.closeText;
+ });
+
+ var getIsOpen, setIsOpen;
+ if ( attrs.isOpen ) {
+ getIsOpen = $parse(attrs.isOpen);
+ setIsOpen = getIsOpen.assign;
+
+ originalScope.$watch(getIsOpen, function updateOpen(value) {
+ scope.isOpen = !! value;
+ });
+ }
+ scope.isOpen = getIsOpen ? getIsOpen(originalScope) : false; // Initial state
+
+ function setOpen( value ) {
+ if (setIsOpen) {
+ setIsOpen(originalScope, !!value);
+ } else {
+ scope.isOpen = !!value;
+ }
+ }
+
+ var documentClickBind = function(event) {
+ if (scope.isOpen && event.target !== element[0]) {
+ scope.$apply(function() {
+ setOpen(false);
+ });
+ }
+ };
+
+ var elementFocusBind = function() {
+ scope.$apply(function() {
+ setOpen( true );
+ });
+ };
+
+ // popup element used to display calendar
+ var popupEl = angular.element('<div datepicker-popup-wrap><div datepicker></div></div>');
+ popupEl.attr({
+ 'ng-model': 'date',
+ 'ng-change': 'dateSelection()'
+ });
+ var datepickerEl = angular.element(popupEl.children()[0]);
+ if (attrs.datepickerOptions) {
+ datepickerEl.attr(angular.extend({}, originalScope.$eval(attrs.datepickerOptions)));
+ }
+
+ // TODO: reverse from dateFilter string to Date object
+ function parseDate(viewValue) {
+ if (!viewValue) {
+ ngModel.$setValidity('date', true);
+ return null;
+ } else if (angular.isDate(viewValue)) {
+ ngModel.$setValidity('date', true);
+ return viewValue;
+ } else if (angular.isString(viewValue)) {
+ var date = new Date(viewValue);
+ if (isNaN(date)) {
+ ngModel.$setValidity('date', false);
+ return undefined;
+ } else {
+ ngModel.$setValidity('date', true);
+ return date;
+ }
+ } else {
+ ngModel.$setValidity('date', false);
+ return undefined;
+ }
+ }
+ ngModel.$parsers.unshift(parseDate);
+
+ // Inner change
+ scope.dateSelection = function() {
+ ngModel.$setViewValue(scope.date);
+ ngModel.$render();
+
+ if (closeOnDateSelection) {
+ setOpen( false );
+ }
+ };
+
+ element.bind('input change keyup', function() {
+ scope.$apply(function() {
+ updateCalendar();
+ });
+ });
+
+ // Outter change
+ ngModel.$render = function() {
+ var date = ngModel.$viewValue ? dateFilter(ngModel.$viewValue, dateFormat) : '';
+ element.val(date);
+
+ updateCalendar();
+ };
+
+ function updateCalendar() {
+ scope.date = ngModel.$modelValue;
+ updatePosition();
+ }
+
+ function addWatchableAttribute(attribute, scopeProperty, datepickerAttribute) {
+ if (attribute) {
+ originalScope.$watch($parse(attribute), function(value){
+ scope[scopeProperty] = value;
+ });
+ datepickerEl.attr(datepickerAttribute || scopeProperty, scopeProperty);
+ }
+ }
+ addWatchableAttribute(attrs.min, 'min');
+ addWatchableAttribute(attrs.max, 'max');
+ if (attrs.showWeeks) {
+ addWatchableAttribute(attrs.showWeeks, 'showWeeks', 'show-weeks');
+ } else {
+ scope.showWeeks = datepickerConfig.showWeeks;
+ datepickerEl.attr('show-weeks', 'showWeeks');
+ }
+ if (attrs.dateDisabled) {
+ datepickerEl.attr('date-disabled', attrs.dateDisabled);
+ }
+
+ function updatePosition() {
+ scope.position = appendToBody ? $position.offset(element) : $position.position(element);
+ scope.position.top = scope.position.top + element.prop('offsetHeight');
+ }
+
+ var documentBindingInitialized = false, elementFocusInitialized = false;
+ scope.$watch('isOpen', function(value) {
+ if (value) {
+ updatePosition();
+ $document.bind('click', documentClickBind);
+ if(elementFocusInitialized) {
+ element.unbind('focus', elementFocusBind);
+ }
+ element[0].focus();
+ documentBindingInitialized = true;
+ } else {
+ if(documentBindingInitialized) {
+ $document.unbind('click', documentClickBind);
+ }
+ element.bind('focus', elementFocusBind);
+ elementFocusInitialized = true;
+ }
+
+ if ( setIsOpen ) {
+ setIsOpen(originalScope, value);
+ }
+ });
+
+ var $setModelValue = $parse(attrs.ngModel).assign;
+
+ scope.today = function() {
+ $setModelValue(originalScope, new Date());
+ };
+ scope.clear = function() {
+ $setModelValue(originalScope, null);
+ };
+
+ var $popup = $compile(popupEl)(scope);
+ if ( appendToBody ) {
+ $document.find('body').append($popup);
+ } else {
+ element.after($popup);
+ }
+ }
+ };
+}])
+
+.directive('datepickerPopupWrap', function() {
+ return {
+ restrict:'EA',
+ replace: true,
+ transclude: true,
+ templateUrl: 'template/datepicker/popup.html',
+ link:function (scope, element, attrs) {
+ element.bind('click', function(event) {
+ event.preventDefault();
+ event.stopPropagation();
+ });
+ }
+ };
+});
+
+/*
+ * dropdownToggle - Provides dropdown menu functionality in place of bootstrap js
+ * @restrict class or attribute
+ * @example:
+ <li class="dropdown">
+ <a class="dropdown-toggle">My Dropdown Menu</a>
+ <ul class="dropdown-menu">
+ <li ng-repeat="choice in dropChoices">
+ <a ng-href="{{choice.href}}">{{choice.text}}</a>
+ </li>
+ </ul>
+ </li>
+ */
+
+angular.module('ui.bootstrap.dropdownToggle', []).directive('dropdownToggle', ['$document', '$location', function ($document, $location) {
+ var openElement = null,
+ closeMenu = angular.noop;
+ return {
+ restrict: 'CA',
+ link: function(scope, element, attrs) {
+ scope.$watch('$location.path', function() { closeMenu(); });
+ element.parent().bind('click', function() { closeMenu(); });
+ element.bind('click', function (event) {
+
+ var elementWasOpen = (element === openElement);
+
+ event.preventDefault();
+ event.stopPropagation();
+
+ if (!!openElement) {
+ closeMenu();
+ }
+
+ if (!elementWasOpen && !element.hasClass('disabled') && !element.prop('disabled')) {
+ element.parent().addClass('open');
+ openElement = element;
+ closeMenu = function (event) {
+ if (event) {
+ event.preventDefault();
+ event.stopPropagation();
+ }
+ $document.unbind('click', closeMenu);
+ element.parent().removeClass('open');
+ closeMenu = angular.noop;
+ openElement = null;
+ };
+ $document.bind('click', closeMenu);
+ }
+ });
+ }
+ };
+}]);
+
+angular.module('ui.bootstrap.modal', [])
+
+/**
+ * A helper, internal data structure that acts as a map but also allows getting / removing
+ * elements in the LIFO order
+ */
+ .factory('$$stackedMap', function () {
+ return {
+ createNew: function () {
+ var stack = [];
+
+ return {
+ add: function (key, value) {
+ stack.push({
+ key: key,
+ value: value
+ });
+ },
+ get: function (key) {
+ for (var i = 0; i < stack.length; i++) {
+ if (key == stack[i].key) {
+ return stack[i];
+ }
+ }
+ },
+ keys: function() {
+ var keys = [];
+ for (var i = 0; i < stack.length; i++) {
+ keys.push(stack[i].key);
+ }
+ return keys;
+ },
+ top: function () {
+ return stack[stack.length - 1];
+ },
+ remove: function (key) {
+ var idx = -1;
+ for (var i = 0; i < stack.length; i++) {
+ if (key == stack[i].key) {
+ idx = i;
+ break;
+ }
+ }
+ return stack.splice(idx, 1)[0];
+ },
+ removeTop: function () {
+ return stack.splice(stack.length - 1, 1)[0];
+ },
+ length: function () {
+ return stack.length;
+ }
+ };
+ }
+ };
+ })
+
+/**
+ * A helper directive for the $modal service. It creates a backdrop element.
+ */
+ .directive('modalBackdrop', ['$modalStack', '$timeout', function ($modalStack, $timeout) {
+ return {
+ restrict: 'EA',
+ replace: true,
+ templateUrl: 'template/modal/backdrop.html',
+ link: function (scope, element, attrs) {
+
+ //trigger CSS transitions
+ $timeout(function () {
+ scope.animate = true;
+ });
+
+ scope.close = function (evt) {
+ var modal = $modalStack.getTop();
+ if (modal && modal.value.backdrop && modal.value.backdrop != 'static') {
+ evt.preventDefault();
+ evt.stopPropagation();
+ $modalStack.dismiss(modal.key, 'backdrop click');
+ }
+ };
+ }
+ };
+ }])
+
+ .directive('modalWindow', ['$timeout', function ($timeout) {
+ return {
+ restrict: 'EA',
+ scope: {
+ index: '@'
+ },
+ replace: true,
+ transclude: true,
+ templateUrl: 'template/modal/window.html',
+ link: function (scope, element, attrs) {
+ scope.windowClass = attrs.windowClass || '';
+
+ //trigger CSS transitions
+ $timeout(function () {
+ scope.animate = true;
+ });
+ }
+ };
+ }])
+
+ .factory('$modalStack', ['$document', '$compile', '$rootScope', '$$stackedMap',
+ function ($document, $compile, $rootScope, $$stackedMap) {
+
+ var backdropjqLiteEl, backdropDomEl;
+ var backdropScope = $rootScope.$new(true);
+ var body = $document.find('body').eq(0);
+ var openedWindows = $$stackedMap.createNew();
+ var $modalStack = {};
+
+ function backdropIndex() {
+ var topBackdropIndex = -1;
+ var opened = openedWindows.keys();
+ for (var i = 0; i < opened.length; i++) {
+ if (openedWindows.get(opened[i]).value.backdrop) {
+ topBackdropIndex = i;
+ }
+ }
+ return topBackdropIndex;
+ }
+
+ $rootScope.$watch(backdropIndex, function(newBackdropIndex){
+ backdropScope.index = newBackdropIndex;
+ });
+
+ function removeModalWindow(modalInstance) {
+
+ var modalWindow = openedWindows.get(modalInstance).value;
+
+ //clean up the stack
+ openedWindows.remove(modalInstance);
+
+ //remove window DOM element
+ modalWindow.modalDomEl.remove();
+
+ //remove backdrop if no longer needed
+ if (backdropDomEl && backdropIndex() == -1) {
+ backdropDomEl.remove();
+ backdropDomEl = undefined;
+ }
+
+ //destroy scope
+ modalWindow.modalScope.$destroy();
+ }
+
+ $document.bind('keydown', function (evt) {
+ var modal;
+
+ if (evt.which === 27) {
+ modal = openedWindows.top();
+ if (modal && modal.value.keyboard) {
+ $rootScope.$apply(function () {
+ $modalStack.dismiss(modal.key);
+ });
+ }
+ }
+ });
+
+ $modalStack.open = function (modalInstance, modal) {
+
+ openedWindows.add(modalInstance, {
+ deferred: modal.deferred,
+ modalScope: modal.scope,
+ backdrop: modal.backdrop,
+ keyboard: modal.keyboard
+ });
+
+ var angularDomEl = angular.element('<div modal-window></div>');
+ angularDomEl.attr('window-class', modal.windowClass);
+ angularDomEl.attr('index', openedWindows.length() - 1);
+ angularDomEl.html(modal.content);
+
+ var modalDomEl = $compile(angularDomEl)(modal.scope);
+ openedWindows.top().value.modalDomEl = modalDomEl;
+ body.append(modalDomEl);
+
+ if (backdropIndex() >= 0 && !backdropDomEl) {
+ backdropjqLiteEl = angular.element('<div modal-backdrop></div>');
+ backdropDomEl = $compile(backdropjqLiteEl)(backdropScope);
+ body.append(backdropDomEl);
+ }
+ };
+
+ $modalStack.close = function (modalInstance, result) {
+ var modal = openedWindows.get(modalInstance);
+ if (modal) {
+ modal.value.deferred.resolve(result);
+ removeModalWindow(modalInstance);
+ }
+ };
+
+ $modalStack.dismiss = function (modalInstance, reason) {
+ var modalWindow = openedWindows.get(modalInstance).value;
+ if (modalWindow) {
+ modalWindow.deferred.reject(reason);
+ removeModalWindow(modalInstance);
+ }
+ };
+
+ $modalStack.getTop = function () {
+ return openedWindows.top();
+ };
+
+ return $modalStack;
+ }])
+
+ .provider('$modal', function () {
+
+ var $modalProvider = {
+ options: {
+ backdrop: true, //can be also false or 'static'
+ keyboard: true
+ },
+ $get: ['$injector', '$rootScope', '$q', '$http', '$templateCache', '$controller', '$modalStack',
+ function ($injector, $rootScope, $q, $http, $templateCache, $controller, $modalStack) {
+
+ var $modal = {};
+
+ function getTemplatePromise(options) {
+ return options.template ? $q.when(options.template) :
+ $http.get(options.templateUrl, {cache: $templateCache}).then(function (result) {
+ return result.data;
+ });
+ }
+
+ function getResolvePromises(resolves) {
+ var promisesArr = [];
+ angular.forEach(resolves, function (value, key) {
+ if (angular.isFunction(value) || angular.isArray(value)) {
+ promisesArr.push($q.when($injector.invoke(value)));
+ }
+ });
+ return promisesArr;
+ }
+
+ $modal.open = function (modalOptions) {
+
+ var modalResultDeferred = $q.defer();
+ var modalOpenedDeferred = $q.defer();
+
+ //prepare an instance of a modal to be injected into controllers and returned to a caller
+ var modalInstance = {
+ result: modalResultDeferred.promise,
+ opened: modalOpenedDeferred.promise,
+ close: function (result) {
+ $modalStack.close(modalInstance, result);
+ },
+ dismiss: function (reason) {
+ $modalStack.dismiss(modalInstance, reason);
+ }
+ };
+
+ //merge and clean up options
+ modalOptions = angular.extend({}, $modalProvider.options, modalOptions);
+ modalOptions.resolve = modalOptions.resolve || {};
+
+ //verify options
+ if (!modalOptions.template && !modalOptions.templateUrl) {
+ throw new Error('One of template or templateUrl options is required.');
+ }
+
+ var templateAndResolvePromise =
+ $q.all([getTemplatePromise(modalOptions)].concat(getResolvePromises(modalOptions.resolve)));
+
+
+ templateAndResolvePromise.then(function resolveSuccess(tplAndVars) {
+
+ var modalScope = (modalOptions.scope || $rootScope).$new();
+ modalScope.$close = modalInstance.close;
+ modalScope.$dismiss = modalInstance.dismiss;
+
+ var ctrlInstance, ctrlLocals = {};
+ var resolveIter = 1;
+
+ //controllers
+ if (modalOptions.controller) {
+ ctrlLocals.$scope = modalScope;
+ ctrlLocals.$modalInstance = modalInstance;
+ angular.forEach(modalOptions.resolve, function (value, key) {
+ ctrlLocals[key] = tplAndVars[resolveIter++];
+ });
+
+ ctrlInstance = $controller(modalOptions.controller, ctrlLocals);
+ }
+
+ $modalStack.open(modalInstance, {
+ scope: modalScope,
+ deferred: modalResultDeferred,
+ content: tplAndVars[0],
+ backdrop: modalOptions.backdrop,
+ keyboard: modalOptions.keyboard,
+ windowClass: modalOptions.windowClass
+ });
+
+ }, function resolveError(reason) {
+ modalResultDeferred.reject(reason);
+ });
+
+ templateAndResolvePromise.then(function () {
+ modalOpenedDeferred.resolve(true);
+ }, function () {
+ modalOpenedDeferred.reject(false);
+ });
+
+ return modalInstance;
+ };
+
+ return $modal;
+ }]
+ };
+
+ return $modalProvider;
+ });
+
+angular.module('ui.bootstrap.pagination', [])
+
+.controller('PaginationController', ['$scope', '$attrs', '$parse', '$interpolate', function ($scope, $attrs, $parse, $interpolate) {
+ var self = this,
+ setNumPages = $attrs.numPages ? $parse($attrs.numPages).assign : angular.noop;
+
+ this.init = function(defaultItemsPerPage) {
+ if ($attrs.itemsPerPage) {
+ $scope.$parent.$watch($parse($attrs.itemsPerPage), function(value) {
+ self.itemsPerPage = parseInt(value, 10);
+ $scope.totalPages = self.calculateTotalPages();
+ });
+ } else {
+ this.itemsPerPage = defaultItemsPerPage;
+ }
+ };
+
+ this.noPrevious = function() {
+ return this.page === 1;
+ };
+ this.noNext = function() {
+ return this.page === $scope.totalPages;
+ };
+
+ this.isActive = function(page) {
+ return this.page === page;
+ };
+
+ this.calculateTotalPages = function() {
+ var totalPages = this.itemsPerPage < 1 ? 1 : Math.ceil($scope.totalItems / this.itemsPerPage);
+ return Math.max(totalPages || 0, 1);
+ };
+
+ this.getAttributeValue = function(attribute, defaultValue, interpolate) {
+ return angular.isDefined(attribute) ? (interpolate ? $interpolate(attribute)($scope.$parent) : $scope.$parent.$eval(attribute)) : defaultValue;
+ };
+
+ this.render = function() {
+ this.page = parseInt($scope.page, 10) || 1;
+ if (this.page > 0 && this.page <= $scope.totalPages) {
+ $scope.pages = this.getPages(this.page, $scope.totalPages);
+ }
+ };
+
+ $scope.selectPage = function(page) {
+ if ( ! self.isActive(page) && page > 0 && page <= $scope.totalPages) {
+ $scope.page = page;
+ $scope.onSelectPage({ page: page });
+ }
+ };
+
+ $scope.$watch('page', function() {
+ self.render();
+ });
+
+ $scope.$watch('totalItems', function() {
+ $scope.totalPages = self.calculateTotalPages();
+ });
+
+ $scope.$watch('totalPages', function(value) {
+ setNumPages($scope.$parent, value); // Readonly variable
+
+ if ( self.page > value ) {
+ $scope.selectPage(value);
+ } else {
+ self.render();
+ }
+ });
+}])
+
+.constant('paginationConfig', {
+ itemsPerPage: 10,
+ boundaryLinks: false,
+ directionLinks: true,
+ firstText: 'First',
+ previousText: 'Previous',
+ nextText: 'Next',
+ lastText: 'Last',
+ rotate: true
+})
+
+.directive('pagination', ['$parse', 'paginationConfig', function($parse, config) {
+ return {
+ restrict: 'EA',
+ scope: {
+ page: '=',
+ totalItems: '=',
+ onSelectPage:' &'
+ },
+ controller: 'PaginationController',
+ templateUrl: 'template/pagination/pagination.html',
+ replace: true,
+ link: function(scope, element, attrs, paginationCtrl) {
+
+ // Setup configuration parameters
+ var maxSize,
+ boundaryLinks = paginationCtrl.getAttributeValue(attrs.boundaryLinks, config.boundaryLinks ),
+ directionLinks = paginationCtrl.getAttributeValue(attrs.directionLinks, config.directionLinks ),
+ firstText = paginationCtrl.getAttributeValue(attrs.firstText, config.firstText, true),
+ previousText = paginationCtrl.getAttributeValue(attrs.previousText, config.previousText, true),
+ nextText = paginationCtrl.getAttributeValue(attrs.nextText, config.nextText, true),
+ lastText = paginationCtrl.getAttributeValue(attrs.lastText, config.lastText, true),
+ rotate = paginationCtrl.getAttributeValue(attrs.rotate, config.rotate);
+
+ paginationCtrl.init(config.itemsPerPage);
+
+ if (attrs.maxSize) {
+ scope.$parent.$watch($parse(attrs.maxSize), function(value) {
+ maxSize = parseInt(value, 10);
+ paginationCtrl.render();
+ });
+ }
+
+ // Create page object used in template
+ function makePage(number, text, isActive, isDisabled) {
+ return {
+ number: number,
+ text: text,
+ active: isActive,
+ disabled: isDisabled
+ };
+ }
+
+ paginationCtrl.getPages = function(currentPage, totalPages) {
+ var pages = [];
+
+ // Default page limits
+ var startPage = 1, endPage = totalPages;
+ var isMaxSized = ( angular.isDefined(maxSize) && maxSize < totalPages );
+
+ // recompute if maxSize
+ if ( isMaxSized ) {
+ if ( rotate ) {
+ // Current page is displayed in the middle of the visible ones
+ startPage = Math.max(currentPage - Math.floor(maxSize/2), 1);
+ endPage = startPage + maxSize - 1;
+
+ // Adjust if limit is exceeded
+ if (endPage > totalPages) {
+ endPage = totalPages;
+ startPage = endPage - maxSize + 1;
+ }
+ } else {
+ // Visible pages are paginated with maxSize
+ startPage = ((Math.ceil(currentPage / maxSize) - 1) * maxSize) + 1;
+
+ // Adjust last page if limit is exceeded
+ endPage = Math.min(startPage + maxSize - 1, totalPages);
+ }
+ }
+
+ // Add page number links
+ for (var number = startPage; number <= endPage; number++) {
+ var page = makePage(number, number, paginationCtrl.isActive(number), false);
+ pages.push(page);
+ }
+
+ // Add links to move between page sets
+ if ( isMaxSized && ! rotate ) {
+ if ( startPage > 1 ) {
+ var previousPageSet = makePage(startPage - 1, '...', false, false);
+ pages.unshift(previousPageSet);
+ }
+
+ if ( endPage < totalPages ) {
+ var nextPageSet = makePage(endPage + 1, '...', false, false);
+ pages.push(nextPageSet);
+ }
+ }
+
+ // Add previous & next links
+ if (directionLinks) {
+ var previousPage = makePage(currentPage - 1, previousText, false, paginationCtrl.noPrevious());
+ pages.unshift(previousPage);
+
+ var nextPage = makePage(currentPage + 1, nextText, false, paginationCtrl.noNext());
+ pages.push(nextPage);
+ }
+
+ // Add first & last links
+ if (boundaryLinks) {
+ var firstPage = makePage(1, firstText, false, paginationCtrl.noPrevious());
+ pages.unshift(firstPage);
+
+ var lastPage = makePage(totalPages, lastText, false, paginationCtrl.noNext());
+ pages.push(lastPage);
+ }
+
+ return pages;
+ };
+ }
+ };
+}])
+
+.constant('pagerConfig', {
+ itemsPerPage: 10,
+ previousText: '« Previous',
+ nextText: 'Next »',
+ align: true
+})
+
+.directive('pager', ['pagerConfig', function(config) {
+ return {
+ restrict: 'EA',
+ scope: {
+ page: '=',
+ totalItems: '=',
+ onSelectPage:' &'
+ },
+ controller: 'PaginationController',
+ templateUrl: 'template/pagination/pager.html',
+ replace: true,
+ link: function(scope, element, attrs, paginationCtrl) {
+
+ // Setup configuration parameters
+ var previousText = paginationCtrl.getAttributeValue(attrs.previousText, config.previousText, true),
+ nextText = paginationCtrl.getAttributeValue(attrs.nextText, config.nextText, true),
+ align = paginationCtrl.getAttributeValue(attrs.align, config.align);
+
+ paginationCtrl.init(config.itemsPerPage);
+
+ // Create page object used in template
+ function makePage(number, text, isDisabled, isPrevious, isNext) {
+ return {
+ number: number,
+ text: text,
+ disabled: isDisabled,
+ previous: ( align && isPrevious ),
+ next: ( align && isNext )
+ };
+ }
+
+ paginationCtrl.getPages = function(currentPage) {
+ return [
+ makePage(currentPage - 1, previousText, paginationCtrl.noPrevious(), true, false),
+ makePage(currentPage + 1, nextText, paginationCtrl.noNext(), false, true)
+ ];
+ };
+ }
+ };
+}]);
+
+/**
+ * The following features are still outstanding: animation as a
+ * function, placement as a function, inside, support for more triggers than
+ * just mouse enter/leave, html tooltips, and selector delegation.
+ */
+angular.module( 'ui.bootstrap.tooltip', [ 'ui.bootstrap.position', 'ui.bootstrap.bindHtml' ] )
+
+/**
+ * The $tooltip service creates tooltip- and popover-like directives as well as
+ * houses global options for them.
+ */
+.provider( '$tooltip', function () {
+ // The default options tooltip and popover.
+ var defaultOptions = {
+ placement: 'top',
+ animation: true,
+ popupDelay: 0
+ };
+
+ // Default hide triggers for each show trigger
+ var triggerMap = {
+ 'mouseenter': 'mouseleave',
+ 'click': 'click',
+ 'focus': 'blur'
+ };
+
+ // The options specified to the provider globally.
+ var globalOptions = {};
+
+ /**
+ * `options({})` allows global configuration of all tooltips in the
+ * application.
+ *
+ * var app = angular.module( 'App', ['ui.bootstrap.tooltip'], function( $tooltipProvider ) {
+ * // place tooltips left instead of top by default
+ * $tooltipProvider.options( { placement: 'left' } );
+ * });
+ */
+ this.options = function( value ) {
+ angular.extend( globalOptions, value );
+ };
+
+ /**
+ * This allows you to extend the set of trigger mappings available. E.g.:
+ *
+ * $tooltipProvider.setTriggers( 'openTrigger': 'closeTrigger' );
+ */
+ this.setTriggers = function setTriggers ( triggers ) {
+ angular.extend( triggerMap, triggers );
+ };
+
+ /**
+ * This is a helper function for translating camel-case to snake-case.
+ */
+ function snake_case(name){
+ var regexp = /[A-Z]/g;
+ var separator = '-';
+ return name.replace(regexp, function(letter, pos) {
+ return (pos ? separator : '') + letter.toLowerCase();
+ });
+ }
+
+ /**
+ * Returns the actual instance of the $tooltip service.
+ * TODO support multiple triggers
+ */
+ this.$get = [ '$window', '$compile', '$timeout', '$parse', '$document', '$position', '$interpolate', function ( $window, $compile, $timeout, $parse, $document, $position, $interpolate ) {
+ return function $tooltip ( type, prefix, defaultTriggerShow ) {
+ var options = angular.extend( {}, defaultOptions, globalOptions );
+
+ /**
+ * Returns an object of show and hide triggers.
+ *
+ * If a trigger is supplied,
+ * it is used to show the tooltip; otherwise, it will use the `trigger`
+ * option passed to the `$tooltipProvider.options` method; else it will
+ * default to the trigger supplied to this directive factory.
+ *
+ * The hide trigger is based on the show trigger. If the `trigger` option
+ * was passed to the `$tooltipProvider.options` method, it will use the
+ * mapped trigger from `triggerMap` or the passed trigger if the map is
+ * undefined; otherwise, it uses the `triggerMap` value of the show
+ * trigger; else it will just use the show trigger.
+ */
+ function getTriggers ( trigger ) {
+ var show = trigger || options.trigger || defaultTriggerShow;
+ var hide = triggerMap[show] || show;
+ return {
+ show: show,
+ hide: hide
+ };
+ }
+
+ var directiveName = snake_case( type );
+
+ var startSym = $interpolate.startSymbol();
+ var endSym = $interpolate.endSymbol();
+ var template =
+ '<'+ directiveName +'-popup '+
+ 'title="'+startSym+'tt_title'+endSym+'" '+
+ 'content="'+startSym+'tt_content'+endSym+'" '+
+ 'placement="'+startSym+'tt_placement'+endSym+'" '+
+ 'animation="tt_animation" '+
+ 'is-open="tt_isOpen"'+
+ '>'+
+ '</'+ directiveName +'-popup>';
+
+ return {
+ restrict: 'EA',
+ scope: true,
+ link: function link ( scope, element, attrs ) {
+ var tooltip = $compile( template )( scope );
+ var transitionTimeout;
+ var popupTimeout;
+ var $body = $document.find( 'body' );
+ var appendToBody = angular.isDefined( options.appendToBody ) ? options.appendToBody : false;
+ var triggers = getTriggers( undefined );
+ var hasRegisteredTriggers = false;
+ var hasEnableExp = angular.isDefined(attrs[prefix+'Enable']);
+
+ // By default, the tooltip is not open.
+ // TODO add ability to start tooltip opened
+ scope.tt_isOpen = false;
+
+ function toggleTooltipBind () {
+ if ( ! scope.tt_isOpen ) {
+ showTooltipBind();
+ } else {
+ hideTooltipBind();
+ }
+ }
+
+ // Show the tooltip with delay if specified, otherwise show it immediately
+ function showTooltipBind() {
+ if(hasEnableExp && !scope.$eval(attrs[prefix+'Enable'])) {
+ return;
+ }
+ if ( scope.tt_popupDelay ) {
+ popupTimeout = $timeout( show, scope.tt_popupDelay );
+ } else {
+ scope.$apply( show );
+ }
+ }
+
+ function hideTooltipBind () {
+ scope.$apply(function () {
+ hide();
+ });
+ }
+
+ // Show the tooltip popup element.
+ function show() {
+ var position,
+ ttWidth,
+ ttHeight,
+ ttPosition;
+
+ // Don't show empty tooltips.
+ if ( ! scope.tt_content ) {
+ return;
+ }
+
+ // If there is a pending remove transition, we must cancel it, lest the
+ // tooltip be mysteriously removed.
+ if ( transitionTimeout ) {
+ $timeout.cancel( transitionTimeout );
+ }
+
+ // Set the initial positioning.
+ tooltip.css({ top: 0, left: 0, display: 'block' });
+
+ // Now we add it to the DOM because need some info about it. But it's not
+ // visible yet anyway.
+ if ( appendToBody ) {
+ $body.append( tooltip );
+ } else {
+ element.after( tooltip );
+ }
+
+ // Get the position of the directive element.
+ position = appendToBody ? $position.offset( element ) : $position.position( element );
+
+ // Get the height and width of the tooltip so we can center it.
+ ttWidth = tooltip.prop( 'offsetWidth' );
+ ttHeight = tooltip.prop( 'offsetHeight' );
+
+ // Calculate the tooltip's top and left coordinates to center it with
+ // this directive.
+ switch ( scope.tt_placement ) {
+ case 'right':
+ ttPosition = {
+ top: position.top + position.height / 2 - ttHeight / 2,
+ left: position.left + position.width
+ };
+ break;
+ case 'bottom':
+ ttPosition = {
+ top: position.top + position.height,
+ left: position.left + position.width / 2 - ttWidth / 2
+ };
+ break;
+ case 'left':
+ ttPosition = {
+ top: position.top + position.height / 2 - ttHeight / 2,
+ left: position.left - ttWidth
+ };
+ break;
+ default:
+ ttPosition = {
+ top: position.top - ttHeight,
+ left: position.left + position.width / 2 - ttWidth / 2
+ };
+ break;
+ }
+
+ ttPosition.top += 'px';
+ ttPosition.left += 'px';
+
+ // Now set the calculated positioning.
+ tooltip.css( ttPosition );
+
+ // And show the tooltip.
+ scope.tt_isOpen = true;
+ }
+
+ // Hide the tooltip popup element.
+ function hide() {
+ // First things first: we don't show it anymore.
+ scope.tt_isOpen = false;
+
+ //if tooltip is going to be shown after delay, we must cancel this
+ $timeout.cancel( popupTimeout );
+
+ // And now we remove it from the DOM. However, if we have animation, we
+ // need to wait for it to expire beforehand.
+ // FIXME: this is a placeholder for a port of the transitions library.
+ if ( scope.tt_animation ) {
+ transitionTimeout = $timeout(function () {
+ tooltip.remove();
+ }, 500);
+ } else {
+ tooltip.remove();
+ }
+ }
+
+ /**
+ * Observe the relevant attributes.
+ */
+ attrs.$observe( type, function ( val ) {
+ if (val) {
+ scope.tt_content = val;
+ } else {
+ if ( scope.tt_isOpen ) {
+ hide();
+ }
+ }
+ });
+
+ attrs.$observe( prefix+'Title', function ( val ) {
+ scope.tt_title = val;
+ });
+
+ attrs.$observe( prefix+'Placement', function ( val ) {
+ scope.tt_placement = angular.isDefined( val ) ? val : options.placement;
+ });
+
+ attrs.$observe(prefix + 'Animation', function (val) {
+ scope.tt_animation = angular.isDefined(val) ? !!val : options.animation;
+ });
+
+ attrs.$observe( prefix+'PopupDelay', function ( val ) {
+ var delay = parseInt( val, 10 );
+ scope.tt_popupDelay = ! isNaN(delay) ? delay : options.popupDelay;
+ });
+
+ attrs.$observe( prefix+'Trigger', function ( val ) {
+
+ if (hasRegisteredTriggers) {
+ element.unbind( triggers.show, showTooltipBind );
+ element.unbind( triggers.hide, hideTooltipBind );
+ }
+
+ triggers = getTriggers( val );
+
+ if ( triggers.show === triggers.hide ) {
+ element.bind( triggers.show, toggleTooltipBind );
+ } else {
+ element.bind( triggers.show, showTooltipBind );
+ element.bind( triggers.hide, hideTooltipBind );
+ }
+
+ hasRegisteredTriggers = true;
+ });
+
+ attrs.$observe( prefix+'AppendToBody', function ( val ) {
+ appendToBody = angular.isDefined( val ) ? $parse( val )( scope ) : appendToBody;
+ });
+
+ // if a tooltip is attached to <body> we need to remove it on
+ // location change as its parent scope will probably not be destroyed
+ // by the change.
+ if ( appendToBody ) {
+ scope.$on('$locationChangeSuccess', function closeTooltipOnLocationChangeSuccess () {
+ if ( scope.tt_isOpen ) {
+ hide();
+ }
+ });
+ }
+
+ // Make sure tooltip is destroyed and removed.
+ scope.$on('$destroy', function onDestroyTooltip() {
+ $timeout.cancel( popupTimeout );
+ tooltip.remove();
+ tooltip.unbind();
+ tooltip = null;
+ $body = null;
+ });
+ }
+ };
+ };
+ }];
+})
+
+.directive( 'tooltipPopup', function () {
+ return {
+ restrict: 'E',
+ replace: true,
+ scope: { content: '@', placement: '@', animation: '&', isOpen: '&' },
+ templateUrl: 'template/tooltip/tooltip-popup.html'
+ };
+})
+
+.directive( 'tooltip', [ '$tooltip', function ( $tooltip ) {
+ return $tooltip( 'tooltip', 'tooltip', 'mouseenter' );
+}])
+
+.directive( 'tooltipHtmlUnsafePopup', function () {
+ return {
+ restrict: 'E',
+ replace: true,
+ scope: { content: '@', placement: '@', animation: '&', isOpen: '&' },
+ templateUrl: 'template/tooltip/tooltip-html-unsafe-popup.html'
+ };
+})
+
+.directive( 'tooltipHtmlUnsafe', [ '$tooltip', function ( $tooltip ) {
+ return $tooltip( 'tooltipHtmlUnsafe', 'tooltip', 'mouseenter' );
+}]);
+
+/**
+ * The following features are still outstanding: popup delay, animation as a
+ * function, placement as a function, inside, support for more triggers than
+ * just mouse enter/leave, html popovers, and selector delegatation.
+ */
+angular.module( 'ui.bootstrap.popover', [ 'ui.bootstrap.tooltip' ] )
+.directive( 'popoverPopup', function () {
+ return {
+ restrict: 'EA',
+ replace: true,
+ scope: { title: '@', content: '@', placement: '@', animation: '&', isOpen: '&' },
+ templateUrl: 'template/popover/popover.html'
+ };
+})
+.directive( 'popover', [ '$compile', '$timeout', '$parse', '$window', '$tooltip', function ( $compile, $timeout, $parse, $window, $tooltip ) {
+ return $tooltip( 'popover', 'popover', 'click' );
+}]);
+
+
+angular.module('ui.bootstrap.progressbar', ['ui.bootstrap.transition'])
+
+.constant('progressConfig', {
+ animate: true,
+ autoType: false,
+ stackedTypes: ['success', 'info', 'warning', 'danger']
+})
+
+.controller('ProgressBarController', ['$scope', '$attrs', 'progressConfig', function($scope, $attrs, progressConfig) {
+
+ // Whether bar transitions should be animated
+ var animate = angular.isDefined($attrs.animate) ? $scope.$eval($attrs.animate) : progressConfig.animate;
+ var autoType = angular.isDefined($attrs.autoType) ? $scope.$eval($attrs.autoType) : progressConfig.autoType;
+ var stackedTypes = angular.isDefined($attrs.stackedTypes) ? $scope.$eval('[' + $attrs.stackedTypes + ']') : progressConfig.stackedTypes;
+
+ // Create bar object
+ this.makeBar = function(newBar, oldBar, index) {
+ var newValue = (angular.isObject(newBar)) ? newBar.value : (newBar || 0);
+ var oldValue = (angular.isObject(oldBar)) ? oldBar.value : (oldBar || 0);
+ var type = (angular.isObject(newBar) && angular.isDefined(newBar.type)) ? newBar.type : (autoType) ? getStackedType(index || 0) : null;
+
+ return {
+ from: oldValue,
+ to: newValue,
+ type: type,
+ animate: animate
+ };
+ };
+
+ function getStackedType(index) {
+ return stackedTypes[index];
+ }
+
+ this.addBar = function(bar) {
+ $scope.bars.push(bar);
+ $scope.totalPercent += bar.to;
+ };
+
+ this.clearBars = function() {
+ $scope.bars = [];
+ $scope.totalPercent = 0;
+ };
+ this.clearBars();
+}])
+
+.directive('progress', function() {
+ return {
+ restrict: 'EA',
+ replace: true,
+ controller: 'ProgressBarController',
+ scope: {
+ value: '=percent',
+ onFull: '&',
+ onEmpty: '&'
+ },
+ templateUrl: 'template/progressbar/progress.html',
+ link: function(scope, element, attrs, controller) {
+ scope.$watch('value', function(newValue, oldValue) {
+ controller.clearBars();
+
+ if (angular.isArray(newValue)) {
+ // Stacked progress bar
+ for (var i=0, n=newValue.length; i < n; i++) {
+ controller.addBar(controller.makeBar(newValue[i], oldValue[i], i));
+ }
+ } else {
+ // Simple bar
+ controller.addBar(controller.makeBar(newValue, oldValue));
+ }
+ }, true);
+
+ // Total percent listeners
+ scope.$watch('totalPercent', function(value) {
+ if (value >= 100) {
+ scope.onFull();
+ } else if (value <= 0) {
+ scope.onEmpty();
+ }
+ }, true);
+ }
+ };
+})
+
+.directive('progressbar', ['$transition', function($transition) {
+ return {
+ restrict: 'EA',
+ replace: true,
+ scope: {
+ width: '=',
+ old: '=',
+ type: '=',
+ animate: '='
+ },
+ templateUrl: 'template/progressbar/bar.html',
+ link: function(scope, element) {
+ scope.$watch('width', function(value) {
+ if (scope.animate) {
+ element.css('width', scope.old + '%');
+ $transition(element, {width: value + '%'});
+ } else {
+ element.css('width', value + '%');
+ }
+ });
+ }
+ };
+}]);
+angular.module('ui.bootstrap.rating', [])
+
+.constant('ratingConfig', {
+ max: 5,
+ stateOn: null,
+ stateOff: null
+})
+
+.controller('RatingController', ['$scope', '$attrs', '$parse', 'ratingConfig', function($scope, $attrs, $parse, ratingConfig) {
+
+ this.maxRange = angular.isDefined($attrs.max) ? $scope.$parent.$eval($attrs.max) : ratingConfig.max;
+ this.stateOn = angular.isDefined($attrs.stateOn) ? $scope.$parent.$eval($attrs.stateOn) : ratingConfig.stateOn;
+ this.stateOff = angular.isDefined($attrs.stateOff) ? $scope.$parent.$eval($attrs.stateOff) : ratingConfig.stateOff;
+
+ this.createRateObjects = function(states) {
+ var defaultOptions = {
+ stateOn: this.stateOn,
+ stateOff: this.stateOff
+ };
+
+ for (var i = 0, n = states.length; i < n; i++) {
+ states[i] = angular.extend({ index: i }, defaultOptions, states[i]);
+ }
+ return states;
+ };
+
+ // Get objects used in template
+ $scope.range = angular.isDefined($attrs.ratingStates) ? this.createRateObjects(angular.copy($scope.$parent.$eval($attrs.ratingStates))): this.createRateObjects(new Array(this.maxRange));
+
+ $scope.rate = function(value) {
+ if ( $scope.readonly || $scope.value === value) {
+ return;
+ }
+
+ $scope.value = value;
+ };
+
+ $scope.enter = function(value) {
+ if ( ! $scope.readonly ) {
+ $scope.val = value;
+ }
+ $scope.onHover({value: value});
+ };
+
+ $scope.reset = function() {
+ $scope.val = angular.copy($scope.value);
+ $scope.onLeave();
+ };
+
+ $scope.$watch('value', function(value) {
+ $scope.val = value;
+ });
+
+ $scope.readonly = false;
+ if ($attrs.readonly) {
+ $scope.$parent.$watch($parse($attrs.readonly), function(value) {
+ $scope.readonly = !!value;
+ });
+ }
+}])
+
+.directive('rating', function() {
+ return {
+ restrict: 'EA',
+ scope: {
+ value: '=',
+ onHover: '&',
+ onLeave: '&'
+ },
+ controller: 'RatingController',
+ templateUrl: 'template/rating/rating.html',
+ replace: true
+ };
+});
+
+/**
+ * @ngdoc overview
+ * @name ui.bootstrap.tabs
+ *
+ * @description
+ * AngularJS version of the tabs directive.
+ */
+
+angular.module('ui.bootstrap.tabs', [])
+
+.directive('tabs', function() {
+ return function() {
+ throw new Error("The `tabs` directive is deprecated, please migrate to `tabset`. Instructions can be found at http://github.com/angular-ui/bootstrap/tree/master/CHANGELOG.md");
+ };
+})
+
+.controller('TabsetController', ['$scope', function TabsetCtrl($scope) {
+ var ctrl = this,
+ tabs = ctrl.tabs = $scope.tabs = [];
+
+ ctrl.select = function(tab) {
+ angular.forEach(tabs, function(tab) {
+ tab.active = false;
+ });
+ tab.active = true;
+ };
+
+ ctrl.addTab = function addTab(tab) {
+ tabs.push(tab);
+ if (tabs.length === 1 || tab.active) {
+ ctrl.select(tab);
+ }
+ };
+
+ ctrl.removeTab = function removeTab(tab) {
+ var index = tabs.indexOf(tab);
+ //Select a new tab if the tab to be removed is selected
+ if (tab.active && tabs.length > 1) {
+ //If this is the last tab, select the previous tab. else, the next tab.
+ var newActiveIndex = index == tabs.length - 1 ? index - 1 : index + 1;
+ ctrl.select(tabs[newActiveIndex]);
+ }
+ tabs.splice(index, 1);
+ };
+}])
+
+/**
+ * @ngdoc directive
+ * @name ui.bootstrap.tabs.directive:tabset
+ * @restrict EA
+ *
+ * @description
+ * Tabset is the outer container for the tabs directive
+ *
+ * @param {boolean=} vertical Whether or not to use vertical styling for the tabs.
+ * @param {string=} direction What direction the tabs should be rendered. Available:
+ * 'right', 'left', 'below'.
+ *
+ * @example
+<example module="ui.bootstrap">
+ <file name="index.html">
+ <tabset>
+ <tab heading="Vertical Tab 1"><b>First</b> Content!</tab>
+ <tab heading="Vertical Tab 2"><i>Second</i> Content!</tab>
+ </tabset>
+ <hr />
+ <tabset vertical="true">
+ <tab heading="Vertical Tab 1"><b>First</b> Vertical Content!</tab>
+ <tab heading="Vertical Tab 2"><i>Second</i> Vertical Content!</tab>
+ </tabset>
+ </file>
+</example>
+ */
+.directive('tabset', function() {
+ return {
+ restrict: 'EA',
+ transclude: true,
+ replace: true,
+ require: '^tabset',
+ scope: {},
+ controller: 'TabsetController',
+ templateUrl: 'template/tabs/tabset.html',
+ compile: function(elm, attrs, transclude) {
+ return function(scope, element, attrs, tabsetCtrl) {
+ scope.vertical = angular.isDefined(attrs.vertical) ? scope.$parent.$eval(attrs.vertical) : false;
+ scope.type = angular.isDefined(attrs.type) ? scope.$parent.$eval(attrs.type) : 'tabs';
+ scope.direction = angular.isDefined(attrs.direction) ? scope.$parent.$eval(attrs.direction) : 'top';
+ scope.tabsAbove = (scope.direction != 'below');
+ tabsetCtrl.$scope = scope;
+ tabsetCtrl.$transcludeFn = transclude;
+ };
+ }
+ };
+})
+
+/**
+ * @ngdoc directive
+ * @name ui.bootstrap.tabs.directive:tab
+ * @restrict EA
+ *
+ * @param {string=} heading The visible heading, or title, of the tab. Set HTML headings with {@link ui.bootstrap.tabs.directive:tabHeading tabHeading}.
+ * @param {string=} select An expression to evaluate when the tab is selected.
+ * @param {boolean=} active A binding, telling whether or not this tab is selected.
+ * @param {boolean=} disabled A binding, telling whether or not this tab is disabled.
+ *
+ * @description
+ * Creates a tab with a heading and content. Must be placed within a {@link ui.bootstrap.tabs.directive:tabset tabset}.
+ *
+ * @example
+<example module="ui.bootstrap">
+ <file name="index.html">
+ <div ng-controller="TabsDemoCtrl">
+ <button class="btn btn-small" ng-click="items[0].active = true">
+ Select item 1, using active binding
+ </button>
+ <button class="btn btn-small" ng-click="items[1].disabled = !items[1].disabled">
+ Enable/disable item 2, using disabled binding
+ </button>
+ <br />
+ <tabset>
+ <tab heading="Tab 1">First Tab</tab>
+ <tab select="alertMe()">
+ <tab-heading><i class="icon-bell"></i> Alert me!</tab-heading>
+ Second Tab, with alert callback and html heading!
+ </tab>
+ <tab ng-repeat="item in items"
+ heading="{{item.title}}"
+ disabled="item.disabled"
+ active="item.active">
+ {{item.content}}
+ </tab>
+ </tabset>
+ </div>
+ </file>
+ <file name="script.js">
+ function TabsDemoCtrl($scope) {
+ $scope.items = [
+ { title:"Dynamic Title 1", content:"Dynamic Item 0" },
+ { title:"Dynamic Title 2", content:"Dynamic Item 1", disabled: true }
+ ];
+
+ $
<TRUNCATED>