aurora-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ma...@apache.org
Subject [08/29] Upgrade Aurora UI to bootstrap3
Date Wed, 28 May 2014 19:05:17 GMT
http://git-wip-us.apache.org/repos/asf/incubator-aurora/blob/3a992e2c/3rdparty/javascript/bower_components/smart-table/smart-table-module/lib/angular/angular-bootstrap.js
----------------------------------------------------------------------
diff --git a/3rdparty/javascript/bower_components/smart-table/smart-table-module/lib/angular/angular-bootstrap.js
b/3rdparty/javascript/bower_components/smart-table/smart-table-module/lib/angular/angular-bootstrap.js
new file mode 100644
index 0000000..ac18347
--- /dev/null
+++ b/3rdparty/javascript/bower_components/smart-table/smart-table-module/lib/angular/angular-bootstrap.js
@@ -0,0 +1,180 @@
+/**
+ * @license AngularJS v1.0.7
+ * (c) 2010-2012 Google, Inc. http://angularjs.org
+ * License: MIT
+ */
+(function (window, angular, undefined) {
+    'use strict';
+
+    var directive = {};
+
+    directive.dropdownToggle =
+        ['$document', '$location', '$window',
+            function ($document, $location, $window) {
+                var openElement = null, close;
+                return {
+                    restrict: 'C',
+                    link: function (scope, element, attrs) {
+                        scope.$watch(function dropdownTogglePathWatch() {
+                            return $location.path();
+                        }, function dropdownTogglePathWatchAction() {
+                            close && close();
+                        });
+
+                        element.parent().bind('click', function (event) {
+                            close && close();
+                        });
+
+                        element.bind('click', function (event) {
+                            event.preventDefault();
+                            event.stopPropagation();
+
+                            var iWasOpen = false;
+
+                            if (openElement) {
+                                iWasOpen = openElement === element;
+                                close();
+                            }
+
+                            if (!iWasOpen) {
+                                element.parent().addClass('open');
+                                openElement = element;
+
+                                close = function (event) {
+                                    event && event.preventDefault();
+                                    event && event.stopPropagation();
+                                    $document.unbind('click', close);
+                                    element.parent().removeClass('open');
+                                    close = null;
+                                    openElement = null;
+                                }
+
+                                $document.bind('click', close);
+                            }
+                        });
+                    }
+                };
+            }];
+
+
+    directive.tabbable = function () {
+        return {
+            restrict: 'C',
+            compile: function (element) {
+                var navTabs = angular.element('<ul class="nav nav-tabs"></ul>'),
+                    tabContent = angular.element('<div class="tab-content"></div>');
+
+                tabContent.append(element.contents());
+                element.append(navTabs).append(tabContent);
+            },
+            controller: ['$scope', '$element', function ($scope, $element) {
+                var navTabs = $element.contents().eq(0),
+                    ngModel = $element.controller('ngModel') || {},
+                    tabs = [],
+                    selectedTab;
+
+                ngModel.$render = function () {
+                    var $viewValue = this.$viewValue;
+
+                    if (selectedTab ? (selectedTab.value != $viewValue) : $viewValue) {
+                        if (selectedTab) {
+                            selectedTab.paneElement.removeClass('active');
+                            selectedTab.tabElement.removeClass('active');
+                            selectedTab = null;
+                        }
+                        if ($viewValue) {
+                            for (var i = 0, ii = tabs.length; i < ii; i++) {
+                                if ($viewValue == tabs[i].value) {
+                                    selectedTab = tabs[i];
+                                    break;
+                                }
+                            }
+                            if (selectedTab) {
+                                selectedTab.paneElement.addClass('active');
+                                selectedTab.tabElement.addClass('active');
+                            }
+                        }
+
+                    }
+                };
+
+                this.addPane = function (element, attr) {
+                    var li = angular.element('<li><a href></a></li>'),
+                        a = li.find('a'),
+                        tab = {
+                            paneElement: element,
+                            paneAttrs: attr,
+                            tabElement: li
+                        };
+
+                    tabs.push(tab);
+
+                    attr.$observe('value', update)();
+                    attr.$observe('title', function () {
+                        update();
+                        a.text(tab.title);
+                    })();
+
+                    function update() {
+                        tab.title = attr.title;
+                        tab.value = attr.value || attr.title;
+                        if (!ngModel.$setViewValue && (!ngModel.$viewValue || tab
== selectedTab)) {
+                            // we are not part of angular
+                            ngModel.$viewValue = tab.value;
+                        }
+                        ngModel.$render();
+                    }
+
+                    navTabs.append(li);
+                    li.bind('click', function (event) {
+                        event.preventDefault();
+                        event.stopPropagation();
+                        if (ngModel.$setViewValue) {
+                            $scope.$apply(function () {
+                                ngModel.$setViewValue(tab.value);
+                                ngModel.$render();
+                            });
+                        } else {
+                            // we are not part of angular
+                            ngModel.$viewValue = tab.value;
+                            ngModel.$render();
+                        }
+                    });
+
+                    return function () {
+                        tab.tabElement.remove();
+                        for (var i = 0, ii = tabs.length; i < ii; i++) {
+                            if (tab == tabs[i]) {
+                                tabs.splice(i, 1);
+                            }
+                        }
+                    };
+                }
+            }]
+        };
+    };
+
+    directive.table = function () {
+        return {
+            restrict: 'E',
+            link: function (scope, element, attrs) {
+                element[0].className = 'table table-bordered table-striped code-table';
+            }
+        };
+    };
+
+    directive.tabPane = function () {
+        return {
+            require: '^tabbable',
+            restrict: 'C',
+            link: function (scope, element, attrs, tabsCtrl) {
+                element.bind('$remove', tabsCtrl.addPane(element, attrs));
+            }
+        };
+    };
+
+
+    angular.module('bootstrap', []).directive(directive);
+
+
+})(window, window.angular);

