2016-01-21 17:23:03 +03:00
|
|
|
|
/* global oc_isadmin */
|
|
|
|
|
|
2013-02-07 11:11:18 +04:00
|
|
|
|
var oc_debug;
|
|
|
|
|
var oc_webroot;
|
2013-06-26 13:23:21 +04:00
|
|
|
|
|
|
|
|
|
var oc_current_user = document.getElementsByTagName('head')[0].getAttribute('data-user');
|
|
|
|
|
var oc_requesttoken = document.getElementsByTagName('head')[0].getAttribute('data-requesttoken');
|
|
|
|
|
|
2014-02-04 16:56:10 +04:00
|
|
|
|
window.oc_config = window.oc_config || {};
|
|
|
|
|
|
2013-02-08 21:44:52 +04:00
|
|
|
|
if (typeof oc_webroot === "undefined") {
|
2013-12-13 15:54:08 +04:00
|
|
|
|
oc_webroot = location.pathname;
|
|
|
|
|
var pos = oc_webroot.indexOf('/index.php/');
|
|
|
|
|
if (pos !== -1) {
|
|
|
|
|
oc_webroot = oc_webroot.substr(0, pos);
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
oc_webroot = oc_webroot.substr(0, oc_webroot.lastIndexOf('/'));
|
|
|
|
|
}
|
2013-02-08 21:44:52 +04:00
|
|
|
|
}
|
2016-09-05 12:25:47 +03:00
|
|
|
|
if (typeof console === "undefined" || typeof console.log === "undefined") {
|
2012-11-15 22:43:10 +04:00
|
|
|
|
if (!window.console) {
|
|
|
|
|
window.console = {};
|
|
|
|
|
}
|
2014-04-15 06:44:24 +04:00
|
|
|
|
var noOp = function() { };
|
2014-03-17 22:39:19 +04:00
|
|
|
|
var methods = ['log', 'debug', 'warn', 'info', 'error', 'assert', 'time', 'timeEnd'];
|
2012-11-15 22:43:10 +04:00
|
|
|
|
for (var i = 0; i < methods.length; i++) {
|
2014-04-15 06:44:24 +04:00
|
|
|
|
console[methods[i]] = noOp;
|
2012-11-15 22:43:10 +04:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2013-07-07 22:26:09 +04:00
|
|
|
|
/**
|
2014-04-21 15:46:33 +04:00
|
|
|
|
* Sanitizes a HTML string by replacing all potential dangerous characters with HTML entities
|
2014-04-21 16:42:50 +04:00
|
|
|
|
* @param {string} s String to sanitize
|
2014-04-21 15:46:33 +04:00
|
|
|
|
* @return {string} Sanitized string
|
2012-10-12 16:01:47 +04:00
|
|
|
|
*/
|
|
|
|
|
function escapeHTML(s) {
|
2014-04-13 17:24:35 +04:00
|
|
|
|
return s.toString().split('&').join('&').split('<').join('<').split('>').join('>').split('"').join('"').split('\'').join(''');
|
2012-10-12 16:01:47 +04:00
|
|
|
|
}
|
|
|
|
|
|
2014-06-24 01:56:10 +04:00
|
|
|
|
/** @namespace */
|
2016-09-19 20:43:47 +03:00
|
|
|
|
var OCP = {},
|
|
|
|
|
OC = {
|
2017-11-02 16:55:58 +03:00
|
|
|
|
PERMISSION_NONE:0,
|
2012-08-31 02:59:10 +04:00
|
|
|
|
PERMISSION_CREATE:4,
|
|
|
|
|
PERMISSION_READ:1,
|
|
|
|
|
PERMISSION_UPDATE:2,
|
|
|
|
|
PERMISSION_DELETE:8,
|
|
|
|
|
PERMISSION_SHARE:16,
|
2013-08-14 00:58:27 +04:00
|
|
|
|
PERMISSION_ALL:31,
|
2014-11-18 20:53:45 +03:00
|
|
|
|
TAG_FAVORITE: '_$!<Favorite>!$_',
|
2014-05-26 20:43:26 +04:00
|
|
|
|
/* jshint camelcase: false */
|
2015-07-13 16:26:01 +03:00
|
|
|
|
/**
|
2016-11-24 18:05:05 +03:00
|
|
|
|
* Relative path to Nextcloud root.
|
|
|
|
|
* For example: "/nextcloud"
|
2015-07-13 16:26:01 +03:00
|
|
|
|
*
|
|
|
|
|
* @type string
|
|
|
|
|
*
|
|
|
|
|
* @deprecated since 8.2, use OC.getRootPath() instead
|
|
|
|
|
* @see OC#getRootPath
|
|
|
|
|
*/
|
2011-07-26 00:30:55 +04:00
|
|
|
|
webroot:oc_webroot,
|
2015-07-13 16:26:01 +03:00
|
|
|
|
|
2017-12-01 12:36:13 +03:00
|
|
|
|
/**
|
|
|
|
|
* Capabilities
|
|
|
|
|
*
|
|
|
|
|
* @type array
|
|
|
|
|
*/
|
|
|
|
|
_capabilities: window.oc_capabilities || null,
|
|
|
|
|
|
2013-01-07 23:15:51 +04:00
|
|
|
|
appswebroots:(typeof oc_appswebroots !== 'undefined') ? oc_appswebroots:false,
|
2016-02-01 17:11:42 +03:00
|
|
|
|
/**
|
|
|
|
|
* Currently logged in user or null if none
|
|
|
|
|
*
|
|
|
|
|
* @type String
|
|
|
|
|
* @deprecated use {@link OC.getCurrentUser} instead
|
|
|
|
|
*/
|
2011-08-11 18:53:00 +04:00
|
|
|
|
currentUser:(typeof oc_current_user!=='undefined')?oc_current_user:false,
|
2014-05-30 21:02:19 +04:00
|
|
|
|
config: window.oc_config,
|
|
|
|
|
appConfig: window.oc_appconfig || {},
|
|
|
|
|
theme: window.oc_defaults || {},
|
2015-01-13 18:42:04 +03:00
|
|
|
|
coreApps:['', 'admin','log','core/search','settings','core','3rdparty'],
|
2015-08-26 18:08:25 +03:00
|
|
|
|
requestToken: oc_requesttoken,
|
2015-03-26 13:59:30 +03:00
|
|
|
|
menuSpeed: 50,
|
2014-05-19 17:44:19 +04:00
|
|
|
|
|
2011-08-07 01:18:49 +04:00
|
|
|
|
/**
|
2014-04-21 15:46:33 +04:00
|
|
|
|
* Get an absolute url to a file in an app
|
|
|
|
|
* @param {string} app the id of the app the file belongs to
|
|
|
|
|
* @param {string} file the file path relative to the app folder
|
|
|
|
|
* @return {string} Absolute URL to a file
|
2011-08-07 01:18:49 +04:00
|
|
|
|
*/
|
2011-07-26 00:30:55 +04:00
|
|
|
|
linkTo:function(app,file){
|
|
|
|
|
return OC.filePath(app,'',file);
|
|
|
|
|
},
|
2014-10-07 14:02:58 +04:00
|
|
|
|
|
2013-01-25 19:00:26 +04:00
|
|
|
|
/**
|
2014-04-21 15:46:33 +04:00
|
|
|
|
* Creates a relative url for remote use
|
|
|
|
|
* @param {string} service id
|
|
|
|
|
* @return {string} the url
|
2013-01-25 19:00:26 +04:00
|
|
|
|
*/
|
|
|
|
|
linkToRemoteBase:function(service) {
|
|
|
|
|
return OC.webroot + '/remote.php/' + service;
|
|
|
|
|
},
|
2014-03-03 01:30:24 +04:00
|
|
|
|
|
2014-04-21 15:46:33 +04:00
|
|
|
|
/**
|
|
|
|
|
* @brief Creates an absolute url for remote use
|
|
|
|
|
* @param {string} service id
|
|
|
|
|
* @return {string} the url
|
|
|
|
|
*/
|
|
|
|
|
linkToRemote:function(service) {
|
|
|
|
|
return window.location.protocol + '//' + window.location.host + OC.linkToRemoteBase(service);
|
|
|
|
|
},
|
2014-04-30 19:42:35 +04:00
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Gets the base path for the given OCS API service.
|
|
|
|
|
* @param {string} service name
|
2015-11-16 16:21:45 +03:00
|
|
|
|
* @param {int} version OCS API version
|
2014-04-30 19:42:35 +04:00
|
|
|
|
* @return {string} OCS API base path
|
|
|
|
|
*/
|
2015-11-16 16:21:45 +03:00
|
|
|
|
linkToOCS: function(service, version) {
|
|
|
|
|
version = (version !== 2) ? 1 : 2;
|
|
|
|
|
return window.location.protocol + '//' + window.location.host + OC.webroot + '/ocs/v' + version + '.php/' + service + '/';
|
2014-04-30 19:42:35 +04:00
|
|
|
|
},
|
|
|
|
|
|
2014-03-03 02:15:37 +04:00
|
|
|
|
/**
|
|
|
|
|
* Generates the absolute url for the given relative url, which can contain parameters.
|
2015-02-16 22:07:45 +03:00
|
|
|
|
* Parameters will be URL encoded automatically.
|
2014-04-21 16:42:50 +04:00
|
|
|
|
* @param {string} url
|
2015-02-11 16:01:22 +03:00
|
|
|
|
* @param [params] params
|
2015-02-16 22:07:45 +03:00
|
|
|
|
* @param [options] options
|
|
|
|
|
* @param {bool} [options.escape=true] enable/disable auto escape of placeholders (by default enabled)
|
2014-04-21 15:46:33 +04:00
|
|
|
|
* @return {string} Absolute URL for the given relative URL
|
2014-03-03 02:15:37 +04:00
|
|
|
|
*/
|
2015-02-16 22:07:45 +03:00
|
|
|
|
generateUrl: function(url, params, options) {
|
|
|
|
|
var defaultOptions = {
|
|
|
|
|
escape: true
|
|
|
|
|
},
|
|
|
|
|
allOptions = options || {};
|
|
|
|
|
_.defaults(allOptions, defaultOptions);
|
|
|
|
|
|
2014-03-03 01:30:24 +04:00
|
|
|
|
var _build = function (text, vars) {
|
2017-05-01 07:09:29 +03:00
|
|
|
|
vars = vars || [];
|
2014-03-03 01:30:24 +04:00
|
|
|
|
return text.replace(/{([^{}]*)}/g,
|
|
|
|
|
function (a, b) {
|
2015-02-16 22:07:45 +03:00
|
|
|
|
var r = (vars[b]);
|
|
|
|
|
if(allOptions.escape) {
|
|
|
|
|
return (typeof r === 'string' || typeof r === 'number') ? encodeURIComponent(r) : encodeURIComponent(a);
|
|
|
|
|
} else {
|
|
|
|
|
return (typeof r === 'string' || typeof r === 'number') ? r : a;
|
|
|
|
|
}
|
2014-03-03 01:30:24 +04:00
|
|
|
|
}
|
|
|
|
|
);
|
|
|
|
|
};
|
|
|
|
|
if (url.charAt(0) !== '/') {
|
|
|
|
|
url = '/' + url;
|
|
|
|
|
|
|
|
|
|
}
|
2015-02-11 03:10:03 +03:00
|
|
|
|
|
|
|
|
|
if(oc_config.modRewriteWorking == true) {
|
|
|
|
|
return OC.webroot + _build(url, params);
|
|
|
|
|
}
|
|
|
|
|
|
2014-03-03 01:30:24 +04:00
|
|
|
|
return OC.webroot + '/index.php' + _build(url, params);
|
|
|
|
|
},
|
|
|
|
|
|
2013-01-25 19:00:26 +04:00
|
|
|
|
/**
|
2014-04-21 15:46:33 +04:00
|
|
|
|
* Get the absolute url for a file in an app
|
|
|
|
|
* @param {string} app the id of the app
|
|
|
|
|
* @param {string} type the type of the file to link to (e.g. css,img,ajax.template)
|
|
|
|
|
* @param {string} file the filename
|
|
|
|
|
* @return {string} Absolute URL for a file in an app
|
2011-08-07 01:18:49 +04:00
|
|
|
|
*/
|
2011-07-26 00:30:55 +04:00
|
|
|
|
filePath:function(app,type,file){
|
2012-09-23 05:16:52 +04:00
|
|
|
|
var isCore=OC.coreApps.indexOf(app)!==-1,
|
|
|
|
|
link=OC.webroot;
|
2014-07-21 15:03:14 +04:00
|
|
|
|
if(file.substring(file.length-3) === 'php' && !isCore){
|
2012-08-15 19:38:55 +04:00
|
|
|
|
link+='/index.php/apps/' + app;
|
2012-05-11 07:04:27 +04:00
|
|
|
|
if (file != 'index.php') {
|
2012-08-15 19:38:55 +04:00
|
|
|
|
link+='/';
|
2012-05-11 07:04:27 +04:00
|
|
|
|
if(type){
|
|
|
|
|
link+=encodeURI(type + '/');
|
|
|
|
|
}
|
|
|
|
|
link+= file;
|
2012-04-24 23:54:09 +04:00
|
|
|
|
}
|
2012-09-23 05:16:52 +04:00
|
|
|
|
}else if(file.substring(file.length-3) !== 'php' && !isCore){
|
2012-06-06 23:54:57 +04:00
|
|
|
|
link=OC.appswebroots[app];
|
2012-04-24 23:33:34 +04:00
|
|
|
|
if(type){
|
2012-06-22 14:24:10 +04:00
|
|
|
|
link+= '/'+type+'/';
|
2012-04-24 23:33:34 +04:00
|
|
|
|
}
|
2012-09-23 05:16:52 +04:00
|
|
|
|
if(link.substring(link.length-1) !== '/'){
|
2012-07-04 01:58:08 +04:00
|
|
|
|
link+='/';
|
2012-09-23 05:16:52 +04:00
|
|
|
|
}
|
2012-04-24 23:54:09 +04:00
|
|
|
|
link+=file;
|
2012-04-21 00:35:12 +04:00
|
|
|
|
}else{
|
2012-10-28 22:28:44 +04:00
|
|
|
|
if ((app == 'settings' || app == 'core' || app == 'search') && type == 'ajax') {
|
2012-09-29 20:08:54 +04:00
|
|
|
|
link+='/index.php/';
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
link+='/';
|
|
|
|
|
}
|
2012-04-21 00:35:12 +04:00
|
|
|
|
if(!isCore){
|
|
|
|
|
link+='apps/';
|
|
|
|
|
}
|
2012-09-23 05:16:52 +04:00
|
|
|
|
if (app !== '') {
|
2012-05-07 20:35:02 +04:00
|
|
|
|
app+='/';
|
|
|
|
|
link+=app;
|
|
|
|
|
}
|
2012-04-21 00:35:12 +04:00
|
|
|
|
if(type){
|
|
|
|
|
link+=type+'/';
|
|
|
|
|
}
|
2012-07-31 14:21:06 +04:00
|
|
|
|
link+=file;
|
2011-07-26 00:30:55 +04:00
|
|
|
|
}
|
|
|
|
|
return link;
|
|
|
|
|
},
|
2014-10-07 14:02:58 +04:00
|
|
|
|
|
2017-02-13 18:51:23 +03:00
|
|
|
|
/**
|
|
|
|
|
* Check if a user file is allowed to be handled.
|
|
|
|
|
* @param {string} file to check
|
|
|
|
|
*/
|
|
|
|
|
fileIsBlacklisted: function(file) {
|
|
|
|
|
return !!(file.match(oc_config.blacklist_files_regex));
|
|
|
|
|
},
|
|
|
|
|
|
2014-01-24 16:32:31 +04:00
|
|
|
|
/**
|
|
|
|
|
* Redirect to the target URL, can also be used for downloads.
|
2014-04-21 15:46:33 +04:00
|
|
|
|
* @param {string} targetURL URL to redirect to
|
2014-01-24 16:32:31 +04:00
|
|
|
|
*/
|
2014-04-21 16:42:50 +04:00
|
|
|
|
redirect: function(targetURL) {
|
|
|
|
|
window.location = targetURL;
|
2014-01-24 16:32:31 +04:00
|
|
|
|
},
|
2014-10-07 14:02:58 +04:00
|
|
|
|
|
2015-12-10 20:08:40 +03:00
|
|
|
|
/**
|
|
|
|
|
* Reloads the current page
|
|
|
|
|
*/
|
|
|
|
|
reload: function() {
|
|
|
|
|
window.location.reload();
|
|
|
|
|
},
|
|
|
|
|
|
2015-01-19 13:56:04 +03:00
|
|
|
|
/**
|
2016-11-24 18:05:05 +03:00
|
|
|
|
* Protocol that is used to access this Nextcloud instance
|
2015-01-19 13:56:04 +03:00
|
|
|
|
* @return {string} Used protocol
|
|
|
|
|
*/
|
|
|
|
|
getProtocol: function() {
|
|
|
|
|
return window.location.protocol.split(':')[0];
|
|
|
|
|
},
|
|
|
|
|
|
2015-07-13 16:26:01 +03:00
|
|
|
|
/**
|
2016-11-24 18:05:05 +03:00
|
|
|
|
* Returns the host used to access this Nextcloud instance
|
2016-02-03 13:28:07 +03:00
|
|
|
|
* Host is sometimes the same as the hostname but now always.
|
2015-07-13 16:26:01 +03:00
|
|
|
|
*
|
2016-02-03 13:28:07 +03:00
|
|
|
|
* Examples:
|
|
|
|
|
* http://example.com => example.com
|
2016-04-04 11:57:17 +03:00
|
|
|
|
* https://example.com => example.com
|
2016-02-03 13:28:07 +03:00
|
|
|
|
* http://example.com:8080 => example.com:8080
|
|
|
|
|
*
|
|
|
|
|
* @return {string} host
|
2015-07-13 16:26:01 +03:00
|
|
|
|
*
|
|
|
|
|
* @since 8.2
|
|
|
|
|
*/
|
|
|
|
|
getHost: function() {
|
|
|
|
|
return window.location.host;
|
|
|
|
|
},
|
|
|
|
|
|
2016-02-03 13:28:07 +03:00
|
|
|
|
/**
|
2016-11-24 18:05:05 +03:00
|
|
|
|
* Returns the hostname used to access this Nextcloud instance
|
2016-02-03 13:28:07 +03:00
|
|
|
|
* The hostname is always stripped of the port
|
|
|
|
|
*
|
|
|
|
|
* @return {string} hostname
|
|
|
|
|
* @since 9.0
|
|
|
|
|
*/
|
|
|
|
|
getHostName: function() {
|
|
|
|
|
return window.location.hostname;
|
|
|
|
|
},
|
|
|
|
|
|
2015-07-13 16:26:01 +03:00
|
|
|
|
/**
|
2016-11-24 18:05:05 +03:00
|
|
|
|
* Returns the port number used to access this Nextcloud instance
|
2015-07-13 16:26:01 +03:00
|
|
|
|
*
|
|
|
|
|
* @return {int} port number
|
|
|
|
|
*
|
|
|
|
|
* @since 8.2
|
|
|
|
|
*/
|
|
|
|
|
getPort: function() {
|
|
|
|
|
return window.location.port;
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
/**
|
2016-11-24 18:05:05 +03:00
|
|
|
|
* Returns the web root path where this Nextcloud instance
|
2015-07-13 16:26:01 +03:00
|
|
|
|
* is accessible, with a leading slash.
|
2016-11-24 18:05:05 +03:00
|
|
|
|
* For example "/nextcloud".
|
2015-07-13 16:26:01 +03:00
|
|
|
|
*
|
|
|
|
|
* @return {string} web root path
|
|
|
|
|
*
|
|
|
|
|
* @since 8.2
|
|
|
|
|
*/
|
|
|
|
|
getRootPath: function() {
|
|
|
|
|
return OC.webroot;
|
|
|
|
|
},
|
|
|
|
|
|
2017-12-01 12:36:13 +03:00
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Returns the capabilities
|
|
|
|
|
*
|
|
|
|
|
* @return {array} capabilities
|
|
|
|
|
*
|
2018-02-15 13:06:51 +03:00
|
|
|
|
* @since 14.0
|
2017-12-01 12:36:13 +03:00
|
|
|
|
*/
|
|
|
|
|
getCapabilities: function() {
|
|
|
|
|
return OC._capabilities;
|
|
|
|
|
},
|
|
|
|
|
|
2016-02-01 17:11:42 +03:00
|
|
|
|
/**
|
|
|
|
|
* Returns the currently logged in user or null if there is no logged in
|
|
|
|
|
* user (public page mode)
|
|
|
|
|
*
|
|
|
|
|
* @return {OC.CurrentUser} user spec
|
|
|
|
|
* @since 9.0.0
|
|
|
|
|
*/
|
|
|
|
|
getCurrentUser: function() {
|
|
|
|
|
if (_.isUndefined(this._currentUserDisplayName)) {
|
|
|
|
|
this._currentUserDisplayName = document.getElementsByTagName('head')[0].getAttribute('data-user-displayname');
|
|
|
|
|
}
|
|
|
|
|
return {
|
|
|
|
|
uid: this.currentUser,
|
|
|
|
|
displayName: this._currentUserDisplayName
|
|
|
|
|
};
|
|
|
|
|
},
|
|
|
|
|
|
2011-08-07 01:18:49 +04:00
|
|
|
|
/**
|
|
|
|
|
* get the absolute path to an image file
|
2014-10-07 14:02:58 +04:00
|
|
|
|
* if no extension is given for the image, it will automatically decide
|
2014-04-21 15:46:33 +04:00
|
|
|
|
* between .png and .svg based on what the browser supports
|
|
|
|
|
* @param {string} app the app id to which the image belongs
|
|
|
|
|
* @param {string} file the name of the image file
|
|
|
|
|
* @return {string}
|
2012-07-31 14:21:06 +04:00
|
|
|
|
*/
|
2011-07-26 00:30:55 +04:00
|
|
|
|
imagePath:function(app,file){
|
2016-06-23 13:15:16 +03:00
|
|
|
|
if(file.indexOf('.')==-1){//if no extension is given, use svg
|
|
|
|
|
file+='.svg';
|
2011-07-28 06:28:04 +04:00
|
|
|
|
}
|
2011-07-26 00:30:55 +04:00
|
|
|
|
return OC.filePath(app,'img',file);
|
|
|
|
|
},
|
2014-10-07 14:02:58 +04:00
|
|
|
|
|
2014-11-18 20:53:45 +03:00
|
|
|
|
/**
|
|
|
|
|
* URI-Encodes a file path but keep the path slashes.
|
|
|
|
|
*
|
|
|
|
|
* @param path path
|
|
|
|
|
* @return encoded path
|
|
|
|
|
*/
|
|
|
|
|
encodePath: function(path) {
|
|
|
|
|
if (!path) {
|
|
|
|
|
return path;
|
|
|
|
|
}
|
|
|
|
|
var parts = path.split('/');
|
|
|
|
|
var result = [];
|
|
|
|
|
for (var i = 0; i < parts.length; i++) {
|
|
|
|
|
result.push(encodeURIComponent(parts[i]));
|
|
|
|
|
}
|
|
|
|
|
return result.join('/');
|
|
|
|
|
},
|
|
|
|
|
|
2011-08-07 01:18:49 +04:00
|
|
|
|
/**
|
2014-10-07 14:02:58 +04:00
|
|
|
|
* Load a script for the server and load it. If the script is already loaded,
|
2014-04-22 11:54:25 +04:00
|
|
|
|
* the event handler will be called directly
|
2014-04-21 15:46:33 +04:00
|
|
|
|
* @param {string} app the app id to which the script belongs
|
2014-04-21 16:42:50 +04:00
|
|
|
|
* @param {string} script the filename of the script
|
2014-04-22 11:54:25 +04:00
|
|
|
|
* @param ready event handler to be called when the script is loaded
|
2011-08-07 01:18:49 +04:00
|
|
|
|
*/
|
2011-07-26 00:30:55 +04:00
|
|
|
|
addScript:function(app,script,ready){
|
2012-09-23 05:16:52 +04:00
|
|
|
|
var deferred, path=OC.filePath(app,'js',script+'.js');
|
2017-03-26 15:11:58 +03:00
|
|
|
|
if(!OC.addScript.loaded[path]) {
|
2017-03-26 20:45:36 +03:00
|
|
|
|
deferred = jQuery.ajax({
|
|
|
|
|
url: path,
|
|
|
|
|
cache: true,
|
|
|
|
|
success: function (content) {
|
2017-06-09 14:43:09 +03:00
|
|
|
|
window.eval(content);
|
2017-03-26 20:45:36 +03:00
|
|
|
|
if(ready) {
|
2017-03-26 15:17:01 +03:00
|
|
|
|
ready();
|
2017-03-26 16:26:10 +03:00
|
|
|
|
}
|
2017-03-26 20:45:36 +03:00
|
|
|
|
}
|
|
|
|
|
});
|
2017-03-26 15:11:58 +03:00
|
|
|
|
OC.addScript.loaded[path] = deferred;
|
|
|
|
|
} else {
|
|
|
|
|
if (ready) {
|
2011-07-30 23:18:54 +04:00
|
|
|
|
ready();
|
|
|
|
|
}
|
2011-07-26 00:30:55 +04:00
|
|
|
|
}
|
2012-08-29 03:57:35 +04:00
|
|
|
|
return OC.addScript.loaded[path];
|
2011-07-26 00:30:55 +04:00
|
|
|
|
},
|
2011-08-07 01:18:49 +04:00
|
|
|
|
/**
|
2014-04-21 15:46:33 +04:00
|
|
|
|
* Loads a CSS file
|
|
|
|
|
* @param {string} app the app id to which the css style belongs
|
2014-04-21 16:42:50 +04:00
|
|
|
|
* @param {string} style the filename of the css file
|
2011-08-07 01:18:49 +04:00
|
|
|
|
*/
|
2011-07-26 00:30:55 +04:00
|
|
|
|
addStyle:function(app,style){
|
|
|
|
|
var path=OC.filePath(app,'css',style+'.css');
|
2012-09-23 05:16:52 +04:00
|
|
|
|
if(OC.addStyle.loaded.indexOf(path)===-1){
|
2011-09-26 23:18:56 +04:00
|
|
|
|
OC.addStyle.loaded.push(path);
|
2013-07-02 19:44:10 +04:00
|
|
|
|
if (document.createStyleSheet) {
|
|
|
|
|
document.createStyleSheet(path);
|
|
|
|
|
} else {
|
|
|
|
|
style=$('<link rel="stylesheet" type="text/css" href="'+path+'"/>');
|
|
|
|
|
$('head').append(style);
|
|
|
|
|
}
|
2011-07-30 20:05:20 +04:00
|
|
|
|
}
|
|
|
|
|
},
|
2014-10-07 14:02:58 +04:00
|
|
|
|
|
2014-11-18 14:13:44 +03:00
|
|
|
|
/**
|
|
|
|
|
* Loads translations for the given app asynchronously.
|
|
|
|
|
*
|
|
|
|
|
* @param {String} app app name
|
|
|
|
|
* @param {Function} callback callback to call after loading
|
|
|
|
|
* @return {Promise}
|
|
|
|
|
*/
|
|
|
|
|
addTranslations: function(app, callback) {
|
|
|
|
|
return OC.L10N.load(app, callback);
|
|
|
|
|
},
|
|
|
|
|
|
2014-04-21 15:46:33 +04:00
|
|
|
|
/**
|
2014-06-24 01:56:10 +04:00
|
|
|
|
* Returns the base name of the given path.
|
|
|
|
|
* For example for "/abc/somefile.txt" it will return "somefile.txt"
|
|
|
|
|
*
|
|
|
|
|
* @param {String} path
|
|
|
|
|
* @return {String} base name
|
2014-04-21 15:46:33 +04:00
|
|
|
|
*/
|
2012-09-09 01:56:37 +04:00
|
|
|
|
basename: function(path) {
|
|
|
|
|
return path.replace(/\\/g,'/').replace( /.*\//, '' );
|
|
|
|
|
},
|
2014-10-07 14:02:58 +04:00
|
|
|
|
|
2014-04-21 15:46:33 +04:00
|
|
|
|
/**
|
2014-06-24 01:56:10 +04:00
|
|
|
|
* Returns the dir name of the given path.
|
|
|
|
|
* For example for "/abc/somefile.txt" it will return "/abc"
|
|
|
|
|
*
|
|
|
|
|
* @param {String} path
|
|
|
|
|
* @return {String} dir name
|
2014-04-21 15:46:33 +04:00
|
|
|
|
*/
|
2012-09-09 01:56:37 +04:00
|
|
|
|
dirname: function(path) {
|
2012-09-23 05:16:52 +04:00
|
|
|
|
return path.replace(/\\/g,'/').replace(/\/[^\/]*$/, '');
|
2012-09-09 02:35:02 +04:00
|
|
|
|
},
|
2014-10-07 14:02:58 +04:00
|
|
|
|
|
2015-12-21 15:10:03 +03:00
|
|
|
|
/**
|
|
|
|
|
* Returns whether the given paths are the same, without
|
|
|
|
|
* leading, trailing or doubled slashes and also removing
|
|
|
|
|
* the dot sections.
|
|
|
|
|
*
|
|
|
|
|
* @param {String} path1 first path
|
|
|
|
|
* @param {String} path2 second path
|
|
|
|
|
* @return {bool} true if the paths are the same
|
|
|
|
|
*
|
|
|
|
|
* @since 9.0
|
|
|
|
|
*/
|
|
|
|
|
isSamePath: function(path1, path2) {
|
|
|
|
|
var filterDot = function(p) {
|
|
|
|
|
return p !== '.';
|
|
|
|
|
};
|
|
|
|
|
var pathSections1 = _.filter((path1 || '').split('/'), filterDot);
|
|
|
|
|
var pathSections2 = _.filter((path2 || '').split('/'), filterDot);
|
|
|
|
|
path1 = OC.joinPaths.apply(OC, pathSections1);
|
|
|
|
|
path2 = OC.joinPaths.apply(OC, pathSections2);
|
|
|
|
|
return path1 === path2;
|
|
|
|
|
},
|
|
|
|
|
|
2015-07-10 14:01:01 +03:00
|
|
|
|
/**
|
|
|
|
|
* Join path sections
|
|
|
|
|
*
|
|
|
|
|
* @param {...String} path sections
|
|
|
|
|
*
|
|
|
|
|
* @return {String} joined path, any leading or trailing slash
|
|
|
|
|
* will be kept
|
|
|
|
|
*
|
|
|
|
|
* @since 8.2
|
|
|
|
|
*/
|
|
|
|
|
joinPaths: function() {
|
|
|
|
|
if (arguments.length < 1) {
|
|
|
|
|
return '';
|
|
|
|
|
}
|
|
|
|
|
var path = '';
|
2015-07-13 11:57:52 +03:00
|
|
|
|
// convert to array
|
|
|
|
|
var args = Array.prototype.slice.call(arguments);
|
|
|
|
|
// discard empty arguments
|
|
|
|
|
args = _.filter(args, function(arg) {
|
|
|
|
|
return arg.length > 0;
|
|
|
|
|
});
|
|
|
|
|
if (args.length < 1) {
|
|
|
|
|
return '';
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
var lastArg = args[args.length - 1];
|
|
|
|
|
var leadingSlash = args[0].charAt(0) === '/';
|
2015-07-10 14:01:01 +03:00
|
|
|
|
var trailingSlash = lastArg.charAt(lastArg.length - 1) === '/';
|
|
|
|
|
var sections = [];
|
|
|
|
|
var i;
|
2015-07-13 11:57:52 +03:00
|
|
|
|
for (i = 0; i < args.length; i++) {
|
|
|
|
|
sections = sections.concat(args[i].split('/'));
|
2015-07-10 14:01:01 +03:00
|
|
|
|
}
|
|
|
|
|
var first = !leadingSlash;
|
|
|
|
|
for (i = 0; i < sections.length; i++) {
|
|
|
|
|
if (sections[i] !== '') {
|
|
|
|
|
if (first) {
|
|
|
|
|
first = false;
|
|
|
|
|
} else {
|
|
|
|
|
path += '/';
|
|
|
|
|
}
|
|
|
|
|
path += sections[i];
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (trailingSlash) {
|
|
|
|
|
// add it back
|
|
|
|
|
path += '/';
|
|
|
|
|
}
|
|
|
|
|
return path;
|
|
|
|
|
},
|
|
|
|
|
|
2011-08-07 01:18:49 +04:00
|
|
|
|
/**
|
2014-04-21 15:46:33 +04:00
|
|
|
|
* Do a search query and display the results
|
|
|
|
|
* @param {string} query the search query
|
2011-08-07 01:18:49 +04:00
|
|
|
|
*/
|
2014-12-10 19:11:02 +03:00
|
|
|
|
search: function (query) {
|
2014-12-17 20:49:39 +03:00
|
|
|
|
OC.Search.search(query, null, 0, 30);
|
2014-12-10 19:11:02 +03:00
|
|
|
|
},
|
2014-06-24 01:56:10 +04:00
|
|
|
|
/**
|
|
|
|
|
* Dialog helper for jquery dialogs.
|
|
|
|
|
*
|
|
|
|
|
* @namespace OC.dialogs
|
|
|
|
|
*/
|
2012-04-02 21:39:24 +04:00
|
|
|
|
dialogs:OCdialogs,
|
2013-08-17 15:07:18 +04:00
|
|
|
|
/**
|
|
|
|
|
* Parses a URL query string into a JS map
|
2014-04-21 15:46:33 +04:00
|
|
|
|
* @param {string} queryString query string in the format param1=1234¶m2=abcde¶m3=xyz
|
2014-06-24 01:56:10 +04:00
|
|
|
|
* @return {Object.<string, string>} map containing key/values matching the URL parameters
|
2013-08-17 15:07:18 +04:00
|
|
|
|
*/
|
|
|
|
|
parseQueryString:function(queryString){
|
|
|
|
|
var parts,
|
2014-01-28 19:16:09 +04:00
|
|
|
|
pos,
|
2013-08-17 15:07:18 +04:00
|
|
|
|
components,
|
|
|
|
|
result = {},
|
|
|
|
|
key,
|
|
|
|
|
value;
|
|
|
|
|
if (!queryString){
|
|
|
|
|
return null;
|
|
|
|
|
}
|
2014-01-28 19:16:09 +04:00
|
|
|
|
pos = queryString.indexOf('?');
|
|
|
|
|
if (pos >= 0){
|
|
|
|
|
queryString = queryString.substr(pos + 1);
|
2013-08-17 15:07:18 +04:00
|
|
|
|
}
|
2014-01-28 19:16:09 +04:00
|
|
|
|
parts = queryString.replace(/\+/g, '%20').split('&');
|
2013-08-17 15:07:18 +04:00
|
|
|
|
for (var i = 0; i < parts.length; i++){
|
2014-01-28 19:16:09 +04:00
|
|
|
|
// split on first equal sign
|
2014-04-21 16:28:54 +04:00
|
|
|
|
var part = parts[i];
|
2014-01-28 19:16:09 +04:00
|
|
|
|
pos = part.indexOf('=');
|
|
|
|
|
if (pos >= 0) {
|
|
|
|
|
components = [
|
|
|
|
|
part.substr(0, pos),
|
|
|
|
|
part.substr(pos + 1)
|
2014-04-15 06:44:24 +04:00
|
|
|
|
];
|
2014-01-28 19:16:09 +04:00
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
// key only
|
|
|
|
|
components = [part];
|
|
|
|
|
}
|
2013-08-17 15:07:18 +04:00
|
|
|
|
if (!components.length){
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
key = decodeURIComponent(components[0]);
|
|
|
|
|
if (!key){
|
|
|
|
|
continue;
|
|
|
|
|
}
|
2014-01-28 19:16:09 +04:00
|
|
|
|
// if equal sign was there, return string
|
|
|
|
|
if (components.length > 1) {
|
|
|
|
|
result[key] = decodeURIComponent(components[1]);
|
|
|
|
|
}
|
|
|
|
|
// no equal sign => null value
|
|
|
|
|
else {
|
|
|
|
|
result[key] = null;
|
|
|
|
|
}
|
2013-08-17 15:07:18 +04:00
|
|
|
|
}
|
|
|
|
|
return result;
|
|
|
|
|
},
|
2014-01-24 15:44:31 +04:00
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Builds a URL query from a JS map.
|
2014-06-24 01:56:10 +04:00
|
|
|
|
* @param {Object.<string, string>} params map containing key/values matching the URL parameters
|
2014-04-21 15:46:33 +04:00
|
|
|
|
* @return {string} String containing a URL query (without question) mark
|
2014-01-24 15:44:31 +04:00
|
|
|
|
*/
|
|
|
|
|
buildQueryString: function(params) {
|
|
|
|
|
if (!params) {
|
2014-04-15 06:44:24 +04:00
|
|
|
|
return '';
|
2014-01-24 15:44:31 +04:00
|
|
|
|
}
|
2014-04-15 06:44:24 +04:00
|
|
|
|
return $.map(params, function(value, key) {
|
|
|
|
|
var s = encodeURIComponent(key);
|
2014-01-24 15:44:31 +04:00
|
|
|
|
if (value !== null && typeof(value) !== 'undefined') {
|
|
|
|
|
s += '=' + encodeURIComponent(value);
|
|
|
|
|
}
|
2014-04-15 06:44:24 +04:00
|
|
|
|
return s;
|
|
|
|
|
}).join('&');
|
2014-01-24 15:44:31 +04:00
|
|
|
|
},
|
|
|
|
|
|
2012-07-31 18:03:08 +04:00
|
|
|
|
/**
|
|
|
|
|
* Opens a popup with the setting for an app.
|
2014-04-21 15:46:33 +04:00
|
|
|
|
* @param {string} appid The ID of the app e.g. 'calendar', 'contacts' or 'files'.
|
|
|
|
|
* @param {boolean|string} loadJS If true 'js/settings.js' is loaded. If it's a string
|
2012-07-31 18:03:08 +04:00
|
|
|
|
* it will attempt to load a script by that name in the 'js' directory.
|
2014-04-21 15:46:33 +04:00
|
|
|
|
* @param {boolean} [cache] If true the javascript file won't be forced refreshed. Defaults to true.
|
|
|
|
|
* @param {string} [scriptName] The name of the PHP file to load. Defaults to 'settings.php' in
|
2012-07-31 18:03:08 +04:00
|
|
|
|
* the root of the app directory hierarchy.
|
|
|
|
|
*/
|
2012-07-31 16:17:28 +04:00
|
|
|
|
appSettings:function(args) {
|
|
|
|
|
if(typeof args === 'undefined' || typeof args.appid === 'undefined') {
|
2012-07-31 18:03:08 +04:00
|
|
|
|
throw { name: 'MissingParameter', message: 'The parameter appid is missing' };
|
2012-07-31 16:17:28 +04:00
|
|
|
|
}
|
2012-07-31 18:03:08 +04:00
|
|
|
|
var props = {scriptName:'settings.php', cache:true};
|
|
|
|
|
$.extend(props, args);
|
2012-07-31 14:21:06 +04:00
|
|
|
|
var settings = $('#appsettings');
|
2014-04-15 06:44:24 +04:00
|
|
|
|
if(settings.length === 0) {
|
2012-07-31 18:03:08 +04:00
|
|
|
|
throw { name: 'MissingDOMElement', message: 'There has be be an element with id "appsettings" for the popup to show.' };
|
|
|
|
|
}
|
2012-08-12 20:42:54 +04:00
|
|
|
|
var popup = $('#appsettings_popup');
|
2014-04-15 06:44:24 +04:00
|
|
|
|
if(popup.length === 0) {
|
2012-08-12 20:42:54 +04:00
|
|
|
|
$('body').prepend('<div class="popup hidden" id="appsettings_popup"></div>');
|
2013-02-09 20:20:08 +04:00
|
|
|
|
popup = $('#appsettings_popup');
|
2012-08-12 20:42:54 +04:00
|
|
|
|
popup.addClass(settings.hasClass('topright') ? 'topright' : 'bottomleft');
|
|
|
|
|
}
|
|
|
|
|
if(popup.is(':visible')) {
|
|
|
|
|
popup.hide().remove();
|
2012-07-31 14:21:06 +04:00
|
|
|
|
} else {
|
2012-08-12 20:42:54 +04:00
|
|
|
|
var arrowclass = settings.hasClass('topright') ? 'up' : 'left';
|
|
|
|
|
var jqxhr = $.get(OC.filePath(props.appid, '', props.scriptName), function(data) {
|
|
|
|
|
popup.html(data).ready(function() {
|
2016-06-23 14:39:28 +03:00
|
|
|
|
popup.prepend('<span class="arrow '+arrowclass+'"></span><h2>'+t('core', 'Settings')+'</h2><a class="close"></a>').show();
|
2012-08-12 20:42:54 +04:00
|
|
|
|
popup.find('.close').bind('click', function() {
|
|
|
|
|
popup.remove();
|
2012-09-06 00:17:33 +04:00
|
|
|
|
});
|
2012-08-12 20:42:54 +04:00
|
|
|
|
if(typeof props.loadJS !== 'undefined') {
|
|
|
|
|
var scriptname;
|
|
|
|
|
if(props.loadJS === true) {
|
|
|
|
|
scriptname = 'settings.js';
|
|
|
|
|
} else if(typeof props.loadJS === 'string') {
|
|
|
|
|
scriptname = props.loadJS;
|
|
|
|
|
} else {
|
|
|
|
|
throw { name: 'InvalidParameter', message: 'The "loadJS" parameter must be either boolean or a string.' };
|
2012-07-31 18:03:08 +04:00
|
|
|
|
}
|
2012-08-12 20:42:54 +04:00
|
|
|
|
if(props.cache) {
|
|
|
|
|
$.ajaxSetup({cache: true});
|
|
|
|
|
}
|
|
|
|
|
$.getScript(OC.filePath(props.appid, 'js', scriptname))
|
|
|
|
|
.fail(function(jqxhr, settings, e) {
|
|
|
|
|
throw e;
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
}).show();
|
|
|
|
|
}, 'html');
|
2012-07-31 14:21:06 +04:00
|
|
|
|
}
|
2014-03-14 13:33:19 +04:00
|
|
|
|
},
|
|
|
|
|
|
2014-04-21 15:46:33 +04:00
|
|
|
|
/**
|
2014-04-22 11:54:25 +04:00
|
|
|
|
* For menu toggling
|
2014-04-21 15:46:33 +04:00
|
|
|
|
* @todo Write documentation
|
2017-01-24 09:47:14 +03:00
|
|
|
|
*
|
|
|
|
|
* @param {jQuery} $toggle
|
|
|
|
|
* @param {jQuery} $menuEl
|
|
|
|
|
* @param {function|undefined} toggle callback invoked everytime the menu is opened
|
2018-02-21 17:12:42 +03:00
|
|
|
|
* @param {boolean} headerMenu is this a top right header menu?
|
2017-01-24 09:47:14 +03:00
|
|
|
|
* @returns {undefined}
|
2014-04-21 15:46:33 +04:00
|
|
|
|
*/
|
2018-02-21 17:12:42 +03:00
|
|
|
|
registerMenu: function($toggle, $menuEl, toggle, headerMenu) {
|
2015-07-16 16:28:45 +03:00
|
|
|
|
var self = this;
|
2014-03-14 13:33:19 +04:00
|
|
|
|
$menuEl.addClass('menu');
|
2018-08-22 10:47:00 +03:00
|
|
|
|
|
|
|
|
|
// On link, the enter key trigger a click event
|
|
|
|
|
// Only use the click to avoid two fired events
|
|
|
|
|
$toggle.on($toggle.prop('tagName') === 'A'
|
|
|
|
|
? 'click.menu'
|
|
|
|
|
: 'click.menu keyup.menu', function(event) {
|
2015-04-09 15:46:26 +03:00
|
|
|
|
// prevent the link event (append anchor to URL)
|
|
|
|
|
event.preventDefault();
|
|
|
|
|
|
2018-07-20 21:51:23 +03:00
|
|
|
|
// allow enter key as a trigger
|
2018-07-23 11:17:32 +03:00
|
|
|
|
if (event.key && event.key !== "Enter") {
|
2018-07-20 21:51:23 +03:00
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2014-03-14 13:33:19 +04:00
|
|
|
|
if ($menuEl.is(OC._currentMenu)) {
|
2015-07-16 16:28:45 +03:00
|
|
|
|
self.hideMenus();
|
2015-04-09 15:46:26 +03:00
|
|
|
|
return;
|
2014-03-14 13:33:19 +04:00
|
|
|
|
}
|
|
|
|
|
// another menu was open?
|
|
|
|
|
else if (OC._currentMenu) {
|
|
|
|
|
// close it
|
2015-07-16 16:28:45 +03:00
|
|
|
|
self.hideMenus();
|
2014-03-14 13:33:19 +04:00
|
|
|
|
}
|
2018-02-21 11:48:07 +03:00
|
|
|
|
|
2018-02-21 17:12:42 +03:00
|
|
|
|
if (headerMenu === true) {
|
2018-02-22 11:59:48 +03:00
|
|
|
|
$menuEl.parent().addClass('openedMenu');
|
2018-02-21 17:12:42 +03:00
|
|
|
|
}
|
2018-02-21 11:48:07 +03:00
|
|
|
|
|
2018-04-18 14:33:08 +03:00
|
|
|
|
// Set menu to expanded
|
|
|
|
|
$toggle.attr('aria-expanded', true);
|
|
|
|
|
|
2017-01-24 09:47:14 +03:00
|
|
|
|
$menuEl.slideToggle(OC.menuSpeed, toggle);
|
2014-03-14 13:33:19 +04:00
|
|
|
|
OC._currentMenu = $menuEl;
|
|
|
|
|
OC._currentMenuToggle = $toggle;
|
|
|
|
|
});
|
2014-03-18 16:09:25 +04:00
|
|
|
|
},
|
|
|
|
|
|
2014-04-21 15:46:33 +04:00
|
|
|
|
/**
|
|
|
|
|
* @todo Write documentation
|
|
|
|
|
*/
|
2014-03-18 16:09:25 +04:00
|
|
|
|
unregisterMenu: function($toggle, $menuEl) {
|
|
|
|
|
// close menu if opened
|
|
|
|
|
if ($menuEl.is(OC._currentMenu)) {
|
2015-07-16 16:28:45 +03:00
|
|
|
|
this.hideMenus();
|
2014-03-18 16:09:25 +04:00
|
|
|
|
}
|
|
|
|
|
$toggle.off('click.menu').removeClass('menutoggle');
|
|
|
|
|
$menuEl.removeClass('menu');
|
2014-03-18 19:02:13 +04:00
|
|
|
|
},
|
|
|
|
|
|
2015-07-16 16:28:45 +03:00
|
|
|
|
/**
|
|
|
|
|
* Hides any open menus
|
|
|
|
|
*
|
|
|
|
|
* @param {Function} complete callback when the hiding animation is done
|
|
|
|
|
*/
|
|
|
|
|
hideMenus: function(complete) {
|
|
|
|
|
if (OC._currentMenu) {
|
2015-08-11 12:35:46 +03:00
|
|
|
|
var lastMenu = OC._currentMenu;
|
2015-07-16 16:28:45 +03:00
|
|
|
|
OC._currentMenu.trigger(new $.Event('beforeHide'));
|
2015-08-11 12:35:46 +03:00
|
|
|
|
OC._currentMenu.slideUp(OC.menuSpeed, function() {
|
|
|
|
|
lastMenu.trigger(new $.Event('afterHide'));
|
|
|
|
|
if (complete) {
|
|
|
|
|
complete.apply(this, arguments);
|
|
|
|
|
}
|
|
|
|
|
});
|
2015-07-16 16:28:45 +03:00
|
|
|
|
}
|
2018-04-18 14:33:08 +03:00
|
|
|
|
|
|
|
|
|
// Set menu to closed
|
|
|
|
|
$('.menutoggle').attr('aria-expanded', false);
|
|
|
|
|
|
2018-02-21 11:48:07 +03:00
|
|
|
|
$('.openedMenu').removeClass('openedMenu');
|
2015-07-16 16:28:45 +03:00
|
|
|
|
OC._currentMenu = null;
|
|
|
|
|
OC._currentMenuToggle = null;
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Shows a given element as menu
|
|
|
|
|
*
|
|
|
|
|
* @param {Object} [$toggle=null] menu toggle
|
|
|
|
|
* @param {Object} $menuEl menu element
|
|
|
|
|
* @param {Function} complete callback when the showing animation is done
|
|
|
|
|
*/
|
|
|
|
|
showMenu: function($toggle, $menuEl, complete) {
|
|
|
|
|
if ($menuEl.is(OC._currentMenu)) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
this.hideMenus();
|
|
|
|
|
OC._currentMenu = $menuEl;
|
|
|
|
|
OC._currentMenuToggle = $toggle;
|
|
|
|
|
$menuEl.trigger(new $.Event('beforeShow'));
|
|
|
|
|
$menuEl.show();
|
|
|
|
|
$menuEl.trigger(new $.Event('afterShow'));
|
|
|
|
|
// no animation
|
2015-08-12 18:28:55 +03:00
|
|
|
|
if (_.isFunction(complete)) {
|
2015-07-16 16:28:45 +03:00
|
|
|
|
complete();
|
|
|
|
|
}
|
|
|
|
|
},
|
|
|
|
|
|
2014-03-18 19:02:13 +04:00
|
|
|
|
/**
|
|
|
|
|
* Wrapper for matchMedia
|
|
|
|
|
*
|
|
|
|
|
* This is makes it possible for unit tests to
|
|
|
|
|
* stub matchMedia (which doesn't work in PhantomJS)
|
2014-06-24 01:56:10 +04:00
|
|
|
|
* @private
|
2014-03-18 19:02:13 +04:00
|
|
|
|
*/
|
|
|
|
|
_matchMedia: function(media) {
|
|
|
|
|
if (window.matchMedia) {
|
|
|
|
|
return window.matchMedia(media);
|
|
|
|
|
}
|
|
|
|
|
return false;
|
2014-11-18 14:13:44 +03:00
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Returns the user's locale
|
|
|
|
|
*
|
|
|
|
|
* @return {String} locale string
|
|
|
|
|
*/
|
|
|
|
|
getLocale: function() {
|
2017-11-12 12:38:33 +03:00
|
|
|
|
return $('html').data('locale');
|
2017-07-17 11:08:51 +03:00
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Returns the user's language
|
|
|
|
|
*
|
|
|
|
|
* @returns {String} language string
|
|
|
|
|
*/
|
|
|
|
|
getLanguage: function () {
|
2014-11-18 14:13:44 +03:00
|
|
|
|
return $('html').prop('lang');
|
2016-01-21 17:23:03 +03:00
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Returns whether the current user is an administrator
|
|
|
|
|
*
|
|
|
|
|
* @return {bool} true if the user is an admin, false otherwise
|
|
|
|
|
* @since 9.0.0
|
|
|
|
|
*/
|
|
|
|
|
isUserAdmin: function() {
|
|
|
|
|
return oc_isadmin;
|
|
|
|
|
},
|
2015-12-10 20:08:40 +03:00
|
|
|
|
|
2016-09-20 00:49:42 +03:00
|
|
|
|
/**
|
|
|
|
|
* Warn users that the connection to the server was lost temporarily
|
|
|
|
|
*
|
|
|
|
|
* This function is throttled to prevent stacked notfications.
|
|
|
|
|
* After 7sec the first notification is gone, then we can show another one
|
|
|
|
|
* if necessary.
|
|
|
|
|
*/
|
|
|
|
|
_ajaxConnectionLostHandler: _.throttle(function() {
|
|
|
|
|
OC.Notification.showTemporary(t('core', 'Connection to server lost'));
|
|
|
|
|
}, 7 * 1000, {trailing: false}),
|
|
|
|
|
|
2015-12-10 20:08:40 +03:00
|
|
|
|
/**
|
|
|
|
|
* Process ajax error, redirects to main page
|
|
|
|
|
* if an error/auth error status was returned.
|
|
|
|
|
*/
|
|
|
|
|
_processAjaxError: function(xhr) {
|
2016-03-22 20:28:54 +03:00
|
|
|
|
var self = this;
|
2015-12-10 20:08:40 +03:00
|
|
|
|
// purposefully aborted request ?
|
2016-03-22 18:54:01 +03:00
|
|
|
|
// this._userIsNavigatingAway needed to distinguish ajax calls cancelled by navigating away
|
|
|
|
|
// from calls cancelled by failed cross-domain ajax due to SSO redirect
|
2016-03-22 20:28:54 +03:00
|
|
|
|
if (xhr.status === 0 && (xhr.statusText === 'abort' || xhr.statusText === 'timeout' || self._reloadCalled)) {
|
2015-12-10 20:08:40 +03:00
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2016-12-02 01:44:50 +03:00
|
|
|
|
if (_.contains([302, 303, 307, 401], xhr.status) && OC.currentUser) {
|
2016-03-22 20:28:54 +03:00
|
|
|
|
// sometimes "beforeunload" happens later, so need to defer the reload a bit
|
|
|
|
|
setTimeout(function() {
|
|
|
|
|
if (!self._userIsNavigatingAway && !self._reloadCalled) {
|
2017-02-04 08:47:09 +03:00
|
|
|
|
var timer = 0;
|
|
|
|
|
var seconds = 5;
|
|
|
|
|
var interval = setInterval( function() {
|
2017-02-08 09:55:31 +03:00
|
|
|
|
OC.Notification.showUpdate(n('core', 'Problem loading page, reloading in %n second', 'Problem loading page, reloading in %n seconds', seconds - timer));
|
2017-02-04 08:47:09 +03:00
|
|
|
|
if (timer >= seconds) {
|
2017-02-08 09:55:31 +03:00
|
|
|
|
clearInterval(interval);
|
2017-02-04 08:47:09 +03:00
|
|
|
|
OC.reload();
|
2017-02-08 09:55:31 +03:00
|
|
|
|
}
|
2017-02-04 08:47:09 +03:00
|
|
|
|
timer++;
|
|
|
|
|
}, 1000 // 1 second interval
|
|
|
|
|
);
|
|
|
|
|
|
2016-03-22 20:28:54 +03:00
|
|
|
|
// only call reload once
|
|
|
|
|
self._reloadCalled = true;
|
|
|
|
|
}
|
|
|
|
|
}, 100);
|
2016-09-20 00:49:42 +03:00
|
|
|
|
} else if(xhr.status === 0) {
|
|
|
|
|
// Connection lost (e.g. WiFi disconnected or server is down)
|
|
|
|
|
setTimeout(function() {
|
|
|
|
|
if (!self._userIsNavigatingAway && !self._reloadCalled) {
|
|
|
|
|
self._ajaxConnectionLostHandler();
|
|
|
|
|
}
|
|
|
|
|
}, 100);
|
2015-12-10 20:08:40 +03:00
|
|
|
|
}
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Registers XmlHttpRequest object for global error processing.
|
|
|
|
|
*
|
|
|
|
|
* This means that if this XHR object returns 401 or session timeout errors,
|
|
|
|
|
* the current page will automatically be reloaded.
|
|
|
|
|
*
|
|
|
|
|
* @param {XMLHttpRequest} xhr
|
|
|
|
|
*/
|
|
|
|
|
registerXHRForErrorProcessing: function(xhr) {
|
|
|
|
|
var loadCallback = function() {
|
|
|
|
|
if (xhr.readyState !== 4) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (xhr.status >= 200 && xhr.status < 300 || xhr.status === 304) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// fire jquery global ajax error handler
|
|
|
|
|
$(document).trigger(new $.Event('ajaxError'), xhr);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
var errorCallback = function() {
|
|
|
|
|
// fire jquery global ajax error handler
|
|
|
|
|
$(document).trigger(new $.Event('ajaxError'), xhr);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
if (xhr.addEventListener) {
|
|
|
|
|
xhr.addEventListener('load', loadCallback);
|
|
|
|
|
xhr.addEventListener('error', errorCallback);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
}
|
2012-02-22 01:31:35 +04:00
|
|
|
|
};
|
2014-04-21 15:46:33 +04:00
|
|
|
|
|
2016-02-01 17:11:42 +03:00
|
|
|
|
/**
|
|
|
|
|
* Current user attributes
|
|
|
|
|
*
|
|
|
|
|
* @typedef {Object} OC.CurrentUser
|
|
|
|
|
*
|
|
|
|
|
* @property {String} uid user id
|
|
|
|
|
* @property {String} displayName display name
|
|
|
|
|
*/
|
|
|
|
|
|
2014-12-01 18:17:28 +03:00
|
|
|
|
/**
|
|
|
|
|
* @namespace OC.Plugins
|
|
|
|
|
*/
|
|
|
|
|
OC.Plugins = {
|
|
|
|
|
/**
|
|
|
|
|
* @type Array.<OC.Plugin>
|
|
|
|
|
*/
|
|
|
|
|
_plugins: {},
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Register plugin
|
|
|
|
|
*
|
|
|
|
|
* @param {String} targetName app name / class name to hook into
|
|
|
|
|
* @param {OC.Plugin} plugin
|
|
|
|
|
*/
|
|
|
|
|
register: function(targetName, plugin) {
|
|
|
|
|
var plugins = this._plugins[targetName];
|
|
|
|
|
if (!plugins) {
|
|
|
|
|
plugins = this._plugins[targetName] = [];
|
|
|
|
|
}
|
|
|
|
|
plugins.push(plugin);
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Returns all plugin registered to the given target
|
|
|
|
|
* name / app name / class name.
|
|
|
|
|
*
|
|
|
|
|
* @param {String} targetName app name / class name to hook into
|
|
|
|
|
* @return {Array.<OC.Plugin>} array of plugins
|
|
|
|
|
*/
|
|
|
|
|
getPlugins: function(targetName) {
|
|
|
|
|
return this._plugins[targetName] || [];
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Call attach() on all plugins registered to the given target name.
|
|
|
|
|
*
|
|
|
|
|
* @param {String} targetName app name / class name
|
|
|
|
|
* @param {Object} object to be extended
|
|
|
|
|
* @param {Object} [options] options
|
|
|
|
|
*/
|
|
|
|
|
attach: function(targetName, targetObject, options) {
|
|
|
|
|
var plugins = this.getPlugins(targetName);
|
|
|
|
|
for (var i = 0; i < plugins.length; i++) {
|
|
|
|
|
if (plugins[i].attach) {
|
|
|
|
|
plugins[i].attach(targetObject, options);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Call detach() on all plugins registered to the given target name.
|
|
|
|
|
*
|
|
|
|
|
* @param {String} targetName app name / class name
|
|
|
|
|
* @param {Object} object to be extended
|
|
|
|
|
* @param {Object} [options] options
|
|
|
|
|
*/
|
|
|
|
|
detach: function(targetName, targetObject, options) {
|
|
|
|
|
var plugins = this.getPlugins(targetName);
|
|
|
|
|
for (var i = 0; i < plugins.length; i++) {
|
|
|
|
|
if (plugins[i].detach) {
|
|
|
|
|
plugins[i].detach(targetObject, options);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Plugin
|
|
|
|
|
*
|
|
|
|
|
* @todo make this a real class in the future
|
|
|
|
|
* @typedef {Object} OC.Plugin
|
|
|
|
|
*
|
|
|
|
|
* @property {String} name plugin name
|
|
|
|
|
* @property {Function} attach function that will be called when the
|
|
|
|
|
* plugin is attached
|
|
|
|
|
* @property {Function} [detach] function that will be called when the
|
|
|
|
|
* plugin is detached
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
2014-06-24 01:56:10 +04:00
|
|
|
|
/**
|
|
|
|
|
* @namespace OC.search
|
|
|
|
|
*/
|
2014-12-06 02:53:06 +03:00
|
|
|
|
OC.search.customResults = {};
|
|
|
|
|
/**
|
|
|
|
|
* @deprecated use get/setFormatter() instead
|
|
|
|
|
*/
|
|
|
|
|
OC.search.resultTypes = {};
|
|
|
|
|
|
2011-07-30 20:05:20 +04:00
|
|
|
|
OC.addStyle.loaded=[];
|
|
|
|
|
OC.addScript.loaded=[];
|
|
|
|
|
|
2014-04-21 15:46:33 +04:00
|
|
|
|
/**
|
2015-02-13 18:10:13 +03:00
|
|
|
|
* A little class to manage a status field for a "saving" process.
|
|
|
|
|
* It can be used to display a starting message (e.g. "Saving...") and then
|
|
|
|
|
* replace it with a green success message or a red error message.
|
|
|
|
|
*
|
|
|
|
|
* @namespace OC.msg
|
2014-04-21 15:46:33 +04:00
|
|
|
|
*/
|
2015-02-13 18:10:13 +03:00
|
|
|
|
OC.msg = {
|
2014-04-21 15:46:33 +04:00
|
|
|
|
/**
|
2015-02-13 18:10:13 +03:00
|
|
|
|
* Displayes a "Saving..." message in the given message placeholder
|
|
|
|
|
*
|
|
|
|
|
* @param {Object} selector Placeholder to display the message in
|
2014-04-21 15:46:33 +04:00
|
|
|
|
*/
|
2015-02-13 18:10:13 +03:00
|
|
|
|
startSaving: function(selector) {
|
|
|
|
|
this.startAction(selector, t('core', 'Saving...'));
|
2014-02-19 13:20:52 +04:00
|
|
|
|
},
|
2014-10-07 14:02:58 +04:00
|
|
|
|
|
2014-04-21 15:46:33 +04:00
|
|
|
|
/**
|
2015-02-13 18:10:13 +03:00
|
|
|
|
* Displayes a custom message in the given message placeholder
|
|
|
|
|
*
|
|
|
|
|
* @param {Object} selector Placeholder to display the message in
|
|
|
|
|
* @param {string} message Plain text message to display (no HTML allowed)
|
2014-04-21 15:46:33 +04:00
|
|
|
|
*/
|
2015-02-13 18:10:13 +03:00
|
|
|
|
startAction: function(selector, message) {
|
|
|
|
|
$(selector).text(message)
|
|
|
|
|
.removeClass('success')
|
|
|
|
|
.removeClass('error')
|
|
|
|
|
.stop(true, true)
|
|
|
|
|
.show();
|
2014-02-19 13:20:52 +04:00
|
|
|
|
},
|
2014-10-07 14:02:58 +04:00
|
|
|
|
|
2014-04-21 15:46:33 +04:00
|
|
|
|
/**
|
2015-02-13 18:10:13 +03:00
|
|
|
|
* Displayes an success/error message in the given selector
|
|
|
|
|
*
|
|
|
|
|
* @param {Object} selector Placeholder to display the message in
|
|
|
|
|
* @param {Object} response Response of the server
|
|
|
|
|
* @param {Object} response.data Data of the servers response
|
|
|
|
|
* @param {string} response.data.message Plain text message to display (no HTML allowed)
|
|
|
|
|
* @param {string} response.status is being used to decide whether the message
|
|
|
|
|
* is displayed as an error/success
|
|
|
|
|
*/
|
|
|
|
|
finishedSaving: function(selector, response) {
|
|
|
|
|
this.finishedAction(selector, response);
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Displayes an success/error message in the given selector
|
|
|
|
|
*
|
|
|
|
|
* @param {Object} selector Placeholder to display the message in
|
|
|
|
|
* @param {Object} response Response of the server
|
|
|
|
|
* @param {Object} response.data Data of the servers response
|
|
|
|
|
* @param {string} response.data.message Plain text message to display (no HTML allowed)
|
|
|
|
|
* @param {string} response.status is being used to decide whether the message
|
|
|
|
|
* is displayed as an error/success
|
|
|
|
|
*/
|
|
|
|
|
finishedAction: function(selector, response) {
|
|
|
|
|
if (response.status === "success") {
|
|
|
|
|
this.finishedSuccess(selector, response.data.message);
|
|
|
|
|
} else {
|
|
|
|
|
this.finishedError(selector, response.data.message);
|
|
|
|
|
}
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Displayes an success message in the given selector
|
|
|
|
|
*
|
|
|
|
|
* @param {Object} selector Placeholder to display the message in
|
|
|
|
|
* @param {string} message Plain text success message to display (no HTML allowed)
|
2014-04-21 15:46:33 +04:00
|
|
|
|
*/
|
2015-02-13 18:10:13 +03:00
|
|
|
|
finishedSuccess: function(selector, message) {
|
|
|
|
|
$(selector).text(message)
|
|
|
|
|
.addClass('success')
|
2014-02-19 13:20:52 +04:00
|
|
|
|
.removeClass('error')
|
|
|
|
|
.stop(true, true)
|
2015-02-13 18:10:13 +03:00
|
|
|
|
.delay(3000)
|
|
|
|
|
.fadeOut(900)
|
2014-02-19 13:20:52 +04:00
|
|
|
|
.show();
|
|
|
|
|
},
|
2014-10-07 14:02:58 +04:00
|
|
|
|
|
2014-04-21 15:46:33 +04:00
|
|
|
|
/**
|
2015-02-13 18:10:13 +03:00
|
|
|
|
* Displayes an error message in the given selector
|
|
|
|
|
*
|
|
|
|
|
* @param {Object} selector Placeholder to display the message in
|
|
|
|
|
* @param {string} message Plain text error message to display (no HTML allowed)
|
2014-04-21 15:46:33 +04:00
|
|
|
|
*/
|
2015-02-13 18:10:13 +03:00
|
|
|
|
finishedError: function(selector, message) {
|
|
|
|
|
$(selector).text(message)
|
|
|
|
|
.addClass('error')
|
|
|
|
|
.removeClass('success')
|
|
|
|
|
.show();
|
2014-02-19 13:20:52 +04:00
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
|
2014-04-21 15:46:33 +04:00
|
|
|
|
/**
|
|
|
|
|
* @todo Write documentation
|
2014-06-24 01:56:10 +04:00
|
|
|
|
* @namespace
|
2014-04-21 15:46:33 +04:00
|
|
|
|
*/
|
2013-01-05 02:34:09 +04:00
|
|
|
|
OC.Notification={
|
2013-03-02 22:24:37 +04:00
|
|
|
|
queuedNotifications: [],
|
2013-02-09 20:20:08 +04:00
|
|
|
|
getDefaultNotificationFunction: null,
|
2016-02-19 14:09:46 +03:00
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* @type Array.<int> array of notification timers
|
|
|
|
|
*/
|
|
|
|
|
notificationTimers: [],
|
2014-10-07 14:02:58 +04:00
|
|
|
|
|
2014-04-21 15:46:33 +04:00
|
|
|
|
/**
|
|
|
|
|
* @param callback
|
|
|
|
|
* @todo Write documentation
|
|
|
|
|
*/
|
2013-02-09 20:20:08 +04:00
|
|
|
|
setDefault: function(callback) {
|
|
|
|
|
OC.Notification.getDefaultNotificationFunction = callback;
|
|
|
|
|
},
|
2014-10-07 14:02:58 +04:00
|
|
|
|
|
2014-04-21 15:46:33 +04:00
|
|
|
|
/**
|
2016-02-19 14:09:46 +03:00
|
|
|
|
* Hides a notification.
|
|
|
|
|
*
|
|
|
|
|
* If a row is given, only hide that one.
|
|
|
|
|
* If no row is given, hide all notifications.
|
|
|
|
|
*
|
|
|
|
|
* @param {jQuery} [$row] notification row
|
|
|
|
|
* @param {Function} [callback] callback
|
2014-04-21 15:46:33 +04:00
|
|
|
|
*/
|
2016-02-19 14:09:46 +03:00
|
|
|
|
hide: function($row, callback) {
|
|
|
|
|
var self = this;
|
|
|
|
|
var $notification = $('#notification');
|
|
|
|
|
|
|
|
|
|
if (_.isFunction($row)) {
|
|
|
|
|
// first arg is the callback
|
|
|
|
|
callback = $row;
|
|
|
|
|
$row = undefined;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!$row) {
|
|
|
|
|
console.warn('Missing argument $row in OC.Notification.hide() call, caller needs to be adjusted to only dismiss its own notification');
|
|
|
|
|
// assume that the row to be hidden is the first one
|
|
|
|
|
$row = $notification.find('.row:first');
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if ($row && $notification.find('.row').length > 1) {
|
|
|
|
|
// remove the row directly
|
|
|
|
|
$row.remove();
|
2013-02-09 20:20:08 +04:00
|
|
|
|
if (callback) {
|
|
|
|
|
callback.call();
|
|
|
|
|
}
|
2016-02-19 14:09:46 +03:00
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
_.defer(function() {
|
|
|
|
|
// fade out is supposed to only fade when there is a single row
|
|
|
|
|
// however, some code might call hide() and show() directly after,
|
|
|
|
|
// which results in more than one element
|
|
|
|
|
// in this case, simply delete that one element that was supposed to
|
|
|
|
|
// fade out
|
|
|
|
|
//
|
|
|
|
|
// FIXME: remove once all callers are adjusted to only hide their own notifications
|
|
|
|
|
if ($notification.find('.row').length > 1) {
|
|
|
|
|
$row.remove();
|
|
|
|
|
return;
|
2013-02-09 20:20:08 +04:00
|
|
|
|
}
|
2016-02-19 14:09:46 +03:00
|
|
|
|
|
|
|
|
|
// else, fade out whatever was present
|
|
|
|
|
$notification.fadeOut('400', function(){
|
|
|
|
|
if (self.isHidden()) {
|
|
|
|
|
if (self.getDefaultNotificationFunction) {
|
|
|
|
|
self.getDefaultNotificationFunction.call();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (callback) {
|
|
|
|
|
callback.call();
|
|
|
|
|
}
|
|
|
|
|
$notification.empty();
|
|
|
|
|
});
|
2013-02-09 20:20:08 +04:00
|
|
|
|
});
|
|
|
|
|
},
|
2014-10-07 14:02:58 +04:00
|
|
|
|
|
2014-04-21 15:46:33 +04:00
|
|
|
|
/**
|
|
|
|
|
* Shows a notification as HTML without being sanitized before.
|
2014-04-22 11:54:25 +04:00
|
|
|
|
* If you pass unsanitized user input this may lead to a XSS vulnerability.
|
2014-04-21 15:46:33 +04:00
|
|
|
|
* Consider using show() instead of showHTML()
|
2016-02-19 14:09:46 +03:00
|
|
|
|
*
|
2014-04-21 15:46:33 +04:00
|
|
|
|
* @param {string} html Message to display
|
2016-02-19 14:09:46 +03:00
|
|
|
|
* @param {Object} [options] options
|
2018-01-04 12:05:15 +03:00
|
|
|
|
* @param {string} [options.type] notification type
|
2016-02-19 14:09:46 +03:00
|
|
|
|
* @param {int} [options.timeout=0] timeout value, defaults to 0 (permanent)
|
|
|
|
|
* @return {jQuery} jQuery element for notification row
|
2014-04-21 15:46:33 +04:00
|
|
|
|
*/
|
2016-02-19 14:09:46 +03:00
|
|
|
|
showHtml: function(html, options) {
|
|
|
|
|
options = options || {};
|
|
|
|
|
_.defaults(options, {
|
|
|
|
|
timeout: 0
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
var self = this;
|
|
|
|
|
var $notification = $('#notification');
|
|
|
|
|
if (this.isHidden()) {
|
|
|
|
|
$notification.fadeIn().css('display','inline-block');
|
|
|
|
|
}
|
|
|
|
|
var $row = $('<div class="row"></div>');
|
|
|
|
|
if (options.type) {
|
|
|
|
|
$row.addClass('type-' + options.type);
|
|
|
|
|
}
|
|
|
|
|
if (options.type === 'error') {
|
|
|
|
|
// add a close button
|
|
|
|
|
var $closeButton = $('<a class="action close icon-close" href="#"></a>');
|
|
|
|
|
$closeButton.attr('alt', t('core', 'Dismiss'));
|
|
|
|
|
$row.append($closeButton);
|
|
|
|
|
$closeButton.one('click', function() {
|
|
|
|
|
self.hide($row);
|
|
|
|
|
return false;
|
|
|
|
|
});
|
|
|
|
|
$row.addClass('closeable');
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
$row.prepend(html);
|
|
|
|
|
$notification.append($row);
|
|
|
|
|
|
|
|
|
|
if(options.timeout > 0) {
|
|
|
|
|
// register timeout to vanish notification
|
|
|
|
|
this.notificationTimers.push(setTimeout(function() {
|
|
|
|
|
self.hide($row);
|
|
|
|
|
}, (options.timeout * 1000)));
|
2013-02-09 20:20:08 +04:00
|
|
|
|
}
|
2016-02-19 14:09:46 +03:00
|
|
|
|
|
|
|
|
|
return $row;
|
2013-02-09 20:20:08 +04:00
|
|
|
|
},
|
2014-10-07 14:02:58 +04:00
|
|
|
|
|
2014-04-21 15:46:33 +04:00
|
|
|
|
/**
|
|
|
|
|
* Shows a sanitized notification
|
2016-02-19 14:09:46 +03:00
|
|
|
|
*
|
2014-04-21 15:46:33 +04:00
|
|
|
|
* @param {string} text Message to display
|
2016-02-19 14:09:46 +03:00
|
|
|
|
* @param {Object} [options] options
|
2016-07-20 14:03:27 +03:00
|
|
|
|
* @param {string} [options.type] notification type
|
2016-02-19 14:09:46 +03:00
|
|
|
|
* @param {int} [options.timeout=0] timeout value, defaults to 0 (permanent)
|
|
|
|
|
* @return {jQuery} jQuery element for notification row
|
2014-04-21 15:46:33 +04:00
|
|
|
|
*/
|
2016-02-19 14:09:46 +03:00
|
|
|
|
show: function(text, options) {
|
|
|
|
|
return this.showHtml($('<div/>').text(text).html(), options);
|
2013-02-09 20:20:08 +04:00
|
|
|
|
},
|
2014-10-07 14:02:58 +04:00
|
|
|
|
|
2017-02-04 08:47:09 +03:00
|
|
|
|
/**
|
|
|
|
|
* Updates (replaces) a sanitized notification.
|
2017-07-28 15:44:29 +03:00
|
|
|
|
*
|
2017-02-04 08:47:09 +03:00
|
|
|
|
* @param {string} text Message to display
|
|
|
|
|
* @return {jQuery} JQuery element for notificaiton row
|
|
|
|
|
*/
|
|
|
|
|
showUpdate: function(text) {
|
|
|
|
|
var $notification = $('#notification');
|
|
|
|
|
// sanitise
|
|
|
|
|
var $html = $('<div/>').text(text).html();
|
|
|
|
|
|
|
|
|
|
// new notification
|
|
|
|
|
if (text && $notification.find('.row').length == 0) {
|
|
|
|
|
return this.showHtml($html);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
var $row = $('<div class="row"></div>').prepend($html);
|
|
|
|
|
|
|
|
|
|
// just update html in notification
|
|
|
|
|
$notification.html($row);
|
|
|
|
|
|
|
|
|
|
return $row;
|
|
|
|
|
},
|
|
|
|
|
|
2015-01-07 16:51:20 +03:00
|
|
|
|
/**
|
|
|
|
|
* Shows a notification that disappears after x seconds, default is
|
|
|
|
|
* 7 seconds
|
2016-02-19 14:09:46 +03:00
|
|
|
|
*
|
2015-01-07 16:51:20 +03:00
|
|
|
|
* @param {string} text Message to show
|
|
|
|
|
* @param {array} [options] options array
|
|
|
|
|
* @param {int} [options.timeout=7] timeout in seconds, if this is 0 it will show the message permanently
|
|
|
|
|
* @param {boolean} [options.isHTML=false] an indicator for HTML notifications (true) or text (false)
|
2016-07-20 14:03:27 +03:00
|
|
|
|
* @param {string} [options.type] notification type
|
2015-01-07 16:51:20 +03:00
|
|
|
|
*/
|
|
|
|
|
showTemporary: function(text, options) {
|
|
|
|
|
var defaults = {
|
2016-02-19 14:09:46 +03:00
|
|
|
|
isHTML: false,
|
|
|
|
|
timeout: 7
|
|
|
|
|
};
|
|
|
|
|
options = options || {};
|
2015-01-07 16:51:20 +03:00
|
|
|
|
// merge defaults with passed in options
|
|
|
|
|
_.defaults(options, defaults);
|
|
|
|
|
|
2016-02-19 14:09:46 +03:00
|
|
|
|
var $row;
|
2015-01-07 16:51:20 +03:00
|
|
|
|
if(options.isHTML) {
|
2016-02-19 14:09:46 +03:00
|
|
|
|
$row = this.showHtml(text, options);
|
2015-01-07 16:51:20 +03:00
|
|
|
|
} else {
|
2016-02-19 14:09:46 +03:00
|
|
|
|
$row = this.show(text, options);
|
2015-01-07 16:51:20 +03:00
|
|
|
|
}
|
2016-02-19 14:09:46 +03:00
|
|
|
|
return $row;
|
2015-01-07 16:51:20 +03:00
|
|
|
|
},
|
|
|
|
|
|
2014-04-21 15:46:33 +04:00
|
|
|
|
/**
|
2014-10-07 14:02:58 +04:00
|
|
|
|
* Returns whether a notification is hidden.
|
2014-04-21 15:46:33 +04:00
|
|
|
|
* @return {boolean}
|
|
|
|
|
*/
|
2013-01-19 03:31:49 +04:00
|
|
|
|
isHidden: function() {
|
2016-02-19 14:09:46 +03:00
|
|
|
|
return !$("#notification").find('.row').length;
|
2013-01-19 03:31:49 +04:00
|
|
|
|
}
|
2013-01-05 02:34:09 +04:00
|
|
|
|
};
|
|
|
|
|
|
2014-02-04 16:56:10 +04:00
|
|
|
|
/**
|
|
|
|
|
* Initializes core
|
|
|
|
|
*/
|
|
|
|
|
function initCore() {
|
2015-09-14 15:08:16 +03:00
|
|
|
|
/**
|
|
|
|
|
* Disable automatic evaluation of responses for $.ajax() functions (and its
|
|
|
|
|
* higher-level alternatives like $.get() and $.post()).
|
|
|
|
|
*
|
|
|
|
|
* If a response to a $.ajax() request returns a content type of "application/javascript"
|
|
|
|
|
* JQuery would previously execute the response body. This is a pretty unexpected
|
|
|
|
|
* behaviour and can result in a bypass of our Content-Security-Policy as well as
|
|
|
|
|
* multiple unexpected XSS vectors.
|
|
|
|
|
*/
|
|
|
|
|
$.ajaxSetup({
|
|
|
|
|
contents: {
|
|
|
|
|
script: false
|
|
|
|
|
}
|
|
|
|
|
});
|
2014-02-04 16:56:10 +04:00
|
|
|
|
|
2017-03-17 01:03:02 +03:00
|
|
|
|
/**
|
|
|
|
|
* Disable execution of eval in jQuery. We do require an allowed eval CSP
|
|
|
|
|
* configuration at the moment for handlebars et al. But for jQuery there is
|
|
|
|
|
* not much of a reason to execute JavaScript directly via eval.
|
|
|
|
|
*
|
|
|
|
|
* This thus mitigates some unexpected XSS vectors.
|
|
|
|
|
*/
|
|
|
|
|
jQuery.globalEval = function(){};
|
|
|
|
|
|
2014-10-22 18:38:17 +04:00
|
|
|
|
/**
|
2014-11-18 14:13:44 +03:00
|
|
|
|
* Set users locale to moment.js as soon as possible
|
2014-10-22 18:38:17 +04:00
|
|
|
|
*/
|
2014-11-18 14:13:44 +03:00
|
|
|
|
moment.locale(OC.getLocale());
|
2014-10-22 18:38:17 +04:00
|
|
|
|
|
2016-04-19 12:55:40 +03:00
|
|
|
|
var userAgent = window.navigator.userAgent;
|
|
|
|
|
var msie = userAgent.indexOf('MSIE ');
|
|
|
|
|
var trident = userAgent.indexOf('Trident/');
|
|
|
|
|
var edge = userAgent.indexOf('Edge/');
|
|
|
|
|
|
|
|
|
|
if (msie > 0 || trident > 0) {
|
|
|
|
|
// (IE 10 or older) || IE 11
|
2015-11-10 16:05:05 +03:00
|
|
|
|
$('html').addClass('ie');
|
2016-04-19 12:55:40 +03:00
|
|
|
|
} else if (edge > 0) {
|
2015-11-10 16:05:05 +03:00
|
|
|
|
// for edge
|
|
|
|
|
$('html').addClass('edge');
|
|
|
|
|
}
|
2014-10-22 18:38:17 +04:00
|
|
|
|
|
2018-06-14 20:04:09 +03:00
|
|
|
|
// css variables fallback for IE
|
|
|
|
|
if (msie > 0 || trident > 0) {
|
|
|
|
|
cssVars();
|
|
|
|
|
}
|
|
|
|
|
|
2016-03-23 12:53:40 +03:00
|
|
|
|
$(window).on('unload.main', function() {
|
2016-03-22 18:54:01 +03:00
|
|
|
|
OC._unloadCalled = true;
|
|
|
|
|
});
|
2016-03-23 12:53:40 +03:00
|
|
|
|
$(window).on('beforeunload.main', function() {
|
2016-03-22 18:54:01 +03:00
|
|
|
|
// super-trick thanks to http://stackoverflow.com/a/4651049
|
|
|
|
|
// in case another handler displays a confirmation dialog (ex: navigating away
|
|
|
|
|
// during an upload), there are two possible outcomes: user clicked "ok" or
|
|
|
|
|
// "cancel"
|
|
|
|
|
|
|
|
|
|
// first timeout handler is called after unload dialog is closed
|
|
|
|
|
setTimeout(function() {
|
|
|
|
|
OC._userIsNavigatingAway = true;
|
|
|
|
|
|
|
|
|
|
// second timeout event is only called if user cancelled (Chrome),
|
|
|
|
|
// but in other browsers it might still be triggered, so need to
|
|
|
|
|
// set a higher delay...
|
|
|
|
|
setTimeout(function() {
|
|
|
|
|
if (!OC._unloadCalled) {
|
|
|
|
|
OC._userIsNavigatingAway = false;
|
|
|
|
|
}
|
|
|
|
|
}, 10000);
|
|
|
|
|
},1);
|
|
|
|
|
});
|
2015-12-10 20:08:40 +03:00
|
|
|
|
$(document).on('ajaxError.main', function( event, request, settings ) {
|
|
|
|
|
if (settings && settings.allowAuthErrors) {
|
|
|
|
|
return;
|
2015-06-06 23:43:41 +03:00
|
|
|
|
}
|
2015-12-10 20:08:40 +03:00
|
|
|
|
OC._processAjaxError(request);
|
2015-06-06 23:43:41 +03:00
|
|
|
|
});
|
|
|
|
|
|
2014-02-04 16:56:10 +04:00
|
|
|
|
/**
|
2018-02-26 19:13:23 +03:00
|
|
|
|
* Calls the server periodically to ensure that session and CSRF
|
|
|
|
|
* token doesn't expire
|
2014-02-04 16:56:10 +04:00
|
|
|
|
*/
|
2018-02-26 19:13:23 +03:00
|
|
|
|
function initSessionHeartBeat() {
|
2014-02-04 16:56:10 +04:00
|
|
|
|
// interval in seconds
|
|
|
|
|
var interval = 900;
|
|
|
|
|
if (oc_config.session_lifetime) {
|
|
|
|
|
interval = Math.floor(oc_config.session_lifetime / 2);
|
|
|
|
|
}
|
|
|
|
|
// minimum one minute
|
2018-02-26 19:13:23 +03:00
|
|
|
|
interval = Math.max(60, interval);
|
|
|
|
|
// max interval in seconds set to 24 hours
|
|
|
|
|
interval = Math.min(24 * 3600, interval);
|
|
|
|
|
|
|
|
|
|
var url = OC.generateUrl('/csrftoken');
|
|
|
|
|
setInterval(function() {
|
|
|
|
|
$.ajax(url).then(function(resp) {
|
|
|
|
|
oc_requesttoken = resp.token;
|
|
|
|
|
OC.requestToken = resp.token;
|
|
|
|
|
}).fail(function(e) {
|
|
|
|
|
console.error('session heartbeat failed', e);
|
|
|
|
|
});
|
|
|
|
|
}, interval * 1000);
|
2014-02-04 16:56:10 +04:00
|
|
|
|
}
|
|
|
|
|
|
2014-02-04 23:58:06 +04:00
|
|
|
|
// session heartbeat (defaults to enabled)
|
2014-02-04 16:56:10 +04:00
|
|
|
|
if (typeof(oc_config.session_keepalive) === 'undefined' ||
|
|
|
|
|
!!oc_config.session_keepalive) {
|
|
|
|
|
|
|
|
|
|
initSessionHeartBeat();
|
|
|
|
|
}
|
2011-10-04 20:54:07 +04:00
|
|
|
|
|
2018-02-21 17:12:42 +03:00
|
|
|
|
OC.registerMenu($('#expand'), $('#expanddiv'), false, true);
|
2011-08-14 16:55:43 +04:00
|
|
|
|
|
2014-03-14 13:33:19 +04:00
|
|
|
|
// toggle for menus
|
2018-07-20 21:51:23 +03:00
|
|
|
|
//$(document).on('mouseup.closemenus keyup', function(event) {
|
2014-03-14 13:33:19 +04:00
|
|
|
|
$(document).on('mouseup.closemenus', function(event) {
|
2018-07-20 21:51:23 +03:00
|
|
|
|
|
|
|
|
|
// allow enter as a trigger
|
2018-07-23 11:17:32 +03:00
|
|
|
|
// if (event.key && event.key !== "Enter") {
|
2018-07-20 21:51:23 +03:00
|
|
|
|
// return;
|
|
|
|
|
// }
|
|
|
|
|
|
2014-03-14 13:33:19 +04:00
|
|
|
|
var $el = $(event.target);
|
|
|
|
|
if ($el.closest('.menu').length || $el.closest('.menutoggle').length) {
|
|
|
|
|
// don't close when clicking on the menu directly or a menu toggle
|
|
|
|
|
return false;
|
|
|
|
|
}
|
2015-07-16 16:28:45 +03:00
|
|
|
|
|
|
|
|
|
OC.hideMenus();
|
2014-03-14 13:33:19 +04:00
|
|
|
|
});
|
|
|
|
|
|
2014-03-18 16:09:25 +04:00
|
|
|
|
/**
|
|
|
|
|
* Set up the main menu toggle to react to media query changes.
|
|
|
|
|
* If the screen is small enough, the main menu becomes a toggle.
|
|
|
|
|
* If the screen is bigger, the main menu is not a toggle any more.
|
|
|
|
|
*/
|
|
|
|
|
function setupMainMenu() {
|
2017-03-02 01:21:38 +03:00
|
|
|
|
|
2017-03-03 04:09:49 +03:00
|
|
|
|
// init the more-apps menu
|
2018-08-22 10:47:00 +03:00
|
|
|
|
OC.registerMenu($('#more-apps > a'), $('#navigation'));
|
2017-03-03 04:09:49 +03:00
|
|
|
|
|
2014-05-16 18:04:36 +04:00
|
|
|
|
// toggle the navigation
|
2017-03-02 01:21:38 +03:00
|
|
|
|
var $toggle = $('#header .header-appname-container');
|
2014-03-18 18:52:06 +04:00
|
|
|
|
var $navigation = $('#navigation');
|
2017-04-25 18:31:04 +03:00
|
|
|
|
var $appmenu = $('#appmenu');
|
2014-03-18 16:09:25 +04:00
|
|
|
|
|
2014-05-17 20:03:00 +04:00
|
|
|
|
// init the menu
|
|
|
|
|
OC.registerMenu($toggle, $navigation);
|
|
|
|
|
$toggle.data('oldhref', $toggle.attr('href'));
|
|
|
|
|
$toggle.attr('href', '#');
|
|
|
|
|
$navigation.hide();
|
2014-06-04 15:18:05 +04:00
|
|
|
|
|
|
|
|
|
// show loading feedback
|
2016-08-18 12:46:00 +03:00
|
|
|
|
$navigation.delegate('a', 'click', function(event) {
|
2014-06-04 15:18:05 +04:00
|
|
|
|
var $app = $(event.target);
|
|
|
|
|
if(!$app.is('a')) {
|
|
|
|
|
$app = $app.closest('a');
|
|
|
|
|
}
|
2016-08-19 11:47:02 +03:00
|
|
|
|
if(event.which === 1 && !event.ctrlKey && !event.metaKey) {
|
2014-07-07 12:39:48 +04:00
|
|
|
|
$app.addClass('app-loading');
|
2016-04-14 12:53:20 +03:00
|
|
|
|
} else {
|
2016-08-18 12:46:00 +03:00
|
|
|
|
// Close navigation when opening app in
|
|
|
|
|
// a new tab
|
2017-05-01 06:42:53 +03:00
|
|
|
|
OC.hideMenus(function(){return false;});
|
2016-08-19 11:47:02 +03:00
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
$navigation.delegate('a', 'mouseup', function(event) {
|
|
|
|
|
if(event.which === 2) {
|
|
|
|
|
// Close navigation when opening app in
|
|
|
|
|
// a new tab via middle click
|
2017-05-01 06:42:53 +03:00
|
|
|
|
OC.hideMenus(function(){return false;});
|
2014-07-07 12:39:48 +04:00
|
|
|
|
}
|
2014-06-04 15:18:05 +04:00
|
|
|
|
});
|
2017-04-25 18:31:04 +03:00
|
|
|
|
|
|
|
|
|
$appmenu.delegate('a', 'click', function(event) {
|
|
|
|
|
var $app = $(event.target);
|
|
|
|
|
if(!$app.is('a')) {
|
|
|
|
|
$app = $app.closest('a');
|
|
|
|
|
}
|
|
|
|
|
if(event.which === 1 && !event.ctrlKey && !event.metaKey) {
|
|
|
|
|
$app.addClass('app-loading');
|
|
|
|
|
} else {
|
|
|
|
|
// Close navigation when opening app in
|
|
|
|
|
// a new tab
|
2017-05-01 06:42:53 +03:00
|
|
|
|
OC.hideMenus(function(){return false;});
|
2017-04-25 18:31:04 +03:00
|
|
|
|
}
|
|
|
|
|
});
|
2014-03-17 23:40:22 +04:00
|
|
|
|
}
|
2014-03-18 16:09:25 +04:00
|
|
|
|
|
2016-04-14 12:53:09 +03:00
|
|
|
|
function setupUserMenu() {
|
|
|
|
|
var $menu = $('#header #settings');
|
|
|
|
|
|
2016-08-19 11:47:02 +03:00
|
|
|
|
// show loading feedback
|
2016-08-18 12:46:00 +03:00
|
|
|
|
$menu.delegate('a', 'click', function(event) {
|
2016-04-14 12:53:09 +03:00
|
|
|
|
var $page = $(event.target);
|
|
|
|
|
if (!$page.is('a')) {
|
|
|
|
|
$page = $page.closest('a');
|
|
|
|
|
}
|
2016-08-19 11:47:02 +03:00
|
|
|
|
if(event.which === 1 && !event.ctrlKey && !event.metaKey) {
|
|
|
|
|
$page.find('img').remove();
|
|
|
|
|
$page.find('div').remove(); // prevent odd double-clicks
|
2018-02-21 11:48:07 +03:00
|
|
|
|
$page.prepend($('<div/>').addClass('icon-loading-small'));
|
2016-08-19 11:47:02 +03:00
|
|
|
|
} else {
|
|
|
|
|
// Close navigation when opening menu entry in
|
|
|
|
|
// a new tab
|
2017-05-01 06:42:53 +03:00
|
|
|
|
OC.hideMenus(function(){return false;});
|
2016-08-19 11:47:02 +03:00
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
$menu.delegate('a', 'mouseup', function(event) {
|
|
|
|
|
if(event.which === 2) {
|
|
|
|
|
// Close navigation when opening app in
|
|
|
|
|
// a new tab via middle click
|
2017-05-01 06:42:53 +03:00
|
|
|
|
OC.hideMenus(function(){return false;});
|
2016-08-19 11:47:02 +03:00
|
|
|
|
}
|
2016-04-14 12:53:09 +03:00
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
|
2017-01-24 09:47:14 +03:00
|
|
|
|
function setupContactsMenu() {
|
|
|
|
|
new OC.ContactsMenu({
|
|
|
|
|
el: $('#contactsmenu .menu'),
|
|
|
|
|
trigger: $('#contactsmenu .menutoggle')
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
|
2014-05-17 20:03:00 +04:00
|
|
|
|
setupMainMenu();
|
2016-04-14 12:53:09 +03:00
|
|
|
|
setupUserMenu();
|
2017-01-24 09:47:14 +03:00
|
|
|
|
setupContactsMenu();
|
2014-06-05 15:19:56 +04:00
|
|
|
|
|
2015-03-26 18:25:29 +03:00
|
|
|
|
// move triangle of apps dropdown to align with app name triangle
|
2015-03-26 19:10:59 +03:00
|
|
|
|
// 2 is the additional offset between the triangles
|
2015-03-26 18:25:29 +03:00
|
|
|
|
if($('#navigation').length) {
|
2017-03-03 04:09:49 +03:00
|
|
|
|
$('#header #nextcloud + .menutoggle').on('click', function(){
|
|
|
|
|
$('#menu-css-helper').remove();
|
|
|
|
|
var caretPosition = $('.header-appname + .icon-caret').offset().left - 2;
|
2015-03-26 18:25:29 +03:00
|
|
|
|
if(caretPosition > 255) {
|
|
|
|
|
// if the app name is longer than the menu, just put the triangle in the middle
|
|
|
|
|
return;
|
|
|
|
|
} else {
|
2017-03-03 04:09:49 +03:00
|
|
|
|
$('head').append('<style id="menu-css-helper">#navigation:after { left: '+ caretPosition +'px; }</style>');
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
$('#header #appmenu .menutoggle').on('click', function() {
|
|
|
|
|
$('#appmenu').toggleClass('menu-open');
|
|
|
|
|
if($('#appmenu').is(':visible')) {
|
|
|
|
|
$('#menu-css-helper').remove();
|
2015-03-26 18:25:29 +03:00
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
|
2017-03-28 16:04:56 +03:00
|
|
|
|
var resizeMenu = function() {
|
|
|
|
|
var appList = $('#appmenu li');
|
2018-08-24 16:45:39 +03:00
|
|
|
|
var headerWidth = $('.header-left').outerWidth() - $('#nextcloud').outerWidth();
|
2017-06-10 18:33:01 +03:00
|
|
|
|
var usePercentualAppMenuLimit = 0.33;
|
2017-06-14 12:08:45 +03:00
|
|
|
|
var minAppsDesktop = 8;
|
|
|
|
|
var availableWidth = headerWidth - $(appList).width();
|
|
|
|
|
var isMobile = $(window).width() < 768;
|
|
|
|
|
if (!isMobile) {
|
|
|
|
|
availableWidth = headerWidth * usePercentualAppMenuLimit;
|
|
|
|
|
}
|
2017-06-10 18:33:01 +03:00
|
|
|
|
var appCount = Math.floor((availableWidth / $(appList).width()));
|
2017-06-14 12:08:45 +03:00
|
|
|
|
if (isMobile && appCount > minAppsDesktop) {
|
|
|
|
|
appCount = minAppsDesktop;
|
|
|
|
|
}
|
|
|
|
|
if (!isMobile && appCount < minAppsDesktop) {
|
|
|
|
|
appCount = minAppsDesktop;
|
|
|
|
|
}
|
|
|
|
|
|
2017-03-28 16:04:56 +03:00
|
|
|
|
// show at least 2 apps in the popover
|
|
|
|
|
if(appList.length-1-appCount >= 1) {
|
|
|
|
|
appCount--;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
$('#more-apps a').removeClass('active');
|
|
|
|
|
var lastShownApp;
|
|
|
|
|
for (var k = 0; k < appList.length-1; k++) {
|
|
|
|
|
var name = $(appList[k]).data('id');
|
|
|
|
|
if(k < appCount) {
|
|
|
|
|
$(appList[k]).removeClass('hidden');
|
|
|
|
|
$('#apps li[data-id=' + name + ']').addClass('in-header');
|
|
|
|
|
lastShownApp = appList[k];
|
|
|
|
|
} else {
|
|
|
|
|
$(appList[k]).addClass('hidden');
|
|
|
|
|
$('#apps li[data-id=' + name + ']').removeClass('in-header');
|
|
|
|
|
// move active app to last position if it is active
|
|
|
|
|
if(appCount > 0 && $(appList[k]).children('a').hasClass('active')) {
|
|
|
|
|
$(lastShownApp).addClass('hidden');
|
|
|
|
|
$('#apps li[data-id=' + $(lastShownApp).data('id') + ']').removeClass('in-header');
|
|
|
|
|
$(appList[k]).removeClass('hidden');
|
|
|
|
|
$('#apps li[data-id=' + name + ']').addClass('in-header');
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// show/hide more apps icon
|
|
|
|
|
if($('#apps li:not(.in-header)').length === 0) {
|
|
|
|
|
$('#more-apps').hide();
|
|
|
|
|
$('#navigation').hide();
|
|
|
|
|
} else {
|
|
|
|
|
$('#more-apps').show();
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
$(window).resize(resizeMenu);
|
|
|
|
|
resizeMenu();
|
|
|
|
|
|
2014-06-06 03:20:31 +04:00
|
|
|
|
// just add snapper for logged in users
|
2014-06-10 19:14:49 +04:00
|
|
|
|
if($('#app-navigation').length && !$('html').hasClass('lte9')) {
|
2014-06-05 19:06:21 +04:00
|
|
|
|
|
2014-06-06 03:20:31 +04:00
|
|
|
|
// App sidebar on mobile
|
|
|
|
|
var snapper = new Snap({
|
|
|
|
|
element: document.getElementById('app-content'),
|
|
|
|
|
disable: 'right',
|
2018-07-23 21:14:19 +03:00
|
|
|
|
maxPosition: 300, // $navigation-width
|
2015-07-21 18:03:45 +03:00
|
|
|
|
minDragDistance: 100
|
2014-06-06 03:20:31 +04:00
|
|
|
|
});
|
2018-07-17 14:10:25 +03:00
|
|
|
|
|
|
|
|
|
$('#app-content').prepend('<div id="app-navigation-toggle" class="icon-menu" style="display:none;" tabindex="0"></div>');
|
|
|
|
|
|
|
|
|
|
var toggleSnapperOnButton = function(){
|
2014-06-06 03:20:31 +04:00
|
|
|
|
if(snapper.state().state == 'left'){
|
|
|
|
|
snapper.close();
|
|
|
|
|
} else {
|
|
|
|
|
snapper.open('left');
|
|
|
|
|
}
|
2018-07-17 14:10:25 +03:00
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
$('#app-navigation-toggle').click(function(){
|
|
|
|
|
toggleSnapperOnButton();
|
2014-06-06 03:20:31 +04:00
|
|
|
|
});
|
2018-07-17 14:10:25 +03:00
|
|
|
|
|
|
|
|
|
$('#app-navigation-toggle').keypress(function(e) {
|
|
|
|
|
if(e.which == 13) {
|
|
|
|
|
toggleSnapperOnButton();
|
|
|
|
|
}
|
2014-06-06 03:20:31 +04:00
|
|
|
|
});
|
2018-07-17 14:10:25 +03:00
|
|
|
|
|
2014-06-06 03:20:31 +04:00
|
|
|
|
// close sidebar when switching navigation entry
|
|
|
|
|
var $appNavigation = $('#app-navigation');
|
2015-06-16 20:41:20 +03:00
|
|
|
|
$appNavigation.delegate('a, :button', 'click', function(event) {
|
2014-06-06 03:20:31 +04:00
|
|
|
|
var $target = $(event.target);
|
|
|
|
|
// don't hide navigation when changing settings or adding things
|
|
|
|
|
if($target.is('.app-navigation-noclose') ||
|
|
|
|
|
$target.closest('.app-navigation-noclose').length) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
2016-07-31 12:57:03 +03:00
|
|
|
|
if($target.is('.app-navigation-entry-utils-menu-button') ||
|
|
|
|
|
$target.closest('.app-navigation-entry-utils-menu-button').length) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
2014-06-06 03:20:31 +04:00
|
|
|
|
if($target.is('.add-new') ||
|
|
|
|
|
$target.closest('.add-new').length) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
if($target.is('#app-settings') ||
|
|
|
|
|
$target.closest('#app-settings').length) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
2014-06-05 15:19:56 +04:00
|
|
|
|
snapper.close();
|
2014-06-06 03:20:31 +04:00
|
|
|
|
});
|
|
|
|
|
|
2017-10-23 02:01:01 +03:00
|
|
|
|
var navigationBarSlideGestureEnabled = false;
|
|
|
|
|
var navigationBarSlideGestureAllowed = true;
|
|
|
|
|
var navigationBarSlideGestureEnablePending = false;
|
|
|
|
|
|
|
|
|
|
OC.allowNavigationBarSlideGesture = function() {
|
|
|
|
|
navigationBarSlideGestureAllowed = true;
|
|
|
|
|
|
|
|
|
|
if (navigationBarSlideGestureEnablePending) {
|
|
|
|
|
snapper.enable();
|
|
|
|
|
|
|
|
|
|
navigationBarSlideGestureEnabled = true;
|
|
|
|
|
navigationBarSlideGestureEnablePending = false;
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
OC.disallowNavigationBarSlideGesture = function() {
|
|
|
|
|
navigationBarSlideGestureAllowed = false;
|
|
|
|
|
|
|
|
|
|
if (navigationBarSlideGestureEnabled) {
|
2017-12-14 20:12:12 +03:00
|
|
|
|
var endCurrentDrag = true;
|
|
|
|
|
snapper.disable(endCurrentDrag);
|
2017-10-23 02:01:01 +03:00
|
|
|
|
|
|
|
|
|
navigationBarSlideGestureEnabled = false;
|
|
|
|
|
navigationBarSlideGestureEnablePending = true;
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
|
2014-06-06 03:20:31 +04:00
|
|
|
|
var toggleSnapperOnSize = function() {
|
|
|
|
|
if($(window).width() > 768) {
|
|
|
|
|
snapper.close();
|
|
|
|
|
snapper.disable();
|
2017-10-23 02:01:01 +03:00
|
|
|
|
|
|
|
|
|
navigationBarSlideGestureEnabled = false;
|
|
|
|
|
navigationBarSlideGestureEnablePending = false;
|
|
|
|
|
} else if (navigationBarSlideGestureAllowed) {
|
2014-06-06 03:20:31 +04:00
|
|
|
|
snapper.enable();
|
2017-10-23 02:01:01 +03:00
|
|
|
|
|
|
|
|
|
navigationBarSlideGestureEnabled = true;
|
|
|
|
|
navigationBarSlideGestureEnablePending = false;
|
|
|
|
|
} else {
|
|
|
|
|
navigationBarSlideGestureEnablePending = true;
|
2014-06-06 03:20:31 +04:00
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
|
2014-06-06 11:50:46 +04:00
|
|
|
|
$(window).resize(_.debounce(toggleSnapperOnSize, 250));
|
2014-06-06 03:20:31 +04:00
|
|
|
|
|
|
|
|
|
// initial call
|
|
|
|
|
toggleSnapperOnSize();
|
|
|
|
|
|
|
|
|
|
}
|
2016-08-31 18:33:00 +03:00
|
|
|
|
|
|
|
|
|
// Update live timestamps every 30 seconds
|
|
|
|
|
setInterval(function() {
|
|
|
|
|
$('.live-relative-timestamp').each(function() {
|
|
|
|
|
$(this).text(OC.Util.relativeModifiedDate(parseInt($(this).attr('data-timestamp'), 10)));
|
|
|
|
|
});
|
|
|
|
|
}, 30 * 1000);
|
2016-09-19 16:33:30 +03:00
|
|
|
|
|
|
|
|
|
OC.PasswordConfirmation.init();
|
2014-02-04 16:56:10 +04:00
|
|
|
|
}
|
|
|
|
|
|
2016-09-19 16:33:30 +03:00
|
|
|
|
OC.PasswordConfirmation = {
|
2016-09-19 17:52:29 +03:00
|
|
|
|
callback: null,
|
2017-12-27 23:11:16 +03:00
|
|
|
|
pageLoadTime: null,
|
2016-09-19 16:33:30 +03:00
|
|
|
|
init: function() {
|
|
|
|
|
$('.password-confirm-required').on('click', _.bind(this.requirePasswordConfirmation, this));
|
2017-12-27 23:11:16 +03:00
|
|
|
|
this.pageLoadTime = moment.now();
|
2016-09-19 16:33:30 +03:00
|
|
|
|
},
|
|
|
|
|
|
2016-09-19 17:52:29 +03:00
|
|
|
|
requiresPasswordConfirmation: function() {
|
2017-12-27 23:11:16 +03:00
|
|
|
|
var serverTimeDiff = this.pageLoadTime - (nc_pageLoad * 1000);
|
|
|
|
|
var timeSinceLogin = moment.now() - (serverTimeDiff + (nc_lastLogin * 1000));
|
2018-02-21 11:48:07 +03:00
|
|
|
|
|
2017-12-13 16:41:56 +03:00
|
|
|
|
// if timeSinceLogin > 30 minutes and user backend allows password confirmation
|
|
|
|
|
return (backendAllowsPasswordConfirmation && timeSinceLogin > 30 * 60 * 1000);
|
2016-09-19 17:52:29 +03:00
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* @param {function} callback
|
|
|
|
|
*/
|
2018-05-24 11:53:58 +03:00
|
|
|
|
requirePasswordConfirmation: function(callback, options) {
|
|
|
|
|
options = typeof options !== 'undefined' ? options : {};
|
|
|
|
|
var defaults = {
|
|
|
|
|
title: t('core','Authentication required'),
|
|
|
|
|
text: t(
|
|
|
|
|
'core',
|
|
|
|
|
'This action requires you to confirm your password'
|
|
|
|
|
),
|
|
|
|
|
confirm: t('core', 'Confirm'),
|
|
|
|
|
label: t('core','Password'),
|
|
|
|
|
error: '',
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
var config = _.extend(defaults, options);
|
|
|
|
|
|
2016-11-17 12:36:39 +03:00
|
|
|
|
var self = this;
|
|
|
|
|
|
2016-09-19 17:52:29 +03:00
|
|
|
|
if (this.requiresPasswordConfirmation()) {
|
2016-11-17 12:36:39 +03:00
|
|
|
|
OC.dialogs.prompt(
|
2018-05-24 11:53:58 +03:00
|
|
|
|
config.text,
|
|
|
|
|
config.title,
|
2016-11-17 12:36:39 +03:00
|
|
|
|
function (result, password) {
|
|
|
|
|
if (result && password !== '') {
|
2018-05-24 11:53:58 +03:00
|
|
|
|
self._confirmPassword(password, config);
|
2016-11-17 12:36:39 +03:00
|
|
|
|
}
|
|
|
|
|
},
|
|
|
|
|
true,
|
2018-05-24 11:53:58 +03:00
|
|
|
|
config.label,
|
2016-11-17 12:36:39 +03:00
|
|
|
|
true
|
|
|
|
|
).then(function() {
|
|
|
|
|
var $dialog = $('.oc-dialog:visible');
|
|
|
|
|
$dialog.find('.ui-icon').remove();
|
2018-05-24 11:53:58 +03:00
|
|
|
|
$dialog.addClass('password-confirmation');
|
|
|
|
|
if (config.error !== '') {
|
|
|
|
|
var $error = $('<p></p>').addClass('msg warning').text(config.error);
|
|
|
|
|
}
|
|
|
|
|
$dialog.find('.oc-dialog-content').append($error);
|
2016-11-17 12:36:39 +03:00
|
|
|
|
|
|
|
|
|
var $buttons = $dialog.find('button');
|
2018-05-24 11:53:58 +03:00
|
|
|
|
$buttons.eq(0).hide();
|
|
|
|
|
$buttons.eq(1).text(config.confirm);
|
2016-11-17 12:36:39 +03:00
|
|
|
|
});
|
2016-09-19 16:33:30 +03:00
|
|
|
|
}
|
2016-09-19 17:52:29 +03:00
|
|
|
|
|
|
|
|
|
this.callback = callback;
|
2016-09-19 16:33:30 +03:00
|
|
|
|
},
|
|
|
|
|
|
2018-05-24 11:53:58 +03:00
|
|
|
|
_confirmPassword: function(password, config) {
|
2016-09-19 16:33:30 +03:00
|
|
|
|
var self = this;
|
|
|
|
|
|
|
|
|
|
$.ajax({
|
|
|
|
|
url: OC.generateUrl('/login/confirm'),
|
|
|
|
|
data: {
|
2016-11-17 12:36:39 +03:00
|
|
|
|
password: password
|
2016-09-19 16:33:30 +03:00
|
|
|
|
},
|
|
|
|
|
type: 'POST',
|
|
|
|
|
success: function(response) {
|
|
|
|
|
nc_lastLogin = response.lastLogin;
|
2016-09-19 17:52:29 +03:00
|
|
|
|
|
2016-09-19 19:37:55 +03:00
|
|
|
|
if (_.isFunction(self.callback)) {
|
2016-09-19 17:52:29 +03:00
|
|
|
|
self.callback();
|
|
|
|
|
}
|
2016-09-19 16:33:30 +03:00
|
|
|
|
},
|
|
|
|
|
error: function() {
|
2018-05-24 11:53:58 +03:00
|
|
|
|
config.error = t('core', 'Failed to authenticate, try again');
|
|
|
|
|
OC.PasswordConfirmation.requirePasswordConfirmation(self.callback, config);
|
2016-09-19 16:33:30 +03:00
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
|
2014-02-04 16:56:10 +04:00
|
|
|
|
$(document).ready(initCore);
|
2011-08-08 13:07:44 +04:00
|
|
|
|
|
2011-11-02 01:35:13 +04:00
|
|
|
|
/**
|
|
|
|
|
* Filter Jquery selector by attribute value
|
2012-11-14 04:18:26 +04:00
|
|
|
|
*/
|
2012-07-31 14:21:06 +04:00
|
|
|
|
$.fn.filterAttr = function(attr_name, attr_value) {
|
2012-08-25 02:05:07 +04:00
|
|
|
|
return this.filter(function() { return $(this).attr(attr_name) === attr_value; });
|
2011-11-02 01:35:13 +04:00
|
|
|
|
};
|
2012-01-15 22:11:25 +04:00
|
|
|
|
|
2014-04-21 15:46:33 +04:00
|
|
|
|
/**
|
2014-04-22 11:54:25 +04:00
|
|
|
|
* Returns a human readable file size
|
2014-04-21 16:42:50 +04:00
|
|
|
|
* @param {number} size Size in bytes
|
2014-06-02 12:38:46 +04:00
|
|
|
|
* @param {boolean} skipSmallSizes return '< 1 kB' for small files
|
2014-04-21 15:46:33 +04:00
|
|
|
|
* @return {string}
|
|
|
|
|
*/
|
2014-06-02 12:38:46 +04:00
|
|
|
|
function humanFileSize(size, skipSmallSizes) {
|
2016-01-19 12:51:57 +03:00
|
|
|
|
var humanList = ['B', 'KB', 'MB', 'GB', 'TB'];
|
2012-02-26 17:03:53 +04:00
|
|
|
|
// Calculate Log with base 1024: size = 1024 ** order
|
2015-01-29 19:27:28 +03:00
|
|
|
|
var order = size > 0 ? Math.floor(Math.log(size) / Math.log(1024)) : 0;
|
2012-02-26 17:03:53 +04:00
|
|
|
|
// Stay in range of the byte sizes that are defined
|
2012-02-27 01:09:21 +04:00
|
|
|
|
order = Math.min(humanList.length - 1, order);
|
2012-09-23 05:16:52 +04:00
|
|
|
|
var readableFormat = humanList[order];
|
|
|
|
|
var relativeSize = (size / Math.pow(1024, order)).toFixed(1);
|
2014-06-02 12:38:46 +04:00
|
|
|
|
if(skipSmallSizes === true && order === 0) {
|
|
|
|
|
if(relativeSize !== "0.0"){
|
2016-01-19 12:51:57 +03:00
|
|
|
|
return '< 1 KB';
|
2014-06-02 12:38:46 +04:00
|
|
|
|
} else {
|
2016-01-19 12:51:57 +03:00
|
|
|
|
return '0 KB';
|
2014-06-02 12:38:46 +04:00
|
|
|
|
}
|
|
|
|
|
}
|
2013-11-25 15:26:03 +04:00
|
|
|
|
if(order < 2){
|
|
|
|
|
relativeSize = parseFloat(relativeSize).toFixed(0);
|
2013-12-18 18:43:45 +04:00
|
|
|
|
}
|
2013-11-25 15:26:03 +04:00
|
|
|
|
else if(relativeSize.substr(relativeSize.length-2,2)==='.0'){
|
2012-02-26 17:03:53 +04:00
|
|
|
|
relativeSize=relativeSize.substr(0,relativeSize.length-2);
|
2012-02-26 00:19:32 +04:00
|
|
|
|
}
|
2012-02-26 17:03:53 +04:00
|
|
|
|
return relativeSize + ' ' + readableFormat;
|
2012-02-26 00:19:32 +04:00
|
|
|
|
}
|
2012-01-15 22:11:25 +04:00
|
|
|
|
|
2014-04-21 15:46:33 +04:00
|
|
|
|
/**
|
|
|
|
|
* Format an UNIX timestamp to a human understandable format
|
2014-08-26 22:17:33 +04:00
|
|
|
|
* @param {number} timestamp UNIX timestamp
|
2014-04-21 15:46:33 +04:00
|
|
|
|
* @return {string} Human readable format
|
|
|
|
|
*/
|
2014-08-26 22:17:33 +04:00
|
|
|
|
function formatDate(timestamp){
|
|
|
|
|
return OC.Util.formatDate(timestamp);
|
2012-02-26 00:19:32 +04:00
|
|
|
|
}
|
2012-08-29 23:52:42 +04:00
|
|
|
|
|
2014-10-07 14:02:58 +04:00
|
|
|
|
//
|
2014-04-21 15:46:33 +04:00
|
|
|
|
/**
|
|
|
|
|
* Get the value of a URL parameter
|
|
|
|
|
* @link http://stackoverflow.com/questions/1403888/get-url-parameter-with-jquery
|
|
|
|
|
* @param {string} name URL parameter
|
|
|
|
|
* @return {string}
|
|
|
|
|
*/
|
2013-08-01 00:24:52 +04:00
|
|
|
|
function getURLParameter(name) {
|
2016-09-16 17:03:15 +03:00
|
|
|
|
return decodeURIComponent(
|
|
|
|
|
(new RegExp('[?|&]' + name + '=' + '([^&;]+?)(&|#|;|$)').exec(
|
|
|
|
|
location.search)||[,''])[1].replace(/\+/g, '%20')
|
|
|
|
|
)||'';
|
2013-08-01 00:24:52 +04:00
|
|
|
|
}
|
|
|
|
|
|
2012-11-14 04:18:26 +04:00
|
|
|
|
/**
|
2014-04-21 15:46:33 +04:00
|
|
|
|
* Takes an absolute timestamp and return a string with a human-friendly relative date
|
2014-04-21 16:42:50 +04:00
|
|
|
|
* @param {number} timestamp A Unix timestamp
|
2012-11-06 19:56:42 +04:00
|
|
|
|
*/
|
|
|
|
|
function relative_modified_date(timestamp) {
|
2014-08-26 22:17:33 +04:00
|
|
|
|
/*
|
|
|
|
|
Were multiplying by 1000 to bring the timestamp back to its original value
|
|
|
|
|
per https://github.com/owncloud/core/pull/10647#discussion_r16790315
|
|
|
|
|
*/
|
|
|
|
|
return OC.Util.relativeModifiedDate(timestamp * 1000);
|
2012-11-06 19:56:42 +04:00
|
|
|
|
}
|
|
|
|
|
|
2014-04-21 15:46:33 +04:00
|
|
|
|
/**
|
2014-02-12 17:50:23 +04:00
|
|
|
|
* Utility functions
|
2014-06-24 01:56:10 +04:00
|
|
|
|
* @namespace
|
2014-04-21 15:46:33 +04:00
|
|
|
|
*/
|
2014-04-04 13:32:07 +04:00
|
|
|
|
OC.Util = {
|
2014-02-11 19:52:56 +04:00
|
|
|
|
// TODO: remove original functions from global namespace
|
|
|
|
|
humanFileSize: humanFileSize,
|
2016-12-07 13:03:15 +03:00
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Returns a file size in bytes from a humanly readable string
|
2016-12-07 13:43:44 +03:00
|
|
|
|
* Makes 2kB to 2048.
|
|
|
|
|
* Inspired by computerFileSize in helper.php
|
2016-12-07 13:03:15 +03:00
|
|
|
|
* @param {string} string file size in human readable format
|
|
|
|
|
* @return {number} or null if string could not be parsed
|
|
|
|
|
*
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
computerFileSize: function (string) {
|
2017-02-27 09:49:15 +03:00
|
|
|
|
if (typeof string !== 'string') {
|
2016-12-07 13:43:44 +03:00
|
|
|
|
return null;
|
|
|
|
|
}
|
|
|
|
|
|
2017-02-28 05:40:34 +03:00
|
|
|
|
var s = string.toLowerCase().trim();
|
2017-02-27 09:49:15 +03:00
|
|
|
|
var bytes = null;
|
2016-12-07 13:03:15 +03:00
|
|
|
|
|
2016-12-07 13:43:44 +03:00
|
|
|
|
var bytesArray = {
|
2016-12-07 13:03:15 +03:00
|
|
|
|
'b' : 1,
|
|
|
|
|
'k' : 1024,
|
|
|
|
|
'kb': 1024,
|
|
|
|
|
'mb': 1024 * 1024,
|
|
|
|
|
'm' : 1024 * 1024,
|
|
|
|
|
'gb': 1024 * 1024 * 1024,
|
|
|
|
|
'g' : 1024 * 1024 * 1024,
|
|
|
|
|
'tb': 1024 * 1024 * 1024 * 1024,
|
|
|
|
|
't' : 1024 * 1024 * 1024 * 1024,
|
|
|
|
|
'pb': 1024 * 1024 * 1024 * 1024 * 1024,
|
|
|
|
|
'p' : 1024 * 1024 * 1024 * 1024 * 1024
|
|
|
|
|
};
|
|
|
|
|
|
2017-02-27 09:49:15 +03:00
|
|
|
|
var matches = s.match(/^[\s+]?([0-9]*)(\.([0-9]+))?( +)?([kmgtp]?b?)$/i);
|
|
|
|
|
if (matches !== null) {
|
|
|
|
|
bytes = parseFloat(s);
|
|
|
|
|
if (!isFinite(bytes)) {
|
|
|
|
|
return null;
|
|
|
|
|
}
|
2016-12-07 13:43:44 +03:00
|
|
|
|
} else {
|
2016-12-07 13:03:15 +03:00
|
|
|
|
return null;
|
|
|
|
|
}
|
2017-02-27 09:49:15 +03:00
|
|
|
|
if (matches[5]) {
|
|
|
|
|
bytes = bytes * bytesArray[matches[5]];
|
|
|
|
|
}
|
2016-12-07 13:03:15 +03:00
|
|
|
|
|
|
|
|
|
bytes = Math.round(bytes);
|
|
|
|
|
return bytes;
|
|
|
|
|
},
|
2014-08-26 22:17:33 +04:00
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* @param timestamp
|
|
|
|
|
* @param format
|
|
|
|
|
* @returns {string} timestamp formatted as requested
|
|
|
|
|
*/
|
|
|
|
|
formatDate: function (timestamp, format) {
|
2015-03-24 15:41:55 +03:00
|
|
|
|
format = format || "LLL";
|
2014-08-26 22:17:33 +04:00
|
|
|
|
return moment(timestamp).format(format);
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* @param timestamp
|
|
|
|
|
* @returns {string} human readable difference from now
|
|
|
|
|
*/
|
|
|
|
|
relativeModifiedDate: function (timestamp) {
|
2015-10-02 11:16:21 +03:00
|
|
|
|
var diff = moment().diff(moment(timestamp));
|
|
|
|
|
if (diff >= 0 && diff < 45000 ) {
|
|
|
|
|
return t('core', 'seconds ago');
|
|
|
|
|
}
|
2014-08-26 22:17:33 +04:00
|
|
|
|
return moment(timestamp).fromNow();
|
|
|
|
|
},
|
2014-07-14 18:05:46 +04:00
|
|
|
|
|
2015-10-21 11:50:06 +03:00
|
|
|
|
/**
|
|
|
|
|
* Returns whether this is IE
|
|
|
|
|
*
|
|
|
|
|
* @return {bool} true if this is IE, false otherwise
|
|
|
|
|
*/
|
|
|
|
|
isIE: function() {
|
|
|
|
|
return $('html').hasClass('ie');
|
|
|
|
|
},
|
|
|
|
|
|
2015-10-02 19:02:55 +03:00
|
|
|
|
/**
|
|
|
|
|
* Returns the width of a generic browser scrollbar
|
|
|
|
|
*
|
|
|
|
|
* @return {int} width of scrollbar
|
|
|
|
|
*/
|
|
|
|
|
getScrollBarWidth: function() {
|
|
|
|
|
if (this._scrollBarWidth) {
|
|
|
|
|
return this._scrollBarWidth;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
var inner = document.createElement('p');
|
|
|
|
|
inner.style.width = "100%";
|
|
|
|
|
inner.style.height = "200px";
|
|
|
|
|
|
|
|
|
|
var outer = document.createElement('div');
|
|
|
|
|
outer.style.position = "absolute";
|
|
|
|
|
outer.style.top = "0px";
|
|
|
|
|
outer.style.left = "0px";
|
|
|
|
|
outer.style.visibility = "hidden";
|
|
|
|
|
outer.style.width = "200px";
|
|
|
|
|
outer.style.height = "150px";
|
|
|
|
|
outer.style.overflow = "hidden";
|
|
|
|
|
outer.appendChild (inner);
|
|
|
|
|
|
|
|
|
|
document.body.appendChild (outer);
|
|
|
|
|
var w1 = inner.offsetWidth;
|
|
|
|
|
outer.style.overflow = 'scroll';
|
|
|
|
|
var w2 = inner.offsetWidth;
|
|
|
|
|
if(w1 === w2) {
|
|
|
|
|
w2 = outer.clientWidth;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
document.body.removeChild (outer);
|
|
|
|
|
|
|
|
|
|
this._scrollBarWidth = (w1 - w2);
|
|
|
|
|
|
|
|
|
|
return this._scrollBarWidth;
|
|
|
|
|
},
|
|
|
|
|
|
2014-07-14 18:05:46 +04:00
|
|
|
|
/**
|
|
|
|
|
* Remove the time component from a given date
|
|
|
|
|
*
|
|
|
|
|
* @param {Date} date date
|
|
|
|
|
* @return {Date} date with stripped time
|
|
|
|
|
*/
|
|
|
|
|
stripTime: function(date) {
|
|
|
|
|
// FIXME: likely to break when crossing DST
|
|
|
|
|
// would be better to use a library like momentJS
|
|
|
|
|
return new Date(date.getFullYear(), date.getMonth(), date.getDate());
|
2014-02-18 15:29:05 +04:00
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
_chunkify: function(t) {
|
|
|
|
|
// Adapted from http://my.opera.com/GreyWyvern/blog/show.dml/1671288
|
|
|
|
|
var tz = [], x = 0, y = -1, n = 0, code, c;
|
|
|
|
|
|
|
|
|
|
while (x < t.length) {
|
|
|
|
|
c = t.charAt(x);
|
2014-07-23 14:52:13 +04:00
|
|
|
|
// only include the dot in strings
|
|
|
|
|
var m = ((!n && c === '.') || (c >= '0' && c <= '9'));
|
2014-02-18 15:29:05 +04:00
|
|
|
|
if (m !== n) {
|
|
|
|
|
// next chunk
|
|
|
|
|
y++;
|
|
|
|
|
tz[y] = '';
|
|
|
|
|
n = m;
|
|
|
|
|
}
|
|
|
|
|
tz[y] += c;
|
|
|
|
|
x++;
|
|
|
|
|
}
|
|
|
|
|
return tz;
|
|
|
|
|
},
|
|
|
|
|
/**
|
|
|
|
|
* Compare two strings to provide a natural sort
|
|
|
|
|
* @param a first string to compare
|
|
|
|
|
* @param b second string to compare
|
|
|
|
|
* @return -1 if b comes before a, 1 if a comes before b
|
|
|
|
|
* or 0 if the strings are identical
|
|
|
|
|
*/
|
|
|
|
|
naturalSortCompare: function(a, b) {
|
2014-07-23 14:52:13 +04:00
|
|
|
|
var x;
|
2014-02-18 15:29:05 +04:00
|
|
|
|
var aa = OC.Util._chunkify(a);
|
|
|
|
|
var bb = OC.Util._chunkify(b);
|
|
|
|
|
|
|
|
|
|
for (x = 0; aa[x] && bb[x]; x++) {
|
|
|
|
|
if (aa[x] !== bb[x]) {
|
|
|
|
|
var aNum = Number(aa[x]), bNum = Number(bb[x]);
|
|
|
|
|
// note: == is correct here
|
|
|
|
|
if (aNum == aa[x] && bNum == bb[x]) {
|
|
|
|
|
return aNum - bNum;
|
|
|
|
|
} else {
|
|
|
|
|
// Forcing 'en' locale to match the server-side locale which is
|
|
|
|
|
// always 'en'.
|
|
|
|
|
//
|
|
|
|
|
// Note: This setting isn't supported by all browsers but for the ones
|
|
|
|
|
// that do there will be more consistency between client-server sorting
|
|
|
|
|
return aa[x].localeCompare(bb[x], 'en');
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return aa.length - bb.length;
|
2015-07-07 16:16:37 +03:00
|
|
|
|
},
|
|
|
|
|
/**
|
|
|
|
|
* Calls the callback in a given interval until it returns true
|
|
|
|
|
* @param {function} callback
|
|
|
|
|
* @param {integer} interval in milliseconds
|
|
|
|
|
*/
|
|
|
|
|
waitFor: function(callback, interval) {
|
|
|
|
|
var internalCallback = function() {
|
|
|
|
|
if(callback() !== true) {
|
|
|
|
|
setTimeout(internalCallback, interval);
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
internalCallback();
|
|
|
|
|
},
|
|
|
|
|
/**
|
|
|
|
|
* Checks if a cookie with the given name is present and is set to the provided value.
|
|
|
|
|
* @param {string} name name of the cookie
|
|
|
|
|
* @param {string} value value of the cookie
|
|
|
|
|
* @return {boolean} true if the cookie with the given name has the given value
|
|
|
|
|
*/
|
|
|
|
|
isCookieSetToValue: function(name, value) {
|
|
|
|
|
var cookies = document.cookie.split(';');
|
|
|
|
|
for (var i=0; i < cookies.length; i++) {
|
|
|
|
|
var cookie = cookies[i].split('=');
|
|
|
|
|
if (cookie[0].trim() === name && cookie[1].trim() === value) {
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return false;
|
2014-04-04 13:32:07 +04:00
|
|
|
|
}
|
2015-07-07 16:16:37 +03:00
|
|
|
|
};
|
2014-04-04 13:32:07 +04:00
|
|
|
|
|
2014-05-09 00:06:30 +04:00
|
|
|
|
/**
|
|
|
|
|
* Utility class for the history API,
|
|
|
|
|
* includes fallback to using the URL hash when
|
|
|
|
|
* the browser doesn't support the history API.
|
2014-06-24 01:56:10 +04:00
|
|
|
|
*
|
|
|
|
|
* @namespace
|
2014-05-09 00:06:30 +04:00
|
|
|
|
*/
|
|
|
|
|
OC.Util.History = {
|
|
|
|
|
_handlers: [],
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Push the current URL parameters to the history stack
|
|
|
|
|
* and change the visible URL.
|
|
|
|
|
* Note: this includes a workaround for IE8/IE9 that uses
|
|
|
|
|
* the hash part instead of the search part.
|
|
|
|
|
*
|
2017-03-24 13:51:58 +03:00
|
|
|
|
* @param {Object|string} params to append to the URL, can be either a string
|
2014-05-09 00:06:30 +04:00
|
|
|
|
* or a map
|
2017-03-24 13:51:58 +03:00
|
|
|
|
* @param {string} [url] URL to be used, otherwise the current URL will be used,
|
|
|
|
|
* using the params as query string
|
2016-05-04 12:17:53 +03:00
|
|
|
|
* @param {boolean} [replace=false] whether to replace instead of pushing
|
2014-05-09 00:06:30 +04:00
|
|
|
|
*/
|
2017-03-24 13:51:58 +03:00
|
|
|
|
_pushState: function(params, url, replace) {
|
2014-05-09 00:06:30 +04:00
|
|
|
|
var strParams;
|
|
|
|
|
if (typeof(params) === 'string') {
|
|
|
|
|
strParams = params;
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
strParams = OC.buildQueryString(params);
|
|
|
|
|
}
|
|
|
|
|
if (window.history.pushState) {
|
2017-03-24 13:51:58 +03:00
|
|
|
|
url = url || location.pathname + '?' + strParams;
|
2016-11-04 16:51:03 +03:00
|
|
|
|
// Workaround for bug with SVG and window.history.pushState on Firefox < 51
|
|
|
|
|
// https://bugzilla.mozilla.org/show_bug.cgi?id=652991
|
|
|
|
|
var isFirefox = navigator.userAgent.toLowerCase().indexOf('firefox') > -1;
|
|
|
|
|
if (isFirefox && parseInt(navigator.userAgent.split('/').pop()) < 51) {
|
2016-11-08 02:06:40 +03:00
|
|
|
|
var patterns = document.querySelectorAll('[fill^="url(#"], [stroke^="url(#"], [filter^="url(#invert"]');
|
2016-11-04 16:51:03 +03:00
|
|
|
|
for (var i = 0, ii = patterns.length, pattern; i < ii; i++) {
|
|
|
|
|
pattern = patterns[i];
|
|
|
|
|
pattern.style.fill = pattern.style.fill;
|
|
|
|
|
pattern.style.stroke = pattern.style.stroke;
|
2016-11-08 02:06:40 +03:00
|
|
|
|
pattern.removeAttribute("filter");
|
|
|
|
|
pattern.setAttribute("filter", "url(#invert)");
|
2016-11-04 16:51:03 +03:00
|
|
|
|
}
|
|
|
|
|
}
|
2016-05-04 12:17:53 +03:00
|
|
|
|
if (replace) {
|
|
|
|
|
window.history.replaceState(params, '', url);
|
|
|
|
|
} else {
|
|
|
|
|
window.history.pushState(params, '', url);
|
|
|
|
|
}
|
2014-05-09 00:06:30 +04:00
|
|
|
|
}
|
|
|
|
|
// use URL hash for IE8
|
|
|
|
|
else {
|
|
|
|
|
window.location.hash = '?' + strParams;
|
|
|
|
|
// inhibit next onhashchange that just added itself
|
|
|
|
|
// to the event queue
|
|
|
|
|
this._cancelPop = true;
|
|
|
|
|
}
|
|
|
|
|
},
|
|
|
|
|
|
2016-05-04 12:17:53 +03:00
|
|
|
|
/**
|
|
|
|
|
* Push the current URL parameters to the history stack
|
|
|
|
|
* and change the visible URL.
|
|
|
|
|
* Note: this includes a workaround for IE8/IE9 that uses
|
|
|
|
|
* the hash part instead of the search part.
|
|
|
|
|
*
|
2017-03-24 13:51:58 +03:00
|
|
|
|
* @param {Object|string} params to append to the URL, can be either a string
|
2016-05-04 12:17:53 +03:00
|
|
|
|
* or a map
|
2017-03-24 13:51:58 +03:00
|
|
|
|
* @param {string} [url] URL to be used, otherwise the current URL will be used,
|
|
|
|
|
* using the params as query string
|
2016-05-04 12:17:53 +03:00
|
|
|
|
*/
|
2017-03-24 13:51:58 +03:00
|
|
|
|
pushState: function(params, url) {
|
|
|
|
|
return this._pushState(params, url, false);
|
2016-05-04 12:17:53 +03:00
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Push the current URL parameters to the history stack
|
|
|
|
|
* and change the visible URL.
|
|
|
|
|
* Note: this includes a workaround for IE8/IE9 that uses
|
|
|
|
|
* the hash part instead of the search part.
|
|
|
|
|
*
|
2017-03-24 13:51:58 +03:00
|
|
|
|
* @param {Object|string} params to append to the URL, can be either a string
|
2016-05-04 12:17:53 +03:00
|
|
|
|
* or a map
|
2017-03-24 13:51:58 +03:00
|
|
|
|
* @param {string} [url] URL to be used, otherwise the current URL will be used,
|
|
|
|
|
* using the params as query string
|
2016-05-04 12:17:53 +03:00
|
|
|
|
*/
|
2017-03-24 13:51:58 +03:00
|
|
|
|
replaceState: function(params, url) {
|
|
|
|
|
return this._pushState(params, url, true);
|
2016-05-04 12:17:53 +03:00
|
|
|
|
},
|
|
|
|
|
|
2014-05-09 00:06:30 +04:00
|
|
|
|
/**
|
|
|
|
|
* Add a popstate handler
|
|
|
|
|
*
|
|
|
|
|
* @param handler function
|
|
|
|
|
*/
|
|
|
|
|
addOnPopStateHandler: function(handler) {
|
|
|
|
|
this._handlers.push(handler);
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Parse a query string from the hash part of the URL.
|
|
|
|
|
* (workaround for IE8 / IE9)
|
|
|
|
|
*/
|
|
|
|
|
_parseHashQuery: function() {
|
|
|
|
|
var hash = window.location.hash,
|
|
|
|
|
pos = hash.indexOf('?');
|
|
|
|
|
if (pos >= 0) {
|
|
|
|
|
return hash.substr(pos + 1);
|
|
|
|
|
}
|
2014-06-25 14:37:11 +04:00
|
|
|
|
if (hash.length) {
|
|
|
|
|
// remove hash sign
|
|
|
|
|
return hash.substr(1);
|
|
|
|
|
}
|
2014-05-09 00:06:30 +04:00
|
|
|
|
return '';
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
_decodeQuery: function(query) {
|
|
|
|
|
return query.replace(/\+/g, ' ');
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Parse the query/search part of the URL.
|
|
|
|
|
* Also try and parse it from the URL hash (for IE8)
|
|
|
|
|
*
|
|
|
|
|
* @return map of parameters
|
|
|
|
|
*/
|
|
|
|
|
parseUrlQuery: function() {
|
|
|
|
|
var query = this._parseHashQuery(),
|
|
|
|
|
params;
|
|
|
|
|
// try and parse from URL hash first
|
|
|
|
|
if (query) {
|
|
|
|
|
params = OC.parseQueryString(this._decodeQuery(query));
|
|
|
|
|
}
|
|
|
|
|
// else read from query attributes
|
2015-09-28 19:37:40 +03:00
|
|
|
|
params = _.extend(params || {}, OC.parseQueryString(this._decodeQuery(location.search)));
|
2014-05-09 00:06:30 +04:00
|
|
|
|
return params || {};
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
_onPopState: function(e) {
|
|
|
|
|
if (this._cancelPop) {
|
|
|
|
|
this._cancelPop = false;
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
var params;
|
|
|
|
|
if (!this._handlers.length) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
2016-05-06 17:13:39 +03:00
|
|
|
|
params = (e && e.state);
|
|
|
|
|
if (_.isString(params)) {
|
|
|
|
|
params = OC.parseQueryString(params);
|
|
|
|
|
} else if (!params) {
|
|
|
|
|
params = this.parseUrlQuery() || {};
|
|
|
|
|
}
|
2014-05-09 00:06:30 +04:00
|
|
|
|
for (var i = 0; i < this._handlers.length; i++) {
|
|
|
|
|
this._handlers[i](params);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
// fallback to hashchange when no history support
|
|
|
|
|
if (window.history.pushState) {
|
|
|
|
|
window.onpopstate = _.bind(OC.Util.History._onPopState, OC.Util.History);
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
$(window).on('hashchange', _.bind(OC.Util.History._onPopState, OC.Util.History));
|
|
|
|
|
}
|
|
|
|
|
|
2012-08-29 23:52:42 +04:00
|
|
|
|
/**
|
2014-04-21 15:46:33 +04:00
|
|
|
|
* Get a variable by name
|
|
|
|
|
* @param {string} name
|
|
|
|
|
* @return {*}
|
2012-08-29 23:52:42 +04:00
|
|
|
|
*/
|
|
|
|
|
OC.get=function(name) {
|
|
|
|
|
var namespaces = name.split(".");
|
|
|
|
|
var tail = namespaces.pop();
|
|
|
|
|
var context=window;
|
2013-07-07 22:26:09 +04:00
|
|
|
|
|
2012-08-29 23:52:42 +04:00
|
|
|
|
for(var i = 0; i < namespaces.length; i++) {
|
|
|
|
|
context = context[namespaces[i]];
|
|
|
|
|
if(!context){
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return context[tail];
|
2012-09-23 05:16:52 +04:00
|
|
|
|
};
|
2012-08-29 23:52:42 +04:00
|
|
|
|
|
|
|
|
|
/**
|
2014-04-21 15:46:33 +04:00
|
|
|
|
* Set a variable by name
|
|
|
|
|
* @param {string} name
|
2014-04-21 16:42:50 +04:00
|
|
|
|
* @param {*} value
|
2012-08-29 23:52:42 +04:00
|
|
|
|
*/
|
|
|
|
|
OC.set=function(name, value) {
|
|
|
|
|
var namespaces = name.split(".");
|
|
|
|
|
var tail = namespaces.pop();
|
|
|
|
|
var context=window;
|
2013-07-07 22:26:09 +04:00
|
|
|
|
|
2012-08-29 23:52:42 +04:00
|
|
|
|
for(var i = 0; i < namespaces.length; i++) {
|
|
|
|
|
if(!context[namespaces[i]]){
|
|
|
|
|
context[namespaces[i]]={};
|
|
|
|
|
}
|
|
|
|
|
context = context[namespaces[i]];
|
|
|
|
|
}
|
|
|
|
|
context[tail]=value;
|
2012-09-23 05:16:52 +04:00
|
|
|
|
};
|
2013-02-26 22:34:46 +04:00
|
|
|
|
|
2014-02-20 21:42:59 +04:00
|
|
|
|
// fix device width on windows phone
|
|
|
|
|
(function() {
|
|
|
|
|
if ("-ms-user-select" in document.documentElement.style && navigator.userAgent.match(/IEMobile\/10\.0/)) {
|
|
|
|
|
var msViewportStyle = document.createElement("style");
|
|
|
|
|
msViewportStyle.appendChild(
|
|
|
|
|
document.createTextNode("@-ms-viewport{width:auto!important}")
|
|
|
|
|
);
|
|
|
|
|
document.getElementsByTagName("head")[0].appendChild(msViewportStyle);
|
|
|
|
|
}
|
|
|
|
|
})();
|
|
|
|
|
|
2014-05-08 21:00:42 +04:00
|
|
|
|
/**
|
|
|
|
|
* Namespace for apps
|
2014-06-24 01:56:10 +04:00
|
|
|
|
* @namespace OCA
|
2014-05-08 21:00:42 +04:00
|
|
|
|
*/
|
|
|
|
|
window.OCA = {};
|
|
|
|
|
|
2013-05-13 17:54:45 +04:00
|
|
|
|
/**
|
|
|
|
|
* select a range in an input field
|
|
|
|
|
* @link http://stackoverflow.com/questions/499126/jquery-set-cursor-position-in-text-area
|
|
|
|
|
* @param {type} start
|
|
|
|
|
* @param {type} end
|
|
|
|
|
*/
|
2013-09-16 15:47:37 +04:00
|
|
|
|
jQuery.fn.selectRange = function(start, end) {
|
2013-05-13 17:54:45 +04:00
|
|
|
|
return this.each(function() {
|
|
|
|
|
if (this.setSelectionRange) {
|
|
|
|
|
this.focus();
|
|
|
|
|
this.setSelectionRange(start, end);
|
|
|
|
|
} else if (this.createTextRange) {
|
|
|
|
|
var range = this.createTextRange();
|
|
|
|
|
range.collapse(true);
|
|
|
|
|
range.moveEnd('character', end);
|
|
|
|
|
range.moveStart('character', start);
|
|
|
|
|
range.select();
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
};
|
2013-02-26 22:34:46 +04:00
|
|
|
|
|
2013-09-16 15:47:37 +04:00
|
|
|
|
/**
|
|
|
|
|
* check if an element exists.
|
|
|
|
|
* allows you to write if ($('#myid').exists()) to increase readability
|
|
|
|
|
* @link http://stackoverflow.com/questions/31044/is-there-an-exists-function-for-jquery
|
|
|
|
|
*/
|
|
|
|
|
jQuery.fn.exists = function(){
|
|
|
|
|
return this.length > 0;
|
2013-10-22 20:11:03 +04:00
|
|
|
|
};
|
2015-03-27 03:34:55 +03:00
|
|
|
|
|
2015-06-22 13:48:04 +03:00
|
|
|
|
/**
|
|
|
|
|
* jQuery tipsy shim for the bootstrap tooltip
|
|
|
|
|
*/
|
|
|
|
|
jQuery.fn.tipsy = function(argument) {
|
|
|
|
|
console.warn('Deprecation warning: tipsy is deprecated. Use tooltip instead.');
|
|
|
|
|
if(typeof argument === 'object' && argument !== null) {
|
|
|
|
|
|
|
|
|
|
// tipsy defaults
|
|
|
|
|
var options = {
|
|
|
|
|
placement: 'bottom',
|
|
|
|
|
delay: { 'show': 0, 'hide': 0},
|
|
|
|
|
trigger: 'hover',
|
2015-10-27 13:22:41 +03:00
|
|
|
|
html: false,
|
|
|
|
|
container: 'body'
|
2015-06-22 13:48:04 +03:00
|
|
|
|
};
|
|
|
|
|
if(argument.gravity) {
|
|
|
|
|
switch(argument.gravity) {
|
|
|
|
|
case 'n':
|
|
|
|
|
case 'nw':
|
|
|
|
|
case 'ne':
|
|
|
|
|
options.placement='bottom';
|
|
|
|
|
break;
|
|
|
|
|
case 's':
|
|
|
|
|
case 'sw':
|
|
|
|
|
case 'se':
|
|
|
|
|
options.placement='top';
|
|
|
|
|
break;
|
|
|
|
|
case 'w':
|
|
|
|
|
options.placement='right';
|
|
|
|
|
break;
|
|
|
|
|
case 'e':
|
|
|
|
|
options.placement='left';
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if(argument.trigger) {
|
|
|
|
|
options.trigger = argument.trigger;
|
|
|
|
|
}
|
|
|
|
|
if(argument.delayIn) {
|
2017-05-01 06:45:41 +03:00
|
|
|
|
options.delay.show = argument.delayIn;
|
2015-06-22 13:48:04 +03:00
|
|
|
|
}
|
|
|
|
|
if(argument.delayOut) {
|
2017-05-01 06:45:41 +03:00
|
|
|
|
options.delay.hide = argument.delayOut;
|
2015-06-22 13:48:04 +03:00
|
|
|
|
}
|
|
|
|
|
if(argument.html) {
|
|
|
|
|
options.html = true;
|
|
|
|
|
}
|
2015-07-26 18:09:28 +03:00
|
|
|
|
if(argument.fallback) {
|
2015-07-25 23:10:21 +03:00
|
|
|
|
options.title = argument.fallback;
|
2015-06-22 13:48:04 +03:00
|
|
|
|
}
|
2015-07-08 11:53:17 +03:00
|
|
|
|
// destroy old tooltip in case the title has changed
|
|
|
|
|
jQuery.fn.tooltip.call(this, 'destroy');
|
2015-06-22 13:48:04 +03:00
|
|
|
|
jQuery.fn.tooltip.call(this, options);
|
2015-07-08 11:53:17 +03:00
|
|
|
|
} else {
|
|
|
|
|
this.tooltip(argument);
|
|
|
|
|
jQuery.fn.tooltip.call(this, argument);
|
2015-06-22 13:48:04 +03:00
|
|
|
|
}
|
2015-09-23 00:31:50 +03:00
|
|
|
|
return this;
|
2017-05-01 06:42:53 +03:00
|
|
|
|
};
|