define([
|
'dojo/_base/declare',
|
'dojo/_base/lang',
|
'dojo/_base/array',
|
'dojo/_base/html',
|
'dijit/_WidgetBase',
|
'dojo/Deferred',
|
'dojo/promise/all',
|
'../utils',
|
'../WidgetPlaceholder',
|
'../OnScreenWidgetIcon'
|
],
|
|
function(declare, lang, array, html, _WidgetBase, Deferred, all, jimuUtils, WidgetPlaceholder, OnScreenWidgetIcon) {
|
var instance = null, clazz;
|
|
/*jshint unused:false */
|
/* global jimuConfig:true */
|
|
clazz = declare([_WidgetBase], {
|
constructor: function() {
|
this.widgetPlaceholders = [];
|
this.onScreenWidgetIcons = [];
|
this.invisibleWidgetIds = [];
|
},
|
|
name: 'BaseLayoutManager',
|
mapId: 'map',
|
map: null,
|
layoutId: 'jimu-layout-manager',
|
|
postCreate: function(){
|
this.containerNode = this.domNode;
|
this.layoutId = jimuConfig.layoutId;
|
},
|
|
resize: function() {
|
},
|
|
isSupportEdit: function(){
|
return false;
|
},
|
|
getMapDiv: function(){
|
},
|
|
setMap: function(map){
|
this.map = map;
|
},
|
|
onEnter: function(appConfig, mapId){
|
var def = new Deferred();
|
this.appConfig = appConfig;
|
this.mapId = mapId;
|
def.resolve();
|
return def;
|
},
|
|
onLeave: function(){
|
|
},
|
|
onThemeLoad: function() {
|
},
|
|
/**
|
* do load and layout job in this function, including onscreen widgets and map
|
*
|
* @param {[type]} appConfig [description]
|
* @return {[type]} [description]
|
*/
|
loadAndLayout: function(appConfig){
|
|
},
|
|
openWidget: function(widgetId){
|
|
},
|
|
/////////////functions to handle builder events
|
onLayoutChange: function(appConfig){
|
|
},
|
|
onWidgetChange: function(appConfig, widgetJson){
|
|
},
|
|
onGroupChange: function(appConfig, groupJson){
|
|
},
|
|
onWidgetPoolChange: function(appConfig, changeData){
|
this.reloadControllerWidget(appConfig, changeData.controllerId);
|
},
|
|
onOnScreenOrderChange: function(appConfig, onscreenWidgets){
|
array.forEach(onscreenWidgets, lang.hitch(this, function(widgetConfig) {
|
if (!widgetConfig.uri) {
|
array.some(this.widgetPlaceholders, lang.hitch(this, function(phDijit) {
|
if (phDijit.index === widgetConfig.placeholderIndex) {
|
var style = jimuUtils.getPositionStyle({
|
top: widgetConfig.position.top,
|
left: widgetConfig.position.left,
|
right: widgetConfig.position.right,
|
bottom: widgetConfig.position.bottom,
|
width: 40,
|
height: 40
|
});
|
html.setStyle(phDijit.domNode, style);
|
return true;
|
}
|
}));
|
} else {
|
array.some(this.onScreenWidgetIcons, lang.hitch(this, function(iconDijit) {
|
if (iconDijit.configId === widgetConfig.id) {
|
html.setStyle(iconDijit.domNode, jimuUtils.getPositionStyle({
|
top: widgetConfig.position.top,
|
left: widgetConfig.position.left,
|
right: widgetConfig.position.right,
|
bottom: widgetConfig.position.bottom,
|
width: 40,
|
height: 40
|
}));
|
iconDijit.moveTo(widgetConfig.position);
|
return true;
|
}
|
}));
|
}
|
}));
|
},
|
|
onActionTriggered: function(actionInfo){
|
},
|
|
onLayoutDefinitionChange: function(appConfig, layoutDefinition){
|
|
},
|
|
onOnScreenGroupsChange: function(appConfig, groups){
|
|
},
|
|
destroyOnScreenWidgetsAndGroups: function(appConfig){
|
|
},
|
|
/*
|
Because, for now, onscreen widgets are managed by the same way by these 2 layout manager, so, put code here.
|
when we have a layout that does not use the same way to manage onscreen widgets, we'll refactor the code
|
These functions are used to called by sub class, not used to be inherited.
|
*/
|
|
loadOnScreenWidgets: function(appConfig){
|
var defs = [];
|
array.forEach(appConfig.widgetOnScreen.widgets, function(widgetConfig) {
|
if(widgetConfig.visible === false){
|
this.invisibleWidgetIds.push(widgetConfig.id);
|
return;
|
}
|
defs.push(this.loadOnScreenWidget(widgetConfig, appConfig));
|
}, this);
|
|
return all(defs);
|
},
|
|
loadOnScreenWidget: function(widgetConfig, appConfig){
|
var def = new Deferred();
|
|
if(appConfig.mode === 'config' && !widgetConfig.uri){
|
var placeholder = this._createOnScreenWidgetPlaceHolder(widgetConfig);
|
def.resolve(placeholder);
|
return def;
|
}else if(!widgetConfig.uri){
|
//in run mode, when no uri, do nothing
|
def.resolve(null);
|
return def;
|
}
|
|
var iconDijit;
|
if(widgetConfig.inPanel || widgetConfig.closeable){//TODO closeable rename
|
//in panel widget or closeable off panel widget
|
iconDijit = this._createOnScreenWidgetIcon(widgetConfig);
|
def.resolve(iconDijit);
|
}else{
|
//off panel
|
this.widgetManager.loadWidget(widgetConfig).then(lang.hitch(this, function(widget){
|
try{
|
widget.setPosition(widget.position);
|
this.widgetManager.openWidget(widget);
|
}catch(err){
|
console.log(console.error('fail to startup widget ' + widget.name + '. ' + err.stack));
|
}
|
|
widget.configId = widgetConfig.id;
|
def.resolve(widget);
|
}), function(err){
|
def.reject(err);
|
});
|
}
|
|
return def;
|
},
|
|
onOnScreenWidgetChange: function(appConfig, widgetJson){
|
widgetJson = appConfig.getConfigElementById(widgetJson.id);
|
if(widgetJson.isController){
|
this.reloadControllerWidget(appConfig, widgetJson.id);
|
return;
|
}
|
array.forEach(this.widgetPlaceholders, function(placeholder){
|
if(placeholder.configId === widgetJson.id){
|
placeholder.destroy();
|
this.loadOnScreenWidget(widgetJson, appConfig);
|
}
|
}, this);
|
this.removeDestroyed(this.widgetPlaceholders);
|
this._updatePlaceholder(appConfig);
|
|
array.forEach(this.onScreenWidgetIcons, function(icon){
|
if(icon.configId === widgetJson.id){
|
var state = icon.state;
|
icon.destroy();
|
this.loadOnScreenWidget(widgetJson, appConfig).then(function(iconNew){
|
if(widgetJson.uri && state === 'opened'){
|
iconNew.onClick();
|
}
|
});
|
}
|
}, this);
|
this.removeDestroyed(this.onScreenWidgetIcons);
|
|
array.forEach(this.widgetManager.getOnScreenOffPanelWidgets(), function(widget){
|
if(widget.configId === widgetJson.id){
|
widget.destroy();
|
if(widgetJson.visible === false){
|
if(this.invisibleWidgetIds.indexOf(widgetJson.id) < 0){
|
this.invisibleWidgetIds.push(widgetJson.id);
|
}
|
return;
|
}
|
this.loadOnScreenWidget(widgetJson, appConfig);
|
}
|
}, this);
|
|
//if widget change visible from invisible, it's not exist in onscreen offpanel Widgets
|
//so, load it here
|
array.forEach(this.invisibleWidgetIds, function(widgetId){
|
if(widgetId === widgetJson.id && widgetJson.visible !== false){
|
this.loadOnScreenWidget(widgetJson, appConfig);
|
var i = this.invisibleWidgetIds.indexOf(widgetJson.id);
|
this.invisibleWidgetIds.splice(i, 1);
|
}
|
}, this);
|
|
if(!widgetJson.isOnScreen){
|
array.forEach(this.widgetManager.getControllerWidgets(), function(controllerWidget){
|
if(controllerWidget.widgetIsControlled(widgetJson.id)){
|
this.reloadControllerWidget(appConfig, controllerWidget.id);
|
}
|
}, this);
|
}
|
},
|
|
destroyOnScreenWidgetIcons: function(){
|
array.forEach(this.onScreenWidgetIcons, function(icon){
|
icon.destroy();
|
}, this);
|
this.onScreenWidgetIcons = [];
|
},
|
|
destroyOnScreenOffPanelWidgets: function(){
|
array.forEach(this.widgetManager.getOnScreenOffPanelWidgets(), function(widget){
|
if(widget.isController){
|
this._destroyControllerWidget(widget);
|
}else{
|
this.widgetManager.destroyWidget(widget);
|
}
|
}, this);
|
},
|
|
destroyWidgetPlaceholders: function(){
|
array.forEach(this.widgetPlaceholders, function(placeholder){
|
placeholder.destroy();
|
}, this);
|
this.widgetPlaceholders = [];
|
},
|
|
removeDestroyed: function(_array){
|
var willBeDestroyed = [];
|
array.forEach(_array, function(e){
|
if(e._destroyed){
|
willBeDestroyed.push(e);
|
}
|
});
|
array.forEach(willBeDestroyed, function(e){
|
var i = _array.indexOf(e);
|
_array.splice(i, 1);
|
});
|
},
|
|
_createOnScreenWidgetPlaceHolder: function(widgetConfig){
|
var pid;
|
if(widgetConfig.position.relativeTo === 'map'){
|
pid = this.mapId;
|
}else{
|
pid = this.layoutId;
|
}
|
var cfg = lang.clone(widgetConfig);
|
|
cfg.position.width = 40;
|
cfg.position.height = 40;
|
var style = jimuUtils.getPositionStyle(cfg.position);
|
var phDijit = new WidgetPlaceholder({
|
index: cfg.placeholderIndex,
|
configId: widgetConfig.id
|
});
|
html.setStyle(phDijit.domNode, style);
|
html.place(phDijit.domNode, pid);
|
this.widgetPlaceholders.push(phDijit);
|
return phDijit;
|
},
|
|
_createOnScreenWidgetIcon: function(widgetConfig){
|
var iconDijit = new OnScreenWidgetIcon({
|
panelManager: this.panelManager,
|
widgetManager: this.widgetManager,
|
widgetConfig: widgetConfig,
|
configId: widgetConfig.id,
|
map: this.map
|
});
|
|
if(widgetConfig.position.relativeTo === 'map'){
|
html.place(iconDijit.domNode, this.mapId);
|
}else{
|
html.place(iconDijit.domNode, this.layoutId);
|
}
|
//icon position doesn't use width/height in config
|
html.setStyle(iconDijit.domNode, jimuUtils.getPositionStyle({
|
top: widgetConfig.position.top,
|
left: widgetConfig.position.left,
|
right: widgetConfig.position.right,
|
bottom: widgetConfig.position.bottom,
|
width: 40,
|
height: 40
|
}));
|
iconDijit.startup();
|
|
if(!this.openAtStartWidget && widgetConfig.openAtStart){
|
iconDijit.switchToOpen();
|
this.openAtStartWidget = widgetConfig.name;
|
}
|
|
this.onScreenWidgetIcons.push(iconDijit);
|
return iconDijit;
|
},
|
|
reloadControllerWidget: function(appConfig, controllerId){
|
var controllerWidget = this.widgetManager.getWidgetById(controllerId);
|
if(!controllerWidget){
|
this._loadControllerWidget(appConfig, controllerId);
|
return;
|
}
|
|
//get old info
|
var openedIds = controllerWidget.getOpenedIds();
|
var windowState = controllerWidget.windowState;
|
|
this._destroyControllerWidget(controllerWidget);
|
this._loadControllerWidget(appConfig, controllerId, openedIds, windowState);
|
},
|
|
_destroyControllerWidget: function(controllerWidget){
|
//destory all panels controlled by the controller.
|
//we can't destroy the opened only, because some panels are closed but the
|
//instance is still exists
|
|
//destroy controlled widgets
|
array.forEach(controllerWidget.getAllConfigs(), function(configJson){
|
if(configJson.widgets){//it's group
|
this.panelManager.destroyPanel(configJson.id + '_panel');
|
array.forEach(configJson.widgets, function(widgetItem){
|
//Group items must be in panel
|
this.panelManager.destroyPanel(widgetItem.id + '_panel');
|
}, this);
|
}else{
|
var widget = this.widgetManager.getWidgetById(configJson.id);
|
if(!widget){
|
return;
|
}
|
if(configJson.inPanel){
|
this.panelManager.destroyPanel(widget.getPanel());
|
}else{
|
this.widgetManager.destroyWidget(widget);
|
}
|
}
|
|
}, this);
|
|
//destroy controller itself
|
this.widgetManager.destroyWidget(controllerWidget);
|
},
|
|
_loadControllerWidget: function(appConfig, controllerId, openedIds, windowState){
|
//load widget
|
var newControllerJson = appConfig.getConfigElementById(controllerId);
|
if(newControllerJson.visible === false){
|
return;
|
}
|
this.loadOnScreenWidget(newControllerJson, appConfig).then(lang.hitch(this, function(widget){
|
if(windowState){
|
this.widgetManager.changeWindowStateTo(widget, windowState);
|
}
|
if(openedIds){
|
widget.setOpenedIds(openedIds);
|
}
|
}));
|
},
|
|
_updatePlaceholder: function (appConfig) {
|
array.forEach(this.widgetPlaceholders, function(placehoder){
|
placehoder.setIndex(appConfig.getConfigElementById(placehoder.configId).placeholderIndex);
|
}, this);
|
}
|
|
});
|
|
clazz.getInstance = function() {
|
if (instance === null) {
|
instance = new clazz();
|
}
|
return instance;
|
};
|
return clazz;
|
});
|
