def __init__(self, loader, *containers): super(ContainerManager, self).__init__() self.onViewAddedToContainer = Event() proxy = weakref.proxy(self) self.__containers = {} for container in containers: raise isinstance(container, AbstractViewContainer) or AssertionError self.__containers[container.getViewType()] = container(proxy) self._loadingViews = dict() self.__loader = loader self.__loader.onViewLoaded += self.__loader_onViewLoaded self.__scopeController = GlobalScopeController() self.__scopeController.create()
def __init__(self, loader, *containers): super(ContainerManager, self).__init__() self.onViewAddedToContainer = Event() self.__globalContainer = _GlobalViewContainer(weakref.proxy(self)) for container in containers: raise isinstance(container, ViewContainer) or AssertionError self.__globalContainer.addChildContainer(container) self.__loader = loader self.__loader.onViewLoaded += self.__onViewLoaded self.__scopeController = GlobalScopeController() self.__scopeController.create() self.__viewCache = _ViewCollection() self.__chainMng = _ChainManager(weakref.proxy(self))
def __init__(self, loader): super(ContainerManager, self).__init__() proxy = weakref.proxy(self) self.__containers = { ViewTypes.DEFAULT: _DefaultContainer(proxy), ViewTypes.CURSOR: _DefaultContainer(proxy), ViewTypes.WAITING: _DefaultContainer(proxy), ViewTypes.WINDOW: _PopUpContainer(proxy), ViewTypes.BROWSER: _PopUpContainer(proxy), ViewTypes.TOP_WINDOW: _PopUpContainer(proxy), ViewTypes.SERVICE_LAYOUT: _DefaultContainer(proxy) } self._loadingViews = dict() self.__loader = loader self.__loader.onViewLoaded += self.__loader_onViewLoaded self.__scopeController = GlobalScopeController() self.__scopeController.create()
def __init__(self, loader): super(ContainerManager, self).__init__() proxy = weakref.proxy(self) self.__containers = {ViewTypes.DEFAULT: _DefaultContainer(proxy), ViewTypes.CURSOR: _DefaultContainer(proxy), ViewTypes.WAITING: _DefaultContainer(proxy), ViewTypes.WINDOW: _PopUpContainer(proxy), ViewTypes.BROWSER: _PopUpContainer(proxy), ViewTypes.TOP_WINDOW: _PopUpContainer(proxy), ViewTypes.SERVICE_LAYOUT: _DefaultContainer(proxy)} self._loadingViews = dict() self.__loader = loader self.__loader.onViewLoaded += self.__loader_onViewLoaded self.__scopeController = GlobalScopeController() self.__scopeController.create()
class ContainerManager(ContainerManagerMeta): """ Class of container manager. """ def __init__(self, loader, *containers): super(ContainerManager, self).__init__() self.onViewAddedToContainer = Event() proxy = weakref.proxy(self) self.__containers = {} for container in containers: raise isinstance(container, AbstractViewContainer) or AssertionError self.__containers[container.getViewType()] = container(proxy) self._loadingViews = dict() self.__loader = loader self.__loader.onViewLoaded += self.__loader_onViewLoaded self.__scopeController = GlobalScopeController() self.__scopeController.create() def load(self, alias, name=None, *args, **kwargs): """ Loads view to container. :param alias: :param name: :param args: :param kwargs: :return: """ if name is None: name = alias isViewExists = self.as_getViewS(name) if not isViewExists and (alias, name) not in self._loadingViews: pyEntity = self.__loader.loadView(alias, name, *args, **kwargs) self.__scopeController.addLoadingView(pyEntity, False) curType = pyEntity.settings.type if self.canCancelPreviousLoading(curType): result = [] for kev, val in self._loadingViews.iteritems(): if val.settings.type == pyEntity.settings.type: result.append(val) if result: self.__cancelLoadingForPyEntities(result) self._loadingViews[alias, name] = pyEntity return def canCancelPreviousLoading(self, containerType): container = self.getContainer(containerType) if container is not None: return container.canCancelPreviousLoading() else: return False return def addContainer(self, viewType, name, container=None): result = True if viewType not in self.__containers: if container is None: self.__containers[viewType] = DefaultContainer( viewType, weakref.proxy(self)) self.as_registerContainerS(viewType, name) elif isinstance(container, AbstractViewContainer): self.__containers[viewType] = container self.as_registerContainerS(viewType, name) else: LOG_ERROR('Container must be implemented IViewContainer', container) result = False else: LOG_ERROR('Container already registered', viewType) result = False return result def removeContainer(self, viewType): self.__scopeController.removeSubScopeController( ScopeTemplates.VIEW_TYPES_TO_SCOPES[viewType].getScopeType()) result = True if viewType in self.__containers: container = self.__containers[viewType] container.destroy() self.as_unregisterContainerS(viewType) del self.__containers[viewType] else: result = False return result def getContainer(self, viewType): if viewType in self.__containers: return self.__containers[viewType] else: return None def isModalViewsIsExists(self): for viewType in _POPUPS_CONTAINERS: container = self.getContainer(viewType) if container is not None and container.getViewCount(isModal=True): return True return False def getView(self, viewType, criteria=None): container = self.getContainer(viewType) if container is not None: view = container.getView(criteria=criteria) else: raise Exception('Container for %s view is None!' % viewType) return view def isViewAvailable(self, viewType, criteria=None): container = self.getContainer(viewType) if container is not None: return container.getView(criteria=criteria) is not None else: return False return def showContainers(self, *viewTypes): self.as_showContainersS(viewTypes) def hideContainers(self, *viewTypes): self.as_hideContainersS(viewTypes) def isContainerShown(self, viewType): return self.as_isContainerShownS(viewType) def closePopUps(self): self.as_closePopUpsS() def clear(self): for viewType in _POPUPS_CONTAINERS: container = self.getContainer(viewType) if container is not None: container.clear() return def removeLoadingView(self, alias, uniqueName): self._loadingViews.pop((alias, uniqueName), None) return def _dispose(self): if self.__loader is not None: self.__loader.onViewLoaded -= self.__loader_onViewLoaded self.__loader = None for viewType in _CONTAINERS_DESTROY_ORDER: if viewType in self.__containers: container = self.__containers.pop(viewType) LOG_DEBUG('CONTAINER: {}/{}'.format(container, viewType)) container.destroy() if len(self.__containers): LOG_ERROR('No all containers are destructed.') self.__containers.clear() self.onViewAddedToContainer.clear() self.__scopeController.destroy() self.__scopeController = None self._loadingViews.clear() self._loadingViews = None super(ContainerManager, self)._dispose() return def __cancelLoadingForPyEntities(self, pyEntities): for curEntity in pyEntities: self._loadingViews.pop( (curEntity.settings.alias, curEntity.uniqueName)) self.__loader.cancelLoadingByName(curEntity.uniqueName) curEntity.destroy() def __loader_onViewLoaded(self, pyView): viewType = pyView.settings.type if viewType is None: LOG_ERROR('Type of view is not defined', pyView.settings) viewKey = (pyView.alias, pyView.uniqueName) if viewKey in self._loadingViews: self._loadingViews.pop(viewKey) if viewType in self.__containers: if ViewTypes.DEFAULT == viewType: self.closePopUps() if self.__scopeController.isViewLoading(pyView): container = self.__containers[viewType] if container.add(pyView): self.__scopeController.addView(pyView, False) self.as_showS(pyView.uniqueName, 0, 0) pyView.create() subContainerType = pyView.getSubContainerType() if subContainerType is not None: self.addContainer(subContainerType, pyView.uniqueName) LOG_DEBUG('View added to container', pyView) self.onViewAddedToContainer(container, pyView) else: LOG_DEBUG( '"%s" view cancelled to load, because its scope has been destroyed.' % str(pyView)) self.as_hideS(pyView.uniqueName) pyView.destroy() else: LOG_ERROR('Type "%s" of view "%s" is not supported' % (viewType, pyView)) return
class ContainerManager(ContainerManagerMeta, IContainerManager): """ The container manager manages overlapping of views and their life time based on their type and scope. Performs loading of views through the specified loader. 1. Overlapping of views UI consists of several layers. Each layer has its own Z index. It allows to control overlapping of views (views of the top level layer overlap views of underlying layers). The set of default layers depends on entry (application) type (lobby and battle have their own configuration). Each view can belong to one layer and it is defined by view's type. With each layer associated one view container that is managed by the container manager. There are two types of layers (view containers): - DefaultContainer - only one top level view can be placed in the container (layer) and if a new view is placed to it the previous one is destroyed; - PopUpContainer - several views can exist at the same time in one layer. Also any top level view can include a subview that is placed into a sub-container. If a top level view can include a sub-view, the sub-container is created after the top level view is loaded and initialized. When sub-view is loaded, it is placed into the top level view's sub-container. The sub-container is destroyed when the top level view is destroyed. 2. Views life time The 'view scope' concept is introduced to simplify views lifetime management. View lifetime is defined by its scope and is controlled by the container manager through the scope controller. View scope defines when the view should be destroyed: if the parent view (parent scope) is destroyed, the subview is destroyed too. For details please see ScopeController description. """ def __init__(self, loader, *containers): super(ContainerManager, self).__init__() self.onViewAddedToContainer = Event() self.__globalContainer = _GlobalViewContainer(weakref.proxy(self)) for container in containers: raise isinstance(container, ViewContainer) or AssertionError self.__globalContainer.addChildContainer(container) self.__loader = loader self.__loader.onViewLoaded += self.__onViewLoaded self.__scopeController = GlobalScopeController() self.__scopeController.create() self.__viewCache = _ViewCollection() self.__chainMng = _ChainManager(weakref.proxy(self)) def _dispose(self): self.__viewCache.destroy() self.__chainMng.destroy() if self.__loader is not None: self.__loader.onViewLoaded -= self.__onViewLoaded self.__loader = None for viewType in _CONTAINERS_DESTROY_ORDER: container = self.__globalContainer.findContainer(viewType) if container is not None: LOG_DEBUG('Destroy container {} ({})'.format( viewType, container)) container.destroy() self.__globalContainer.destroy() self.onViewAddedToContainer.clear() self.__scopeController.destroy() self.__scopeController = None super(ContainerManager, self)._dispose() return def destroyViews(self, alias, name=None): def compareByAlias(view): return view.key.alias == alias def compareByAliasAndName(view): viewKey = view.key return viewKey.alias == alias and viewKey.name == name if name is None: comparator = compareByAlias else: comparator = compareByAliasAndName views = self.__scopeController.findViews(comparator) views.extend(self.__viewCache.findViews(comparator)) for view in views: if not view.isDisposed(): LOG_DEBUG('The view {} will be destroyed...'.format(view)) view.destroy() viewKey = ViewKey(alias, name) chain = self.__chainMng.getChainByViewKey(viewKey) if chain is not None: chain.removeViewByViewKey(viewKey) return def loadChain(self, chainItems): """ Loads the given views (chain items) one after the other. :param chainItems: list of ChainItem items. """ chain = _LoadingChain(chainItems) if self.__chainMng.addChain(chain): chain.run() else: LOG_WARNING( 'Could not add a new chain. Loading of chain [{}] is canceled.' .format(chainItems)) chain.destroy() def load(self, loadParams, *args, **kwargs): """ Loads a view with the given alias and puts it to the appropriate container (layer). :param loadParams: instance of ViewLoadParams :param args: args to be passed to view's constructor. :param kwargs: kwargs to be passed to view's constructor. :return: instance of view (loading or loaded). None if no view is loaded. """ viewKey = loadParams.viewKey viewLoadingItem = self.__loader.getViewLoadingItem(viewKey) if viewLoadingItem is not None: LOG_DEBUG('View with key {} is already loading. item=[{}]'.format( viewKey, viewLoadingItem)) view = viewLoadingItem.pyEntity if loadParams.loadMode == ViewLoadMode.DEFAULT: loadingViewLoadMode = viewLoadingItem.loadParams.loadMode if loadingViewLoadMode == ViewLoadMode.PRELOAD: viewLoadingItem.loadParams = loadParams self.__addLoadingView(view) elif loadParams.loadMode == ViewLoadMode.PRELOAD: pass else: LOG_WARNING( 'Unsupported load mode {}. View loading will be skipped.'. format(loadParams)) view = None else: view = self.__globalContainer.findView(viewKey) if view is None: view = self.__viewCache.getView(viewKey) if view is None: chain = self.__chainMng.getChainByViewKey(viewKey) if chain is not None: LOG_WARNING( 'View with loadParams={} is in the loading chain {}. The request will be skipped.' .format(loadParams, chain)) else: LOG_DEBUG( 'Load view with loadParams={}. Loader=[{}]'.format( loadParams, self.__loader)) if loadParams.loadMode == ViewLoadMode.DEFAULT: view = self.__loader.loadView( loadParams, *args, **kwargs) self.__addLoadingView(view) elif loadParams.loadMode == ViewLoadMode.PRELOAD: view = self.__loader.loadView( loadParams, *args, **kwargs) else: LOG_WARNING( 'Unsupported load mode {}. View loading will be skipped.' .format(loadParams)) elif loadParams.loadMode == ViewLoadMode.PRELOAD: LOG_DEBUG( 'View with key {} ({}) is already pre-loaded.'.format( viewKey, view)) elif loadParams.loadMode == ViewLoadMode.DEFAULT: LOG_DEBUG( 'Load view with loadParams={} from the cache. Cache=[{}]' .format(loadParams, self.__viewCache)) self.__viewCache.removeView(viewKey) self.__showAndInitializeView(view) view.validate(*args, **kwargs) else: LOG_WARNING( 'Unsupported load mode {}. View loading will be skipped.' .format(loadParams)) view = None else: LOG_DEBUG('View with key {} ({}) is already loaded.'.format( viewKey, view)) viewType = view.settings.type viewContainer = self.__globalContainer.findContainer(viewType) viewContainer.addView(view) view.validate(*args, **kwargs) return view def getContainer(self, viewType): """ Returns container by the given type or None if there is no such container. :param viewType: viewType: View type. @see ViewTypes. """ return self.__globalContainer.findContainer(viewType) def isModalViewsIsExists(self): """ Returns True if a modal view exists, otherwise returns False. """ for viewType in _POPUPS_CONTAINERS: container = self.__globalContainer.findContainer(viewType) if container is not None and container.getViewCount(isModal=True): return True return False def getView(self, viewType, criteria=None): """ Gets view by the given type and criteria if it is defined. :param viewType: type of view. @see ViewTypes. :param criteria: criteria to find view in container. :return: instance of view. """ container = self.__globalContainer.findContainer(viewType) if container is not None: return container.getView(criteria=criteria) else: LOG_WARNING('Could not found container {}.'.format(viewType)) return def isViewAvailable(self, viewType, criteria=None): """ If you want to get some view from some container, it`s may be unsafely operation. For example, I want to get a Hangar from a Lobby view. it`s a bad situation and method "getView" detects this state. Then, if you just want to detect an existing View, use isViewAvailable method. :param viewType: type of view. @see ViewTypes. :param criteria: criteria to find view in container. """ container = self.__globalContainer.findContainer(viewType) if container is not None: return container.getView(criteria=criteria) is not None else: return False def showContainers(self, *viewTypes): """ Shows containers for given view types. :param viewTypes: View types """ self.as_showContainersS(viewTypes) def hideContainers(self, *viewTypes): """ Hides containers for given view types. :param viewTypes: View types """ self.as_hideContainersS(viewTypes) def isContainerShown(self, viewType): """ Returns True if a container with the given view type is shown, otherwise returns False. :param viewType: View types """ return self.as_isContainerShownS(viewType) def clear(self): """ Clears pop-ups containers. """ for viewType in _POPUPS_CONTAINERS: container = self.__globalContainer.findContainer(viewType) if container is not None: container.clear() return def closePopUps(self): """ Closes all popUps: widows and dialogs. """ self.as_closePopUpsS() def registerViewContainer(self, viewType, uniqueName): self.as_registerContainerS(viewType, uniqueName) LOG_DEBUG( 'A new container [type={}, name={}] has been registered.'.format( viewType, uniqueName)) def unregisterViewContainer(self, viewType): self.as_unregisterContainerS(viewType) LOG_DEBUG( 'The container [type={}] has been unregistered.'.format(viewType)) def __addLoadingView(self, pyView): viewType = pyView.settings.type viewContainer = self.__globalContainer.findContainer(viewType) if viewContainer is not None: viewContainer.addLoadingView(pyView) else: LOG_WARNING( 'Loading of view {} is requested but the container {} is still not exist!' .format(pyView, viewType)) self.__scopeController.addLoadingView(pyView, False) return def __showAndInitializeView(self, pyView): viewType = pyView.settings.type if viewType is None: LOG_ERROR( 'Type of view is not defined. View {} will be destroyed.', pyView) pyView.destroy() return False else: status = False container = self.__globalContainer.findContainer(viewType) if container is not None: if ViewTypes.DEFAULT == viewType: self.closePopUps() if container.addView(pyView): self.__scopeController.addView(pyView, False) self.as_showS(pyView.uniqueName, 0, 0) pyView.create() self.onViewAddedToContainer(container, pyView) status = True else: LOG_ERROR( '{} view cannot be added to container {} and will be destroyed.' .format(pyView, container)) pyView.destroy() else: LOG_ERROR( 'Type {} of view {} is not supported or container has not been properly created' .format(viewType, pyView)) pyView.destroy() return status def __addViewToCache(self, pyView): view = self.__viewCache.getView(pyView.key) if view is not None: LOG_UNEXPECTED( 'The view with key {} is already in the cache.'.format( pyView.key), pyView, view) if view != pyView: view.destroy() if self.__viewCache.addView(pyView): LOG_DEBUG('View {} has been added to the cache {}'.format( pyView, self.__viewCache)) else: LOG_DEBUG('Cannot add view {} in the cache {}'.format( pyView, self.__viewCache)) elif self.__viewCache.addView(pyView): LOG_DEBUG('View {} has been added to the cache {}'.format( pyView, self.__viewCache)) else: LOG_DEBUG('Cannot add view {} in the cache {}'.format( pyView, self.__viewCache)) return def __onViewLoaded(self, pyView, loadParams): loadMode = loadParams.loadMode if loadMode == ViewLoadMode.DEFAULT: if self.__scopeController.isViewLoading(pyView=pyView): self.__showAndInitializeView(pyView) else: LOG_DEBUG( '{} view loading is cancelled because its scope has been destroyed.' .format(pyView)) pyView.destroy() elif loadMode == ViewLoadMode.PRELOAD: self.__addViewToCache(pyView) else: LOG_WARNING( 'Unsupported load mode {}. View {} will be destroyed.'.format( loadMode, pyView)) pyView.destroy()
class ContainerManager(ContainerManagerMeta, IContainerManager): def __init__(self, loader, *containers): super(ContainerManager, self).__init__() self.onViewAddedToContainer = Event() self.onViewLoading = Event() self.onViewLoaded = Event() self.__globalContainer = _GlobalViewContainer(weakref.proxy(self)) for container in containers: self.__globalContainer.addChildContainer(container) self.__loader = loader self.__loader.onViewLoadInit += self.__onViewLoadInit self.__loader.onViewLoaded += self.__onViewLoaded self.__scopeController = GlobalScopeController() self.__scopeController.create() self.__viewCache = _ViewCollection() self.__chainMng = _ChainManager(weakref.proxy(self)) def _dispose(self): self.__viewCache.destroy() self.__chainMng.destroy() if self.__loader is not None: self.__loader.onViewLoaded -= self.__onViewLoaded self.__loader.onViewLoadInit -= self.__onViewLoadInit self.__loader = None for layer, layerName in enumerate(LAYER_NAMES.LAYER_ORDER): container = self.__globalContainer.findContainer(layer) if container is not None: _logger.debug('Destroy container %s (%r)', layerName, container) container.destroy() self.__globalContainer.destroy() self.onViewAddedToContainer.clear() self.__scopeController.destroy() self.__scopeController = None super(ContainerManager, self)._dispose() return def destroyViews(self, alias, name=None): def compareByAlias(view): return view.key.alias == alias def compareByAliasAndName(view): viewKey = view.key return viewKey.alias == alias and viewKey.name == name if name is None: comparator = compareByAlias else: comparator = compareByAliasAndName views = self.__scopeController.findViews(comparator) views.extend(self.__viewCache.findViews(comparator)) for view in views: if not view.isDisposed(): _logger.debug('The view %r will be destroyed...', view) view.destroy() viewKey = ViewKey(alias, name) chain = self.__chainMng.getChainByViewKey(viewKey) if chain is not None: chain.removeViewByViewKey(viewKey) return def loadChain(self, chainItems): chain = _LoadingChain(chainItems) if self.__chainMng.addChain(chain): chain.run() else: _logger.warning( 'Could not add a new chain. Loading of chain [%r] is canceled.', chainItems) chain.destroy() def load(self, loadParams, *args, **kwargs): viewKey = loadParams.viewKey viewLoadingItem = self.__loader.getViewLoadingItem(viewKey) if viewLoadingItem is not None: _logger.debug('View with key %s is already loading. item=[%r]', viewKey, viewLoadingItem) view = viewLoadingItem.pyEntity if loadParams.loadMode == ViewLoadMode.DEFAULT: loadingViewLoadMode = viewLoadingItem.loadParams.loadMode if loadingViewLoadMode == ViewLoadMode.PRELOAD: viewLoadingItem.loadParams = loadParams self.__addLoadingView(view) elif loadParams.loadMode == ViewLoadMode.PRELOAD: pass else: _logger.warning( 'Unsupported load mode %r. View loading will be skipped.', loadParams) view = None else: view = self.__globalContainer.findView(viewKey) if view is None: view = self.__viewCache.getView(viewKey) if view is None: chain = self.__chainMng.getChainByViewKey(viewKey) if chain is not None: _logger.warning( 'View with loadParams=%r is in the loading chain %r. The request will be skipped.', loadParams, chain) else: _logger.debug( 'Load view with loadParams=%r. Loader=[%r]', loadParams, self.__loader) if loadParams.loadMode == ViewLoadMode.DEFAULT: view = self.__loader.loadView( loadParams, *args, **kwargs) self.__addLoadingView(view) elif loadParams.loadMode == ViewLoadMode.PRELOAD: view = self.__loader.loadView( loadParams, *args, **kwargs) else: _logger.warning( 'Unsupported load mode %r. View loading will be skipped.', loadParams) elif loadParams.loadMode == ViewLoadMode.PRELOAD: _logger.debug( 'View with key %s (%r) is already pre-loaded.', viewKey, view) elif loadParams.loadMode == ViewLoadMode.DEFAULT: _logger.debug( 'Load view with loadParams=%r from the cache. Cache=[%r]', loadParams, self.__viewCache) self.__viewCache.removeView(viewKey) self.__showAndInitializeView(view) view.validate(*args, **kwargs) else: _logger.warning( 'Unsupported load mode %r. View loading will be skipped.', loadParams) view = None else: _logger.debug('View with key %s (%r) is already loaded.', viewKey, view) layer = view.layer viewContainer = self.__globalContainer.findContainer(layer) viewContainer.addView(view) view.validate(*args, **kwargs) return view def getContainer(self, layer): return self.__globalContainer.findContainer(layer) def getViewByKey(self, viewKey): if self.__loader is not None: loadingItem = self.__loader.getViewLoadingItem(viewKey) if loadingItem is not None: return loadingItem.pyEntity sources = (self.__globalContainer.findView, self.__viewCache.getView) for source in sources: view = source(viewKey) if view is not None: return view return def isViewCreated(self, viewKey): return self.__globalContainer.findView(viewKey) is not None def isViewInCache(self, viewKey): return self.__viewCache.getView(viewKey) is not None def isModalViewsIsExists(self): for layer in _POPUPS_CONTAINERS: container = self.__globalContainer.findContainer(layer) if container is not None and container.getViewCount( isModal=True) or self.__loader.isModalViewLoading(): return True return False def getView(self, layer, criteria=None): container = self.__globalContainer.findContainer(layer) if container is not None: return container.getView(criteria=criteria) else: _logger.warning('Could not found container %s.', layer) return def isViewAvailable(self, layer, criteria=None): container = self.__globalContainer.findContainer(layer) return container.getView( criteria=criteria) is not None if container is not None else False def showContainers(self, layers, time=0): self.as_showContainersS(layers, time) def hideContainers(self, layers, time=0): self.as_hideContainersS(layers, time) def getVisibleLayers(self): return self.as_getVisibleLayersS() def setVisibleLayers(self, layerList): self.as_setVisibleLayersS(layerList) def isContainerShown(self, layer): return self.as_isContainerShownS(layer) def clear(self): for layer in _POPUPS_CONTAINERS: container = self.__globalContainer.findContainer(layer) if container is not None: container.clear() return def closePopUps(self): self.as_closePopUpsS() def registerViewContainer(self, layer, uniqueName): self.as_registerContainerS(layer, uniqueName) _logger.debug( 'A new container [layer=%d, name=%s] has been registered.', layer, uniqueName) def unregisterViewContainer(self, layer): self.as_unregisterContainerS(layer) _logger.debug('The container [layer=%d] has been unregistered.', layer) def __addLoadingView(self, pyView): layer = pyView.layer viewContainer = self.__globalContainer.findContainer(layer) if viewContainer is not None: viewContainer.addLoadingView(pyView) else: _logger.warning( 'Loading of view %r is requested but the container %d is still not exist!', pyView, layer) self.__scopeController.addLoadingView(pyView, False) return def __showAndInitializeView(self, pyView): layer = pyView.layer if layer is None: _logger.error( 'Type of view is not defined. View %r will be destroyed.', pyView) pyView.destroy() return False else: status = False container = self.__globalContainer.findContainer(layer) if container is not None: if WindowLayer.VIEW == layer: self.closePopUps() if container.addView(pyView): self.__scopeController.addView(pyView, False) if pyView.uiImpl == UIFrameworkImpl.SCALEFORM: self.as_showS(pyView.uniqueName, 0, 0) pyView.create() self.onViewAddedToContainer(container, pyView) status = True else: _logger.error( '%r view cannot be added to container %r and will be destroyed.', pyView, container) pyView.destroy() else: _logger.error( 'Layer %s of view %r is not supported or container has not been properly created', layer, pyView) pyView.destroy() return status def __addViewToCache(self, pyView): view = self.__viewCache.getView(pyView.key) if view is not None: _logger.warning('The view with key %r is already in the cache.', pyView.key) if view != pyView: view.destroy() if self.__viewCache.addView(pyView): _logger.debug('View %r has been added to the cache %r', pyView, self.__viewCache) else: _logger.debug('Cannot add view %r in the cache %r', pyView, self.__viewCache) elif self.__viewCache.addView(pyView): _logger.debug('View %r has been added to the cache %r', pyView, self.__viewCache) else: _logger.debug('Cannot add view %r in the cache %r', pyView, self.__viewCache) return def __onViewLoaded(self, pyView, loadParams): self.onViewLoaded(pyView) loadMode = loadParams.loadMode if loadMode == ViewLoadMode.DEFAULT: if self.__scopeController.isViewLoading(pyView=pyView): self.__showAndInitializeView(pyView) else: _logger.debug( '%r view loading is cancelled because its scope has been destroyed.', pyView) pyView.destroy() elif loadMode == ViewLoadMode.PRELOAD: self.__addViewToCache(pyView) else: _logger.warning( 'Unsupported load mode %s. View %r will be destroyed.', loadMode, pyView) pyView.destroy() def __onViewLoadInit(self, view, *args, **kwargs): self.onViewLoading(view)
class ContainerManager(ContainerManagerMeta): onViewAddedToContainer = Event() __DESTROY_ORDER = (ViewTypes.DEFAULT, ViewTypes.LOBBY_SUB, ViewTypes.WINDOW, ViewTypes.BROWSER, ViewTypes.TOP_WINDOW, ViewTypes.WAITING, ViewTypes.CURSOR, ViewTypes.SERVICE_LAYOUT) __CONTAINERS_TO_CLEAR = (ViewTypes.WINDOW, ViewTypes.BROWSER, ViewTypes.TOP_WINDOW) def __init__(self, loader): super(ContainerManager, self).__init__() proxy = weakref.proxy(self) self.__containers = {ViewTypes.DEFAULT: _DefaultContainer(proxy), ViewTypes.CURSOR: _DefaultContainer(proxy), ViewTypes.WAITING: _DefaultContainer(proxy), ViewTypes.WINDOW: _PopUpContainer(proxy), ViewTypes.BROWSER: _PopUpContainer(proxy), ViewTypes.TOP_WINDOW: _PopUpContainer(proxy), ViewTypes.SERVICE_LAYOUT: _DefaultContainer(proxy)} self._loadingViews = dict() self.__loader = loader self.__loader.onViewLoaded += self.__loader_onViewLoaded self.__scopeController = GlobalScopeController() self.__scopeController.create() def load(self, alias, name = None, *args, **kwargs): if name is None: name = alias isViewExists = self.as_getViewS(name) if not isViewExists and (alias, name) not in self._loadingViews: pyEntity = self.__loader.loadView(alias, name, *args, **kwargs) self.__scopeController.addLoadingView(pyEntity, False) curType = pyEntity.settings.type if self.canCancelPreviousLoading(curType): result = [] for kev, val in self._loadingViews.iteritems(): if val.settings.type == pyEntity.settings.type: result.append(val) if len(result) > 0: self.__cancelLoadingForPyEntities(result) self._loadingViews[alias, name] = pyEntity return def __cancelLoadingForPyEntities(self, pyEntities): for curEntity in pyEntities: self._loadingViews.pop((curEntity.settings.alias, curEntity.uniqueName)) self.__loader.cancelLoadingByName(curEntity.uniqueName) curEntity.destroy() def canCancelPreviousLoading(self, containerType): container = self.getContainer(containerType) if container is not None: return container.canCancelPreviousLoading() else: return False return def addContainer(self, containerType, name, container = None): result = True if containerType not in self.__containers: if container is None: self.__containers[containerType] = _DefaultContainer(weakref.proxy(self)) self.as_registerContainerS(containerType, name) elif isinstance(container, IViewContainer): self.__containers[containerType] = container self.as_registerContainerS(containerType, name) else: LOG_ERROR('Container must be implemented IViewContainer', container) result = False else: LOG_ERROR('Container already registered', containerType) result = False return result def removeContainer(self, viewType): self.__scopeController.removeSubScopeController(ScopeTemplates.VIEW_TYPES_TO_SCOPES[viewType].getScopeType()) result = True if viewType in self.__containers: container = self.__containers[viewType] container.destroy() self.as_unregisterContainerS(viewType) del self.__containers[viewType] else: result = False return result def getContainer(self, viewType): if viewType in self.__containers: return self.__containers[viewType] else: return None def isModalViewsIsExists(self): if self.getContainer(ViewTypes.TOP_WINDOW).getViewCount(isModal=True) > 0: return True elif self.getContainer(ViewTypes.BROWSER).getViewCount(isModal=True) > 0: return True else: return self.getContainer(ViewTypes.WINDOW).getViewCount(isModal=True) > 0 def getView(self, viewType, criteria = None): view = None container = self.getContainer(viewType) if container is not None: view = container.getView(criteria=criteria) else: raise Exception('Container for %s view is None!' % viewType) return view def isViewAvailable(self, viewType, criteria = None): container = self.getContainer(viewType) if container is not None: return container.getView(criteria=criteria) is not None else: return False return def closePopUps(self): self.as_closePopUpsS() def clear(self): for c in self.__CONTAINERS_TO_CLEAR: self.getContainer(c).clear() def _dispose(self): if self.__loader is not None: self.__loader.onViewLoaded -= self.__loader_onViewLoaded self.__loader = None for viewType in self.__DESTROY_ORDER: if viewType in self.__containers: container = self.__containers.pop(viewType) LOG_DEBUG('CONTAINER: ' + str(container) + '/' + viewType) container.destroy() if len(self.__containers): LOG_ERROR('No all containers are destructed.') self.__containers.clear() self.onViewAddedToContainer.clear() self.__scopeController.destroy() self.__scopeController = None self._loadingViews.clear() self._loadingViews = None super(ContainerManager, self)._dispose() return def __loader_onViewLoaded(self, pyView): viewType = pyView.settings.type if viewType is None: LOG_ERROR('Type of view is not defined', pyView.settings) viewKey = (pyView.alias, pyView.uniqueName) if viewKey in self._loadingViews: self._loadingViews.pop(viewKey) if viewType in self.__containers: if ViewTypes.DEFAULT == viewType: self.closePopUps() if self.__scopeController.isViewLoading(pyView): container = self.__containers[viewType] if container.add(pyView): self.__scopeController.addView(pyView, False) self.as_showS(pyView.uniqueName, 0, 0) pyView.create() subContainerType = pyView.getSubContainerType() if subContainerType is not None: self.addContainer(subContainerType, pyView.uniqueName) LOG_DEBUG('View added to container', pyView) self.onViewAddedToContainer(container, pyView) else: LOG_DEBUG('"%s" view cancelled to load, because its scope has been destroyed.' % str(pyView)) self.as_hideS(pyView.uniqueName) pyView.destroy() else: LOG_ERROR('Type "%s" of view "%s" is not supported' % (viewType, pyView)) return
class ContainerManager(ContainerManagerMeta): """ Class of container manager. """ def __init__(self, loader, *containers): super(ContainerManager, self).__init__() self.onViewAddedToContainer = Event() proxy = weakref.proxy(self) self.__containers = {} for container in containers: raise isinstance(container, AbstractViewContainer) or AssertionError self.__containers[container.getViewType()] = container(proxy) self._loadingViews = dict() self.__loader = loader self.__loader.onViewLoaded += self.__loader_onViewLoaded self.__scopeController = GlobalScopeController() self.__scopeController.create() def load(self, alias, name = None, *args, **kwargs): """ Loads view to container. :param alias: :param name: :param args: :param kwargs: :return: """ if name is None: name = alias isViewExists = self.as_getViewS(name) if not isViewExists and (alias, name) not in self._loadingViews: pyEntity = self.__loader.loadView(alias, name, *args, **kwargs) self.__scopeController.addLoadingView(pyEntity, False) curType = pyEntity.settings.type if self.canCancelPreviousLoading(curType): result = [] for kev, val in self._loadingViews.iteritems(): if val.settings.type == pyEntity.settings.type: result.append(val) if result: self.__cancelLoadingForPyEntities(result) self._loadingViews[alias, name] = pyEntity return def canCancelPreviousLoading(self, containerType): container = self.getContainer(containerType) if container is not None: return container.canCancelPreviousLoading() else: return False return def addContainer(self, viewType, name, container = None): result = True if viewType not in self.__containers: if container is None: self.__containers[viewType] = DefaultContainer(viewType, weakref.proxy(self)) self.as_registerContainerS(viewType, name) elif isinstance(container, AbstractViewContainer): self.__containers[viewType] = container self.as_registerContainerS(viewType, name) else: LOG_ERROR('Container must be implemented IViewContainer', container) result = False else: LOG_ERROR('Container already registered', viewType) result = False return result def removeContainer(self, viewType): self.__scopeController.removeSubScopeController(ScopeTemplates.VIEW_TYPES_TO_SCOPES[viewType].getScopeType()) result = True if viewType in self.__containers: container = self.__containers[viewType] container.destroy() self.as_unregisterContainerS(viewType) del self.__containers[viewType] else: result = False return result def getContainer(self, viewType): if viewType in self.__containers: return self.__containers[viewType] else: return None def isModalViewsIsExists(self): for viewType in _POPUPS_CONTAINERS: container = self.getContainer(viewType) if container is not None and container.getViewCount(isModal=True): return True return False def getView(self, viewType, criteria = None): container = self.getContainer(viewType) if container is not None: view = container.getView(criteria=criteria) else: raise Exception('Container for %s view is None!' % viewType) return view def isViewAvailable(self, viewType, criteria = None): container = self.getContainer(viewType) if container is not None: return container.getView(criteria=criteria) is not None else: return False return def showContainers(self, *viewTypes): self.as_showContainersS(viewTypes) def hideContainers(self, *viewTypes): self.as_hideContainersS(viewTypes) def isContainerShown(self, viewType): return self.as_isContainerShownS(viewType) def closePopUps(self): self.as_closePopUpsS() def clear(self): for viewType in _POPUPS_CONTAINERS: container = self.getContainer(viewType) if container is not None: container.clear() return def removeLoadingView(self, alias, uniqueName): self._loadingViews.pop((alias, uniqueName), None) return def _dispose(self): if self.__loader is not None: self.__loader.onViewLoaded -= self.__loader_onViewLoaded self.__loader = None for viewType in _CONTAINERS_DESTROY_ORDER: if viewType in self.__containers: container = self.__containers.pop(viewType) LOG_DEBUG('CONTAINER: {}/{}'.format(container, viewType)) container.destroy() if len(self.__containers): LOG_ERROR('No all containers are destructed.') self.__containers.clear() self.onViewAddedToContainer.clear() self.__scopeController.destroy() self.__scopeController = None self._loadingViews.clear() self._loadingViews = None super(ContainerManager, self)._dispose() return def __cancelLoadingForPyEntities(self, pyEntities): for curEntity in pyEntities: self._loadingViews.pop((curEntity.settings.alias, curEntity.uniqueName)) self.__loader.cancelLoadingByName(curEntity.uniqueName) curEntity.destroy() def __loader_onViewLoaded(self, pyView): viewType = pyView.settings.type if viewType is None: LOG_ERROR('Type of view is not defined', pyView.settings) viewKey = (pyView.alias, pyView.uniqueName) if viewKey in self._loadingViews: self._loadingViews.pop(viewKey) if viewType in self.__containers: if ViewTypes.DEFAULT == viewType: self.closePopUps() if self.__scopeController.isViewLoading(pyView): container = self.__containers[viewType] if container.add(pyView): self.__scopeController.addView(pyView, False) self.as_showS(pyView.uniqueName, 0, 0) pyView.create() subContainerType = pyView.getSubContainerType() if subContainerType is not None: self.addContainer(subContainerType, pyView.uniqueName) LOG_DEBUG('View added to container', pyView) self.onViewAddedToContainer(container, pyView) else: LOG_DEBUG('"%s" view cancelled to load, because its scope has been destroyed.' % str(pyView)) self.as_hideS(pyView.uniqueName) pyView.destroy() else: LOG_ERROR('Type "%s" of view "%s" is not supported' % (viewType, pyView)) return
class ContainerManager(ContainerManagerMeta): onViewAddedToContainer = Event() __DESTROY_ORDER = (ViewTypes.DEFAULT, ViewTypes.LOBBY_SUB, ViewTypes.WINDOW, ViewTypes.BROWSER, ViewTypes.TOP_WINDOW, ViewTypes.WAITING, ViewTypes.CURSOR, ViewTypes.SERVICE_LAYOUT) __CONTAINERS_TO_CLEAR = (ViewTypes.WINDOW, ViewTypes.BROWSER, ViewTypes.TOP_WINDOW) def __init__(self, loader): super(ContainerManager, self).__init__() proxy = weakref.proxy(self) self.__containers = { ViewTypes.DEFAULT: _DefaultContainer(proxy), ViewTypes.CURSOR: _DefaultContainer(proxy), ViewTypes.WAITING: _DefaultContainer(proxy), ViewTypes.WINDOW: _PopUpContainer(proxy), ViewTypes.BROWSER: _PopUpContainer(proxy), ViewTypes.TOP_WINDOW: _PopUpContainer(proxy), ViewTypes.SERVICE_LAYOUT: _DefaultContainer(proxy) } self._loadingViews = dict() self.__loader = loader self.__loader.onViewLoaded += self.__loader_onViewLoaded self.__scopeController = GlobalScopeController() self.__scopeController.create() def load(self, alias, name=None, *args, **kwargs): if name is None: name = alias isViewExists = self.as_getViewS(name) if not isViewExists and (alias, name) not in self._loadingViews: pyEntity = self.__loader.loadView(alias, name, *args, **kwargs) self.__scopeController.addLoadingView(pyEntity, False) curType = pyEntity.settings.type if self.canCancelPreviousLoading(curType): result = [] for kev, val in self._loadingViews.iteritems(): if val.settings.type == pyEntity.settings.type: result.append(val) if len(result) > 0: self.__cancelLoadingForPyEntities(result) self._loadingViews[alias, name] = pyEntity def __cancelLoadingForPyEntities(self, pyEntities): for curEntity in pyEntities: self._loadingViews.pop( (curEntity.settings.alias, curEntity.uniqueName)) self.__loader.cancelLoadingByName(curEntity.uniqueName) curEntity.destroy() def canCancelPreviousLoading(self, containerType): container = self.getContainer(containerType) if container is not None: return container.canCancelPreviousLoading() else: return False def addContainer(self, containerType, name, container=None): result = True if containerType not in self.__containers: if container is None: self.__containers[containerType] = _DefaultContainer( weakref.proxy(self)) self.as_registerContainerS(containerType, name) elif isinstance(container, IViewContainer): self.__containers[containerType] = container self.as_registerContainerS(containerType, name) else: LOG_ERROR('Container must be implemented IViewContainer', container) result = False else: LOG_ERROR('Container already registered', containerType) result = False return result def removeContainer(self, viewType): self.__scopeController.removeSubScopeController( ScopeTemplates.VIEW_TYPES_TO_SCOPES[viewType].getScopeType()) result = True if viewType in self.__containers: container = self.__containers[viewType] container.destroy() self.as_unregisterContainerS(viewType) del self.__containers[viewType] else: result = False return result def getContainer(self, viewType): if viewType in self.__containers: return self.__containers[viewType] def isModalViewsIsExists(self): if self.getContainer( ViewTypes.TOP_WINDOW).getViewCount(isModal=True) > 0: return True elif self.getContainer( ViewTypes.BROWSER).getViewCount(isModal=True) > 0: return True else: return self.getContainer( ViewTypes.WINDOW).getViewCount(isModal=True) > 0 def getView(self, viewType, criteria=None): view = None container = self.getContainer(viewType) if container is not None: view = container.getView(criteria=criteria) else: raise Exception('Container for %s view is None!' % viewType) return view def isViewAvailable(self, viewType, criteria=None): container = self.getContainer(viewType) if container is not None: return container.getView(criteria=criteria) is not None else: return False def closePopUps(self): self.as_closePopUpsS() def clear(self): for c in self.__CONTAINERS_TO_CLEAR: self.getContainer(c).clear() def _dispose(self): if self.__loader is not None: self.__loader.onViewLoaded -= self.__loader_onViewLoaded self.__loader = None for viewType in self.__DESTROY_ORDER: if viewType in self.__containers: container = self.__containers.pop(viewType) LOG_DEBUG('CONTAINER: ' + str(container) + '/' + viewType) container.destroy() if len(self.__containers): LOG_ERROR('No all containers are destructed.') self.__containers.clear() self.onViewAddedToContainer.clear() self.__scopeController.destroy() self.__scopeController = None self._loadingViews.clear() self._loadingViews = None super(ContainerManager, self)._dispose() def __loader_onViewLoaded(self, pyView): viewType = pyView.settings.type if viewType is None: LOG_ERROR('Type of view is not defined', pyView.settings) viewKey = (pyView.alias, pyView.uniqueName) if viewKey in self._loadingViews: self._loadingViews.pop(viewKey) if viewType in self.__containers: if ViewTypes.DEFAULT == viewType: self.closePopUps() if self.__scopeController.isViewLoading(pyView): container = self.__containers[viewType] if container.add(pyView): self.__scopeController.addView(pyView, False) self.as_showS(pyView.uniqueName, 0, 0) pyView.create() subContainerType = pyView.getSubContainerType() if subContainerType is not None: self.addContainer(subContainerType, pyView.uniqueName) LOG_DEBUG('View added to container', pyView) self.onViewAddedToContainer(container, pyView) else: LOG_DEBUG( '"%s" view cancelled to load, because its scope has been destroyed.' % str(pyView)) self.as_hideS(pyView.uniqueName) pyView.destroy() else: LOG_ERROR('Type "%s" of view "%s" is not supported' % (viewType, pyView))
class ContainerManager(ContainerManagerMeta, IContainerManager): def __init__(self, loader, *containers): super(ContainerManager, self).__init__() self.onViewAddedToContainer = Event() self.onViewLoading = Event() self.onViewLoaded = Event() self.__globalContainer = _GlobalViewContainer(weakref.proxy(self)) for container in containers: self.__globalContainer.addChildContainer(container) self.__loader = loader self.__loader.onViewLoadInit += self.__onViewLoadInit self.__loader.onViewLoaded += self.__onViewLoaded self.__scopeController = GlobalScopeController() self.__scopeController.create() self.__viewCache = _ViewCollection() self.__chainMng = _ChainManager(weakref.proxy(self)) def _dispose(self): self.__viewCache.destroy() self.__chainMng.destroy() if self.__loader is not None: self.__loader.onViewLoaded -= self.__onViewLoaded self.__loader.onViewLoadInit -= self.__onViewLoadInit self.__loader = None for viewType in _CONTAINERS_DESTROY_ORDER: container = self.__globalContainer.findContainer(viewType) if container is not None: LOG_DEBUG('Destroy container {} ({})'.format( viewType, container)) container.destroy() self.__globalContainer.destroy() self.onViewAddedToContainer.clear() self.__scopeController.destroy() self.__scopeController = None super(ContainerManager, self)._dispose() return def destroyViews(self, alias, name=None): def compareByAlias(view): return view.key.alias == alias def compareByAliasAndName(view): viewKey = view.key return viewKey.alias == alias and viewKey.name == name if name is None: comparator = compareByAlias else: comparator = compareByAliasAndName views = self.__scopeController.findViews(comparator) views.extend(self.__viewCache.findViews(comparator)) for view in views: if not view.isDisposed(): LOG_DEBUG('The view {} will be destroyed...'.format(view)) view.destroy() viewKey = ViewKey(alias, name) chain = self.__chainMng.getChainByViewKey(viewKey) if chain is not None: chain.removeViewByViewKey(viewKey) return def loadChain(self, chainItems): chain = _LoadingChain(chainItems) if self.__chainMng.addChain(chain): chain.run() else: LOG_WARNING( 'Could not add a new chain. Loading of chain [{}] is canceled.' .format(chainItems)) chain.destroy() def load(self, loadParams, *args, **kwargs): viewKey = loadParams.viewKey viewLoadingItem = self.__loader.getViewLoadingItem(viewKey) if viewLoadingItem is not None: LOG_DEBUG('View with key {} is already loading. item=[{}]'.format( viewKey, viewLoadingItem)) view = viewLoadingItem.pyEntity if loadParams.loadMode == ViewLoadMode.DEFAULT: loadingViewLoadMode = viewLoadingItem.loadParams.loadMode if loadingViewLoadMode == ViewLoadMode.PRELOAD: viewLoadingItem.loadParams = loadParams self.__addLoadingView(view) elif loadParams.loadMode == ViewLoadMode.PRELOAD: pass else: LOG_WARNING( 'Unsupported load mode {}. View loading will be skipped.'. format(loadParams)) view = None else: view = self.__globalContainer.findView(viewKey) if view is None: view = self.__viewCache.getView(viewKey) if view is None: chain = self.__chainMng.getChainByViewKey(viewKey) if chain is not None: LOG_WARNING( 'View with loadParams={} is in the loading chain {}. The request will be skipped.' .format(loadParams, chain)) else: LOG_DEBUG( 'Load view with loadParams={}. Loader=[{}]'.format( loadParams, self.__loader)) if loadParams.loadMode == ViewLoadMode.DEFAULT: view = self.__loader.loadView( loadParams, *args, **kwargs) self.__addLoadingView(view) elif loadParams.loadMode == ViewLoadMode.PRELOAD: view = self.__loader.loadView( loadParams, *args, **kwargs) else: LOG_WARNING( 'Unsupported load mode {}. View loading will be skipped.' .format(loadParams)) elif loadParams.loadMode == ViewLoadMode.PRELOAD: LOG_DEBUG( 'View with key {} ({}) is already pre-loaded.'.format( viewKey, view)) elif loadParams.loadMode == ViewLoadMode.DEFAULT: LOG_DEBUG( 'Load view with loadParams={} from the cache. Cache=[{}]' .format(loadParams, self.__viewCache)) self.__viewCache.removeView(viewKey) self.__showAndInitializeView(view) view.validate(*args, **kwargs) else: LOG_WARNING( 'Unsupported load mode {}. View loading will be skipped.' .format(loadParams)) view = None else: LOG_DEBUG('View with key {} ({}) is already loaded.'.format( viewKey, view)) viewType = view.settings.type viewContainer = self.__globalContainer.findContainer(viewType) viewContainer.addView(view) view.validate(*args, **kwargs) return view def getContainer(self, viewType): return self.__globalContainer.findContainer(viewType) def getViewByKey(self, viewKey): if self.__loader is not None: loadingItem = self.__loader.getViewLoadingItem(viewKey) if loadingItem is not None: return loadingItem.pyEntity sources = (self.__globalContainer.findView, self.__viewCache.getView) for source in sources: view = source(viewKey) if view is not None: return view return def isViewCreated(self, viewKey): return self.__globalContainer.findView(viewKey) is not None def isViewInCache(self, viewKey): return self.__viewCache.getView(viewKey) is not None def isModalViewsIsExists(self): for viewType in _POPUPS_CONTAINERS: container = self.__globalContainer.findContainer(viewType) if container is not None and container.getViewCount(isModal=True): return True return False def getView(self, viewType, criteria=None): container = self.__globalContainer.findContainer(viewType) if container is not None: return container.getView(criteria=criteria) else: LOG_WARNING('Could not found container {}.'.format(viewType)) return def isViewAvailable(self, viewType, criteria=None): container = self.__globalContainer.findContainer(viewType) return container.getView( criteria=criteria) is not None if container is not None else False def showContainers(self, *viewTypes): self.as_showContainersS(viewTypes) def hideContainers(self, *viewTypes): self.as_hideContainersS(viewTypes) def isContainerShown(self, viewType): return self.as_isContainerShownS(viewType) def clear(self): for viewType in _POPUPS_CONTAINERS: container = self.__globalContainer.findContainer(viewType) if container is not None: container.clear() return def closePopUps(self): self.as_closePopUpsS() def registerViewContainer(self, viewType, uniqueName): self.as_registerContainerS(viewType, uniqueName) LOG_DEBUG( 'A new container [type={}, name={}] has been registered.'.format( viewType, uniqueName)) def unregisterViewContainer(self, viewType): self.as_unregisterContainerS(viewType) LOG_DEBUG( 'The container [type={}] has been unregistered.'.format(viewType)) def __addLoadingView(self, pyView): viewType = pyView.settings.type viewContainer = self.__globalContainer.findContainer(viewType) if viewContainer is not None: viewContainer.addLoadingView(pyView) else: LOG_WARNING( 'Loading of view {} is requested but the container {} is still not exist!' .format(pyView, viewType)) self.__scopeController.addLoadingView(pyView, False) return def __showAndInitializeView(self, pyView): viewType = pyView.settings.type if viewType is None: LOG_ERROR( 'Type of view is not defined. View {} will be destroyed.', pyView) pyView.destroy() return False else: status = False container = self.__globalContainer.findContainer(viewType) if container is not None: if ViewTypes.DEFAULT == viewType: self.closePopUps() if container.addView(pyView): self.__scopeController.addView(pyView, False) self.as_showS(pyView.uniqueName, 0, 0) pyView.create() self.onViewAddedToContainer(container, pyView) status = True else: LOG_ERROR( '{} view cannot be added to container {} and will be destroyed.' .format(pyView, container)) pyView.destroy() else: LOG_ERROR( 'Type {} of view {} is not supported or container has not been properly created' .format(viewType, pyView)) pyView.destroy() return status def __addViewToCache(self, pyView): view = self.__viewCache.getView(pyView.key) if view is not None: LOG_UNEXPECTED( 'The view with key {} is already in the cache.'.format( pyView.key), pyView, view) if view != pyView: view.destroy() if self.__viewCache.addView(pyView): LOG_DEBUG('View {} has been added to the cache {}'.format( pyView, self.__viewCache)) else: LOG_DEBUG('Cannot add view {} in the cache {}'.format( pyView, self.__viewCache)) elif self.__viewCache.addView(pyView): LOG_DEBUG('View {} has been added to the cache {}'.format( pyView, self.__viewCache)) else: LOG_DEBUG('Cannot add view {} in the cache {}'.format( pyView, self.__viewCache)) return def __onViewLoaded(self, pyView, loadParams): self.onViewLoaded(pyView) loadMode = loadParams.loadMode if loadMode == ViewLoadMode.DEFAULT: if self.__scopeController.isViewLoading(pyView=pyView): self.__showAndInitializeView(pyView) else: LOG_DEBUG( '{} view loading is cancelled because its scope has been destroyed.' .format(pyView)) pyView.destroy() elif loadMode == ViewLoadMode.PRELOAD: self.__addViewToCache(pyView) else: LOG_WARNING( 'Unsupported load mode {}. View {} will be destroyed.'.format( loadMode, pyView)) pyView.destroy() def __onViewLoadInit(self, view, *args, **kwargs): self.onViewLoading(view)