http://git-wip-us.apache.org/repos/asf/incubator-aurora/blob/3a992e2c/3rdparty/javascript/bower_components/smart-table/smart-table-module/lib/angular/angular-cookies.js
----------------------------------------------------------------------
diff --git a/3rdparty/javascript/bower_components/smart-table/smart-table-module/lib/angular/angular-cookies.js
b/3rdparty/javascript/bower_components/smart-table/smart-table-module/lib/angular/angular-cookies.js
new file mode 100644
index 0000000..63a87b7
--- /dev/null
+++ b/3rdparty/javascript/bower_components/smart-table/smart-table-module/lib/angular/angular-cookies.js
@@ -0,0 +1,185 @@
+/**
+ * @license AngularJS v1.0.7
+ * (c) 2010-2012 Google, Inc. http://angularjs.org
+ * License: MIT
+ */
+(function (window, angular, undefined) {
+    'use strict';
+
+    /**
+     * @ngdoc overview
+     * @name ngCookies
+     */
+
+
+    angular.module('ngCookies', ['ng']).
+    /**
+     * @ngdoc object
+     * @name ngCookies.$cookies
+     * @requires $browser
+     *
+     * @description
+     * Provides read/write access to browser's cookies.
+     *
+     * Only a simple Object is exposed and by adding or removing properties to/from
+     * this object, new cookies are created/deleted at the end of current $eval.
+     *
+     * @example
+     <doc:example>
+     <doc:source>
+     <script>
+     function ExampleController($cookies) {
+           // Retrieving a cookie
+           var favoriteCookie = $cookies.myFavorite;
+           // Setting a cookie
+           $cookies.myFavorite = 'oatmeal';
+         }
+     </script>
+     </doc:source>
+     </doc:example>
+     */
+        factory('$cookies', ['$rootScope', '$browser', function ($rootScope, $browser) {
+            var cookies = {},
+                lastCookies = {},
+                lastBrowserCookies,
+                runEval = false,
+                copy = angular.copy,
+                isUndefined = angular.isUndefined;
+
+            //creates a poller fn that copies all cookies from the $browser to service &
inits the service
+            $browser.addPollFn(function () {
+                var currentCookies = $browser.cookies();
+                if (lastBrowserCookies != currentCookies) { //relies on browser.cookies()
impl
+                    lastBrowserCookies = currentCookies;
+                    copy(currentCookies, lastCookies);
+                    copy(currentCookies, cookies);
+                    if (runEval) $rootScope.$apply();
+                }
+            })();
+
+            runEval = true;
+
+            //at the end of each eval, push cookies
+            //TODO: this should happen before the "delayed" watches fire, because if some
cookies are not
+            //      strings or browser refuses to store some cookies, we update the model
in the push fn.
+            $rootScope.$watch(push);
+
+            return cookies;
+
+
+            /**
+             * Pushes all the cookies from the service to the browser and verifies if all
cookies were stored.
+             */
+            function push() {
+                var name,
+                    value,
+                    browserCookies,
+                    updated;
+
+                //delete any cookies deleted in $cookies
+                for (name in lastCookies) {
+                    if (isUndefined(cookies[name])) {
+                        $browser.cookies(name, undefined);
+                    }
+                }
+
+                //update all cookies updated in $cookies
+                for (name in cookies) {
+                    value = cookies[name];
+                    if (!angular.isString(value)) {
+                        if (angular.isDefined(lastCookies[name])) {
+                            cookies[name] = lastCookies[name];
+                        } else {
+                            delete cookies[name];
+                        }
+                    } else if (value !== lastCookies[name]) {
+                        $browser.cookies(name, value);
+                        updated = true;
+                    }
+                }
+
+                //verify what was actually stored
+                if (updated) {
+                    updated = false;
+                    browserCookies = $browser.cookies();
+
+                    for (name in cookies) {
+                        if (cookies[name] !== browserCookies[name]) {
+                            //delete or reset all cookies that the browser dropped from $cookies
+                            if (isUndefined(browserCookies[name])) {
+                                delete cookies[name];
+                            } else {
+                                cookies[name] = browserCookies[name];
+                            }
+                            updated = true;
+                        }
+                    }
+                }
+            }
+        }]).
+
+
+    /**
+     * @ngdoc object
+     * @name ngCookies.$cookieStore
+     * @requires $cookies
+     *
+     * @description
+     * Provides a key-value (string-object) storage, that is backed by session cookies.
+     * Objects put or retrieved from this storage are automatically serialized or
+     * deserialized by angular's toJson/fromJson.
+     * @example
+     */
+        factory('$cookieStore', ['$cookies', function ($cookies) {
+
+            return {
+                /**
+                 * @ngdoc method
+                 * @name ngCookies.$cookieStore#get
+                 * @methodOf ngCookies.$cookieStore
+                 *
+                 * @description
+                 * Returns the value of given cookie key
+                 *
+                 * @param {string} key Id to use for lookup.
+                 * @returns {Object} Deserialized cookie value.
+                 */
+                get: function (key) {
+                    var value = $cookies[key];
+                    return value ? angular.fromJson(value) : value;
+                },
+
+                /**
+                 * @ngdoc method
+                 * @name ngCookies.$cookieStore#put
+                 * @methodOf ngCookies.$cookieStore
+                 *
+                 * @description
+                 * Sets a value for given cookie key
+                 *
+                 * @param {string} key Id for the `value`.
+                 * @param {Object} value Value to be stored.
+                 */
+                put: function (key, value) {
+                    $cookies[key] = angular.toJson(value);
+                },
+
+                /**
+                 * @ngdoc method
+                 * @name ngCookies.$cookieStore#remove
+                 * @methodOf ngCookies.$cookieStore
+                 *
+                 * @description
+                 * Remove given cookie
+                 *
+                 * @param {string} key Id of the key-value pair to delete.
+                 */
+                remove: function (key) {
+                    delete $cookies[key];
+                }
+            };
+
+        }]);
+
+
+})(window, window.angular);

