define(['dojo/_base/declare',
|
'dojo/_base/lang',
|
'dojo/_base/array',
|
'dojo/_base/html',
|
'dojo/Deferred',
|
'dojo/topic',
|
'dojo/Evented',
|
'dojo/on',
|
'dojo/aspect',
|
'dojo/json',
|
'dojo/query',
|
'dojo/request/xhr',
|
'dojo/promise/all',
|
'dijit/registry',
|
'./utils',
|
'./dijit/Message'
|
],
|
function(declare, lang, array, html, Deferred, topic, Evented, on, aspect,
|
json, query, xhr, all, registry, utils, Message) {
|
var instance = null,
|
clazz = declare(Evented, {
|
|
constructor: function() {
|
//the loaded widget list
|
this.loaded = [];
|
|
//action is triggered, but the widget has not been loaded
|
//{id: widgetId, action: {}}
|
this.missedActions = [];
|
|
this.activeWidget = null;
|
|
if(window.isBuilder){
|
topic.subscribe("app/mapLoaded", lang.hitch(this, this._onMapLoaded));
|
topic.subscribe("app/mapChanged", lang.hitch(this, this._onMapChanged));
|
}else{
|
topic.subscribe("mapLoaded", lang.hitch(this, this._onMapLoaded));
|
topic.subscribe("mapChanged", lang.hitch(this, this._onMapChanged));
|
}
|
|
if(window.isBuilder){
|
topic.subscribe("app/sceneViewLoaded", lang.hitch(this, this._onSceneViewLoaded));
|
topic.subscribe("app/sceneViewChanged", lang.hitch(this, this._onSceneViewChanged));
|
}else{
|
topic.subscribe("sceneViewLoaded", lang.hitch(this, this._onSceneViewLoaded));
|
topic.subscribe("sceneViewChanged", lang.hitch(this, this._onSceneViewChanged));
|
}
|
|
if(window.isBuilder){
|
topic.subscribe("app/appConfigLoaded", lang.hitch(this, this._onAppConfigLoaded));
|
topic.subscribe("app/appConfigChanged", lang.hitch(this, this._onAppConfigChanged));
|
}else{
|
topic.subscribe("appConfigLoaded", lang.hitch(this, this._onAppConfigLoaded));
|
topic.subscribe("appConfigChanged", lang.hitch(this, this._onAppConfigChanged));
|
}
|
|
|
topic.subscribe('userSignIn', lang.hitch(this, this._onUserSignIn));
|
topic.subscribe('userSignOut', lang.hitch(this, this._onUserSignOut));
|
|
//events from builder
|
topic.subscribe('builder/actionTriggered', lang.hitch(this, this._onActionTriggered));
|
|
//see panel manager
|
topic.subscribe('/dnd/move/start', lang.hitch(this, this._onMoveStart));
|
|
},
|
|
loadWidget: function(setting) {
|
// summary:
|
// load and create widget, return deferred. when defer is resolved,
|
// widget is returned.
|
// description:
|
// setting should contain 2 properties:
|
// id: id should be unique, same id will return same widget object.
|
// uri: the widget's main class
|
var def = new Deferred(),
|
findWidget;
|
|
setting = lang.clone(setting);
|
|
findWidget = this.getWidgetById(setting.id);
|
|
if (findWidget) {
|
//widget have loaded(identified by id)
|
def.resolve(findWidget);
|
} else {
|
all([this.loadWidgetClass(setting), this.loadWidgetManifest(setting)])
|
.then(lang.hitch(this, function(results) {
|
var clazz = results[0];
|
var setting = results[1];
|
this.loadWidgetResources(setting).then(lang.hitch(this, function(resouces) {
|
try {
|
var widget = this.createWidget(setting, clazz, resouces);
|
html.setAttr(widget.domNode, 'data-widget-name', setting.name);
|
console.log('widget [' + setting.uri + '] created.');
|
} catch (err) {
|
console.log('create [' + setting.uri + '] error:' + err.stack);
|
new Message({
|
message: window.jimuNls.widgetManager.createWidgetError + ': ' + setting.uri
|
});
|
|
//when creation is failed, but the dijit is still registered
|
if(registry.byId(setting.id)){
|
registry.byId(setting.id).destroy();
|
}
|
def.reject(err);
|
}
|
|
//use timeout to let the widget can get the correct dimension in startup function
|
setTimeout(lang.hitch(this, function() {
|
def.resolve(widget);
|
this.emit('widget-created', widget);
|
topic.publish('widgetCreated', widget);
|
}), 50);
|
|
}), function(err) {
|
def.reject(err);
|
});
|
}), function(err) {
|
def.reject(err);
|
});
|
}
|
return def;
|
},
|
|
loadWidgetClass: function(setting) {
|
// summary:
|
// load the widget's main class, and return deferred
|
var def = new Deferred();
|
|
var uri;
|
if(setting.isRemote){
|
uri = setting.uri + '.js';
|
}else{
|
uri = setting.uri;
|
}
|
require(utils.getRequireConfig(), [uri], lang.hitch(this, function(clazz) {
|
def.resolve(clazz);
|
}));
|
|
utils.checkError(setting.uri, def);
|
return def;
|
},
|
|
loadWidgetResources: function(setting) {
|
// summary:
|
// load the widget's resources(local, style, etc.), and return deferred
|
|
var def = new Deferred(),
|
defConfig, defI18n, defStyle, defTemplate, defs = [];
|
|
var setting2 = lang.clone(setting);
|
|
defConfig = this.tryLoadWidgetConfig(setting2);
|
defI18n = this._tryLoadResource(setting2, 'i18n');
|
defStyle = this._tryLoadResource(setting2, 'style');
|
defTemplate = this._tryLoadResource(setting2, 'template');
|
|
defs.push(defConfig);
|
defs.push(defI18n);
|
defs.push(defTemplate);
|
defs.push(defStyle);
|
|
all(defs).then(lang.hitch(this, function(results) {
|
var res = {};
|
res.config = results[0];
|
res.i18n = results[1];
|
res.template = results[2];
|
res.style = results[3];
|
def.resolve(res);
|
}), function(err) {
|
def.reject(err);
|
});
|
|
return def;
|
},
|
|
loadWidgetManifest: function(widgetJson){
|
var def = new Deferred();
|
var info = utils.getUriInfo(widgetJson.uri);
|
var url;
|
if(info.isRemote){
|
url = info.folderUrl + 'manifest.json?f=json';
|
}else{
|
url = info.folderUrl + 'manifest.json';
|
}
|
|
//json.manifest is added in configmanager if manifest is merged.
|
if(widgetJson.manifest){
|
def.resolve(widgetJson);
|
return def;
|
}
|
|
xhr(url, {
|
handleAs:'json',
|
headers: {
|
"X-Requested-With": null
|
}
|
}).then(lang.hitch(this, function(manifest){
|
if(manifest.error && manifest.error.code){
|
//request manifest from AGOL item, and there is an error
|
//error code may be: 400, 403
|
return def.reject(manifest.error);
|
}
|
|
manifest.category = 'widget';
|
lang.mixin(manifest, utils.getUriInfo(widgetJson.uri));
|
|
utils.manifest.addI18NLabel(manifest).then(lang.hitch(this, function(){
|
this._processManifest(manifest);
|
utils.widgetJson.addManifest2WidgetJson(widgetJson, manifest);
|
def.resolve(widgetJson);
|
}));
|
}), function(err){
|
def.reject(err);
|
});
|
|
return def;
|
},
|
|
getWidgetMarginBox: function(widget) {
|
if (typeof widget === 'string') {
|
widget = this.getWidgetById(widget);
|
if (!widget) {
|
return {};
|
}
|
}
|
if(widget._marginBox){
|
return widget._marginBox;
|
}
|
|
var position = {
|
left: -9999,
|
top: -9999,
|
relativeTo: widget.position.relativeTo
|
};
|
widget._isTestSizeFlag = true;//set flag for getSize
|
widget.setPosition(position);
|
this.openWidget(widget);
|
|
widget._marginBox = widget.getMarginBox();
|
|
this.closeWidget(widget);
|
|
if ("undefined" !== typeof widget._isTestSizeFlag) {
|
delete widget._isTestSizeFlag;//delete flag
|
}
|
return widget._marginBox;
|
},
|
|
_processManifest: function(manifest){
|
utils.manifest.addManifestProperies(manifest);
|
utils.manifest.processManifestLabel(manifest, window.dojoConfig.locale);
|
},
|
|
createWidget: function(setting, clazz, resouces) {
|
var widget;
|
|
//here, check whether widget have loaded again because loading and create a widget
|
//needs some time. If in this period time, more then one loading request will create
|
//more widgets with the same id, it's a error.
|
|
if (this.getWidgetById(setting.id)) {
|
return this.getWidgetById(setting.id);
|
}
|
|
//the config can contain i18n placeholders
|
if (resouces.config && resouces.i18n) {
|
resouces.config = utils.replacePlaceHolder(resouces.config, resouces.i18n);
|
}
|
|
setting.rawConfig = setting.config;
|
setting.config = resouces.config || {};
|
if (this.appConfig._appData) {
|
this._mergeAgolConfig(setting);
|
}
|
setting.nls = resouces.i18n || {};
|
if (resouces.template) {
|
setting.templateString = resouces.template;
|
}
|
|
setting['class'] = 'jimu-widget';
|
if (!setting.label) {
|
setting.label = setting.name;
|
}
|
if (this.map) {
|
setting.map = this.map;
|
}
|
setting.appConfig = this.appConfig;
|
|
// for IE8
|
var setting2 = {};
|
for (var prop in setting) {
|
if (setting.hasOwnProperty(prop)) {
|
setting2[prop] = setting[prop];
|
}
|
}
|
|
setting2.widgetManager = this;
|
|
widget = new clazz(setting2);
|
widget.clazz = clazz;
|
aspect.after(widget, 'startup', lang.hitch(this, this._postWidgetStartup, widget));
|
aspect.before(widget, 'destroy', lang.hitch(this, this._onDestroyWidget, widget));
|
|
// on(widget.domNode, 'click', lang.hitch(this, this._onClickWidget, widget));
|
widget.domNode.addEventListener('click', lang.hitch(this, this._onClickWidget, widget), {capture: true});
|
|
this.loaded.push(widget);
|
return widget;
|
},
|
|
getAllWidgets: function() {
|
return this.loaded;
|
},
|
|
destroyAllWidgets: function() {
|
var allWidgetIds = array.map(this.loaded, function(widget) {
|
return widget.id;
|
});
|
array.forEach(allWidgetIds, function(widgetId) {
|
this.destroyWidget(widgetId);
|
}, this);
|
this.loaded = [];
|
},
|
|
//load the widget setting page class and create setting page object
|
//do not cache for now.
|
loadWidgetSettingPage: function(setting) {
|
var def = new Deferred();
|
setting = lang.clone(setting);
|
|
setting.id = setting.id + '_setting';
|
all([this.loadWidgetSettingClass(setting)]).
|
then(lang.hitch(this, function(results) {
|
var clazz = results[0];
|
|
this.loadWidgetSettingPageResources(setting).then(lang.hitch(this, function(resources) {
|
var settingObject; // style = results[2]
|
|
// for IE8
|
var setting2 = {
|
nls: resources.i18n,
|
templateString: resources.template,
|
appConfig: this.appConfig,
|
// map: this.map,
|
'class': 'jimu-widget-setting'
|
};
|
|
if(window.appInfo.appType === "HTML3D"){
|
//for 3D Map, we pass sceneView
|
setting2.sceneView = this.sceneView;
|
}else{
|
//for 2D Map, we pass map
|
setting2.map = this.map;
|
}
|
|
for (var prop in setting) {
|
if (setting.hasOwnProperty(prop)) {
|
setting2[prop] = setting[prop];
|
}
|
}
|
try {
|
settingObject = new clazz(setting2);
|
html.setAttr(settingObject.domNode, 'data-widget-name-setting', setting2.name);
|
aspect.before(settingObject, 'destroy',
|
lang.hitch(this, this._onDestroyWidgetSetting, settingObject));
|
def.resolve(settingObject);
|
} catch (err) {
|
new Message({
|
message: window.jimuNls.widgetManager.createWidgetSettingPageError + ':' + setting.uri
|
});
|
//when creation is failed, but the dijit is still registered
|
if(registry.byId(setting2.id)){
|
registry.byId(setting2.id).destroy();
|
}
|
def.reject(err);
|
}
|
}), function(err) {
|
console.log(err);
|
});
|
|
}), function(err) {
|
def.reject(err);
|
});
|
return def;
|
},
|
|
loadWidgetSettingClass: function(setting) {
|
// summary:
|
// load the widget's main class, and return deferred
|
var def = new Deferred();
|
|
var uri;
|
if(setting.isRemote){
|
uri = setting.folderUrl + 'setting/Setting.js';
|
}else{
|
uri = setting.amdFolder + 'setting/Setting';
|
}
|
require(utils.getRequireConfig(), [uri],
|
lang.hitch(this, function(clazz) {
|
def.resolve(clazz);
|
}));
|
|
utils.checkError(setting.folderUrl + 'setting/Setting.js', def);
|
return def;
|
},
|
|
loadWidgetSettingPageResources: function(setting) {
|
var def = new Deferred();
|
var defI18n, defStyle, defTemplate, defs = [];
|
|
setting = lang.clone(setting);
|
defI18n = this._tryLoadResource(setting, 'settingI18n');
|
defTemplate = this._tryLoadResource(setting, 'settingTemplate');
|
defStyle = this._tryLoadResource(setting, 'settingStyle');
|
|
defs.push(defI18n);
|
defs.push(defTemplate);
|
defs.push(defStyle);
|
|
all(defs).then(lang.hitch(this, function(results) {
|
var res = {};
|
res.i18n = results[0] || {};
|
res.template = results[1];
|
res.style = results[2];
|
def.resolve(res);
|
}), function(err) {
|
console.log(err);
|
});
|
|
return def;
|
},
|
|
getWidgetById: function(id) {
|
var ret;
|
array.some(this.loaded, function(w) {
|
if (w.id === id) {
|
ret = w;
|
return true;
|
}
|
}, this);
|
return ret;
|
},
|
|
getWidgetByLabel: function(label) {
|
var ret;
|
array.some(this.loaded, function(w) {
|
if (w.label === label) {
|
ret = w;
|
return true;
|
}
|
}, this);
|
return ret;
|
},
|
|
getWidgetsByName: function(name) {
|
var ret = [];
|
array.some(this.loaded, function(w) {
|
if (w.name === name) {
|
ret.push(w);
|
}
|
}, this);
|
return ret;
|
},
|
|
//normal, minimized, maximized
|
changeWindowStateTo: function(widget, state) {
|
if (state === 'normal') {
|
this.normalizeWidget(widget);
|
} else if (state === 'minimized') {
|
this.minimizeWidget(widget);
|
} else if (state === 'maximized') {
|
this.maximizeWidget(widget);
|
} else {
|
console.log('error state: ' + state);
|
}
|
},
|
|
closeWidget: function(widget) {
|
if (typeof widget === 'string') {
|
widget = this.getWidgetById(widget);
|
if (!widget) {
|
return;
|
}
|
}
|
if (widget.state !== 'closed') {
|
if(this.activeWidget && this.activeWidget.id === widget.id){
|
this.activeWidget.onDeActive();
|
this.activeWidget = null;
|
}
|
html.setStyle(widget.domNode, 'display', 'none');
|
widget.setState('closed');
|
try {
|
widget.onClose();
|
} catch (err) {
|
console.log(console.error('fail to close widget ' + widget.name + '. ' + err.stack));
|
}
|
}
|
|
if(!this.appConfig.mode){
|
this._removeDataSourceUsage(widget);
|
}
|
},
|
|
openWidget: function(widget) {
|
if (typeof widget === 'string') {
|
widget = this.getWidgetById(widget);
|
if (!widget) {
|
return;
|
}
|
}
|
if(!widget.started){
|
try {
|
widget.started = true;
|
widget.startup();
|
} catch (err) {
|
console.error('fail to startup widget ' + widget.name + '. ' + err.stack);
|
}
|
}
|
if (widget.state === 'closed') {
|
html.setStyle(widget.domNode, 'display', '');
|
widget.setState('opened');
|
try {
|
widget.onOpen();
|
} catch (err) {
|
console.error('fail to open widget ' + widget.name + '. ' + err.stack);
|
}
|
}
|
|
if(!this.appConfig.mode){
|
this._addDataSourceUsage(widget);
|
}
|
},
|
|
activateWidget: function(widget){
|
//activate a widget, the widget must be opened first
|
if (typeof widget === 'string') {
|
widget = this.getWidgetById(widget);
|
if (!widget) {
|
return;
|
}
|
}
|
if(widget.state !== 'opened'){
|
return;
|
}
|
|
this._activeWidget(widget);
|
},
|
|
maximizeWidget: function(widget) {
|
if (typeof widget === 'string') {
|
widget = this.getWidgetById(widget);
|
if (!widget) {
|
return;
|
}
|
}
|
if (widget.state === 'closed') {
|
this.openWidget(widget);
|
}
|
|
widget.setWindowState('maximized');
|
try {
|
widget.onMaximize();
|
} catch (err) {
|
console.log(console.error('fail to maximize widget ' + widget.name + '. ' + err.stack));
|
}
|
},
|
|
minimizeWidget: function(widget) {
|
if (typeof widget === 'string') {
|
widget = this.getWidgetById(widget);
|
if (!widget) {
|
return;
|
}
|
}
|
|
if (widget.state === 'closed') {
|
this.openWidget(widget);
|
}
|
widget.setWindowState('minimized');
|
try {
|
widget.onMinimize();
|
} catch (err) {
|
console.log(console.error('fail to minimize widget ' + widget.name + '. ' + err.stack));
|
}
|
},
|
|
normalizeWidget: function(widget) {
|
if (typeof widget === 'string') {
|
widget = this.getWidgetById(widget);
|
if (!widget) {
|
return;
|
}
|
}
|
|
if (widget.state === 'closed') {
|
this.openWidget(widget);
|
}
|
widget.setWindowState('normal');
|
try {
|
widget.onNormalize();
|
} catch (err) {
|
console.log(console.error('fail to normalize widget ' + widget.name + '. ' +
|
err.stack));
|
}
|
},
|
|
destroyWidget: function(widget) {
|
var m;
|
if (typeof widget === 'string') {
|
m = this.getWidgetById(widget);
|
if (!m) {
|
//maybe, the widget is loading
|
return;
|
} else {
|
widget = m;
|
}
|
}
|
this._removeWidget(widget);
|
try {
|
widget.destroy();
|
} catch (err) {
|
console.log(console.error('fail to destroy widget ' + widget.name + '. ' + err.stack));
|
}
|
},
|
|
tryLoadWidgetConfig: function(setting) {
|
return this._tryLoadWidgetConfig(setting).then(lang.hitch(this, function(config) {
|
return this._upgradeWidgetConfig(setting, config).then(function(widgetConfig){
|
setting.config = widgetConfig;
|
return widgetConfig;
|
});
|
}));
|
},
|
|
triggerWidgetOpen: function(widgetId){
|
var def = new Deferred();
|
var widget = this.getWidgetById(widgetId);
|
if(widget){
|
if(widget.state !== 'closed'){
|
def.resolve(widget);
|
return def;
|
}else{
|
resolveAfterOpen(widget);
|
}
|
}else{
|
var handle = topic.subscribe('widgetCreated', lang.hitch(this, function(_widget){
|
if(_widget.id === widgetId){
|
handle.remove();
|
//we resolve here instead of waiting for onOpen, because onOpen may have been
|
//triggered before this call back.
|
def.resolve(_widget);
|
}
|
}));
|
}
|
|
topic.publish('openWidget', widgetId);
|
|
function resolveAfterOpen(widget){
|
var handle = aspect.after(widget, 'onOpen', function(){
|
handle.remove();
|
def.resolve(widget);
|
});
|
}
|
|
return def;
|
},
|
|
_tryLoadWidgetConfig: function(setting) {
|
var def = new Deferred();
|
//need load config first, because the template may be use the config data
|
if (setting.config && lang.isObject(setting.config)) {
|
//if widget is configurated in the app config.json, the i18n has beed processed
|
def.resolve(setting.config);
|
return def;
|
} else if (setting.config) {
|
if(require.cache['url:' + setting.config]){
|
def.resolve(json.parse(require.cache['url:' + setting.config]));
|
return def;
|
}
|
var configFile = utils.processUrlInAppConfig(setting.config);
|
// The widgetConfig filename is dependent on widget label,
|
// IE8 & IE9 do not encode automatically while attempt to request file.
|
var configFileArray = configFile.split('/');
|
configFileArray[configFileArray.length - 1] =
|
encodeURIComponent(configFileArray[configFileArray.length - 1]);
|
configFile = configFileArray.join('/');
|
return xhr(configFile, {
|
handleAs: "json",
|
headers: {
|
"X-Requested-With": null
|
}
|
});
|
} else {
|
return this._tryLoadResource(setting, 'config').then(function(config){
|
//this property is used in map config plugin
|
setting.isDefaultConfig = true;
|
return config;
|
});
|
}
|
},
|
|
_upgradeWidgetConfig: function(json, oldConfig){
|
var def = new Deferred();
|
var widgetVersion = json.manifest.version;
|
var configVersion = json.version;
|
var newConfig;
|
|
if(widgetVersion === configVersion){
|
def.resolve(oldConfig);
|
return def;
|
}
|
|
if(json.hasVersionManager === false){
|
//widget config loaded from builder needs update version
|
json.version = widgetVersion;
|
|
//if widget doesn't have version manager, we assume the widget
|
//is old version compatible
|
def.resolve(oldConfig);
|
return def;
|
}
|
|
require(utils.getRequireConfig(), [json.amdFolder + (json.isRemote? 'VersionManager.js': 'VersionManager')],
|
lang.hitch(this, function(VersionManager) {
|
var versionManager = new VersionManager();
|
|
var configVersionIndex = versionManager.getVersionIndex(configVersion);
|
var widgetVersionIndex = versionManager.getVersionIndex(widgetVersion);
|
if(configVersionIndex > widgetVersionIndex){
|
def.reject('Bad widget version number, ' + json.name + ',' + configVersion);
|
}else{
|
try{
|
newConfig = versionManager.upgrade(oldConfig, configVersion, widgetVersion);
|
json.version = widgetVersion;
|
def.resolve(newConfig);
|
}catch(err){
|
console.log('Read widget [' + json.name + '] old config error,' + err.stack);
|
def.resolve(oldConfig);
|
}
|
}
|
}));
|
|
return def;
|
},
|
|
/*
|
* Load the css file in a widget.
|
* This function load the widget's css file and insert it into the HTML page through <link>.
|
* It also ensure that the css file is inserted only one time.
|
*/
|
loadWidgetStyle: function(widgetSetting) {
|
var id = this._getStyleIdFromWidgetJson(widgetSetting, false),
|
def = new Deferred();
|
if (html.byId(id)) {
|
def.resolve('load');
|
return def;
|
}
|
var themeCommonStyleId = 'theme_' + this.appConfig.theme.name + '_style_common';
|
//insert widget style before theme style, to let theme style over widget style
|
return utils.loadStyleLink(id, widgetSetting.styleFile, themeCommonStyleId);
|
},
|
|
loadWidgetSettingStyle: function(widgetSetting) {
|
var id = this._getStyleIdFromWidgetJson(widgetSetting, true),
|
def = new Deferred();
|
if (html.byId(id)) {
|
def.resolve('load');
|
return def;
|
}
|
return utils.loadStyleLink(id, widgetSetting.settingStyleFile);
|
},
|
|
loadWidgetConfig: function(widgetSetting) {
|
var configFilePath = require(utils.getRequireConfig()).toUrl(widgetSetting.configFile);
|
if(require.cache['url:' + configFilePath]){
|
var def = new Deferred();
|
def.resolve(json.parse(require.cache['url:' + configFilePath]));
|
return def;
|
}
|
return xhr(configFilePath, {
|
handleAs: "json",
|
headers: {
|
"X-Requested-With": null
|
}
|
});
|
},
|
|
loadWidgetI18n: function(widgetSetting) {
|
var def = new Deferred();
|
require(utils.getRequireConfig(), ['dojo/i18n!' + widgetSetting.i18nFile],
|
function(bundle) {
|
def.resolve(bundle);
|
});
|
return def;
|
},
|
|
loadWidgetSettingI18n: function(widgetSetting) {
|
var def = new Deferred();
|
require(utils.getRequireConfig(), ['dojo/i18n!' + widgetSetting.settingI18nFile],
|
function(bundle) {
|
def.resolve(bundle);
|
});
|
return def;
|
},
|
|
loadWidgetTemplate: function(widgetSetting) {
|
var def = new Deferred();
|
require(utils.getRequireConfig(), ['dojo/text!' + widgetSetting.templateFile],
|
function(template) {
|
def.resolve(template);
|
});
|
|
utils.checkError(widgetSetting.templateFile, def);
|
return def;
|
},
|
|
loadWidgetSettingTemplate: function(widgetSetting) {
|
var def = new Deferred();
|
require(utils.getRequireConfig(), ['dojo/text!' + widgetSetting.settingTemplateFile],
|
function(template) {
|
def.resolve(template);
|
});
|
|
utils.checkError(widgetSetting.settingTemplateFile, def);
|
return def;
|
},
|
|
removeWidgetStyle: function(widget) {
|
this._removeStyle(this._getStyleIdFromWidgetJson(widget, false));
|
},
|
|
removeWidgetSettingStyle: function(widget) {
|
this._removeStyle(this._getStyleIdFromWidgetJson(widget, true));
|
},
|
|
_removeStyle: function(styleId){
|
if(!html.byId(styleId)){
|
return;
|
}
|
var importStyles = html.attr(styleId, 'data-import-styles');
|
if(importStyles){
|
for(var i = 0; i < parseInt(importStyles, 10); i ++){
|
html.destroy(styleId + '_import_' + i);
|
}
|
}
|
html.destroy(styleId);
|
},
|
|
_getStyleIdFromWidgetJson: function(widgetJson, isSetting){
|
var p = widgetJson.itemId? widgetJson.itemId: widgetJson.uri;
|
var id = 'widget/style/' + p + (isSetting? '/setting': '');
|
return this._replaceId(id);
|
},
|
|
getControllerWidgets: function() {
|
return array.filter(this.loaded, function(widget) {
|
return widget.isController;
|
});
|
},
|
|
getOffPanelWidgets: function() {
|
return array.filter(this.loaded, function(widget) {
|
return !widget.inPanel;
|
});
|
},
|
|
getOnScreenOffPanelWidgets: function() {
|
return array.filter(this.loaded, function(widget) {
|
return widget.isOnScreen && !widget.inPanel;
|
});
|
},
|
|
closeOtherWidgetsInTheSameGroup: function(widget){
|
if (typeof widget === 'string') {
|
widget = this.getWidgetById(widget);
|
if (!widget) {
|
return;
|
}
|
}
|
for(var i = 0; i < this.loaded.length; i++){
|
if(this.loaded[i].gid === widget.gid && this.loaded[i].id !== widget.id){
|
this.closeWidget(this.loaded[i]);
|
}
|
}
|
},
|
|
closeAllWidgetsInGroup: function (groupId){
|
for(var i = 0; i < this.loaded.length; i++){
|
if(this.loaded[i].gid === groupId){
|
this.closeWidget(this.loaded[i]);
|
}
|
}
|
},
|
|
_addDataSourceUsage: function(widget){
|
|
},
|
|
_removeDataSourceUsage: function(widget){
|
|
},
|
|
_getUsedDataSourceIdFromWidget: function(widget){
|
var widgetJson = this.appConfig.getConfigElementById(widget.id);
|
if(!widgetJson || !widgetJson.config){
|
return;
|
}
|
var configStr = json.stringify(widgetJson.config);
|
return array.filter(Object.keys(this.appConfig.dataSource.dataSources), function(dsId){
|
return configStr.indexOf(dsId) > -1;
|
}, this);
|
},
|
|
// Merge AGOL configs when first open widget (because the
|
// widgetConfig just loaded if the widget has not been edited yet).
|
// This method only merge fields in widget config,
|
// the other fields were merged in ConfigManager.js
|
_mergeAgolConfig: function(setting) {
|
var values = this.appConfig._appData.values;
|
function doMerge(sectionKey) {
|
for (var key in values) {
|
var sectionKeyIndex = key.replace(/\//g, '_').indexOf(sectionKey + '_config');
|
if (sectionKeyIndex >= 0){
|
utils.template.setConfigValue(setting,
|
key.replace(/\//g, '_').substr(sectionKeyIndex, key.length).
|
replace(sectionKey, 'widget'),
|
values[key]);
|
}
|
}
|
}
|
var sectionKey;
|
sectionKey = 'widgets[' + setting.id + ']';
|
doMerge(sectionKey);
|
},
|
|
_onUserSignIn: function(credential) {
|
array.forEach(this.loaded, function(m) {
|
m.onSignIn(credential);
|
}, this);
|
},
|
|
_onUserSignOut: function() {
|
array.forEach(this.loaded, function(m) {
|
m.onSignOut();
|
}, this);
|
},
|
|
_activeWidget: function(widget){
|
if(this.activeWidget){
|
if(this.activeWidget.id === widget.id){
|
//zIndex may be reset by widget self, we do not set in-panel widget zindex
|
if(this.activeWidget.inPanel === false && this.activeWidget.moveTopOnActive){
|
html.setStyle(this.activeWidget.domNode, 'zIndex', 101);
|
}
|
return;
|
}
|
if(this.activeWidget.state === 'active'){
|
this.activeWidget.setState('opened');
|
if(this.activeWidget.inPanel === false){
|
html.setStyle(widget.domNode, 'zIndex',
|
'zIndex' in widget.position? widget.position.zIndex: 'auto');
|
}
|
this.activeWidget.onDeActive();
|
}
|
}
|
this.activeWidget = widget;
|
if(this.activeWidget.state !== 'opened'){
|
return;
|
}
|
this.activeWidget.setState('active');
|
if(this.activeWidget.inPanel === false && this.activeWidget.moveTopOnActive){
|
html.setStyle(this.activeWidget.domNode, 'zIndex', 101);
|
}
|
this.activeWidget.onActive();
|
topic.publish('widgetActived', widget);
|
},
|
|
_onClickWidget: function(widget, evt){
|
var childWidgets = query('.jimu-widget', widget.domNode);
|
if(childWidgets.length > 0){
|
for(var i = 0; i < childWidgets.length; i++){
|
if(evt.target === childWidgets[i] || html.isDescendant(evt.target, childWidgets[i])){
|
//click on the child widget or child widget's children dom
|
return;
|
}
|
}
|
}
|
this._activeWidget(widget);
|
},
|
|
_onMoveStart: function(mover){
|
array.forEach(this.loaded, function(widget){
|
if(widget.domNode === mover.node){
|
this._activeWidget(widget);
|
}
|
}, this);
|
},
|
|
_onAppConfigLoaded: function(_appConfig) {
|
var appConfig = lang.clone(_appConfig);
|
this.appConfig = appConfig;
|
},
|
|
_onMapLoaded: function(map) {
|
this.map = map;
|
},
|
|
_onMapChanged: function(map) {
|
this.map = map;
|
},
|
|
_onSceneViewLoaded: function(sceneView){
|
this.sceneView = sceneView;
|
},
|
|
_onSceneViewChanged: function(sceneView){
|
this.sceneView = sceneView;
|
},
|
|
_onAppConfigChanged: function(_appConfig, reason, changedData, otherOptions) {
|
var appConfig = lang.clone(_appConfig);
|
this.appConfig = appConfig;
|
array.forEach(this.loaded, function(w) {
|
if (!w) {
|
//widget maybe deleted in the handler of appConfigChange event
|
return;
|
}
|
w.onAppConfigChanged(appConfig, reason, changedData, otherOptions);
|
if (reason === 'widgetChange') {
|
this._onConfigChanged(changedData.id, changedData.config, otherOptions);
|
}
|
}, this);
|
},
|
|
_onConfigChanged: function(id, config) {
|
//summary:
|
// widget which care it's own config change should override onConfigChanged function
|
var w = this.getWidgetById(id);
|
if (!w) {
|
return;
|
}
|
|
w.onConfigChanged(config);
|
lang.mixin(w.config, config);
|
},
|
|
_onActionTriggered: function(info) {
|
if (info.elementId === 'map' || info.elementId === 'app') {
|
return;
|
}
|
var m = this.getWidgetById(info.elementId);
|
if (!m) {
|
this.missedActions.push({
|
id: info.elementId,
|
action: {
|
name: info.action,
|
data: info.data
|
}
|
});
|
} else {
|
m.onAction(info.action, info.data);
|
}
|
//may be the controller widget also need process the action
|
array.forEach(this.getControllerWidgets(), function(ctrlWidget) {
|
if (ctrlWidget.widgetIsControlled(info.elementId)) {
|
ctrlWidget.onAction(info.action, {
|
widgetId: info.elementId,
|
data: info.data
|
});
|
}
|
}, this);
|
},
|
|
_postWidgetStartup: function(widgetObject) {
|
widgetObject.started = true;//for backward compatibility
|
utils.setVerticalCenter(widgetObject.domNode);
|
aspect.after(widgetObject, 'resize', lang.hitch(this,
|
utils.setVerticalCenter, widgetObject.domNode));
|
this.openWidget(widgetObject);
|
// if(widgetObject.defaultState){
|
// this.changeWindowStateTo(widgetObject, widgetObject.defaultState);
|
// }
|
|
this._triggerMissedAction(widgetObject);
|
},
|
|
_triggerMissedAction: function(widget) {
|
this.missedActions.forEach(function(info) {
|
if (info.id === widget.id) {
|
widget.onAction(info.action.name, info.action.data);
|
}
|
});
|
},
|
|
_remove: function(id) {
|
return array.some(this.loaded, function(w, i) {
|
if (w.id === id) {
|
this.loaded.splice(i, 1);
|
return true;
|
}
|
}, this);
|
},
|
|
_tryLoadResource: function(setting, flag) {
|
var file, hasp,
|
def = new Deferred(),
|
doLoad = function() {
|
var loadDef;
|
if (flag === 'config') {
|
loadDef = this.loadWidgetConfig(setting);
|
} else if (flag === 'style') {
|
loadDef = this.loadWidgetStyle(setting);
|
} else if (flag === 'i18n') {
|
loadDef = this.loadWidgetI18n(setting);
|
} else if (flag === 'template') {
|
loadDef = this.loadWidgetTemplate(setting);
|
} else if (flag === 'settingTemplate') {
|
loadDef = this.loadWidgetSettingTemplate(setting);
|
} else if (flag === 'settingStyle') {
|
loadDef = this.loadWidgetSettingStyle(setting);
|
} else if (flag === 'settingI18n') {
|
loadDef = this.loadWidgetSettingI18n(setting);
|
} else {
|
return def;
|
}
|
loadDef.then(function(data) {
|
def.resolve(data);
|
}, function(err) {
|
console.error('Load widget resource error. resource:', flag);
|
console.error(err);
|
new Message({
|
message: window.jimuNls.widgetManager.loadWidgetResourceError + ': ' + setting.uri
|
});
|
def.reject(err);
|
});
|
};
|
|
if (flag === 'config') {
|
file = setting.amdFolder + 'config.json';
|
setting.configFile = file;
|
hasp = 'hasConfig';
|
} else if (flag === 'style') {
|
file = setting.amdFolder + 'css/style.css';
|
setting.styleFile = file;
|
hasp = 'hasStyle';
|
} else if (flag === 'i18n') {
|
file = setting.amdFolder + 'nls/strings.js';
|
if(setting.isRemote){
|
setting.i18nFile = file;
|
}else{
|
setting.i18nFile = setting.amdFolder + 'nls/strings';
|
}
|
hasp = 'hasLocale';
|
} else if (flag === 'template') {
|
file = setting.amdFolder + 'Widget.html';
|
setting.templateFile = file;
|
hasp = 'hasUIFile';
|
} else if (flag === 'settingTemplate') {
|
file = setting.amdFolder + 'setting/Setting.html';
|
setting.settingTemplateFile = file;
|
hasp = 'hasSettingUIFile';
|
} else if (flag === 'settingI18n') {
|
file = setting.amdFolder + 'setting/nls/strings.js';
|
if(setting.isRemote){
|
setting.settingI18nFile = file;
|
}else{
|
setting.settingI18nFile = setting.amdFolder + 'setting/nls/strings';
|
}
|
hasp = 'hasSettingLocale';
|
} else if (flag === 'settingStyle') {
|
file = setting.amdFolder + 'setting/css/style.css';
|
setting.settingStyleFile = file;
|
hasp = 'hasSettingStyle';
|
} else {
|
return def;
|
}
|
|
if (setting[hasp]){
|
doLoad.apply(this);
|
}else {
|
def.resolve(null);
|
}
|
return def;
|
},
|
|
_replaceId: function(id) {
|
return id.replace(/\//g, '_').replace(/\./g, '_');
|
},
|
|
_onDestroyWidget: function(widget) {
|
if (widget.state !== 'closed') {
|
this.closeWidget(widget);
|
}
|
this._removeWidget(widget);
|
this.emit('widget-destroyed', widget.id);
|
topic.publish('widgetDestroyed', widget.id);
|
console.log('destroy widget [' + widget.uri + '].');
|
},
|
|
_onDestroyWidgetSetting: function(settingWidget) {
|
this.removeWidgetSettingStyle(settingWidget);
|
},
|
|
_removeWidget: function(widget) {
|
var m;
|
if (typeof widget === 'string') {
|
m = this.getWidgetById(widget);
|
if (!m) {
|
//maybe, the widget is loading
|
return;
|
} else {
|
widget = m;
|
}
|
}
|
|
if(this.activeWidget && this.activeWidget.id === widget.id){
|
this.activeWidget = null;
|
}
|
this._remove(widget.id);
|
if(this.getWidgetsByName(widget.name).length === 0){
|
this.removeWidgetStyle(widget);
|
}
|
}
|
});
|
|
clazz.getInstance = function(urlParams) {
|
if (instance === null) {
|
instance = new clazz(urlParams);
|
window._widgetManager = instance;
|
}
|
return instance;
|
};
|
return clazz;
|
});
|