http://git-wip-us.apache.org/repos/asf/incubator-aurora/blob/3a992e2c/3rdparty/javascript/bower_components/smart-table/smart-table-module/lib/angular/angular-loader.js
----------------------------------------------------------------------
diff --git a/3rdparty/javascript/bower_components/smart-table/smart-table-module/lib/angular/angular-loader.js
b/3rdparty/javascript/bower_components/smart-table/smart-table-module/lib/angular/angular-loader.js
new file mode 100644
index 0000000..327f1c0
--- /dev/null
+++ b/3rdparty/javascript/bower_components/smart-table/smart-table-module/lib/angular/angular-loader.js
@@ -0,0 +1,273 @@
+/**
+ * @license AngularJS v1.0.7
+ * (c) 2010-2012 Google, Inc. http://angularjs.org
+ * License: MIT
+ */
+
+(/**
+ * @ngdoc interface
+ * @name angular.Module
+ * @description
+ *
+ * Interface for configuring angular {@link angular.module modules}.
+ */
+
+    function setupModuleLoader(window) {
+
+    function ensure(obj, name, factory) {
+        return obj[name] || (obj[name] = factory());
+    }
+
+    return ensure(ensure(window, 'angular', Object), 'module', function () {
+        /** @type {Object.<string, angular.Module>} */
+        var modules = {};
+
+        /**
+         * @ngdoc function
+         * @name angular.module
+         * @description
+         *
+         * The `angular.module` is a global place for creating and registering Angular modules.
All
+         * modules (angular core or 3rd party) that should be available to an application
must be
+         * registered using this mechanism.
+         *
+         *
+         * # Module
+         *
+         * A module is a collocation of services, directives, filters, and configuration
information. Module
+         * is used to configure the {@link AUTO.$injector $injector}.
+         *
+         * <pre>
+         * // Create a new module
+         * var myModule = angular.module('myModule', []);
+         *
+         * // register a new service
+         * myModule.value('appName', 'MyCoolApp');
+         *
+         * // configure existing services inside initialization blocks.
+         * myModule.config(function($locationProvider) {
+'use strict';
+     *   // Configure existing providers
+     *   $locationProvider.hashPrefix('!');
+     * });
+         * </pre>
+         *
+         * Then you can create an injector and load your modules like this:
+         *
+         * <pre>
+         * var injector = angular.injector(['ng', 'MyModule'])
+         * </pre>
+         *
+         * However it's more likely that you'll just use
+         * {@link ng.directive:ngApp ngApp} or
+         * {@link angular.bootstrap} to simplify this process for you.
+         *
+         * @param {!string} name The name of the module to create or retrieve.
+         * @param {Array.<string>=} requires If specified then new module is being
created. If unspecified then the
+         *        the module is being retrieved for further configuration.
+         * @param {Function} configFn Optional configuration function for the module. Same
as
+         *        {@link angular.Module#config Module#config()}.
+         * @returns {module} new module with the {@link angular.Module} api.
+         */
+        return function module(name, requires, configFn) {
+            if (requires && modules.hasOwnProperty(name)) {
+                modules[name] = null;
+            }
+            return ensure(modules, name, function () {
+                if (!requires) {
+                    throw Error('No module: ' + name);
+                }
+
+                /** @type {!Array.<Array.<*>>} */
+                var invokeQueue = [];
+
+                /** @type {!Array.<Function>} */
+                var runBlocks = [];
+
+                var config = invokeLater('$injector', 'invoke');
+
+                /** @type {angular.Module} */
+                var moduleInstance = {
+                    // Private state
+                    _invokeQueue: invokeQueue,
+                    _runBlocks: runBlocks,
+
+                    /**
+                     * @ngdoc property
+                     * @name angular.Module#requires
+                     * @propertyOf angular.Module
+                     * @returns {Array.<string>} List of module names which must be
loaded before this module.
+                     * @description
+                     * Holds the list of modules which the injector will load before the
current module is loaded.
+                     */
+                    requires: requires,
+
+                    /**
+                     * @ngdoc property
+                     * @name angular.Module#name
+                     * @propertyOf angular.Module
+                     * @returns {string} Name of the module.
+                     * @description
+                     */
+                    name: name,
+
+
+                    /**
+                     * @ngdoc method
+                     * @name angular.Module#provider
+                     * @methodOf angular.Module
+                     * @param {string} name service name
+                     * @param {Function} providerType Construction function for creating
new instance of the service.
+                     * @description
+                     * See {@link AUTO.$provide#provider $provide.provider()}.
+                     */
+                    provider: invokeLater('$provide', 'provider'),
+
+                    /**
+                     * @ngdoc method
+                     * @name angular.Module#factory
+                     * @methodOf angular.Module
+                     * @param {string} name service name
+                     * @param {Function} providerFunction Function for creating new instance
of the service.
+                     * @description
+                     * See {@link AUTO.$provide#factory $provide.factory()}.
+                     */
+                    factory: invokeLater('$provide', 'factory'),
+
+                    /**
+                     * @ngdoc method
+                     * @name angular.Module#service
+                     * @methodOf angular.Module
+                     * @param {string} name service name
+                     * @param {Function} constructor A constructor function that will be
instantiated.
+                     * @description
+                     * See {@link AUTO.$provide#service $provide.service()}.
+                     */
+                    service: invokeLater('$provide', 'service'),
+
+                    /**
+                     * @ngdoc method
+                     * @name angular.Module#value
+                     * @methodOf angular.Module
+                     * @param {string} name service name
+                     * @param {*} object Service instance object.
+                     * @description
+                     * See {@link AUTO.$provide#value $provide.value()}.
+                     */
+                    value: invokeLater('$provide', 'value'),
+
+                    /**
+                     * @ngdoc method
+                     * @name angular.Module#constant
+                     * @methodOf angular.Module
+                     * @param {string} name constant name
+                     * @param {*} object Constant value.
+                     * @description
+                     * Because the constant are fixed, they get applied before other provide
methods.
+                     * See {@link AUTO.$provide#constant $provide.constant()}.
+                     */
+                    constant: invokeLater('$provide', 'constant', 'unshift'),
+
+                    /**
+                     * @ngdoc method
+                     * @name angular.Module#filter
+                     * @methodOf angular.Module
+                     * @param {string} name Filter name.
+                     * @param {Function} filterFactory Factory function for creating new
instance of filter.
+                     * @description
+                     * See {@link ng.$filterProvider#register $filterProvider.register()}.
+                     */
+                    filter: invokeLater('$filterProvider', 'register'),
+
+                    /**
+                     * @ngdoc method
+                     * @name angular.Module#controller
+                     * @methodOf angular.Module
+                     * @param {string} name Controller name.
+                     * @param {Function} constructor Controller constructor function.
+                     * @description
+                     * See {@link ng.$controllerProvider#register $controllerProvider.register()}.
+                     */
+                    controller: invokeLater('$controllerProvider', 'register'),
+
+                    /**
+                     * @ngdoc method
+                     * @name angular.Module#directive
+                     * @methodOf angular.Module
+                     * @param {string} name directive name
+                     * @param {Function} directiveFactory Factory function for creating new
instance of
+                     * directives.
+                     * @description
+                     * See {@link ng.$compileProvider#directive $compileProvider.directive()}.
+                     */
+                    directive: invokeLater('$compileProvider', 'directive'),
+
+                    /**
+                     * @ngdoc method
+                     * @name angular.Module#config
+                     * @methodOf angular.Module
+                     * @param {Function} configFn Execute this function on module load. Useful
for service
+                     *    configuration.
+                     * @description
+                     * Use this method to register work which needs to be performed on module
loading.
+                     */
+                    config: config,
+
+                    /**
+                     * @ngdoc method
+                     * @name angular.Module#run
+                     * @methodOf angular.Module
+                     * @param {Function} initializationFn Execute this function after injector
creation.
+                     *    Useful for application initialization.
+                     * @description
+                     * Use this method to register work which should be performed when the
injector is done
+                     * loading all modules.
+                     */
+                    run: function (block) {
+                        runBlocks.push(block);
+                        return this;
+                    }
+                };
+
+                if (configFn) {
+                    config(configFn);
+                }
+
+                return  moduleInstance;
+
+                /**
+                 * @param {string} provider
+                 * @param {string} method
+                 * @param {String=} insertMethod
+                 * @returns {angular.Module}
+                 */
+                function invokeLater(provider, method, insertMethod) {
+                    return function () {
+                        invokeQueue[insertMethod || 'push']([provider, method, arguments]);
+                        return moduleInstance;
+                    }
+                }
+            });
+        };
+    });
+
+})(window);
+
+/**
+ * Closure compiler type information
+ *
+ * @typedef { {
+ *   requires: !Array.<string>,
+ *   invokeQueue: !Array.<Array.<*>>,
+ *
+ *   service: function(string, Function):angular.Module,
+ *   factory: function(string, Function):angular.Module,
+ *   value: function(string, *):angular.Module,
+ *
+ *   filter: function(string, Function):angular.Module,
+ *
+ *   init: function(Function):angular.Module
+ * } }
+ */
+angular.Module;
+


Mime
View raw message